lld/coff: Simplify error message for comdat selection mismatches

[thakis]

Summary

Turns out nobody understands what "conflicting comdat type" is supposed to mean, so just emit a regular "duplicate symbol" error and move the comdat selection information into /verbose output.

This also fixes a problem where the error output would depend on the order of .obj files passed. Before this patch:

• If passed one_only.obj discard.obj, lld-link would only err "conflicting comdat type"
• If passed discard.obj one_only.obj, lld-link would err "conflicting comdat type" and then "duplicate symbol"

Now lld-link only errs "duplicate symbol" in both cases.

I considered adding a "Detail" parameter to reportDuplicate() that's printed in parens at the end of the "duplicate symbol" diag if present, and then put the comdat selection mismatch details there, but since users don't know what it's supposed to mean decided against it. I also considered special-casing the Detail message for one_only/discard mismatches, which in practice means "function defined as inline in TU 1 but as out-of-line in TU 2", but I wasn't sure how useful it is so I omitted that too.

[ruiu]

lld/COFF/InputFiles.cpp

502–505 ↗

(On Diff #186654)

clang-format?

510 ↗

(On Diff #186654)

I'd return early instead of doing this to effectively disable the following code, but you can't do that because we want to execute the code after the following switch. Maybe it's time to split this into a new function?

[thakis]

pull out function

[thakis]

Extracted a function. Let me know if you want me to do the function extraction without other changes in a different CL, so that it's a behavior-preserving refactoring in one patch and a behavior change in a separate much smaller patch.

[ruiu]

LGTM

lld/COFF/InputFiles.cpp

387 ↗

(On Diff #186768)

Handle -> handle

lld/trunk/COFF/InputFiles.h

 using llvm::object::COFFSymbolRef;
 using llvm::object::coff_import_header;
 using llvm::object::coff_section;
 
 class Chunk;
 class Defined;
 class DefinedImportData;
 class DefinedImportThunk;
+class DefinedRegular;
 class Lazy;
 class SectionChunk;
 class Symbol;
 class Undefined;
 
 // The root class of input files.
 class InputFile {
 public:
public:
 
   // When using Microsoft precompiled headers, this is the PCH's key.
   // The same key is used by both the precompiled object, and objects using the
   // precompiled object. Any difference indicates out-of-date objects.
   llvm::Optional<uint32_t> PCHSignature;
 
 private:
   const coff_section* getSection(uint32_t I);
+  const coff_section *getSection(COFFSymbolRef Sym) {
+    return getSection(Sym.getSectionNumber());
+  }
 
   void initializeChunks();
   void initializeSymbols();
 
   SectionChunk *
   readSection(uint32_t SectionNumber,
               const llvm::object::coff_aux_section_definition *Def,
               StringRef LeaderName);
private:
   void recordPrevailingSymbolForMingw(
       COFFSymbolRef COFFSym,
       llvm::DenseMap<StringRef, uint32_t> &PrevailingSectionMap);
 
   void maybeAssociateSEHForMingw(
       COFFSymbolRef Sym, const llvm::object::coff_aux_section_definition *Def,
       const llvm::DenseMap<StringRef, uint32_t> &PrevailingSectionMap);
 
+  // Given a new symbol Sym with comdat selection Selection, if the new
+  // symbol is not (yet) Prevailing and the existing comdat leader set to
+  // Leader, emits a diagnostic if the new symbol and its selection doesn't
+  // match the existing symbol and its selection. If either old or new
+  // symbol have selection IMAGE_COMDAT_SELECT_LARGEST, Sym might replace
+  // the existing leader. In that case, Prevailing is set to true.
+  void handleComdatSelection(COFFSymbolRef Sym,
+                             llvm::COFF::COMDATType &Selection,
+                             bool &Prevailing, DefinedRegular *Leader);
+
   llvm::Optional<Symbol *>
   createDefined(COFFSymbolRef Sym,
                 std::vector<const llvm::object::coff_aux_section_definition *>
                     &ComdatDefs,
                 bool &PrevailingComdat);
   Symbol *createRegular(COFFSymbolRef Sym);
   Symbol *createUndefined(COFFSymbolRef Sym);
 

lld/trunk/COFF/InputFiles.cpp

 }
 
 Symbol *ObjFile::createUndefined(COFFSymbolRef Sym) {
   StringRef Name;
   COFFObj->getSymbolName(Sym, Name);
   return Symtab->addUndefined(Name, this, Sym.isWeakExternal());
 }
 
-Optional<Symbol *> ObjFile::createDefined(
-    COFFSymbolRef Sym,
-    std::vector<const coff_aux_section_definition *> &ComdatDefs,
-    bool &Prevailing) {
-  Prevailing = false;
-  auto GetName = [&]() {
-    StringRef S;
-    COFFObj->getSymbolName(Sym, S);
-    return S;
-  };
-
-  if (Sym.isCommon()) {
-    auto *C = make<CommonChunk>(Sym);
-    Chunks.push_back(C);
-    return Symtab->addCommon(this, GetName(), Sym.getValue(), Sym.getGeneric(),
-                             C);
-  }
-
-  if (Sym.isAbsolute()) {
-    StringRef Name = GetName();
-
-    // Skip special symbols.
-    if (Name == "@comp.id")
-      return nullptr;
-    if (Name == "@feat.00") {
-      Feat00Flags = Sym.getValue();
-      return nullptr;
-    }
-
-    if (Sym.isExternal())
-      return Symtab->addAbsolute(Name, Sym);
-    return make<DefinedAbsolute>(Name, Sym);
-  }
-
-  int32_t SectionNumber = Sym.getSectionNumber();
-  if (SectionNumber == llvm::COFF::IMAGE_SYM_DEBUG)
-    return nullptr;
-
-  if (llvm::COFF::isReservedSectionNumber(SectionNumber))
-    fatal(toString(this) + ": " + GetName() +
-          " should not refer to special section " + Twine(SectionNumber));
-
-  if ((uint32_t)SectionNumber >= SparseChunks.size())
-    fatal(toString(this) + ": " + GetName() +
-          " should not refer to non-existent section " + Twine(SectionNumber));
-
-  // Comdat handling.
-  // A comdat symbol consists of two symbol table entries.
-  // The first symbol entry has the name of the section (e.g. .text), fixed
-  // values for the other fields, and one auxilliary record.
-  // The second symbol entry has the name of the comdat symbol, called the
-  // "comdat leader".
-  // When this function is called for the first symbol entry of a comdat,
-  // it sets ComdatDefs and returns None, and when it's called for the second
-  // symbol entry it reads ComdatDefs and then sets it back to nullptr.
-
-  // Handle comdat leader.
-  if (const coff_aux_section_definition *Def = ComdatDefs[SectionNumber]) {
-    ComdatDefs[SectionNumber] = nullptr;
-    DefinedRegular *Leader;
-
-    if (Sym.isExternal()) {
-      std::tie(Leader, Prevailing) =
-          Symtab->addComdat(this, GetName(), Sym.getGeneric());
-    } else {
-      Leader = make<DefinedRegular>(this, /*Name*/ "", /*IsCOMDAT*/ false,
-                                    /*IsExternal*/ false, Sym.getGeneric());
-      Prevailing = true;
-    }
-
-    if (Def->Selection < (int)IMAGE_COMDAT_SELECT_NODUPLICATES ||
-        // Intentionally ends at IMAGE_COMDAT_SELECT_LARGEST: link.exe
-        // doesn't understand IMAGE_COMDAT_SELECT_NEWEST either.
-        Def->Selection > (int)IMAGE_COMDAT_SELECT_LARGEST) {
-      fatal("unknown comdat type " + std::to_string((int)Def->Selection) +
-            " for " + GetName() + " in " + toString(this));
-    }
-    COMDATType Selection = (COMDATType)Def->Selection;
-
-    if (!Prevailing && Leader->isCOMDAT()) {
-      // There's already an existing comdat for this symbol: `Leader`.
-      // Use the comdats's selection field to determine if the new
-      // symbol in `Sym` should be discarded, produce a duplicate symbol
-      // error, etc.
+void ObjFile::handleComdatSelection(COFFSymbolRef Sym, COMDATType &Selection,
+                                    bool &Prevailing, DefinedRegular *Leader) {
+  if (Prevailing)
+    return;
 
-      SectionChunk *LeaderChunk = nullptr;
-      COMDATType LeaderSelection = IMAGE_COMDAT_SELECT_ANY;
 
-      if (Leader->Data) {
-        LeaderChunk = Leader->getChunk();
-        LeaderSelection = LeaderChunk->Selection;
-      } else {
-        // FIXME: comdats from LTO files don't know their selection; treat them
-        // as "any".
-        Selection = LeaderSelection;
-      }
 
-      if ((Selection == IMAGE_COMDAT_SELECT_ANY &&
-           LeaderSelection == IMAGE_COMDAT_SELECT_LARGEST) ||
-          (Selection == IMAGE_COMDAT_SELECT_LARGEST &&
-           LeaderSelection == IMAGE_COMDAT_SELECT_ANY)) {
-        // cl.exe picks "any" for vftables when building with /GR- and
-        // "largest" when building with /GR. To be able to link object files
-        // compiled with each flag, "any" and "largest" are merged as "largest".
-        LeaderSelection = Selection = IMAGE_COMDAT_SELECT_LARGEST;
-      }
 
-      // Other than that, comdat selections must match.  This is a bit more
-      // strict than link.exe which allows merging "any" and "largest" if "any"
-      // is the first symbol the linker sees, and it allows merging "largest"
-      // with everything (!) if "largest" is the first symbol the linker sees.
-      // Making this symmetric independent of which selection is seen first
-      // seems better though.
-      // (This behavior matches ModuleLinker::getComdatResult().)
-      if (Selection != LeaderSelection) {
-        std::string Msg = ("conflicting comdat type for " + toString(*Leader) +
-                           ": " + Twine((int)LeaderSelection) + " in " +
-                           toString(Leader->getFile()) + " and " +
-                           Twine((int)Selection) + " in " + toString(this))
-                              .str();
-        if (Config->ForceMultiple)
-          warn(Msg);
-        else
-          error(Msg);
-      }
+    log(("conflicting comdat type for " + toString(*Leader) + ": " +
+         Twine((int)LeaderSelection) + " in " + toString(Leader->getFile()) +
+         " and " + Twine((int)Selection) + " in " + toString(this))
+            .str());
+    Symtab->reportDuplicate(Leader, this);
+    return;
 
-      switch (Selection) {
-      case IMAGE_COMDAT_SELECT_NODUPLICATES:
-        Symtab->reportDuplicate(Leader, this);
-        break;
 
-      case IMAGE_COMDAT_SELECT_ANY:
-        // Nothing to do.
-        break;
 
-      case IMAGE_COMDAT_SELECT_SAME_SIZE:
-        if (LeaderChunk->getSize() != getSection(SectionNumber)->SizeOfRawData)
-          Symtab->reportDuplicate(Leader, this);
-        break;
+    if (LeaderChunk->getSize() != getSection(Sym)->SizeOfRawData)
 
-      case IMAGE_COMDAT_SELECT_EXACT_MATCH: {
-        SectionChunk NewChunk(this, getSection(SectionNumber));
-        // link.exe only compares section contents here and doesn't complain
-        // if the two comdat sections have e.g. different alignment.
-        // Match that.
-        if (LeaderChunk->getContents() != NewChunk.getContents())
-          Symtab->reportDuplicate(Leader, this);
-        break;
-      }
+    SectionChunk NewChunk(this, getSection(Sym));
 
-      case IMAGE_COMDAT_SELECT_ASSOCIATIVE:
-        // createDefined() is never called for IMAGE_COMDAT_SELECT_ASSOCIATIVE.
-        // (This means lld-link doesn't produce duplicate symbol errors for
-        // associative comdats while link.exe does, but associate comdats
-        // are never extern in practice.)
-        llvm_unreachable("createDefined not called for associative comdats");
 
-      case IMAGE_COMDAT_SELECT_LARGEST:
-        if (LeaderChunk->getSize() < getSection(SectionNumber)->SizeOfRawData) {
-          // Replace the existing comdat symbol with the new one.
-          // FIXME: This is incorrect: With /opt:noref, the previous sections
-          // make it into the final executable as well. Correct handling would
-          // be to undo reading of the whole old section that's being replaced,
-          // or doing one pass that determines what the final largest comdat
-          // is for all IMAGE_COMDAT_SELECT_LARGEST comdats and then reading
-          // only the largest one.
-          replaceSymbol<DefinedRegular>(
-              Leader, this, GetName(), /*IsCOMDAT*/ true,
-              /*IsExternal*/ true, Sym.getGeneric(), nullptr);
-          Prevailing = true;
-        }
-        break;
+    if (LeaderChunk->getSize() < getSection(Sym)->SizeOfRawData) {
+      StringRef Name;
+      COFFObj->getSymbolName(Sym, Name);
+      replaceSymbol<DefinedRegular>(Leader, this, Name, /*IsCOMDAT*/ true,
+                                    /*IsExternal*/ true, Sym.getGeneric(),
+                                    nullptr);
 
-      case IMAGE_COMDAT_SELECT_NEWEST:
-        llvm_unreachable("should have been rejected earlier");
-      }
-    }
 
+Optional<Symbol *> ObjFile::createDefined(
+    COFFSymbolRef Sym,
+    std::vector<const coff_aux_section_definition *> &ComdatDefs,
+    bool &Prevailing) {
+  Prevailing = false;
+  auto GetName = [&]() {
+    StringRef S;
+    COFFObj->getSymbolName(Sym, S);
+    return S;
+  };
+
+  if (Sym.isCommon()) {
+    auto *C = make<CommonChunk>(Sym);
+    Chunks.push_back(C);
+    return Symtab->addCommon(this, GetName(), Sym.getValue(), Sym.getGeneric(),
+                             C);
+  }
+
+  if (Sym.isAbsolute()) {
+    StringRef Name = GetName();
+
+    // Skip special symbols.
+    if (Name == "@comp.id")
+      return nullptr;
+    if (Name == "@feat.00") {
+      Feat00Flags = Sym.getValue();
+      return nullptr;
+    }
+
+    if (Sym.isExternal())
+      return Symtab->addAbsolute(Name, Sym);
+    return make<DefinedAbsolute>(Name, Sym);
+  }
+
+  int32_t SectionNumber = Sym.getSectionNumber();
+  if (SectionNumber == llvm::COFF::IMAGE_SYM_DEBUG)
+    return nullptr;
+
+  if (llvm::COFF::isReservedSectionNumber(SectionNumber))
+    fatal(toString(this) + ": " + GetName() +
+          " should not refer to special section " + Twine(SectionNumber));
+
+  if ((uint32_t)SectionNumber >= SparseChunks.size())
+    fatal(toString(this) + ": " + GetName() +
+          " should not refer to non-existent section " + Twine(SectionNumber));
+
+  // Comdat handling.
+  // A comdat symbol consists of two symbol table entries.
+  // The first symbol entry has the name of the section (e.g. .text), fixed
+  // values for the other fields, and one auxilliary record.
+  // The second symbol entry has the name of the comdat symbol, called the
+  // "comdat leader".
+  // When this function is called for the first symbol entry of a comdat,
+  // it sets ComdatDefs and returns None, and when it's called for the second
+  // symbol entry it reads ComdatDefs and then sets it back to nullptr.
+
+  // Handle comdat leader.
+  if (const coff_aux_section_definition *Def = ComdatDefs[SectionNumber]) {
+    ComdatDefs[SectionNumber] = nullptr;
+    DefinedRegular *Leader;
+
+    if (Sym.isExternal()) {
+      std::tie(Leader, Prevailing) =
+          Symtab->addComdat(this, GetName(), Sym.getGeneric());
+    } else {
+      Leader = make<DefinedRegular>(this, /*Name*/ "", /*IsCOMDAT*/ false,
+                                    /*IsExternal*/ false, Sym.getGeneric());
+      Prevailing = true;
+    }
+
+    if (Def->Selection < (int)IMAGE_COMDAT_SELECT_NODUPLICATES ||
+        // Intentionally ends at IMAGE_COMDAT_SELECT_LARGEST: link.exe
+        // doesn't understand IMAGE_COMDAT_SELECT_NEWEST either.
+        Def->Selection > (int)IMAGE_COMDAT_SELECT_LARGEST) {
+      fatal("unknown comdat type " + std::to_string((int)Def->Selection) +
+            " for " + GetName() + " in " + toString(this));
+    }
+    COMDATType Selection = (COMDATType)Def->Selection;
+
+    if (Leader->isCOMDAT())
+      handleComdatSelection(Sym, Selection, Prevailing, Leader);
+
     if (Prevailing) {
       SectionChunk *C = readSection(SectionNumber, Def, GetName());
       SparseChunks[SectionNumber] = C;
       C->Sym = cast<DefinedRegular>(Leader);
       C->Selection = Selection;
       cast<DefinedRegular>(Leader)->Data = &C->Repl;
     } else {
       SparseChunks[SectionNumber] = nullptr;

lld/trunk/test/COFF/comdat-selection.s

 
 
 # Test linking the same symbol with different comdat selection types.
 # link.exe generally rejects this, except for "largest" which is allowed to
 # combine with everything (https://bugs.llvm.org/show_bug.cgi?id=40094#c7).
 # lld-link rejects all comdat selection type mismatches. Spot-test just a few
 # combinations.
 
-# RUN: not lld-link /dll /noentry /nodefaultlib %t.discard.obj %t.one_only.obj 2>&1 | FileCheck --check-prefix=DISCARDONE %s
-# DISCARDONE: lld-link: error: conflicting comdat type for symbol: 2 in
-# RUN: lld-link /force /dll /noentry /nodefaultlib %t.discard.obj %t.one_only.obj 2>&1 | FileCheck --check-prefix=DISCARDONEFORCE %s
-# DISCARDONEFORCE: lld-link: warning: conflicting comdat type for symbol: 2 in
-
-# RUN: not lld-link /dll /noentry /nodefaultlib %t.same_contents.obj %t.same_size.obj 2>&1 | FileCheck --check-prefix=CONTENTSSIZE %s
-# CONTENTSSIZE: lld-link: error: conflicting comdat type for symbol: 4 in
+# RUN: not lld-link /verbose /dll /noentry /nodefaultlib %t.discard.obj %t.one_only.obj 2>&1 | FileCheck --check-prefix=DISCARDONE %s
+# DISCARDONE: lld-link: conflicting comdat type for symbol: 2 in
+# DISCARDONE: lld-link: error: duplicate symbol: symbol
+# RUN: lld-link /verbose /force /dll /noentry /nodefaultlib %t.discard.obj %t.one_only.obj 2>&1 | FileCheck --check-prefix=DISCARDONEFORCE %s
+# DISCARDONEFORCE: lld-link: conflicting comdat type for symbol: 2 in
+# DISCARDONEFORCE: lld-link: warning: duplicate symbol: symbol
+
+# Make sure the error isn't depending on the order of .obj files.
+# RUN: not lld-link /verbose /dll /noentry /nodefaultlib %t.one_only.obj %t.discard.obj 2>&1 | FileCheck --check-prefix=ONEDISCARD %s
+# ONEDISCARD: lld-link: conflicting comdat type for symbol: 1 in
+# ONEDISCARD: lld-link: error: duplicate symbol: symbol
+
+# RUN: not lld-link /verbose /dll /noentry /nodefaultlib %t.same_contents.obj %t.same_size.obj 2>&1 | FileCheck --check-prefix=CONTENTSSIZE %s
+# CONTENTSSIZE: lld-link: conflicting comdat type for symbol: 4 in
+# CONTENTSSIZE: lld-link: error: duplicate symbol: symbol
 
 # Check that linking one 'discard' and one 'largest' has the effect of
 # 'largest'.
 # RUN: lld-link /dll /noentry /nodefaultlib %t.discard.short.2.obj %t.largest.obj
 # RUN: llvm-objdump -s %t.exe | FileCheck --check-prefix=DISCARDLARGEST %s
 # DISCARDLARGEST: Contents of section .text:
 # DISCARDLARGEST:   180001000 01000000 ....
 # RUN: lld-link /dll /noentry /nodefaultlib %t.largest.obj %t.discard.short.2.obj
 # RUN: llvm-objdump -s %t.exe | FileCheck --check-prefix=LARGESTDISCARD %s
 # LARGESTDISCARD: Contents of section .text:
 # LARGESTDISCARD:   180001000 01000000 ....
 
 
 # These cases are accepted by link.exe but not by lld-link.
-# RUN: not lld-link /dll /noentry /nodefaultlib %t.largest.obj %t.one_only.obj 2>&1 | FileCheck --check-prefix=LARGESTONE %s
-# LARGESTONE: lld-link: error: conflicting comdat type for symbol: 6 in
+# RUN: not lld-link /verbose /dll /noentry /nodefaultlib %t.largest.obj %t.one_only.obj 2>&1 | FileCheck --check-prefix=LARGESTONE %s
+# LARGESTONE: lld-link: conflicting comdat type for symbol: 6 in
+# LARGESTONE: lld-link: error: duplicate symbol: symbol