[Demangle] make llvm::demangle take a StringRef; NFC

[nickdesaulniers]

There's a few more callsites I'd like to clean up, tomorrow:

• llvm/tools/llvm-objdump/llvm-objdump.cpp
• llvm/tools/llvm-objdump/XCOFFDump.cpp

[sbc100]

llvm/lib/Demangle/Demangle.cpp

29

Should const be removed? (i.e. is StringRef not inherently const?)

[MaskRay]

Unfortunately we cannot do this. LLVMSupport depends on LLVMDemangle. Due to library layering LLVMDemangle cannot depend on LLVMSupport.
The layering may look weird, but that's what we have.

Using std::string_view may possibly be fine.

[erichkeane]

We're C++17 compilation now, so we should be able to use std::string_view (and I think we're supposed to?).

llvm/lib/Demangle/Demangle.cpp

31

std::string is implicitly constructible from a std::string_view, so I think on line 37 we can just do: MangledName[0] instead of S[0], and just do return MangledName below, rather than constructing it every time, despite it being just destructed in every other branch.

Though, I guess the 'gotcha' here is that despite everything else not modifying the S here, that we're no longer able to use strlen for the length. Perhaps this change should be more viral, in that the other demangle functions should take a string_view instead of a const char * as well.

[nickdesaulniers]

llvm/lib/Demangle/Demangle.cpp

31

Perhaps this change should be more viral, in that the other demangle functions should take a string_view instead of a const char * as well.

Sigh, include/llvm/Demangle/StringView.h has a comment

9 // FIXME: Use std::string_view instead when we support C++17.

and is used throughout llvm/lib/Demangle/. This is potentially a large cleanup. Let me start on that...

[nickdesaulniers]

llvm/lib/Demangle/Demangle.cpp

31

Not having starts_with and ends_with until C++20 is going to be a PITA.

[erichkeane]

llvm/lib/Demangle/Demangle.cpp

31

Ouch, yeah, i could see that being a problem. Perhaps we need an llvm::starts_with/llvm::ends_with that implements in terms of substr?

[nickdesaulniers]

llvm/lib/Demangle/Demangle.cpp

31

Yeah, I guess llvm/ADT/STLExtras.h might be an appropriate place to add them.

So far in the conversion, another pain point has been llvm::StringView's constructor that takes two char*'s. I think to break up this conversion, I might remove that constructor and modify the callsites.

[nickdesaulniers]

Just going to rip out llvm::StringView.

clang/lib/CodeGen/CodeGenAction.cpp

BackendConsumer::StackSizeDiagHandler(const llvm::DiagnosticInfoStackSize &D) {
 
   auto Loc = getFunctionSourceLocation(D.getFunction());
   if (!Loc)
     return false;
 
   Diags.Report(*Loc, diag::warn_fe_frame_larger_than)
       << D.getStackSize()
       << D.getStackLimit()
-      << llvm::demangle(D.getFunction().getName().str());
+      << llvm::demangle(D.getFunction().getName());
   return true;
 }
 
 bool BackendConsumer::ResourceLimitDiagHandler(
     const llvm::DiagnosticInfoResourceLimit &D) {
   auto Loc = getFunctionSourceLocation(D.getFunction());
   if (!Loc)
     return false;
   unsigned DiagID = diag::err_fe_backend_resource_limit;
   ComputeDiagID(D.getSeverity(), backend_resource_limit, DiagID);
 
   Diags.Report(*Loc, DiagID)
       << D.getResourceName() << D.getResourceSize() << D.getResourceLimit()
-      << llvm::demangle(D.getFunction().getName().str());
+      << llvm::demangle(D.getFunction().getName());
   return true;
 }
 
 const FullSourceLoc BackendConsumer::getBestLocationFromDebugLoc(
     const llvm::DiagnosticInfoWithLocationBase &D, bool &BadDebugInfo,
     StringRef &Filename, unsigned &Line, unsigned &Column) const {
   SourceManager &SourceMgr = Context->getSourceManager();
   FileManager &FileMgr = SourceMgr.getFileManager();
void BackendConsumer::DontCallDiagHandler(const DiagnosticInfoDontCall &D) {
   // FIXME: we can't yet diagnose indirect calls. When/if we can, we
   // should instead assert that LocCookie.isValid().
   if (!LocCookie.isValid())
     return;
 
   Diags.Report(LocCookie, D.getSeverity() == DiagnosticSeverity::DS_Error
                               ? diag::err_fe_backend_error_attr
                               : diag::warn_fe_backend_warning_attr)
-      << llvm::demangle(D.getFunctionName().str()) << D.getNote();
+      << llvm::demangle(D.getFunctionName()) << D.getNote();
 }
 
 void BackendConsumer::MisExpectDiagHandler(
     const llvm::DiagnosticInfoMisExpect &D) {
   StringRef Filename;
   unsigned Line, Column;
   bool BadDebugInfo = false;
   FullSourceLoc Loc =

lld/COFF/Symbols.cpp

static std::string maybeDemangleSymbol(const COFFLinkerContext &ctx,
   if (ctx.config.demangle) {
     std::string prefix;
     StringRef prefixless = symName;
     if (prefixless.consume_front("__imp_"))
       prefix = "__declspec(dllimport) ";
     StringRef demangleInput = prefixless;
     if (ctx.config.machine == I386)
       demangleInput.consume_front("_");
-    std::string demangled = demangle(demangleInput.str());
+    std::string demangled = demangle(demangleInput);
     if (demangled != demangleInput)
-      return prefix + demangle(demangleInput.str());
+      return prefix + demangle(demangleInput);
     return (prefix + prefixless).str();
   }
   return std::string(symName);
 }
 std::string toString(const COFFLinkerContext &ctx, coff::Symbol &b) {
   return maybeDemangleSymbol(ctx, b.getName());
 }
 std::string toCOFFString(const COFFLinkerContext &ctx,

lld/ELF/SymbolTable.cpp

StringMap<SmallVector<Symbol *, 0>> &SymbolTable::getDemangledSyms() {
   if (!demangledSyms) {
     demangledSyms.emplace();
     std::string demangled;
     for (Symbol *sym : symVector)
       if (canBeVersioned(*sym)) {
         StringRef name = sym->getName();
         size_t pos = name.find('@');
         if (pos == std::string::npos)
-          demangled = demangle(name.str());
+          demangled = demangle(name);
         else if (pos + 1 == name.size() || name[pos + 1] == '@')
-          demangled = demangle(name.substr(0, pos).str());
+          demangled = demangle(name.substr(0, pos));
         else
           demangled =
-              (demangle(name.substr(0, pos).str()) + name.substr(pos)).str();
+              (demangle(name.substr(0, pos)) + name.substr(pos)).str();
         (*demangledSyms)[demangled].push_back(sym);
       }
   }
   return *demangledSyms;
 }
 
 SmallVector<Symbol *, 0> SymbolTable::findByVersion(SymbolVersion ver) {
   if (ver.isExternCpp)

lld/ELF/Symbols.cpp

LLVM_ATTRIBUTE_UNUSED static inline void assertSymbols() {
   AssertSymbol<Undefined>();
   AssertSymbol<SharedSymbol>();
   AssertSymbol<LazyObject>();
 }
 
 // Returns a symbol for an error message.
 static std::string maybeDemangleSymbol(StringRef symName) {
   if (elf::config->demangle)
-    return demangle(symName.str());
+    return demangle(symName);
   return symName.str();
 }
 
 std::string lld::toString(const elf::Symbol &sym) {
   StringRef name = sym.getName();
   std::string ret = maybeDemangleSymbol(name);
 
   const char *suffix = sym.getVersionSuffix();

lld/MachO/Symbols.cpp

 
 static_assert(sizeof(SymbolUnion) == sizeof(Defined),
               "Defined should be the largest Symbol kind");
 
 // Returns a symbol name for an error message.
 static std::string maybeDemangleSymbol(StringRef symName) {
   if (config->demangle) {
     symName.consume_front("_");
-    return demangle(symName.str());
+    return demangle(symName);
   }
   return symName.str();
 }
 
 std::string lld::toString(const Symbol &sym) {
   return maybeDemangleSymbol(sym.getName());
 }
 

lld/wasm/Symbols.cpp

 }
 
 std::string maybeDemangleSymbol(StringRef name) {
   // WebAssembly requires caller and callee signatures to match, so we mangle
   // `main` in the case where we need to pass it arguments.
   if (name == "__main_argc_argv")
     return "main";
   if (wasm::config->demangle)
-    return demangle(name.str());
+    return demangle(name);
   return name.str();
 }
 
 std::string toString(wasm::Symbol::Kind kind) {
   switch (kind) {
   case wasm::Symbol::DefinedFunctionKind:
     return "DefinedFunction";
   case wasm::Symbol::DefinedDataKind:

llvm/include/llvm/Demangle/Demangle.h

 //===--- Demangle.h ---------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_DEMANGLE_DEMANGLE_H
 #define LLVM_DEMANGLE_DEMANGLE_H
 
+#include "llvm/ADT/StringRef.h"
+
 #include <cstddef>
 #include <string>
 
 namespace llvm {
 /// This is a llvm local version of __cxa_demangle. Other than the name and
 /// being in the llvm namespace it is identical.
 ///
 /// The mangled_name is demangled into buf and returned. If the buffer is not

 // Demangles a D mangled symbol.
 char *dlangDemangle(const char *MangledName);
 
 /// Attempt to demangle a string using different demangling schemes.
 /// The function uses heuristics to determine which demangling scheme to use.
 /// \param MangledName - reference to string to demangle.
 /// \returns - the demangled string, or a copy of the input string if no
 /// demangling occurred.
-std::string demangle(const std::string &MangledName);
+std::string demangle(const StringRef MangledName);
 
 bool nonMicrosoftDemangle(const char *MangledName, std::string &Result);
 
 /// "Partial" demangler. This supports demangling a string into an AST
 /// (typically an intermediate stage in itaniumDemangle) and querying certain
 /// properties or partially printing the demangled name.
 struct ItaniumPartialDemangler {
   ItaniumPartialDemangler();

llvm/lib/DebugInfo/LogicalView/Readers/LVCodeViewVisitor.cpp

if (LVScope *Function = LogicalVisitor->CurrentScope) {
     }
 
     if (Record.kind() == SymbolKind::S_GPROC32 ||
         Record.kind() == SymbolKind::S_GPROC32_ID)
       Function->setIsExternal();
 
     // We don't have a way to see if the symbol is compiler generated. Use
     // the linkage name, to detect `scalar deleting destructor' functions.
-    std::string DemangledSymbol = demangle(std::string(LinkageName));
+    std::string DemangledSymbol = demangle(LinkageName);
     if (DemangledSymbol.find("scalar deleting dtor") != std::string::npos) {
       Function->setIsArtificial();
     } else {
       // Clang generates global ctor and dtor names containing the substrings:
       // 'dynamic initializer for' and 'dynamic atexit destructor for'.
       if (DemangledSymbol.find("dynamic atexit destructor for") !=
           std::string::npos)
         Function->setIsArtificial();

llvm/lib/DebugInfo/Symbolize/MarkupFilter.cpp

 
 bool MarkupFilter::trySymbol(const MarkupNode &Node) {
   if (Node.Tag != "symbol")
     return false;
   if (!checkNumFields(Node, 1))
     return true;
 
   highlight();
-  OS << llvm::demangle(Node.Fields.front().str());
+  OS << llvm::demangle(Node.Fields.front());
   restoreColor();
   return true;
 }
 
 bool MarkupFilter::tryPC(const MarkupNode &Node) {
   if (Node.Tag != "pc")
     return false;
   if (!checkNumFieldsAtLeast(Node, 1))

llvm/lib/Demangle/Demangle.cpp

 
 static bool isRustEncoding(const char *S) { return S[0] == '_' && S[1] == 'R'; }
 
 static bool isDLangEncoding(const std::string &MangledName) {
   return MangledName.size() >= 2 && MangledName[0] == '_' &&
          MangledName[1] == 'D';
 }
 
-std::string llvm::demangle(const std::string &MangledName) {
+std::string llvm::demangle(const StringRef MangledName) {
   std::string Result;
-  const char *S = MangledName.c_str();
+  std::string Copy = MangledName.str();
+  const char *S = Copy.data();
 
   if (nonMicrosoftDemangle(S, Result))
     return Result;
 
   if (S[0] == '_' && nonMicrosoftDemangle(S + 1, Result))
     return Result;
 
   if (char *Demangled =
           microsoftDemangle(S, nullptr, nullptr, nullptr, nullptr)) {
     Result = Demangled;
     std::free(Demangled);
     return Result;
   }
 
-  return MangledName;
+  return Copy;
 }
 
 bool llvm::nonMicrosoftDemangle(const char *MangledName, std::string &Result) {
   char *Demangled = nullptr;
   if (isItaniumEncoding(MangledName))
     Demangled = itaniumDemangle(MangledName, nullptr, nullptr, nullptr);
   else if (isRustEncoding(MangledName))
     Demangled = rustDemangle(MangledName);

llvm/lib/IR/DiagnosticInfo.cpp

if (F->hasFnAttribute(AttrName)) {
       DiagnosticInfoDontCall D(F->getName(), A.getValueAsString(), Sev,
                                LocCookie);
       F->getContext().diagnose(D);
     }
   }
 }
 
 void DiagnosticInfoDontCall::print(DiagnosticPrinter &DP) const {
-  DP << "call to " << demangle(getFunctionName().str())
+  DP << "call to " << demangle(getFunctionName())
      << " marked \"dontcall-";
   if (getSeverity() == DiagnosticSeverity::DS_Error)
     DP << "error\"";
   else
     DP << "warn\"";
   if (!getNote().empty())
     DP << ": " << getNote();
 }

llvm/tools/llvm-nm/llvm-nm.cpp

static std::optional<std::string> demangle(StringRef Name) {
   std::string Demangled;
   if (nonMicrosoftDemangle(Name.str().c_str(), Demangled))
     return Demangled;
   return std::nullopt;
 }
 
 static std::optional<std::string> demangleXCOFF(StringRef Name) {
   if (Name.empty() || Name[0] != '.')
-    return demangle(Name);
+    return ::demangle(Name);
 
   Name = Name.drop_front();
-  std::optional<std::string> DemangledName = demangle(Name);
+  std::optional<std::string> DemangledName = ::demangle(Name);
   if (DemangledName)
     return "." + *DemangledName;
   return std::nullopt;
 }
 
 static std::optional<std::string> demangleMachO(StringRef Name) {
   if (!Name.empty() && Name[0] == '_')
     Name = Name.drop_front();
-  return demangle(Name);
+  return ::demangle(Name);
 }
 
 static bool symbolIsDefined(const NMSymbol &Sym) {
   return Sym.TypeChar != 'U' && Sym.TypeChar != 'w' && Sym.TypeChar != 'v';
 }
 
 static void writeFileName(raw_ostream &S, StringRef ArchiveName,
                           StringRef ArchitectureName) {

llvm/tools/llvm-objdump/ELFDump.cpp

if ((*SymOrErr)->getType() == ELF::STT_SECTION) {
       if (!SecName)
         return SecName.takeError();
       Fmt << *SecName;
     } else {
       Expected<StringRef> SymName = SI->getName();
       if (!SymName)
         return SymName.takeError();
       if (Demangle)
-        Fmt << demangle(std::string(*SymName));
+        Fmt << demangle(*SymName);
       else
         Fmt << *SymName;
     }
   } else {
     Fmt << "*ABS*";
   }
   if (Addend != 0) {
       Fmt << (Addend < 0

llvm/tools/llvm-readobj/ELFDumper.cpp

if (Symtab) {
     auto It = ShndxTables.find(Symtab);
     if (It != ShndxTables.end())
       return It->second;
   }
   return {};
 }
 
 static std::string maybeDemangle(StringRef Name) {
-  return opts::Demangle ? demangle(std::string(Name)) : Name.str();
+  return opts::Demangle ? demangle(Name) : Name.str();
 }
 
 template <typename ELFT>
 std::string ELFDumper<ELFT>::getStaticSymbolName(uint32_t Index) const {
   auto Warn = [&](Error E) -> std::string {
     reportUniqueWarning("unable to read the name of symbol with index " +
                         Twine(Index) + ": " + toString(std::move(E)));
     return "<?>";

llvm/tools/llvm-tli-checker/llvm-tli-checker.cpp

WithColor::warning() << ArchiveFilename << "(" << ChildName
                        << "): member is not usable\n";
 }
 
 // Return Name, and if Name is mangled, append "aka" and the demangled name.
 static std::string getPrintableName(StringRef Name) {
   std::string OutputName = "'";
   OutputName += Name;
   OutputName += "'";
-  std::string DemangledName(demangle(Name.str()));
+  std::string DemangledName(demangle(Name));
   if (Name != DemangledName) {
     OutputName += " aka ";
     OutputName += DemangledName;
   }
   return OutputName;
 }
 
 // Store all the names that TargetLibraryInfo knows about; the bool indicates