Define toString(SymbolBody *) and remove maybeDemangle insteead.

[ruiu]

Summary

Define toString(SymbolBody *) and remove maybeDemangle insteead.

[• rafael]

LGTM with a nit.

ELF/Symbols.h

452

Can it take a const reference instead of a pointer?

ELF/Relocations.cpp

std::string getLocation(InputSectionBase<ELFT> &S, typename ELFT::uint Offset) {
   // missing, we use an actual filename.
   std::string SrcFile = File->SourceFile;
   if (SrcFile.empty())
     SrcFile = toString(File);
 
   // Find a symbol at a given location.
   DefinedRegular<ELFT> *Encl = getSymbolAt(&S, Offset);
   if (Encl && Encl->Type == STT_FUNC)
-    return SrcFile + ":(function " + maybeDemangle(Encl->getName()) + ")";
+    return SrcFile + ":(function " + toString(Encl) + ")";
 
   // If there's no symbol, print out the offset instead of a symbol name.
   return (SrcFile + ":(" + S.Name + "+0x" + Twine::utohexstr(Offset) + ")")
       .str();
 }
 
 template <class ELFT>
 static void reportUndefined(SymbolBody &Sym, InputSectionBase<ELFT> &S,
                             typename ELFT::uint Offset) {
   if (Config->UnresolvedSymbols == UnresolvedPolicy::Ignore)
     return;
 
   if (Config->Shared && Sym.symbol()->Visibility == STV_DEFAULT &&
       Config->UnresolvedSymbols != UnresolvedPolicy::NoUndef)
     return;
 
-  std::string Msg = getLocation(S, Offset) + ": undefined symbol '" +
-                    maybeDemangle(Sym.getName()) + "'";
+  std::string Msg =
+      getLocation(S, Offset) + ": undefined symbol '" + toString(&Sym) + "'";
 
   if (Config->UnresolvedSymbols == UnresolvedPolicy::Warn)
     warn(Msg);
   else
     error(Msg);
 }
 
 template <class RelTy>

ELF/Strings.h

private:
   std::vector<GlobPattern> Patterns;
 };
 
 // Returns a demangled C++ symbol name. If Name is not a mangled
 // name or the system does not provide __cxa_demangle function,
 // it returns an unmodified string.
 std::string demangle(StringRef Name);
 
-// Demangle if Config->Demangle is true.
-std::string maybeDemangle(StringRef Name);
-
 inline StringRef toStringRef(ArrayRef<uint8_t> Arr) {
   return {(const char *)Arr.data(), Arr.size()};
 }
 }
 }
 
 #endif

ELF/Strings.cpp

std::string elf::demangle(StringRef Name) {
 
   char *Buf = itaniumDemangle(Name.str().c_str(), nullptr, nullptr, nullptr);
   if (!Buf)
     return Name;
   std::string S(Buf);
   free(Buf);
   return S;
 }
-
-std::string elf::maybeDemangle(StringRef Name) {
-  if (Config->Demangle)
-    return demangle(Name);
-  return Name;
-}

ELF/SymbolTable.cpp

if (IsNew) {
     Sym = SymVector[V.Idx];
   }
   return {Sym, IsNew};
 }
 
 // Construct a string in the form of "Sym in File1 and File2".
 // Used to construct an error message.
 static std::string conflictMsg(SymbolBody *Existing, InputFile *NewFile) {
-  return "'" + maybeDemangle(Existing->getName()) + "' in " +
-         toString(Existing->File) + " and " + toString(NewFile);
+  return "'" + toString(Existing) + "' in " + toString(Existing->File) +
+         " and " + toString(NewFile);
 }
 
 // Find an existing symbol or create and insert a new one, then apply the given
 // attributes.
 template <class ELFT>
 std::pair<Symbol *, bool>
 SymbolTable<ELFT>::insert(StringRef Name, uint8_t Type, uint8_t Visibility,
                           bool CanOmitFromDynSym, InputFile *File) {
static void reportDuplicate(SymbolBody *Existing,
   if (!D || !D->Section || !ErrSec) {
     reportDuplicate(Existing, ErrSec ? ErrSec->getFile() : nullptr);
     return;
   }
 
   std::string OldLoc = getLocation(*D->Section, D->Value);
   std::string NewLoc = getLocation(*ErrSec, ErrOffset);
 
-  print(NewLoc + ": duplicate symbol '" + maybeDemangle(Existing->getName()) +
-        "'");
+  print(NewLoc + ": duplicate symbol '" + toString(Existing) + "'");
   print(OldLoc + ": previous definition was here");
 }
 
 template <typename ELFT>
 Symbol *SymbolTable<ELFT>::addRegular(StringRef Name, uint8_t StOther,
                                       uint8_t Type, uintX_t Value, uintX_t Size,
                                       uint8_t Binding,
                                       InputSectionBase<ELFT> *Section,

ELF/Symbols.h

 }
 
 inline Symbol *SymbolBody::symbol() {
   assert(!isLocal());
   return reinterpret_cast<Symbol *>(reinterpret_cast<char *>(this) -
                                     offsetof(Symbol, Body));
 }
 
+std::string toString(SymbolBody *B);
+
 } // namespace elf
 } // namespace lld
 
 #endif

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 "Error.h"
 #include "InputFiles.h"
 #include "InputSection.h"
 #include "OutputSections.h"
+#include "Strings.h"
 #include "SyntheticSections.h"
 #include "Target.h"
 
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Path.h"
 #include <cstring>
 
 using namespace llvm;
if (B->isUndefined())
     outs() << ": reference to ";
   else if (B->isCommon())
     outs() << ": common definition of ";
   else
     outs() << ": definition of ";
   outs() << B->getName() << "\n";
 }
 
+// Returns a symbol for an error message.
+std::string elf::toString(SymbolBody *B) {
+  if (Config->Demangle)
+    return demangle(B->getName());
+  return B->getName();
+}
+
 template bool SymbolBody::hasThunk<ELF32LE>() const;
 template bool SymbolBody::hasThunk<ELF32BE>() const;
 template bool SymbolBody::hasThunk<ELF64LE>() const;
 template bool SymbolBody::hasThunk<ELF64BE>() const;
 
 template uint32_t SymbolBody::template getVA<ELF32LE>(uint32_t) const;
 template uint32_t SymbolBody::template getVA<ELF32BE>(uint32_t) const;
 template uint64_t SymbolBody::template getVA<ELF64LE>(uint64_t) const;