[ThinLTO] Keep common symbols in ThinLTO modules

[tejohnson]

Summary

Skip the merging of common symbols for ThinLTO modules, they will be
merged by the final native object link. Trying to merge the symbols and
add to a combined module will incorrectly enable the common symbol to be
internalized in the ThinLTO module. Additionally, we will not want to
create a combined module for ThinLTO distributed builds.

This fixes failures in 7 cpu2006 benchmarks from the new LTO API in
ThinLTO mode.

[mehdi_amini]

LGTM.

include/llvm/LTO/LTO.h

public:
   iterator_range<symbol_iterator> symbols() {
     return llvm::make_range(symbol_iterator(Obj->symbol_begin()),
                             symbol_iterator(Obj->symbol_end()));
   }
 
   StringRef getSourceFileName() const {
     return Obj->getModule().getSourceFileName();
   }
+
+  MemoryBufferRef getMemoryBufferRef() const {
+    return Obj->getMemoryBufferRef();
+  }
 };
 
 /// A ThinBackend defines what happens after the thin-link phase during ThinLTO.
 /// The details of this type definition aren't important; clients can only
 /// create a ThinBackend using one of the create*ThinBackend() functions below.
 typedef std::function<std::unique_ptr<ThinBackendProc>(
     Config &C, ModuleSummaryIndex &CombinedIndex,
     StringMap<GVSummaryMapTy> &ModuleToDefinedGVSummaries,

test/tools/gold/X86/Inputs/common_thinlto.ll

+source_filename = "common2.c"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@P = external global i8* (...)*, align 8
+
+; Function Attrs: nounwind uwtable
+define void @foo() #0 {
+entry:
+  %0 = load i8* (...)*, i8* (...)** @P, align 8
+  %call = call i8* (...) %0()
+  ret void
+}

test/tools/gold/X86/common_thinlto.ll

+; RUN: opt -module-summary %s -o %t1.o
+; RUN: opt -module-summary %p/Inputs/common_thinlto.ll -o %t2.o
+
+; RUN: %gold -plugin %llvmshlibdir/LLVMgold.so \
+; RUN:    --plugin-opt=save-temps \
+; RUN:    --plugin-opt=thinlto \
+; RUN:    -shared %t1.o %t2.o -o %t3
+
+; RUN: llvm-dis %t1.o.2.internalize.bc -o - | FileCheck %s --check-prefix=INTERNALIZE
+; We should not have internalized P, and it should still be common.
+; INTERNALIZE: @P = common global
+
+; RUN: llvm-dis %t1.o.4.opt.bc -o - | FileCheck %s --check-prefix=OPT
+; bar should still exist (if we had internalized P it would look dead).
+; OPT: @bar
+
+; RUN: llvm-nm %t3.o | FileCheck %s --check-prefix=NM
+; NM: bar
+
+source_filename = "common1.c"
+target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
+target triple = "x86_64-unknown-linux-gnu"
+
+@P = common global i8* (...)* null, align 8
+
+define i32 @main() {
+entry:
+  store i8* (...)* bitcast (i8* ()* @bar to i8* (...)*), i8* (...)** @P, align 8
+  %call = call i32 (...) @foo()
+  ret i32 0
+}
+
+declare i32 @foo(...)
+
+define internal i8* @bar() {
+entry:
+  ret i8* null
+}

tools/gold/gold-plugin.cpp

static void addModule(LTO &Lto, claimed_file &F, const void *View) {
   MemoryBufferRef BufferRef(StringRef((const char *)View, F.filesize), F.name);
   Expected<std::unique_ptr<InputFile>> ObjOrErr = InputFile::create(BufferRef);
 
   if (!ObjOrErr)
     message(LDPL_FATAL, "Could not read bitcode from file : %s",
             toString(ObjOrErr.takeError()).c_str());
 
   InputFile &Obj = **ObjOrErr;
+  bool HasThinLTOSummary =
+      hasGlobalValueSummary(Obj.getMemoryBufferRef(), diagnosticHandler);
 
   unsigned SymNum = 0;
   std::vector<SymbolResolution> Resols(F.syms.size());
   for (auto &ObjSym : Obj.symbols()) {
     ld_plugin_symbol &Sym = F.syms[SymNum];
     SymbolResolution &R = Resols[SymNum];
     ++SymNum;
 
case LDPR_PREVAILING_DEF_IRONLY_EXP:
         R.VisibleToRegularObj = true;
       break;
     }
 
     if (Resolution != LDPR_RESOLVED_DYN && Resolution != LDPR_UNDEF &&
         (IsExecutable || !Res.DefaultVisibility))
       R.FinalDefinitionInLinkageUnit = true;
 
-    if (ObjSym.getFlags() & object::BasicSymbolRef::SF_Common) {
+    if ((ObjSym.getFlags() & object::BasicSymbolRef::SF_Common) &&
+        !HasThinLTOSummary) {
       // We ignore gold's resolution for common symbols. A common symbol with
       // the correct size and alignment is added to the module by the pre-opt
       // module hook if any common symbol prevailed.
       CommonResolution &CommonRes = Commons[ObjSym.getIRName()];
       if (R.Prevailing) {
         CommonRes.Prevailing = true;
         CommonRes.VisibleToRegularObj = R.VisibleToRegularObj;
       }