[ThinLTO] Fix importing of writeonly variables in distributed ThinLTO

[tejohnson]

Summary

D69561/dde5893 enabled importing of readonly variables with references,
however, it introduced a bug relating to importing/internalization of
writeonly variables with references.

A fix for this was added in D70006/7f92d66. But this didn't work in
distributed ThinLTO mode. The reason is that the fix (importing the
writeonly var with a zeroinitializer) was only applied when there were
references on the writeonly var summary. In distributed ThinLTO mode,
where we only have a small slice of the index, we will not have the
references on the importing side if we are not importing those
referenced values. Rather than changing this handshaking (which will
require a lot of other changes, since that's how we know what to import
in the distributed backend clang invocation), we can simply always give
the writeonly variable a zero initializer.

[steven_wu]

LGTM

llvm/lib/Transforms/Utils/FunctionImportUtils.cpp

if (GlobalVariable *V = dyn_cast<GlobalVariable>(&GV)) {
         V->addAttribute("thinlto-internalize");
         // Objects referenced by writeonly GV initializer should not be
         // promoted, because there is no any kind of read access to them
         // on behalf of this writeonly GV. To avoid promotion we convert
         // GV initializer to 'zeroinitializer'. This effectively drops
         // references in IR module (not in combined index), so we can
         // ignore them when computing import. We do not export references
         // of writeonly object. See computeImportForReferencedGlobals
-        if (ImportIndex.isWriteOnly(GVS) && GVS->refs().size())
+        if (ImportIndex.isWriteOnly(GVS))
           V->setInitializer(Constant::getNullValue(V->getValueType()));
       }
     }
   }
 
   if (GV.hasLocalLinkage() && shouldPromoteLocalToGlobal(&GV, VI)) {
     // Save the original name string before we rename GV below.
     auto Name = GV.getName().str();

llvm/test/ThinLTO/X86/index-const-prop2.ll

 ; RUN:  -r=%t1.bc,main2,pl \
 ; RUN:  -r=%t1.bc,foo, \
 ; RUN:  -r=%t1.bc,bar, \
 ; RUN:  -r=%t1.bc,baz, \
 ; RUN:  -r=%t1.bc,gBar, \
 ; RUN:  -o %t4
 ; RUN: llvm-dis %t4.1.3.import.bc -o - | FileCheck %s --check-prefix=IMPORT2
 
+; Run again but with main2 exported instead of main to check that write only
+; variables are optimized out.
 ; RUN: llvm-lto2 run %t1.bc %t2.bc -save-temps \
 ; RUN:  -r=%t2.bc,foo,pl \
 ; RUN:  -r=%t2.bc,bar,pl \
 ; RUN:  -r=%t2.bc,baz,pl \
 ; RUN:  -r=%t2.bc,rand, \
 ; RUN:  -r=%t2.bc,gBar,pl \
 ; RUN:  -r=%t1.bc,main,pl \
 ; RUN:  -r=%t1.bc,main2,plx \
 ; RUN:  -r=%t1.bc,foo, \
 ; RUN:  -r=%t1.bc,bar, \
 ; RUN:  -r=%t1.bc,baz, \
 ; RUN:  -r=%t1.bc,gBar, \
 ; RUN:  -o %t5
-; RUN: llvm-dis %t5.1.3.import.bc -o - | FileCheck %s --check-prefix=IMPORT
+; RUN: llvm-dis %t5.1.3.import.bc -o - | FileCheck %s --check-prefix=IMPORT-WRITEONLY
 ; RUN: llvm-dis %t5.1.5.precodegen.bc -o - | FileCheck %s --check-prefix=CODEGEN2
 ; Check that gFoo and gBar were eliminated from source module together
 ; with corresponsing stores
 ; RUN: llvm-dis %t5.2.5.precodegen.bc -o - | FileCheck %s --check-prefix=CODEGEN2-SRC
 
 ; IMPORT:       @gFoo.llvm.0 = internal unnamed_addr global i32 1, align 4
 ; IMPORT-NEXT:  @gBar = internal local_unnamed_addr global i32 2, align 4
 ; IMPORT:       !DICompileUnit({{.*}})
 
+; Write only variables are imported with a zero initializer.
+; IMPORT-WRITEONLY:  @gFoo.llvm.0 = internal unnamed_addr global i32 0
+; IMPORT-WRITEONLY:  @gBar = internal local_unnamed_addr global i32 0
+
 ; CODEGEN:        i32 @main()
 ; CODEGEN-NEXT:     ret i32 3
 
 ; IMPORT2: @gBar = available_externally dso_local local_unnamed_addr global i32 2, align 4
 
 ; CODEGEN2:      i32 @main2
 ; CODEGEN2-NEXT:   %1 = tail call i32 @rand()
 ; CODEGEN2-NEXT:   %2 = tail call i32 @rand()

llvm/test/ThinLTO/X86/writeonly-with-refs.ll

 ; RUN: opt -thinlto-bc %s -o %t1
 ; RUN: opt -thinlto-bc %p/Inputs/writeonly-with-refs.ll -o %t2
 ; RUN: llvm-lto2 run -save-temps %t1 %t2 -o %t-out \
 ; RUN:    -r=%t1,main,plx \
 ; RUN:    -r=%t1,_Z3foov,l \
 ; RUN:    -r=%t2,_Z3foov,pl \
 ; RUN:    -r=%t2,outer,pl
 
 ; @outer should have been internalized and converted to zeroinitilizer.
-; RUN: llvm-dis %t-out.1.5.precodegen.bc -o - | FileCheck %s
-; RUN: llvm-dis %t-out.2.5.precodegen.bc -o - | FileCheck %s
+; RUN: llvm-dis %t-out.1.3.import.bc -o - | FileCheck %s
+; RUN: llvm-dis %t-out.2.3.import.bc -o - | FileCheck %s
 
-; CHECK: @outer = internal unnamed_addr global %struct.Q zeroinitializer
+; CHECK: @outer = internal local_unnamed_addr global %struct.Q zeroinitializer
+
+; Test again in distributed ThinLTO mode.
+; RUN: llvm-lto2 run -save-temps %t1 %t2 -o %t-out \
+; RUN:    -thinlto-distributed-indexes \
+; RUN:    -r=%t1,main,plx \
+; RUN:    -r=%t1,_Z3foov,l \
+; RUN:    -r=%t2,_Z3foov,pl \
+; RUN:    -r=%t2,outer,pl
+; RUN: opt -function-import -import-all-index -enable-import-metadata -summary-file %t1.thinlto.bc %t1 -o %t1.out
+; RUN: opt -function-import -import-all-index -summary-file %t2.thinlto.bc %t2 -o %t2.out
+; RUN: llvm-dis %t1.out -o - | FileCheck %s
+; RUN: llvm-dis %t2.out -o - | FileCheck %s
 
 source_filename = "main.cpp"
 target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Function Attrs: norecurse uwtable
 define dso_local i32 @main() local_unnamed_addr {
 entry:
   tail call void @_Z3foov()
   ret i32 0
 }
 
 declare dso_local void @_Z3foov() local_unnamed_addr

llvm/test/ThinLTO/X86/writeonly.ll

 ; Checks that we optimize writeonly variables and corresponding stores using llvm-lto
 ; -stats requires asserts
 ; REQUIRES: asserts
 
 ; RUN: opt -module-summary %s -o %t1.bc
 ; RUN: opt -module-summary %p/Inputs/index-const-prop.ll -o %t2.bc
 ; RUN: llvm-lto -thinlto-action=thinlink -o %t3.index.bc %t1.bc %t2.bc
 
 ; Check that we optimize write-only variables
 ; RUN: llvm-lto -thinlto-action=import -exported-symbol=main  %t1.bc -thinlto-index=%t3.index.bc -o %t1.imported.bc -stats 2>&1 | FileCheck %s --check-prefix=STATS
 ; RUN: llvm-dis %t1.imported.bc -o - | FileCheck %s --check-prefix=IMPORT
 ; RUN: llvm-lto -thinlto-action=optimize %t1.imported.bc -o - | llvm-dis - -o - | FileCheck %s --check-prefix=OPTIMIZE
 
-; IMPORT: @gFoo.llvm.0 = internal unnamed_addr global i32 1, align 4, !dbg !0
-; IMPORT-NEXT: @gBar = internal local_unnamed_addr global i32 2, align 4, !dbg !5
+; IMPORT: @gFoo.llvm.0 = internal unnamed_addr global i32 0, align 4, !dbg !0
+; IMPORT-NEXT: @gBar = internal local_unnamed_addr global i32 0, align 4, !dbg !5
 ; IMPORT: !DICompileUnit({{.*}})
 
 ; STATS:  2 module-summary-index - Number of live global variables marked write only 
 
 ; Check that we've optimized out variables and corresponding stores
 ; OPTIMIZE-NOT:  gFoo
 ; OPTIMIZE-NOT:  gBar
 ; OPTIMIZE:      i32 @main

llvm/test/ThinLTO/X86/writeonly2.ll

 ; RUN:  -r=%t1.bc,gBar, \
 ; RUN:  -o %t3
 ; RUN: llvm-dis %t3.1.3.import.bc -o - | FileCheck %s --check-prefix=IMPORT
 ; RUN: llvm-dis %t3.1.5.precodegen.bc -o - | FileCheck %s --check-prefix=CODEGEN
 ; Check that gFoo and gBar were eliminated from source module together
 ; with corresponsing stores
 ; RUN: llvm-dis %t3.2.5.precodegen.bc -o - | FileCheck %s --check-prefix=CODEGEN-SRC
 
-; IMPORT:       @gFoo.llvm.0 = internal unnamed_addr global i32 1, align 4
-; IMPORT-NEXT:  @gBar = internal local_unnamed_addr global i32 2, align 4
+; IMPORT:       @gFoo.llvm.0 = internal unnamed_addr global i32 0, align 4
+; IMPORT-NEXT:  @gBar = internal local_unnamed_addr global i32 0, align 4
 ; IMPORT:       !DICompileUnit({{.*}})
 
 ; CODEGEN-NOT:  gFoo
 ; CODEGEN-NOT:  gBar
 ; CODEGEN:      i32 @main
 ; CODEGEN-NEXT:   %1 = tail call i32 @rand()
 ; CODEGEN-NEXT:   %2 = tail call i32 @rand()
 ; CODEGEN-NEXT:   ret i32 0