[Demangle] remove unused params of itaniumDemangle

[nickdesaulniers]

Summary

No call sites use these parameters, so drop them.
Equivalent to D148940.

[nickdesaulniers]

llvm/include/llvm/Demangle/Demangle.h

32

no one cares about status either. @MaskRay should I submit that as a second patch on top of this, or squash it into this review?

[MaskRay]

LGTM to remove char *buf, size_t *n,. If a user somewhat needs the parameters, we can add another API.

llvm/lib/ProfileData/GCOV.cpp

343

llvm-cov gcov uses status.

[nickdesaulniers]

llvm/lib/ProfileData/GCOV.cpp

343

Not meaningfully; all of the call sites seem confused by this terrible interface. Does returning nullptr indicate failure to demangle? Does status returning non-zero mean demangling failed? Should I free the result?

The interface is bad. It should return a std::string that's empty upon demangling failure.

https://reviews.llvm.org/D149707 is the follow up to remove status.

llvm/include/llvm/Demangle/Demangle.h

 enum : int {
   demangle_unknown_error = -4,
   demangle_invalid_args = -3,
   demangle_invalid_mangled_name = -2,
   demangle_memory_alloc_failure = -1,
   demangle_success = 0,
 };
 
-char *itaniumDemangle(const char *mangled_name, char *buf, size_t *n,
-                      int *status);
+char *itaniumDemangle(const char *mangled_name, int *status);
 
 enum MSDemangleFlags {
   MSDF_None = 0,
   MSDF_DumpBackrefs = 1 << 0,
   MSDF_NoAccessSpecifier = 1 << 1,
   MSDF_NoCallingConvention = 1 << 2,
   MSDF_NoReturnType = 1 << 3,
   MSDF_NoMemberType = 1 << 4,

llvm/lib/Demangle/Demangle.cpp

std::string llvm::demangle(const std::string &MangledName) {
   }
 
   return MangledName;
 }
 
 bool llvm::nonMicrosoftDemangle(const char *MangledName, std::string &Result) {
   char *Demangled = nullptr;
   if (isItaniumEncoding(MangledName))
-    Demangled = itaniumDemangle(MangledName, nullptr, nullptr, nullptr);
+    Demangled = itaniumDemangle(MangledName, nullptr);
   else if (isRustEncoding(MangledName))
     Demangled = rustDemangle(MangledName);
   else if (isDLangEncoding(MangledName))
     Demangled = dlangDemangle(MangledName);
 
   if (!Demangled)
     return false;
 
   Result = Demangled;
   std::free(Demangled);
   return true;
 }

llvm/lib/Demangle/ItaniumDemangle.cpp

 }  // unnamed namespace
 
 //===----------------------------------------------------------------------===//
 // Code beyond this point should not be synchronized with libc++abi.
 //===----------------------------------------------------------------------===//
 
 using Demangler = itanium_demangle::ManglingParser<DefaultAllocator>;
 
-char *llvm::itaniumDemangle(const char *MangledName, char *Buf,
-                            size_t *N, int *Status) {
-  if (MangledName == nullptr || (Buf != nullptr && N == nullptr)) {
+char *llvm::itaniumDemangle(const char *MangledName, int *Status) {
+  if (MangledName == nullptr) {
     if (Status)
       *Status = demangle_invalid_args;
     return nullptr;
   }
 
   int InternalStatus = demangle_success;
   Demangler Parser(MangledName, MangledName + std::strlen(MangledName));
   Node *AST = Parser.parse();
 
+  char *Buf;
   if (AST == nullptr)
     InternalStatus = demangle_invalid_mangled_name;
   else {
-    OutputBuffer OB(Buf, N);
+    OutputBuffer OB;
     assert(Parser.ForwardTemplateRefs.empty());
     AST->print(OB);
     OB += '\0';
-    if (N != nullptr)
-      *N = OB.getCurrentPosition();
     Buf = OB.getBuffer();
   }
 
   if (Status)
     *Status = InternalStatus;
   return InternalStatus == demangle_success ? Buf : nullptr;
 }
 

llvm/lib/ProfileData/GCOV.cpp

 StringRef GCOVFunction::getName(bool demangle) const {
   if (!demangle)
     return Name;
   if (demangled.empty()) {
     do {
       if (Name.startswith("_Z")) {
         int status = 0;
         // Name is guaranteed to be NUL-terminated.
-        char *res = itaniumDemangle(Name.data(), nullptr, nullptr, &status);
+        char *res = itaniumDemangle(Name.data(), &status);
         if (status == 0) {
           demangled = res;
           free(res);
           break;
         }
       }
       demangled = Name;
     } while (false);
   }

llvm/lib/Support/Unix/Signals.inc

else
       OS << format(" %-*s", width, name + 1);
 
     OS << format(" %#0*lx", (int)(sizeof(void *) * 2) + 2,
                  (unsigned long)StackTrace[i]);
 
     if (dlinfo.dli_sname != nullptr) {
       OS << ' ';
       int res;
-      char *d = itaniumDemangle(dlinfo.dli_sname, nullptr, nullptr, &res);
+      char *d = itaniumDemangle(dlinfo.dli_sname, &res);
       if (!d)
         OS << dlinfo.dli_sname;
       else
         OS << d;
       free(d);
 
       OS << format(" + %tu", (static_cast<const char *>(StackTrace[i]) -
                               static_cast<const char *>(dlinfo.dli_saddr)));

llvm/tools/llvm-cxxfilt/llvm-cxxfilt.cpp

static std::string demangle(const std::string &Mangled) {
   std::string Result;
   if (nonMicrosoftDemangle(DecoratedStr, Result))
     return Result;
 
   std::string Prefix;
   char *Undecorated = nullptr;
 
   if (Types)
-    Undecorated = itaniumDemangle(DecoratedStr, nullptr, nullptr, nullptr);
+    Undecorated = itaniumDemangle(DecoratedStr, nullptr);
 
   if (!Undecorated && strncmp(DecoratedStr, "__imp_", 6) == 0) {
     Prefix = "import thunk for ";
-    Undecorated = itaniumDemangle(DecoratedStr + 6, nullptr, nullptr, nullptr);
+    Undecorated = itaniumDemangle(DecoratedStr + 6, nullptr);
   }
 
   Result = Undecorated ? Prefix + Undecorated : Mangled;
   free(Undecorated);
   return Result;
 }
 
 // Split 'Source' on any character that fails to pass 'IsLegalChar'.  The

llvm/tools/llvm-itanium-demangle-fuzzer/llvm-itanium-demangle-fuzzer.cpp

 
 #include <cstdint>
 #include <cstdlib>
 #include <string>
 
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
   std::string NullTerminatedString((const char *)Data, Size);
   int status = 0;
-  if (char *demangle = llvm::itaniumDemangle(NullTerminatedString.c_str(), nullptr,
-                                         nullptr, &status))
+  if (char *demangle =
+          llvm::itaniumDemangle(NullTerminatedString.c_str(), &status))
     free(demangle);
 
   return 0;
 }

llvm/tools/llvm-objdump/MachODump.cpp

if (*ReferenceType == LLVMDisassembler_ReferenceType_In_Branch) {
     if (*ReferenceName != nullptr) {
       method_reference(info, ReferenceType, ReferenceName);
       if (*ReferenceType != LLVMDisassembler_ReferenceType_Out_Objc_Message)
         *ReferenceType = LLVMDisassembler_ReferenceType_Out_SymbolStub;
     } else if (SymbolName != nullptr && strncmp(SymbolName, "__Z", 3) == 0) {
       if (info->demangled_name != nullptr)
         free(info->demangled_name);
       int status;
-      info->demangled_name =
-          itaniumDemangle(SymbolName + 1, nullptr, nullptr, &status);
+      info->demangled_name = itaniumDemangle(SymbolName + 1, &status);
       if (info->demangled_name != nullptr) {
         *ReferenceName = info->demangled_name;
         *ReferenceType = LLVMDisassembler_ReferenceType_DeMangled_Name;
       } else
         *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
     } else
       *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
   } else if (*ReferenceType == LLVMDisassembler_ReferenceType_In_PCrel_Load) {
else if (info->O->getArch() == Triple::aarch64 &&
     *ReferenceName =
         GuessLiteralPointer(ReferenceValue, ReferencePC, ReferenceType, info);
     if (*ReferenceName == nullptr)
       *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;
   } else if (SymbolName != nullptr && strncmp(SymbolName, "__Z", 3) == 0) {
     if (info->demangled_name != nullptr)
       free(info->demangled_name);
     int status;
-    info->demangled_name =
-        itaniumDemangle(SymbolName + 1, nullptr, nullptr, &status);
+    info->demangled_name = itaniumDemangle(SymbolName + 1, &status);
     if (info->demangled_name != nullptr) {
       *ReferenceName = info->demangled_name;
       *ReferenceType = LLVMDisassembler_ReferenceType_DeMangled_Name;
     }
   }
   else {
     *ReferenceName = nullptr;
     *ReferenceType = LLVMDisassembler_ReferenceType_InOut_None;

llvm/tools/llvm-opt-report/OptReport.cpp

for (line_iterator LI(*Buf.get(), false); LI != line_iterator(); ++LI) {
             if (FirstFunc)
               FirstFunc = false;
             else
               OS << ", ";
 
             bool Printed = false;
             if (!NoDemangle) {
               int Status = 0;
-              char *Demangled =
-                itaniumDemangle(FuncName.c_str(), nullptr, nullptr, &Status);
+              char *Demangled = itaniumDemangle(FuncName.c_str(), &Status);
               if (Demangled && Status == 0) {
                 OS << Demangled;
                 Printed = true;
               }
 
               if (Demangled)
                 std::free(Demangled);
             }