More fixes for weak undef and pic

[• espindola]

Summary

I am going on vacation in a few hours and will not have time to finish this. Feel free to take over.

It turns out that at least on relocations that have produce a 0 at runtime, we cannot assume it is local. If we do, the architecture dependent part will assume it can always compute 0 from a position in the file. While 0 might always be in range, it will have a different offset in different executions.

If this goes in as is, there will be some code that is redundant and can be cleaned up.

lib/Target/TargetMachine.cpp

bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
 
   // Every other GV is local on COFF.
   // Make an exception for windows OS in the triple: Some firmwares builds use
   // *-win32-macho triples. This (accidentally?) produced windows relocations
   // without GOT tables in older clang versions; Keep this behaviour.
   if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO()))
     return true;
 
+  // A weak undef symbol might resolve to 0. We have to assume it is
+  // not local, as we have no control of where in memory we will end
+  // up.
+  // FIXME: is this true for all architectures?
+  // FIXME2: this is false for some relocations. For example, it should be valid
+  // to produce "call foo" instead of "call foo@plt". It is not clear if that is
+  // a problem.
+  if (GV && GV->hasExternalWeakLinkage() && isPositionIndependent())
+    return false;
+
   if (GV && (GV->hasLocalLinkage() || !GV->hasDefaultVisibility()))
     return true;
 
   if (TT.isOSBinFormatMachO()) {
     if (RM == Reloc::Static)
       return true;
     return GV && GV->isStrongDefinitionForLinker();
   }

test/CodeGen/X86/global-access-pie-copyrelocs.ll

 ; X64-LABEL: my_access_global_load_d:
 ; X64:       movl d(%rip), %eax
 
 entry:
   %0 = load i32, i32* @d, align 4
   ret i32 %0
 }
 
+; ExternalWeak Linkage
+@e = extern_weak global i32, align 4
+
+define i32* @my_access_global_d() #0 {
+; X32-LABEL: my_access_global_d:
+; X32:       addl $_GLOBAL_OFFSET_TABLE_{{.*}}, %eax
+; X32:       movl e@GOT(%eax), %eax
+; X64-LABEL: my_access_global_d:
+; X64:       movq e@GOTPCREL(%rip), %rax
+
+entry:
+  ret i32* @e
+}
+
 ; External Linkage, only declaration, store a value.
 
 define i32 @my_access_global_store_d() #0 {
 ; X32-LABEL: my_access_global_store_d:
 ; X32:       addl $_GLOBAL_OFFSET_TABLE_{{.*}}, %eax
 ; X32-NEXT:  movl $2, d@GOTOFF(%eax)
 ; X64-LABEL: my_access_global_store_d:
 ; X64:  movl $2, d(%rip)

test/CodeGen/X86/hidden-vis-3.ll

 ; RUN: llc < %s -mtriple=i386-apple-darwin9   | FileCheck %s -check-prefix=X32
 ; RUN: llc < %s -mtriple=x86_64-apple-darwin9 | FileCheck %s -check-prefix=X64
 
 @x = external hidden global i32   ; <i32*> [#uses=1]
 @y = extern_weak hidden global i32  ; <i32*> [#uses=1]
 
 define i32 @t() nounwind readonly {
 entry:
 ; X32: _t:
 ; X32: movl _y, %eax
 
 ; X64: _t:
-; X64: movl _y(%rip), %eax
+; X64: movq _y@GOTPCREL(%rip), %rax
+; X64: movl (%rax), %eax
 
   %0 = load i32, i32* @x, align 4    ; <i32> [#uses=1]
   %1 = load i32, i32* @y, align 4    ; <i32> [#uses=1]
   %2 = add i32 %1, %0    ; <i32> [#uses=1]
   ret i32 %2
 }

test/CodeGen/X86/weak-undef.ll

 ; RUN: llc < %s -relocation-model=pic -mtriple=x86_64-pc-linux | FileCheck %s
 ; RUN: llc < %s -relocation-model=pic -mtriple=i386-pc-linux | FileCheck --check-prefix=I386 %s
 
 @foo1 = extern_weak hidden global i32, align 4
 define i32* @bar1() {
   ret i32* @foo1
 }
 ; CHECK: bar1:
 ; CHECK: movq foo1@GOTPCREL(%rip), %rax
 ; I386: bar1:
-; I386: leal foo1@GOTOFF(%eax), %eax
+; I386: movl foo1@GOT(%eax), %eax
 
 @foo2 = external hidden global i32, align 4
 define i32* @bar2() {
   ret i32* @foo2
 }
 ; CHECK: bar2:
 ; CHECK: leaq foo2(%rip), %rax
 ; I386: bar2:
 ; I386: leal foo2@GOTOFF(%eax), %eax
 
 declare extern_weak hidden void @foo3()
 define void @bar3() {
   call void @foo3()
   ret void
 }
 ; CHECK: bar3:
-; CHECK: callq foo3
+; CHECK: callq foo3@PLT
 ; I386: bar3:
-; I386: calll foo3
+; I386: calll foo3@PLT
 
 declare external hidden void @foo4()
 define void @bar4() {
   call void @foo4()
   ret void
 }
 ; CHECK: bar4:
 ; CHECK: callq foo4
 ; I386: bar4:
 ; I386: calll foo4
 
 declare extern_weak hidden i32 @foo5()
 define i32()* @bar5() {
   ret i32()* @foo5
 }
 ; CHECK: bar5:
 ; CHECK: movq foo5@GOTPCREL(%rip), %rax
 ; I386: bar5:
-; I386: leal foo5@GOTOFF(%eax), %eax
+; I386: movl foo5@GOT(%eax), %eax
 
 declare external hidden i32 @foo6()
 define i32()* @bar6() {
   ret i32()* @foo6
 }
 ; CHECK: bar6:
 ; CHECK: leaq foo6(%rip), %rax
 ; I386: bar6:
 ; I386: leal foo6@GOTOFF(%eax), %eax