[lld][nfc] Remove lld::demangle() (partial revert of D116279)

[int3]

Summary

D116279: [lld] Add support for other demanglers other than Itanium, in addition to adding support for other demanglers, also
factored out some of the demangling logic. However, I don't think the
abstraction really carries its weight -- after D135942: [lld-macho][nfc] lld/Common's `demangle()` is redundant for Mach-O, only the ELF
and WASM backends call it with anything other than a non-constant
shouldDemangle argument. The COFF and Mach-O backends were already
doing the should-demangle check before calling demangle().

[sbc100]

lld/wasm/Symbols.cpp

39

Is using std::string(name) preferable to name.str() ?

[MaskRay]

Looks great!

[int3]

lld/wasm/Symbols.cpp

39

no idea. Most of the original code used the std::string constructor though. But... .str() is fewer characters and looks cleaner. I'll switch them over.

lld/COFF/Symbols.cpp

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

lld/ELF/SymbolTable.cpp

 #include "SymbolTable.h"
 #include "Config.h"
 #include "InputFiles.h"
 #include "Symbols.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
 #include "lld/Common/Strings.h"
 #include "llvm/ADT/STLExtras.h"
+#include "llvm/Demangle/Demangle.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 using namespace lld;
 using namespace lld::elf;
 
 SymbolTable elf::symtab;
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, config->demangle);
+          demangled = demangle(name.str());
         else if (pos + 1 == name.size() || name[pos + 1] == '@')
-          demangled = demangle(name.substr(0, pos), config->demangle);
+          demangled = demangle(name.substr(0, pos).str());
         else
-          demangled = (demangle(name.substr(0, pos), config->demangle) +
-                       name.substr(pos))
-                          .str();
+          demangled =
+              (demangle(name.substr(0, pos).str()) + 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

 #include "Driver.h"
 #include "InputFiles.h"
 #include "InputSection.h"
 #include "OutputSections.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "Writer.h"
 #include "lld/Common/ErrorHandler.h"
-#include "lld/Common/Strings.h"
+#include "llvm/Demangle/Demangle.h"
 #include "llvm/Support/Compiler.h"
 #include <cstring>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 using namespace lld;
 using namespace lld::elf;

 LLVM_ATTRIBUTE_UNUSED static inline void assertSymbols() {
   AssertSymbol<Defined>();
   AssertSymbol<CommonSymbol>();
   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 symName.str();
+}
+
 std::string lld::toString(const elf::Symbol &sym) {
   StringRef name = sym.getName();
-  std::string ret = demangle(name, config->demangle);
+  std::string ret = maybeDemangleSymbol(name);
 
   const char *suffix = sym.getVersionSuffix();
   if (*suffix == '@')
     ret += suffix;
   return ret;
 }
 
 Defined *ElfSym::bss;

lld/MachO/SymbolTable.cpp

 #include "ConcatOutputSection.h"
 #include "Config.h"
 #include "InputFiles.h"
 #include "InputSection.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
+#include "llvm/Demangle/Demangle.h"
 
 using namespace llvm;
 using namespace lld;
 using namespace lld::macho;
 
 Symbol *SymbolTable::find(CachedHashStringRef cachedName) {
   auto it = symMap.find(cachedName);
   if (it == symMap.end())

lld/include/lld/Common/Strings.h

 //===- Strings.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 LLD_STRINGS_H
 #define LLD_STRINGS_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Demangle/Demangle.h"
 #include "llvm/Support/GlobPattern.h"
 #include <string>
 #include <vector>
 
 namespace lld {
-// Returns a demangled symbol name. If Name is not a mangled name, it returns
-// name.
-inline std::string demangle(llvm::StringRef symName, bool shouldDemangle) {
-  if (shouldDemangle)
-    return llvm::demangle(symName.str().c_str());
-  return std::string(symName);
-}
 
 llvm::SmallVector<uint8_t, 0> parseHex(llvm::StringRef s);
 bool isValidCIdentifier(llvm::StringRef s);
 
 // Write the contents of the a buffer to a file
 void saveBuffer(llvm::StringRef buffer, const llvm::Twine &path);
 
 // A single pattern to match against. A pattern can either be double-quoted

lld/wasm/Symbols.cpp

 #include "Config.h"
 #include "InputChunks.h"
 #include "InputElement.h"
 #include "InputFiles.h"
 #include "OutputSections.h"
 #include "OutputSegment.h"
 #include "lld/Common/ErrorHandler.h"
 #include "lld/Common/Memory.h"
-#include "lld/Common/Strings.h"
+#include "llvm/Demangle/Demangle.h"
 
 #define DEBUG_TYPE "lld"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::wasm;
 using namespace lld::wasm;
 
 namespace lld {
 std::string toString(const wasm::Symbol &sym) {
   return maybeDemangleSymbol(sym.getName());
 }
 
 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";
-
-  return demangle(name, config->demangle);
+  if (wasm::config->demangle)
+    return demangle(name.str());
+  return name.str();
 }
 
 std::string toString(wasm::Symbol::Kind kind) {
   switch (kind) {
   case wasm::Symbol::DefinedFunctionKind:
     return "DefinedFunction";
   case wasm::Symbol::DefinedDataKind:
     return "DefinedData";