[lto] set AvailableExternallyLinkage for non-prevailing GlobalValues

[inglorion]

Summary

This allows using definitions that are not prevailing, but equivalent to the prevailing one, to be used for link-time optimization.

[inglorion]

D29059 needs this so that when we have a definition in a regular object and one in LTO, and we select the one in the regular object, we can still use the knowledge of the definition in LTO. The COFF linker has a test (lto-comdat.ll) that will fail without this.

[mehdi_amini]

Can you add a test please?

Also, make sure the test verifies that if the first module to be added contains a non-prevailing copy, and then the second one contains the prevailing copy, the prevailing one overwrite the one you kept as available_externally from the first module.

[pcc]

I have a local change (with a test) that does something similar, I'll pull it out of my local branch and send it out.

@inglorion, sorry for the conflict!

[pcc]

D29367

[inglorion]

Yeah, I was going to add a test once we agree that this is the functional change we want, but let's go with @pcc's D29367, which already has a test.

lib/LTO/LTO.cpp

for (const InputFile::Symbol &Sym :
                   InputFile::symbol_iterator(SymTab.symbols().end(), SymTab,
                                              nullptr))) {
     assert(ResI != ResE);
     SymbolResolution Res = *ResI++;
     addSymbolToGlobalRes(Used, Sym, Res, 0);
 
     if (Sym.getFlags() & object::BasicSymbolRef::SF_Undefined)
       continue;
-    if (Res.Prevailing && Sym.isGV()) {
+    if (Sym.isGV()) {
       GlobalValue *GV = Sym.getGV();
+      if (Res.Prevailing) {
         Keep.push_back(GV);
         switch (GV->getLinkage()) {
         default:
           break;
         case GlobalValue::LinkOnceAnyLinkage:
           GV->setLinkage(GlobalValue::WeakAnyLinkage);
           break;
         case GlobalValue::LinkOnceODRLinkage:
           GV->setLinkage(GlobalValue::WeakODRLinkage);
           break;
         }
+      } else {
+        // This definition is not prevailing, but we can still use it for
+        // optimization if it has ODR linkage. This is done by setting its
+        // linkage to AvailableExternallyLinkage.
+        // This causes a declaration to be emitted, and declarations cannot
+        // have comdats. Therefore, we can only set AvailableExternallyLinkage
+        // on symbols that don't have a comdat or from which we can remove
+        // the comdat.
+        if (GV->hasLinkOnceODRLinkage() || GV->hasWeakODRLinkage()) {
+          if (auto *G = dyn_cast<GlobalObject>(GV))
+            G->setComdat(nullptr);
+          if (!GV->hasComdat()) {
+            GV->setLinkage(GlobalValue::AvailableExternallyLinkage);
+          }
+        }
+      }
     }
     // Common resolution: collect the maximum size/alignment over all commons.
     // We also record if we see an instance of a common as prevailing, so that
     // if none is prevailing we can ignore it later.
     if (Sym.getFlags() & object::BasicSymbolRef::SF_Common) {
       // FIXME: We should figure out what to do about commons defined by asm.
       // For now they aren't reported correctly by ModuleSymbolTable.
       auto &CommonRes = RegularLTO.Commons[Sym.getGV()->getName()];