Simplify getLocation() function.

[ruiu]

Summary

All tests pass without the first parameter, so I guess we don't need it.

[evgeny777]

LGTM

lld/trunk/ELF/Relocations.h

 
 template <class ELFT>
 void scanRelocations(InputSectionBase<ELFT> &, const typename ELFT::Shdr &);
 
 template <class ELFT>
 void createThunks(InputSectionBase<ELFT> &, const typename ELFT::Shdr &);
 
 template <class ELFT>
-std::string getLocation(SymbolBody *Sym, InputSectionBase<ELFT> &S,
-                        typename ELFT::uint Offset);
+std::string getLocation(InputSectionBase<ELFT> &S, typename ELFT::uint Offset);
 
 template <class ELFT>
 static inline typename ELFT::uint getAddend(const typename ELFT::Rel &Rel) {
   return 0;
 }
 
 template <class ELFT>
 static inline typename ELFT::uint getAddend(const typename ELFT::Rela &Rel) {
   return Rel.r_addend;
 }
 }
 }
 
 #endif

lld/trunk/ELF/Relocations.cpp

for (SymbolBody *B : S->getFile()->getSymbols())
     if (auto *D = dyn_cast<DefinedRegular<ELFT>>(B))
       if (D->Value <= Offset && D->Value + D->Size > Offset && D->Section == S)
         return D;
 
   return nullptr;
 }
 
 template <class ELFT>
-std::string getLocation(SymbolBody *Sym, InputSectionBase<ELFT> &S,
-                        typename ELFT::uint Offset) {
+std::string getLocation(InputSectionBase<ELFT> &S, typename ELFT::uint Offset) {
   ObjectFile<ELFT> *File = S.getFile();
 
   // First check if we can get desired values from debugging information.
   std::string LineInfo = File->getLineInfo(&S, Offset);
   if (!LineInfo.empty())
     return LineInfo;
 
-  // If don't have STT_FILE typed symbol in object file then
-  // use object file name.
+  // 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 = Sym && Sym->File ? getFilename(Sym->File) : getFilename(File);
+    SrcFile = getFilename(File);
 
   // Find a symbol at a given location.
   DefinedRegular<ELFT> *Encl = getSymbolAt(&S, Offset);
   if (Encl && Encl->Type == STT_FUNC) {
     StringRef Func = getSymbolName(*File, *Encl);
     return SrcFile + " (function " + maybeDemangle(Func) + ")";
   }
 
   // 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(&Sym, S, Offset) + ": undefined symbol '" +
+  std::string Msg = getLocation(S, Offset) + ": undefined symbol '" +
                     maybeDemangle(Sym.getName()) + "'";
 
   if (Config->UnresolvedSymbols == UnresolvedPolicy::Warn)
     warn(Msg);
   else
     error(Msg);
 }
 
template void createThunks<ELF32LE>(InputSectionBase<ELF32LE> &,
                                     const ELF32LE::Shdr &);
 template void createThunks<ELF32BE>(InputSectionBase<ELF32BE> &,
                                     const ELF32BE::Shdr &);
 template void createThunks<ELF64LE>(InputSectionBase<ELF64LE> &,
                                     const ELF64LE::Shdr &);
 template void createThunks<ELF64BE>(InputSectionBase<ELF64BE> &,
                                     const ELF64BE::Shdr &);
 
-template std::string getLocation<ELF32LE>(SymbolBody *Sym,
-                                          InputSectionBase<ELF32LE> &S,
+template std::string getLocation<ELF32LE>(InputSectionBase<ELF32LE> &S,
                                           uint32_t Offset);
-template std::string getLocation<ELF32BE>(SymbolBody *Sym,
-                                          InputSectionBase<ELF32BE> &S,
+template std::string getLocation<ELF32BE>(InputSectionBase<ELF32BE> &S,
                                           uint32_t Offset);
-template std::string getLocation<ELF64LE>(SymbolBody *Sym,
-                                          InputSectionBase<ELF64LE> &S,
+template std::string getLocation<ELF64LE>(InputSectionBase<ELF64LE> &S,
                                           uint64_t Offset);
-template std::string getLocation<ELF64BE>(SymbolBody *Sym,
-                                          InputSectionBase<ELF64BE> &S,
+template std::string getLocation<ELF64BE>(InputSectionBase<ELF64BE> &S,
                                           uint64_t Offset);
 }
 }

lld/trunk/ELF/SymbolTable.cpp

static void reportDuplicate(SymbolBody *Existing,
                             InputSectionBase<ELFT> *ErrSec,
                             typename ELFT::uint ErrOffset) {
   DefinedRegular<ELFT> *D = dyn_cast<DefinedRegular<ELFT>>(Existing);
   if (!D || !D->Section || !ErrSec) {
     reportDuplicate(Existing, ErrSec ? ErrSec->getFile() : nullptr);
     return;
   }
 
-  std::string OldLoc = getLocation(Existing, *D->Section, D->Value);
-  std::string NewLoc = getLocation(nullptr, *ErrSec, ErrOffset);
+  std::string OldLoc = getLocation(*D->Section, D->Value);
+  std::string NewLoc = getLocation(*ErrSec, ErrOffset);
 
   print(NewLoc + ": duplicate symbol '" + maybeDemangle(Existing->getName()) +
         "'");
   print(OldLoc + ": previous definition was here");
 }
 
 template <typename ELFT>
 Symbol *SymbolTable<ELFT>::addRegular(StringRef Name, const Elf_Sym &Sym,