Use debug info to print out the first line of symbol conflict message.

[ruiu]

Summary

If there is a symbol conflict, we will print out an error message like this.

foo.o (.text+0x100): duplicate symbol 'foobar'
bar.o (.text+0x250): previous definition was here

We pass three arguments to reportDuplciate function, namely, the existing
symbol, the new conflicting symbol's section, and the offset of the new symbol.
If the existing is not a regular symbol, we fall back to a less user-friendly
message.

I found that we don't need the existing symbol to print out the first line of
the error message, so that error check was too strict. This patch simplifies
the function and relaxed the restriction.

[evgeny777]

ELF/SymbolTable.cpp

391

ErrSec may be nullptr, if we're adding absolute symbol

394

If Existing is not DefinedRegular but isn't nullptr either, we may still try to use Existing->File to report previously seen location. This isn't covered by initial patch, I think, but would be nice to have.

ELF/SymbolTable.cpp

 
 static void print(const Twine &Msg) {
   if (Config->AllowMultipleDefinition)
     warn(Msg);
   else
     error(Msg);
 }
 
-static void reportDuplicate(SymbolBody *Existing, InputFile *NewFile) {
+static void reportConflict(SymbolBody *Existing, InputFile *NewFile) {
   print("duplicate symbol " + conflictMsg(Existing, NewFile));
 }
 
+// Print out an error message, e.g.
+//
+//   foo.o (.text+0x100): duplicate symbol 'foobar'
+//   bar.o (.text+0x250): previous definition was here
+//
+// Unlike non-regular symbols, we may be able to use DWARF debug info to
+// get the precise error location to print out a user-friendly error message.
+// So, we have a separate function for regular symbols created from ELF.
 template <class ELFT>
-static void reportDuplicate(SymbolBody *Existing,
+static void reportConflictRegular(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(*D->Section, D->Value);
-  std::string NewLoc = getLocation(*ErrSec, ErrOffset);
+  print(getLocation(*ErrSec, ErrOffset) + ": duplicate symbol '" +
+        maybeDemangle(Existing->getName()) + "'");
 
-  print(NewLoc + ": duplicate symbol '" + maybeDemangle(Existing->getName()) +
-        "'");
-  print(OldLoc + ": previous definition was here");
+  if (auto *D = dyn_cast<DefinedRegular<ELFT>>(Existing))
+    if (D->Section)
+      print(getLocation(*D->Section, D->Value) +
+            ": previous definition was here");
 }
 
 template <typename ELFT>
 Symbol *SymbolTable<ELFT>::addRegular(StringRef Name, const Elf_Sym &Sym,
                                       InputSectionBase<ELFT> *Section) {
   return addRegular(Name, Sym.st_other, Sym.getType(), Sym.st_value,
                     Sym.st_size, Sym.getBinding(), Section);
 }
 
 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) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(Name, Type, StOther & 3,
                                     /*CanOmitFromDynSym*/ false,
                                     Section ? Section->getFile() : nullptr);
   int Cmp = compareDefinedNonCommon(S, WasInserted, Binding);
   if (Cmp > 0)
     replaceBody<DefinedRegular<ELFT>>(S, Name, StOther, Type, Value, Size,
                                       Section);
   else if (Cmp == 0)
-    reportDuplicate(S->body(), Section, Value);
+    reportConflictRegular(S->body(), Section, Value);
   return S;
 }
 
 template <typename ELFT>
 Symbol *SymbolTable<ELFT>::addRegular(StringRef Name, uint8_t StOther,
                                       InputSectionBase<ELFT> *Section,
                                       uint8_t Binding, uint8_t Type,
                                       uintX_t Value) {
   return addRegular(Name, StOther, Type, Value, 0, Binding, Section);
 }
 
 template <typename ELFT>
 Symbol *SymbolTable<ELFT>::addSynthetic(StringRef N,
                                         OutputSectionBase<ELFT> *Section,
                                         uintX_t Value, uint8_t StOther) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(N, STT_NOTYPE, /*Visibility*/ StOther & 0x3,
                                     /*CanOmitFromDynSym*/ false, nullptr);
   int Cmp = compareDefinedNonCommon(S, WasInserted, STB_GLOBAL);
   if (Cmp > 0)
     replaceBody<DefinedSynthetic<ELFT>>(S, N, Value, Section);
   else if (Cmp == 0)
-    reportDuplicate(S->body(), nullptr);
+    reportConflict(S->body(), nullptr);
   return S;
 }
 
 template <typename ELFT>
 void SymbolTable<ELFT>::addShared(SharedFile<ELFT> *F, StringRef Name,
                                   const Elf_Sym &Sym,
                                   const typename ELFT::Verdef *Verdef) {
   // DSO symbols do not affect visibility in the output, so we pass STV_DEFAULT
Symbol *SymbolTable<ELFT>::addBitcode(StringRef Name, uint8_t Binding,
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) =
       insert(Name, Type, StOther & 3, CanOmitFromDynSym, F);
   int Cmp = compareDefinedNonCommon(S, WasInserted, Binding);
   if (Cmp > 0)
     replaceBody<DefinedRegular<ELFT>>(S, Name, StOther, Type, F);
   else if (Cmp == 0)
-    reportDuplicate(S->body(), F);
+    reportConflict(S->body(), F);
   return S;
 }
 
 template <class ELFT> SymbolBody *SymbolTable<ELFT>::find(StringRef Name) {
   auto It = Symtab.find(CachedHashStringRef(Name));
   if (It == Symtab.end())
     return nullptr;
   SymIndex V = It->second;