Factor out common code to Common/Strings.cpp.

[ruiu]

Summary

Factor out common code to Common/Strings.cpp.

[ruiu]

• Address review comment

lld/COFF/Strings.h

 #define LLD_COFF_STRINGS_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 
 namespace lld {
 namespace coff {
-llvm::Optional<std::string> demangle(llvm::StringRef S);
+llvm::Optional<std::string> demangleMSVC(llvm::StringRef S);
 }
 }
 
 #endif

lld/COFF/Strings.cpp

 #include <DbgHelp.h>
 #pragma comment(lib, "dbghelp.lib")
 #endif
 
 using namespace lld;
 using namespace lld::coff;
 using namespace llvm;
 
-Optional<std::string> coff::demangle(StringRef S) {
+Optional<std::string> coff::demangleMSVC(StringRef S) {
 #if defined(_MSC_VER)
   // UnDecorateSymbolName is not thread-safe, so we need a mutex.
   static std::mutex Mu;
   std::lock_guard<std::mutex> Lock(Mu);
 
   char Buf[4096];
   if (S.startswith("?"))
     if (size_t Len = UnDecorateSymbolName(S.str().c_str(), Buf, sizeof(Buf), 0))
       return std::string(Buf, Len);
 #endif
   return None;
 }

lld/COFF/Symbols.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 // Returns a symbol name for an error message.
 std::string lld::toString(coff::Symbol &B) {
-  if (Optional<std::string> S = coff::demangle(B.getName()))
+  if (Optional<std::string> S = coff::demangleMSVC(B.getName()))
     return ("\"" + *S + "\" (" + B.getName() + ")").str();
   return B.getName();
 }
 
 namespace lld {
 namespace coff {
 
 StringRef Symbol::getName() {

lld/Common/CMakeLists.txt

 if(NOT LLD_BUILT_STANDALONE)
   set(tablegen_deps intrinsics_gen)
 endif()
 
 add_lld_library(lldCommon
   ErrorHandler.cpp
   Reproduce.cpp
+  Strings.cpp
   TargetOptionsCommandFlags.cpp
   Threads.cpp
   Version.cpp
 
   ADDITIONAL_HEADER_DIRS
   ${LLD_INCLUDE_DIR}/lld/Common
 
   LINK_COMPONENTS

lld/Common/Strings.cpp

 //===- Strings.cpp -------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "Strings.h"
-#include "Config.h"
-#include "llvm/ADT/StringRef.h"
+#include "lld/Common/Strings.h"
 #include "llvm/Demangle/Demangle.h"
 
 using namespace llvm;
+using namespace lld;
 
 // Returns the demangled C++ symbol name for Name.
-Optional<std::string> lld::wasm::demangle(StringRef Name) {
+Optional<std::string> lld::demangleItanium(StringRef Name) {
   // itaniumDemangle can be used to demangle strings other than symbol
   // names which do not necessarily start with "_Z". Name can be
   // either a C or C++ symbol. Don't call itaniumDemangle if the name
   // does not look like a C++ symbol name to avoid getting unexpected
   // result for a C symbol that happens to match a mangled type name.
   if (!Name.startswith("_Z"))
     return None;
 
   char *Buf = itaniumDemangle(Name.str().c_str(), nullptr, nullptr, nullptr);
   if (!Buf)
     return None;
   std::string S(Buf);
   free(Buf);
   return S;
 }
-
-std::string lld::wasm::displayName(StringRef Name) {
-  if (Config->Demangle)
-    if (Optional<std::string> S = demangle(Name))
-      return "`" + *S + "'";
-  return Name;
-}

lld/ELF/Strings.h

public:
   explicit StringMatcher(ArrayRef<StringRef> Pat);
 
   bool match(StringRef S) const;
 
 private:
   std::vector<llvm::GlobPattern> Patterns;
 };
 
-// Returns a demangled C++ symbol name. If Name is not a mangled
-// name, it returns Optional::None.
-llvm::Optional<std::string> demangle(StringRef Name);
-
 inline ArrayRef<uint8_t> toArrayRef(StringRef S) {
   return {(const uint8_t *)S.data(), S.size()};
 }
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/Strings.cpp

 }
 
 // Returns true if S is valid as a C language identifier.
 bool elf::isValidCIdentifier(StringRef S) {
   return !S.empty() && (isAlpha(S[0]) || S[0] == '_') &&
          std::all_of(S.begin() + 1, S.end(),
                      [](char C) { return C == '_' || isAlnum(C); });
 }
-
-// Returns the demangled C++ symbol name for Name.
-Optional<std::string> elf::demangle(StringRef Name) {
-  // itaniumDemangle can be used to demangle strings other than symbol
-  // names which do not necessarily start with "_Z". Name can be
-  // either a C or C++ symbol. Don't call itaniumDemangle if the name
-  // does not look like a C++ symbol name to avoid getting unexpected
-  // result for a C symbol that happens to match a mangled type name.
-  if (!Name.startswith("_Z"))
-    return None;
-
-  char *Buf = itaniumDemangle(Name.str().c_str(), nullptr, nullptr, nullptr);
-  if (!Buf)
-    return None;
-  std::string S(Buf);
-  free(Buf);
-  return S;
-}

lld/ELF/SymbolTable.cpp

 
 #include "SymbolTable.h"
 #include "Config.h"
 #include "LinkerScript.h"
 #include "Memory.h"
 #include "Symbols.h"
 #include "SyntheticSections.h"
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Strings.h"
 #include "llvm/ADT/STLExtras.h"
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf;

 // So, if "extern C++" feature is used, we need to demangle all known
 // symbols.
 StringMap<std::vector<Symbol *>> &SymbolTable::getDemangledSyms() {
   if (!DemangledSyms) {
     DemangledSyms.emplace();
     for (Symbol *Sym : SymVector) {
       if (!Sym->isDefined())
         continue;
-      if (Optional<std::string> S = demangle(Sym->getName()))
+      if (Optional<std::string> S = demangleItanium(Sym->getName()))
         (*DemangledSyms)[*S].push_back(Sym);
       else
         (*DemangledSyms)[Sym->getName()].push_back(Sym);
     }
   }
   return *DemangledSyms;
 }
 

lld/ELF/Symbols.cpp

 //===- Symbols.cpp --------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Symbols.h"
 #include "InputFiles.h"
 #include "InputSection.h"
 #include "OutputSections.h"
-#include "Strings.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 #include "Writer.h"
 
 #include "lld/Common/ErrorHandler.h"
+#include "lld/Common/Strings.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Path.h"
 #include <cstring>
 
 using namespace llvm;
 using namespace llvm::object;
 using namespace llvm::ELF;
 
else
     S = ": definition of ";
 
   message(toString(Sym->File) + S + Sym->getName());
 }
 
 // Returns a symbol for an error message.
 std::string lld::toString(const Symbol &B) {
   if (Config->Demangle)
-    if (Optional<std::string> S = demangle(B.getName()))
+    if (Optional<std::string> S = demangleItanium(B.getName()))
       return *S;
   return B.getName();
 }

lld/include/lld/Common/Strings.h

 //===- Strings.h ------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#ifndef LLD_WASM_STRINGS_H
-#define LLD_WASM_STRINGS_H
+#ifndef LLD_STRINGS_H
+#define LLD_STRINGS_H
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 
 namespace lld {
-namespace wasm {
-
 // Returns a demangled C++ symbol name. If Name is not a mangled
 // name, it returns Optional::None.
-llvm::Optional<std::string> demangle(llvm::StringRef Name);
-
-std::string displayName(llvm::StringRef Name);
-
-} // namespace wasm
-} // namespace lld
+llvm::Optional<std::string> demangleItanium(llvm::StringRef Name);
+}
 
 #endif

lld/wasm/Strings.h

 
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
 #include <string>
 
 namespace lld {
 namespace wasm {
 
-// Returns a demangled C++ symbol name. If Name is not a mangled
-// name, it returns Optional::None.
-llvm::Optional<std::string> demangle(llvm::StringRef Name);
-
 std::string displayName(llvm::StringRef Name);
 
 } // namespace wasm
 } // namespace lld
 
 #endif

lld/wasm/Strings.cpp

 //===- Strings.cpp -------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Strings.h"
 #include "Config.h"
+#include "lld/Common/Strings.h"
 #include "llvm/ADT/StringRef.h"
-#include "llvm/Demangle/Demangle.h"
 
 using namespace llvm;
 
-// Returns the demangled C++ symbol name for Name.
-Optional<std::string> lld::wasm::demangle(StringRef Name) {
-  // itaniumDemangle can be used to demangle strings other than symbol
-  // names which do not necessarily start with "_Z". Name can be
-  // either a C or C++ symbol. Don't call itaniumDemangle if the name
-  // does not look like a C++ symbol name to avoid getting unexpected
-  // result for a C symbol that happens to match a mangled type name.
-  if (!Name.startswith("_Z"))
-    return None;
-
-  char *Buf = itaniumDemangle(Name.str().c_str(), nullptr, nullptr, nullptr);
-  if (!Buf)
-    return None;
-  std::string S(Buf);
-  free(Buf);
-  return S;
-}
-
 std::string lld::wasm::displayName(StringRef Name) {
   if (Config->Demangle)
-    if (Optional<std::string> S = demangle(Name))
+    if (Optional<std::string> S = demangleItanium(Name))
       return "`" + *S + "'";
   return Name;
 }