LTO: Don't follow lazy references when seeing new definitions in the combined LTO object

[hans]

Summary

Following the lazy reference might bring in an object file that depends on bitcode files that weren't part in the LTO step.

[pcc]

LGTM

test/COFF/lto-lazy-reference.ll

3 ↗

(On Diff #74200)

We normally rm -f the archive file before creating it.

13 ↗

(On Diff #74200)

s/real/lazy-reference/

16 ↗

(On Diff #74200)

ditto

[hans]

Thanks for the review!

lld/trunk/COFF/SymbolTable.cpp

for (SymbolBody *Body : Obj->getSymbols()) {
 
     if (Existing == Body)
       continue;
 
     if (isa<DefinedBitcode>(Existing)) {
       Sym->Body = Body;
       continue;
     }
+    if (isa<Undefined>(Body)) {
       if (auto *L = dyn_cast<Lazy>(Existing)) {
         // We may see new references to runtime library symbols such as __chkstk
         // here. These symbols must be wholly defined in non-bitcode files.
         addMemberFile(L);
         continue;
       }
+    }
 
     int Comp = Existing->compare(Body);
     if (Comp == 0)
       fatal("LTO: unexpected duplicate symbol: " + Name);
     if (Comp < 0)
       Sym->Body = Body;
   }
 }

lld/trunk/test/COFF/Inputs/lto-lazy-reference-dummy.ll

+target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
+target triple = "i686-pc-windows-msvc18.0.0"
+
+define void @dummy() {
+  ret void
+}

lld/trunk/test/COFF/Inputs/lto-lazy-reference-quadruple.ll

+target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
+target triple = "i686-pc-windows-msvc18.0.0"
+
+define double @quadruple(double %x) {
+entry:
+  ; The symbol __real@40800000 is used to materialize the 4.0 constant.
+  %mul = fmul double %x, 4.0
+  ret double %mul
+}
+
+
+declare void @dummy()
+define void @f() {
+  call void @dummy()
+  ret void
+}

lld/trunk/test/COFF/lto-lazy-reference.ll

+; RUN: llc -mtriple=i686-pc-windows-msvc -filetype=obj -o %T/lto-lazy-reference-quadruple.obj %S/Inputs/lto-lazy-reference-quadruple.ll
+; RUN: llvm-as -o %T/lto-lazy-reference-dummy.bc %S/Inputs/lto-lazy-reference-dummy.ll
+; RUN: rm -f %t.lib
+; RUN: llvm-ar cru %t.lib %T/lto-lazy-reference-quadruple.obj %T/lto-lazy-reference-dummy.bc
+; RUN: llvm-as -o %t.obj %s
+; RUN: lld-link /out:%t.exe /entry:main /subsystem:console %t.obj %t.lib
+
+target datalayout = "e-m:x-p:32:32-i64:64-f80:32-n8:16:32-a:0:32-S32"
+target triple = "i686-pc-windows-msvc18.0.0"
+
+define double @main(double %x) {
+entry:
+  ; When compiled, this defines the __real@40800000 symbol, which already has a
+  ; lazy definition in the lib file from  lto-lazy-reference-quadruple.obj. This
+  ; test makes sure we *don't* try to take the definition from the lazy
+  ; reference, because that can bring in new references to bitcode files after
+  ; LTO, such as lto-lazy-reference-dummy.bc in this case.
+  %mul = fmul double %x, 4.0
+
+  ret double %mul
+}