Define toString() as a generic function to get a string for error message.

[ruiu]

Summary

We have different functions to stringize objects to construct
error messages. For InputFile, we have getFilename, and for
InputSection, we have getName. You had to memorize them.

I think this is the case where the function overloading comes in handy.

This patch defines toString() functions that are overloaded for all these
types, so that you just call it in error().

[evgeny777]

Great! LGTM

lld/trunk/ELF/GdbIndex.cpp

lld::elf::readCuList(InputSection<ELFT> *DebugInfoSec) {
   typedef typename ELFT::uint uintX_t;
 
   std::unique_ptr<DWARFContext> Dwarf;
   if (Expected<std::unique_ptr<object::ObjectFile>> Obj =
           object::ObjectFile::createObjectFile(DebugInfoSec->getFile()->MB))
     Dwarf.reset(new DWARFContextInMemory(*Obj.get()));
 
   if (!Dwarf) {
-    error(getFilename(DebugInfoSec->getFile()) +
-          ": error creating DWARF context");
+    error(toString(DebugInfoSec->getFile()) + ": error creating DWARF context");
     return {};
   }
 
   std::vector<std::pair<uintX_t, uintX_t>> Ret;
   for (std::unique_ptr<DWARFCompileUnit> &CU : Dwarf->compile_units())
     Ret.push_back(
         {DebugInfoSec->OutSecOff + CU->getOffset(), CU->getLength() + 4});
   return Ret;

lld/trunk/ELF/InputFiles.h

 protected:
   InputFile(Kind K, MemoryBufferRef M) : MB(M), FileKind(K) {}
 
 private:
   const Kind FileKind;
 };
 
 // Returns "(internal)", "foo.a(bar.o)" or "baz.o".
-std::string getFilename(const InputFile *F);
+std::string toString(const InputFile *F);
 
 template <typename ELFT> class ELFFileBase : public InputFile {
 public:
   typedef typename ELFT::Shdr Elf_Shdr;
   typedef typename ELFT::Sym Elf_Sym;
   typedef typename ELFT::Word Elf_Word;
   typedef typename ELFT::SymRange Elf_Sym_Range;
 
public:
   explicit ObjectFile(MemoryBufferRef M);
   void parse(llvm::DenseSet<llvm::CachedHashStringRef> &ComdatGroups);
 
   ArrayRef<InputSectionBase<ELFT> *> getSections() const { return Sections; }
   InputSectionBase<ELFT> *getSection(const Elf_Sym &Sym) const;
 
   SymbolBody &getSymbolBody(uint32_t SymbolIndex) const {
     if (SymbolIndex >= SymbolBodies.size())
-      fatal(getFilename(this) + ": invalid symbol index");
+      fatal(toString(this) + ": invalid symbol index");
     return *SymbolBodies[SymbolIndex];
   }
 
   template <typename RelT>
   SymbolBody &getRelocTargetSym(const RelT &Rel) const {
     uint32_t SymIndex = Rel.getSymbol(Config->Mips64EL);
     return getSymbolBody(SymIndex);
   }

lld/trunk/ELF/InputFiles.cpp

std::string elf::ObjectFile<ELFT>::getLineInfo(InputSectionBase<ELFT> *S,
   Tbl->getFileLineInfoForAddress(S->Offset + Offset, nullptr, Spec.FLIKind,
                                  Info);
   if (Info.Line == 0)
     return "";
   return Info.FileName + ":" + std::to_string(Info.Line);
 }
 
 // Returns "(internal)", "foo.a(bar.o)" or "baz.o".
-std::string elf::getFilename(const InputFile *F) {
+std::string elf::toString(const InputFile *F) {
   if (!F)
     return "(internal)";
   if (!F->ArchiveName.empty())
     return (F->ArchiveName + "(" + F->getName() + ")").str();
   return F->getName();
 }
 
 template <class ELFT> static ELFKind getELFKind() {

 }
 
 template <class ELFT>
 void ELFFileBase<ELFT>::initSymtab(ArrayRef<Elf_Shdr> Sections,
                                    const Elf_Shdr *Symtab) {
   FirstNonLocal = Symtab->sh_info;
   Symbols = check(getObj().symbols(Symtab));
   if (FirstNonLocal == 0 || FirstNonLocal > Symbols.size())
-    fatal(getFilename(this) + ": invalid sh_info in symbol table");
+    fatal(toString(this) + ": invalid sh_info in symbol table");
 
   StringTable = check(getObj().getStringTableForSymtab(*Symtab, Sections));
 }
 
 template <class ELFT>
 elf::ObjectFile<ELFT>::ObjectFile(MemoryBufferRef M)
     : ELFFileBase<ELFT>(Base::ObjectKind, M) {}
 

 
 template <class ELFT>
 ArrayRef<typename elf::ObjectFile<ELFT>::Elf_Word>
 elf::ObjectFile<ELFT>::getShtGroupEntries(const Elf_Shdr &Sec) {
   const ELFFile<ELFT> &Obj = this->getObj();
   ArrayRef<Elf_Word> Entries =
       check(Obj.template getSectionContentsAsArray<Elf_Word>(&Sec));
   if (Entries.empty() || Entries[0] != GRP_COMDAT)
-    fatal(getFilename(this) + ": unsupported SHT_GROUP format");
+    fatal(toString(this) + ": unsupported SHT_GROUP format");
   return Entries.slice(1);
 }
 
 template <class ELFT>
 bool elf::ObjectFile<ELFT>::shouldMerge(const Elf_Shdr &Sec) {
   // We don't merge sections if -O0 (default is -O1). This makes sometimes
   // the linker significantly faster, although the output will be bigger.
   if (Config->Optimize == 0)
bool elf::ObjectFile<ELFT>::shouldMerge(const Elf_Shdr &Sec) {
   // sh_entsize. It says that "the member [sh_entsize] contains 0 if
   // the section does not hold a table of fixed-size entries". We know
   // that Rust 1.13 produces a string mergeable section with a zero
   // sh_entsize. Here we just accept it rather than being picky about it.
   uintX_t EntSize = Sec.sh_entsize;
   if (EntSize == 0)
     return false;
   if (Sec.sh_size % EntSize)
-    fatal(getFilename(this) +
+    fatal(toString(this) +
           ": SHF_MERGE section size must be a multiple of sh_entsize");
 
   uintX_t Flags = Sec.sh_flags;
   if (!(Flags & SHF_MERGE))
     return false;
   if (Flags & SHF_WRITE)
-    fatal(getFilename(this) + ": writable SHF_MERGE section is not supported");
+    fatal(toString(this) + ": writable SHF_MERGE section is not supported");
 
   // Don't try to merge if the alignment is larger than the sh_entsize and this
   // is not SHF_STRINGS.
   //
   // Since this is not a SHF_STRINGS, we would need to pad after every entity.
   // It would be equivalent for the producer of the .o to just set a larger
   // sh_entsize.
   if (Flags & SHF_STRINGS)
for (const Elf_Shdr &Sec : ObjSections) {
     case SHT_GROUP:
       Sections[I] = &InputSection<ELFT>::Discarded;
       if (ComdatGroups.insert(CachedHashStringRef(
                                   getShtGroupSignature(ObjSections, Sec)))
               .second)
         continue;
       for (uint32_t SecIndex : getShtGroupEntries(Sec)) {
         if (SecIndex >= Size)
-          fatal(getFilename(this) + ": invalid section index in group: " +
+          fatal(toString(this) + ": invalid section index in group: " +
                 Twine(SecIndex));
         Sections[SecIndex] = &InputSection<ELFT>::Discarded;
       }
       break;
     case SHT_SYMTAB:
       this->initSymtab(ObjSections, &Sec);
       break;
     case SHT_SYMTAB_SHNDX:
       this->SymtabSHNDX = check(Obj.getSHNDXTable(Sec, ObjSections));
       break;
     case SHT_STRTAB:
     case SHT_NULL:
       break;
     default:
       Sections[I] = createInputSection(Sec, SectionStringTable);
     }
 
     // .ARM.exidx sections have a reverse dependency on the InputSection they
     // have a SHF_LINK_ORDER dependency, this is identified by the sh_link.
     if (Sec.sh_flags & SHF_LINK_ORDER) {
       if (Sec.sh_link >= Sections.size())
-        fatal(getFilename(this) + ": invalid sh_link index: " +
+        fatal(toString(this) + ": invalid sh_link index: " +
               Twine(Sec.sh_link));
       auto *IS = cast<InputSection<ELFT>>(Sections[Sec.sh_link]);
       IS->DependentSection = Sections[I];
     }
   }
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *
 elf::ObjectFile<ELFT>::getRelocTarget(const Elf_Shdr &Sec) {
   uint32_t Idx = Sec.sh_info;
   if (Idx >= Sections.size())
-    fatal(getFilename(this) + ": invalid relocated section index: " +
-          Twine(Idx));
+    fatal(toString(this) + ": invalid relocated section index: " + Twine(Idx));
   InputSectionBase<ELFT> *Target = Sections[Idx];
 
   // Strictly speaking, a relocation section must be included in the
   // group of the section it relocates. However, LLVM 3.3 and earlier
   // would fail to do so, so we gracefully handle that case.
   if (Target == &InputSection<ELFT>::Discarded)
     return nullptr;
 
   if (!Target)
-    fatal(getFilename(this) + ": unsupported relocation reference");
+    fatal(toString(this) + ": unsupported relocation reference");
   return Target;
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *
 elf::ObjectFile<ELFT>::createInputSection(const Elf_Shdr &Sec,
                                           StringRef SectionStringTable) {
   StringRef Name =
if (Config->Relocatable)
       return make<InputSection<ELFT>>(this, &Sec, Name);
 
     // Find the relocation target section and associate this
     // section with it.
     InputSectionBase<ELFT> *Target = getRelocTarget(Sec);
     if (!Target)
       return nullptr;
     if (Target->FirstRelocation)
-      fatal(getFilename(this) +
+      fatal(toString(this) +
             ": multiple relocation sections to one section are not supported");
     if (!isa<InputSection<ELFT>>(Target) && !isa<EhInputSection<ELFT>>(Target))
-      fatal(getFilename(this) +
+      fatal(toString(this) +
             ": relocations pointing to SHF_MERGE are not supported");
 
     size_t NumRelocations;
     if (Sec.sh_type == SHT_RELA) {
       ArrayRef<Elf_Rela> Rels = check(this->getObj().relas(&Sec));
       Target->FirstRelocation = Rels.begin();
       NumRelocations = Rels.size();
       Target->AreRelocsRela = true;
for (const Elf_Sym &Sym : this->Symbols)
     SymbolBodies.push_back(createSymbolBody(&Sym));
 }
 
 template <class ELFT>
 InputSectionBase<ELFT> *
 elf::ObjectFile<ELFT>::getSection(const Elf_Sym &Sym) const {
   uint32_t Index = this->getSectionIndex(Sym);
   if (Index >= Sections.size())
-    fatal(getFilename(this) + ": invalid section index: " + Twine(Index));
+    fatal(toString(this) + ": invalid section index: " + Twine(Index));
   InputSectionBase<ELFT> *S = Sections[Index];
 
   // We found that GNU assembler 2.17.50 [FreeBSD] 2007-07-03 could
   // generate broken objects. STT_SECTION/STT_NOTYPE symbols can be
   // associated with SHT_REL[A]/SHT_SYMTAB/SHT_STRTAB sections.
   // In this case it is fine for section to be null here as we do not
   // allocate sections of these types.
   if (!S) {
     if (Index == 0 || Sym.getType() == STT_SECTION ||
         Sym.getType() == STT_NOTYPE)
       return nullptr;
-    fatal(getFilename(this) + ": invalid section index: " + Twine(Index));
+    fatal(toString(this) + ": invalid section index: " + Twine(Index));
   }
 
   if (S == &InputSection<ELFT>::Discarded)
     return S;
   return S->Repl;
 }
 
 template <class ELFT>
 SymbolBody *elf::ObjectFile<ELFT>::createSymbolBody(const Elf_Sym *Sym) {
   int Binding = Sym->getBinding();
   InputSectionBase<ELFT> *Sec = getSection(*Sym);
 
   if (Binding == STB_LOCAL) {
     if (Sym->getType() == STT_FILE)
       SourceFile = check(Sym->getName(this->StringTable));
 
     if (this->StringTable.size() <= Sym->st_name)
-      fatal(getFilename(this) + ": invalid symbol name offset");
+      fatal(toString(this) + ": invalid symbol name offset");
 
     const char *Name = this->StringTable.data() + Sym->st_name;
     if (Sym->st_shndx == SHN_UNDEF)
       return new (BAlloc) Undefined(Name, Sym->st_other, Sym->getType(), this);
     return new (BAlloc) DefinedRegular<ELFT>(Name, *Sym, Sec);
   }
 
   StringRef Name = check(Sym->getName(this->StringTable));
   uint8_t StOther = Sym->st_other;
   uint8_t Type = Sym->getType();
   uintX_t Value = Sym->st_value;
   uintX_t Size = Sym->st_size;
 
   switch (Sym->st_shndx) {
   case SHN_UNDEF:
     return elf::Symtab<ELFT>::X
         ->addUndefined(Name, Binding, StOther, Type,
                        /*CanOmitFromDynSym=*/false, this)
         ->body();
   case SHN_COMMON:
     if (Value == 0 || Value >= UINT32_MAX)
-      fatal(getFilename(this) + ": common symbol '" + Name +
+      fatal(toString(this) + ": common symbol '" + Name +
             "' has invalid alignment: " + Twine(Value));
     return elf::Symtab<ELFT>::X
         ->addCommon(Name, Size, Value, Binding, StOther, Type, this)
         ->body();
   }
 
   switch (Binding) {
   default:
-    fatal(getFilename(this) + ": unexpected binding: " + Twine(Binding));
+    fatal(toString(this) + ": unexpected binding: " + Twine(Binding));
   case STB_GLOBAL:
   case STB_WEAK:
   case STB_GNU_UNIQUE:
     if (Sec == &InputSection<ELFT>::Discarded)
       return elf::Symtab<ELFT>::X
           ->addUndefined(Name, Binding, StOther, Type,
                          /*CanOmitFromDynSym=*/false, this)
           ->body();
template <class ELFT> void SharedFile<ELFT>::parseSoName() {
   // filenames are used as default sonames.
   SoName = sys::path::filename(this->getName());
 
   if (!DynamicSec)
     return;
 
   ArrayRef<Elf_Dyn> Arr =
       check(Obj.template getSectionContentsAsArray<Elf_Dyn>(DynamicSec),
-            getFilename(this) + ": getSectionContentsAsArray failed");
+            toString(this) + ": getSectionContentsAsArray failed");
   for (const Elf_Dyn &Dyn : Arr) {
     if (Dyn.d_tag == DT_SONAME) {
       uintX_t Val = Dyn.getVal();
       if (Val >= this->StringTable.size())
-        fatal(getFilename(this) + ": invalid DT_SONAME entry");
+        fatal(toString(this) + ": invalid DT_SONAME entry");
       SoName = StringRef(this->StringTable.data() + Val);
       return;
     }
   }
 }
 
 // Parse the version definitions in the object file if present. Returns a vector
 // whose nth element contains a pointer to the Elf_Verdef for version identifier

lld/trunk/ELF/InputSection.h

private:
   template <class RelTy>
   void copyRelocations(uint8_t *Buf, llvm::ArrayRef<RelTy> Rels);
 
   llvm::TinyPtrVector<const Thunk<ELFT> *> Thunks;
 };
 
 template <class ELFT> InputSection<ELFT> InputSection<ELFT>::Discarded;
 
+template <class ELFT> std::string toString(const InputSectionBase<ELFT> *);
+
 } // namespace elf
 } // namespace lld
 
 #endif

lld/trunk/ELF/InputSection.cpp

 using namespace llvm::ELF;
 using namespace llvm::object;
 using namespace llvm::support;
 using namespace llvm::support::endian;
 
 using namespace lld;
 using namespace lld::elf;
 
+// Returns a string to construct an error message.
+template <class ELFT>
+std::string elf::toString(const InputSectionBase<ELFT> *Sec) {
+  return (Sec->getFile()->getName() + ":(" + Sec->Name + ")").str();
+}
+
 template <class ELFT>
 static ArrayRef<uint8_t> getSectionContents(elf::ObjectFile<ELFT> *File,
                                             const typename ELFT::Shdr *Hdr) {
   if (!File || Hdr->sh_type == SHT_NOBITS)
     return makeArrayRef<uint8_t>(nullptr, Hdr->sh_size);
   return check(File->getObj().getSectionContents(Hdr));
 }
 
: InputSectionData(SectionKind, Name, Data, isCompressed<ELFT>(Flags, Name),
       Info(Info), Repl(this) {
   NumRelocations = 0;
   AreRelocsRela = false;
 
   // The ELF spec states that a value of 0 means the section has
   // no alignment constraits.
   uint64_t V = std::max<uint64_t>(Addralign, 1);
   if (!isPowerOf2_64(V))
-    fatal(getFilename(File) + ": section sh_addralign is not a power of 2");
+    fatal(toString(File) + ": section sh_addralign is not a power of 2");
 
   // We reject object files having insanely large alignments even though
   // they are allowed by the spec. I think 4GB is a reasonable limitation.
   // We might want to relax this in the future.
   if (V > UINT32_MAX)
-    fatal(getFilename(File) + ": section sh_addralign is too large");
+    fatal(toString(File) + ": section sh_addralign is too large");
   Alignment = V;
 }
 
 template <class ELFT>
 InputSectionBase<ELFT>::InputSectionBase(elf::ObjectFile<ELFT> *File,
                                          const Elf_Shdr *Hdr, StringRef Name,
                                          Kind SectionKind)
     : InputSectionBase(File, Hdr->sh_flags, Hdr->sh_type, Hdr->sh_entsize,

 }
 
 // Returns compressed data and its size when uncompressed.
 template <class ELFT>
 std::pair<ArrayRef<uint8_t>, uint64_t>
 InputSectionBase<ELFT>::getElfCompressedData(ArrayRef<uint8_t> Data) {
   // Compressed section with Elf_Chdr is the ELF standard.
   if (Data.size() < sizeof(Elf_Chdr))
-    fatal(getName(this) + ": corrupted compressed section");
+    fatal(toString(this) + ": corrupted compressed section");
   auto *Hdr = reinterpret_cast<const Elf_Chdr *>(Data.data());
   if (Hdr->ch_type != ELFCOMPRESS_ZLIB)
-    fatal(getName(this) + ": unsupported compression type");
+    fatal(toString(this) + ": unsupported compression type");
   return {Data.slice(sizeof(*Hdr)), Hdr->ch_size};
 }
 
 // Returns compressed data and its size when uncompressed.
 template <class ELFT>
 std::pair<ArrayRef<uint8_t>, uint64_t>
 InputSectionBase<ELFT>::getRawCompressedData(ArrayRef<uint8_t> Data) {
   // Compressed sections without Elf_Chdr header contain this header
   // instead. This is a GNU extension.
   struct ZlibHeader {
     char Magic[4]; // Should be "ZLIB"
     char Size[8];  // Uncompressed size in big-endian
   };
 
   if (Data.size() < sizeof(ZlibHeader))
-    fatal(getName(this) + ": corrupted compressed section");
+    fatal(toString(this) + ": corrupted compressed section");
   auto *Hdr = reinterpret_cast<const ZlibHeader *>(Data.data());
   if (memcmp(Hdr->Magic, "ZLIB", 4))
-    fatal(getName(this) + ": broken ZLIB-compressed section");
+    fatal(toString(this) + ": broken ZLIB-compressed section");
   return {Data.slice(sizeof(*Hdr)), read64be(Hdr->Size)};
 }
 
 template <class ELFT> void InputSectionBase<ELFT>::uncompress() {
   if (!zlib::isAvailable())
-    fatal(getName(this) +
+    fatal(toString(this) +
           ": build lld with zlib to enable compressed sections support");
 
   // This section is compressed. Here we decompress it. Ideally, all
   // compressed sections have SHF_COMPRESSED bit and their contents
   // start with headers of Elf_Chdr type. However, sections whose
   // names start with ".zdebug_" don't have the bit and contains a raw
   // ZLIB-compressed data (which is a bad thing because section names
   // shouldn't be significant in ELF.) We need to be able to read both.
   ArrayRef<uint8_t> Buf; // Compressed data
   size_t Size;           // Uncompressed size
   if (Flags & SHF_COMPRESSED)
     std::tie(Buf, Size) = getElfCompressedData(Data);
   else
     std::tie(Buf, Size) = getRawCompressedData(Data);
 
   // Uncompress Buf.
   char *OutputBuf = BAlloc.Allocate<char>(Size);
   if (zlib::uncompress(toStringRef(Buf), OutputBuf, Size) != zlib::StatusOK)
-    fatal(getName(this) + ": error while uncompressing section");
+    fatal(toString(this) + ": error while uncompressing section");
   Data = ArrayRef<uint8_t>((uint8_t *)OutputBuf, Size);
 }
 
 template <class ELFT>
 typename ELFT::uint
 InputSectionBase<ELFT>::getOffset(const DefinedRegular<ELFT> &Sym) const {
   return getOffset(Sym.Value);
 }

 std::vector<SectionPiece>
 MergeInputSection<ELFT>::splitStrings(ArrayRef<uint8_t> Data, size_t EntSize) {
   std::vector<SectionPiece> V;
   size_t Off = 0;
   bool IsAlloca = this->Flags & SHF_ALLOC;
   while (!Data.empty()) {
     size_t End = findNull(Data, EntSize);
     if (End == StringRef::npos)
-      fatal(getName(this) + ": string is not null terminated");
+      fatal(toString(this) + ": string is not null terminated");
     size_t Size = End + EntSize;
     V.emplace_back(Off, !IsAlloca);
     Hashes.push_back(hash_value(toStringRef(Data.slice(0, Size))));
     Data = Data.slice(Size);
     Off += Size;
   }
   return V;
 }
static It fastUpperBound(It First, It Last, const T &Value, Compare Comp) {
   return Comp(Value, *First) ? First : First + 1;
 }
 
 template <class ELFT>
 const SectionPiece *
 MergeInputSection<ELFT>::getSectionPiece(uintX_t Offset) const {
   uintX_t Size = this->Data.size();
   if (Offset >= Size)
-    fatal(getName(this) + ": entry is past the end of the section");
+    fatal(toString(this) + ": entry is past the end of the section");
 
   // Find the element this offset points to.
   auto I = fastUpperBound(
       Pieces.begin(), Pieces.end(), Offset,
       [](const uintX_t &A, const SectionPiece &B) { return A < B.InputOff; });
   --I;
   return &*I;
 }

lld/trunk/ELF/Relocations.cpp

for (const RelTy *RI = Rel; RI != End; ++RI) {
     if (RI->getType(Config->Mips64EL) != Type)
       continue;
     if (RI->getSymbol(Config->Mips64EL) != SymIndex)
       continue;
     const endianness E = ELFT::TargetEndianness;
     return ((read32<E>(BufLoc) & 0xffff) << 16) +
            readSignedLo16<E>(Buf + RI->r_offset);
   }
-  warn("can't find matching " + getRelName(Type) + " relocation for " +
-       getRelName(Rel->getType(Config->Mips64EL)));
+  warn("can't find matching " + toString(Type) + " relocation for " +
+       toString(Rel->getType(Config->Mips64EL)));
   return 0;
 }
 
 // True if non-preemptable symbol always has the same value regardless of where
 // the DSO is loaded.
 template <class ELFT> static bool isAbsolute(const SymbolBody &Body) {
   if (Body.isUndefined())
     return !Body.isLocal() && Body.symbol()->isWeak();
static bool isStaticLinkTimeConstant(RelExpr E, uint32_t Type,
   // Relative relocation to an absolute value. This is normally unrepresentable,
   // but if the relocation refers to a weak undefined symbol, we allow it to
   // resolve to the image base. This is a little strange, but it allows us to
   // link function calls to such symbols. Normally such a call will be guarded
   // with a comparison, which will load a zero from the GOT.
   if (AbsVal && RelE) {
     if (Body.isUndefined() && !Body.isLocal() && Body.symbol()->isWeak())
       return true;
-    error(getLocation(S, RelOff) + ": relocation " + getRelName(Type) +
+    error(getLocation(S, RelOff) + ": relocation " + toString(Type) +
           " cannot refer to absolute symbol '" + Body.getName() +
-          "' defined in " + getFilename(Body.File));
+          "' defined in " + toString(Body.File));
     return true;
   }
 
   return Target->usesOnlyLowPageBits(Type);
 }
 
 static RelExpr toPlt(RelExpr Expr) {
   if (Expr == R_PPC_OPD)
if (IsWrite || isStaticLinkTimeConstant<ELFT>(Expr, Type, Body, S, RelOff))
     return Expr;
 
   // This relocation would require the dynamic linker to write a value to read
   // only memory. We can hack around it if we are producing an executable and
   // the refered symbol can be preemepted to refer to the executable.
   if (Config->Shared || (Config->Pic && !isRelExpr(Expr))) {
     StringRef Name = Body.getName();
     error(getLocation(S, RelOff) + ": can't create dynamic relocation " +
-          getRelName(Type) + " against " +
+          toString(Type) + " against " +
           ((Name.empty() ? "local symbol in readonly segment"
                          : "symbol '" + Name + "'")) +
-          " defined in " + getFilename(Body.File));
+          " defined in " + toString(Body.File));
     return Expr;
   }
   if (Body.getVisibility() != STV_DEFAULT) {
     error(getLocation(S, RelOff) + ": cannot preempt symbol '" +
-          Body.getName() + "' defined in " + getFilename(Body.File));
+          Body.getName() + "' defined in " + toString(Body.File));
     return Expr;
   }
   if (Body.isObject()) {
     // Produce a copy relocation.
     auto *B = cast<SharedSymbol<ELFT>>(&Body);
     if (!B->needsCopy())
       addCopyRelSymbol(B);
     return Expr;
if (Body.isFunc()) {
     // the value of the symbol we created. This is true even for got entries, so
     // pointer equality is maintained. To avoid an infinite loop, the only entry
     // that points to the real function is a dedicated got entry used by the
     // plt. That is identified by special relocation types (R_X86_64_JUMP_SLOT,
     // R_386_JMP_SLOT, etc).
     Body.NeedsCopyOrPltAddr = true;
     return toPlt(Expr);
   }
-  error("symbol '" + Body.getName() + "' defined in " + getFilename(Body.File) +
+  error("symbol '" + Body.getName() + "' defined in " + toString(Body.File) +
         " is missing type");
 
   return Expr;
 }
 
 template <class ELFT, class RelTy>
 static typename ELFT::uint computeAddend(const elf::ObjectFile<ELFT> &File,
                                          const uint8_t *SectionData,
std::string getLocation(InputSectionBase<ELFT> &S, typename ELFT::uint Offset) {
   if (!LineInfo.empty())
     return LineInfo;
 
   // File->SourceFile contains STT_FILE symbol contents which is a
   // filename. Compilers usually create STT_FILE symbols. If it's
   // missing, we use an actual filename.
   std::string SrcFile = File->SourceFile;
   if (SrcFile.empty())
-    SrcFile = getFilename(File);
+    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()) + ")";
 
   // If there's no symbol, print out the offset instead of a symbol name.
   return (SrcFile + ":(" + S.Name + "+0x" + Twine::utohexstr(Offset) + ")")

lld/trunk/ELF/SymbolTable.cpp

template <class ELFT> void SymbolTable<ELFT>::addFile(InputFile *File) {
 
   // Lazy object file
   if (auto *F = dyn_cast<LazyObjectFile>(File)) {
     F->parse<ELFT>();
     return;
   }
 
   if (Config->Trace)
-    outs() << getFilename(File) << "\n";
+    outs() << toString(File) << "\n";
 
   // .so file
   if (auto *F = dyn_cast<SharedFile<ELFT>>(File)) {
     // DSOs are uniquified not by filename but by soname.
     F->parseSoName();
     if (HasError || !SoNames.insert(F->getSoName()).second)
       return;
     SharedFiles.push_back(F);
std::pair<Symbol *, bool> SymbolTable<ELFT>::insert(StringRef Name) {
   }
   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 " +
-         getFilename(Existing->File) + " and " + getFilename(NewFile);
+         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) {

lld/trunk/ELF/Symbols.cpp

case SymbolBody::DefinedRegularKind: {
     uintX_t Offset = D.Value;
     if (D.isSection()) {
       Offset += Addend;
       Addend = 0;
     }
     uintX_t VA = (SC->OutSec ? SC->OutSec->Addr : 0) + SC->getOffset(Offset);
     if (D.isTls() && !Config->Relocatable) {
       if (!Out<ELFT>::TlsPhdr)
-        fatal(getFilename(D.File) +
+        fatal(toString(D.File) +
               " has a STT_TLS symbol but doesn't have a PT_TLS section");
       return VA - Out<ELFT>::TlsPhdr->p_vaddr;
     }
     return VA;
   }
   case SymbolBody::DefinedCommonKind:
     return In<ELFT>::Common->OutSec->Addr + In<ELFT>::Common->OutSecOff +
            cast<DefinedCommon>(Body).Offset;
if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
     return false;
   return (ExportDynamic && VersionId != VER_NDX_LOCAL) || body()->isShared() ||
          (body()->isUndefined() && Config->Shared);
 }
 
 // Print out a log message for --trace-symbol.
 void elf::printTraceSymbol(Symbol *Sym) {
   SymbolBody *B = Sym->body();
-  outs() << getFilename(B->File);
+  outs() << toString(B->File);
 
   if (B->isUndefined())
     outs() << ": reference to ";
   else if (B->isCommon())
     outs() << ": common definition of ";
   else
     outs() << ": definition of ";
   outs() << B->getName() << "\n";

lld/trunk/ELF/SyntheticSections.cpp

MipsAbiFlagsSection<ELFT> *MipsAbiFlagsSection<ELFT>::create() {
   bool Create = false;
 
   for (InputSectionBase<ELFT> *Sec : Symtab<ELFT>::X->Sections) {
     if (!Sec->Live || Sec->Type != SHT_MIPS_ABIFLAGS)
       continue;
     Sec->Live = false;
     Create = true;
 
-    std::string Filename = getFilename(Sec->getFile());
+    std::string Filename = toString(Sec->getFile());
     if (Sec->Data.size() != sizeof(Elf_Mips_ABIFlags)) {
       error(Filename + ": invalid size of .MIPS.abiflags section");
       return nullptr;
     }
     auto *S = reinterpret_cast<const Elf_Mips_ABIFlags *>(Sec->Data.data());
     if (S->version != 0) {
       error(Filename + ": unexpected .MIPS.abiflags version " +
             Twine(S->version));
MipsOptionsSection<ELFT> *MipsOptionsSection<ELFT>::create() {
   bool Create = false;
 
   for (InputSectionBase<ELFT> *Sec : Symtab<ELFT>::X->Sections) {
     if (!Sec->Live || Sec->Type != SHT_MIPS_OPTIONS)
       continue;
     Sec->Live = false;
     Create = true;
 
-    std::string Filename = getFilename(Sec->getFile());
+    std::string Filename = toString(Sec->getFile());
     ArrayRef<uint8_t> D = Sec->Data;
 
     while (!D.empty()) {
       if (D.size() < sizeof(Elf_Mips_Options)) {
         error(Filename + ": invalid size of .MIPS.options section");
         break;
       }
 
MipsReginfoSection<ELFT> *MipsReginfoSection<ELFT>::create() {
 
   for (InputSectionBase<ELFT> *Sec : Symtab<ELFT>::X->Sections) {
     if (!Sec->Live || Sec->Type != SHT_MIPS_REGINFO)
       continue;
     Sec->Live = false;
     Create = true;
 
     if (Sec->Data.size() != sizeof(Elf_Mips_RegInfo)) {
-      error(getFilename(Sec->getFile()) + ": invalid size of .reginfo section");
+      error(toString(Sec->getFile()) + ": invalid size of .reginfo section");
       return nullptr;
     }
     auto *R = reinterpret_cast<const Elf_Mips_RegInfo *>(Sec->Data.data());
     if (Config->Relocatable && R->ri_gp_value)
-      error(getFilename(Sec->getFile()) + ": unsupported non-zero ri_gp_value");
+      error(toString(Sec->getFile()) + ": unsupported non-zero ri_gp_value");
 
     Reginfo.ri_gprmask |= R->ri_gprmask;
     Sec->getFile()->MipsGp0 = R->ri_gp_value;
   };
 
   if (Create)
     return make<MipsReginfoSection<ELFT>>(Reginfo);
   return nullptr;

lld/trunk/ELF/Target.h

virtual RelExpr adjustRelaxExpr(uint32_t Type, const uint8_t *Data,
                                   RelExpr Expr) const;
   virtual void relaxGot(uint8_t *Loc, uint64_t Val) const;
   virtual void relaxTlsGdToIe(uint8_t *Loc, uint32_t Type, uint64_t Val) const;
   virtual void relaxTlsGdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const;
   virtual void relaxTlsIeToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const;
   virtual void relaxTlsLdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const;
 };
 
-StringRef getRelName(uint32_t Type);
+std::string toString(uint32_t RelType);
 uint64_t getPPC64TocBase();
 
 const unsigned MipsGPOffset = 0x7ff0;
 
 extern TargetInfo *Target;
 TargetInfo *createTarget();
 }
 }
 
 #endif

lld/trunk/ELF/Target.cpp

 namespace lld {
 namespace elf {
 
 TargetInfo *Target;
 
 static void or32le(uint8_t *P, int32_t V) { write32le(P, read32le(P) | V); }
 static void or32be(uint8_t *P, int32_t V) { write32be(P, read32be(P) | V); }
 
-StringRef getRelName(uint32_t Type) {
+std::string toString(uint32_t Type) {
   return getELFRelocationTypeName(Config->EMachine, Type);
 }
 
 template <unsigned N> static void checkInt(int64_t V, uint32_t Type) {
   if (!isInt<N>(V))
-    error("relocation " + getRelName(Type) + " out of range");
+    error("relocation " + toString(Type) + " out of range");
 }
 
 template <unsigned N> static void checkUInt(uint64_t V, uint32_t Type) {
   if (!isUInt<N>(V))
-    error("relocation " + getRelName(Type) + " out of range");
+    error("relocation " + toString(Type) + " out of range");
 }
 
 template <unsigned N> static void checkIntUInt(uint64_t V, uint32_t Type) {
   if (!isInt<N>(V) && !isUInt<N>(V))
-    error("relocation " + getRelName(Type) + " out of range");
+    error("relocation " + toString(Type) + " out of range");
 }
 
 template <unsigned N> static void checkAlignment(uint64_t V, uint32_t Type) {
   if ((V & (N - 1)) != 0)
-    error("improper alignment for relocation " + getRelName(Type));
+    error("improper alignment for relocation " + toString(Type));
 }
 
 static void errorDynRel(uint32_t Type) {
-  error("relocation " + getRelName(Type) +
+  error("relocation " + toString(Type) +
         " cannot be used against shared object; recompile with -fPIC.");
 }
 
 namespace {
 class X86TargetInfo final : public TargetInfo {
 public:
   X86TargetInfo();
   RelExpr getRelExpr(uint32_t Type, const SymbolBody &S) const override;

lld/trunk/ELF/Writer.cpp

 // Local symbols are not in the linker's symbol table. This function scans
 // each object file's symbol table to copy local symbols to the output.
 template <class ELFT> void Writer<ELFT>::copyLocalSymbols() {
   if (!In<ELFT>::SymTab)
     return;
   for (elf::ObjectFile<ELFT> *F : Symtab<ELFT>::X->getObjectFiles()) {
     for (SymbolBody *B : F->getLocalSymbols()) {
       if (!B->IsLocal)
-        fatal(getFilename(F) +
+        fatal(toString(F) +
               ": broken object: getLocalSymbols returns a non-local symbol");
       auto *DR = dyn_cast<DefinedRegular<ELFT>>(B);
+
       // No reason to keep local undefined symbol in symtab.
       if (!DR)
         continue;
       if (!includeInSymtab<ELFT>(*B))
         continue;
+
       InputSectionBase<ELFT> *Sec = DR->Section;
       if (!shouldKeepInSymtab<ELFT>(Sec, B->getName(), *B))
         continue;
       ++In<ELFT>::SymTab->NumLocals;
       if (Config->Relocatable)
         B->DynsymIndex = In<ELFT>::SymTab->NumLocals;
       F->KeptLocalSyms.push_back(std::make_pair(
           DR, In<ELFT>::SymTab->StrTabSec.addString(B->getName())));