[lld] COFF: Implement SymbolBody::getDebugName() for DefinedBitcode symbols.

[ruiu]

LGTM

lld/trunk/COFF/InputFiles.cpp

for (unsigned I = 0, E = M->getSymbolCount(); I != E; ++I) {
 
     StringRef SymName = Saver.save(M->getSymbolName(I));
     int SymbolDef = Attrs & LTO_SYMBOL_DEFINITION_MASK;
     if (SymbolDef == LTO_SYMBOL_DEFINITION_UNDEFINED) {
       SymbolBodies.push_back(new (Alloc) Undefined(SymName));
     } else {
       bool Replaceable = (SymbolDef == LTO_SYMBOL_DEFINITION_TENTATIVE ||
                           (Attrs & LTO_SYMBOL_COMDAT));
-      SymbolBodies.push_back(new (Alloc) DefinedBitcode(SymName, Replaceable));
+      SymbolBodies.push_back(new (Alloc) DefinedBitcode(this, SymName,
+                                                        Replaceable));
     }
   }
 
   Directives = M->getLinkerOpts();
   return std::error_code();
 }
 
 } // namespace coff
 } // namespace lld

lld/trunk/COFF/Symbols.h

 namespace coff {
 
 using llvm::object::Archive;
 using llvm::object::COFFSymbolRef;
 using llvm::object::coff_import_header;
 using llvm::object::coff_symbol_generic;
 
 class ArchiveFile;
+class BitcodeFile;
 class InputFile;
 class ObjectFile;
 class SymbolBody;
 
 // A real symbol object, SymbolBody, is usually accessed indirectly
 // through a Symbol. There's always one Symbol for each symbol name.
 // The resolver updates SymbolBody pointers as it resolves symbols.
 struct Symbol {
public:
 
   Chunk *getChunk() { return &Data; }
 
 private:
   LocalImportChunk Data;
 };
 
 class DefinedBitcode : public Defined {
+  friend SymbolBody;
 public:
-  DefinedBitcode(StringRef N, bool IsReplaceable)
-      : Defined(DefinedBitcodeKind, N) {
+  DefinedBitcode(BitcodeFile *F, StringRef N, bool IsReplaceable)
+      : Defined(DefinedBitcodeKind, N), File(F) {
     this->IsReplaceable = IsReplaceable;
   }
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == DefinedBitcodeKind;
   }
+
+private:
+  BitcodeFile *File;
 };
 
 } // namespace coff
 } // namespace lld
 
 #endif

lld/trunk/COFF/Symbols.cpp

int SymbolBody::compare(SymbolBody *Other) {
   llvm_unreachable("unknown symbol kind");
 }
 
 std::string SymbolBody::getDebugName() {
   std::string N = getName().str();
   if (auto *D = dyn_cast<DefinedCOFF>(this)) {
     N += " ";
     N += D->File->getShortName();
+  } else if (auto *D = dyn_cast<DefinedBitcode>(this)) {
+    N += " ";
+    N += D->File->getShortName();
   }
   return N;
 }
 
 uint64_t Defined::getRVA() {
   switch (kind()) {
   case DefinedAbsoluteKind:
     return cast<DefinedAbsolute>(this)->getRVA();

lld/trunk/test/COFF/Inputs/conflict.ll

+define void @foo() {
+  ret void
+}

lld/trunk/test/COFF/conflict.test

 # RUN: yaml2obj < %s > %t1.obj
 # RUN: yaml2obj < %s > %t2.obj
 # RUN: not lld -flavor link2 /out:%t.exe %t1.obj %t2.obj >& %t.log
 # RUN: FileCheck %s < %t.log
 
-# CHECK: duplicate symbol: foo {{.+}} and foo {{.+}}
+# RUN: llvm-as -o %t.lto1.obj %S/Inputs/conflict.ll
+# RUN: llvm-as -o %t.lto2.obj %S/Inputs/conflict.ll
+# RUN: not lld -flavor link2 /out:%t.exe %t.lto1.obj %t.lto2.obj >& %t.log
+# RUN: FileCheck %s < %t.log
+
+# CHECK: duplicate symbol: foo {{.+}}1.obj and foo {{.+}}2.obj
 
 ---
 header:
   Machine:         IMAGE_FILE_MACHINE_AMD64
   Characteristics: []
 sections:
   - Name:            .text
     Characteristics: [ IMAGE_SCN_CNT_CODE, IMAGE_SCN_MEM_EXECUTE, IMAGE_SCN_MEM_READ ]