Make CanUseCopyRelocWithPIE a llc option, -pie-copy-relocations

[tmsriram]

Summary

This patch added CanUseCopyRelocWithPIE:
http://llvm.org/viewvc/llvm-project?view=revision&revision=273958

I am converting this into a llvm option -pie-copy-relocations

Rreviously, copy relocations with PIE was discussed here:
https://reviews.llvm.org/D19995

[davide]

Can you give a little bit more context? How do you plan to use this option?

[tmsriram]

In D24849#551075, @davide wrote:

Can you give a little bit more context? How do you plan to use this option?

https://reviews.llvm.org/D19995 discusses this in detail but here is the quick summary:

• When linking executables in non-PIE mode, references to external globals do not use the GOT. They are treated as if the globals were defined in the executable.
• If it so happens that the global is not defined in the executable, a copy relocation is used to duplicate the definition in the executable.
• Currently, in PIE mode, all accesses to external globals use an extra load from the GOT to get its address which is then dereferenced.
• This is particularly inefficient if it turns out at link time that the global ends up being defined in the executable from a different compilation unit.
• Using GOT accesses for globals that end up defined in the executable regresses some of our benchmarks by a few percent.
• It turns out that copy relocations can be used here just like non-PIE mode to always avoid the extra load from the GOT and directly access the global.
• Gold and GNU ld started supporting copy relocations for pie only recently. Gold supports via this patch : https://sourceware.org/ml/binutils/2014-05/msg00092.html
• This option is meant to be used when the linker allows copy relocations for PIE. The default is off.
• GCC already does this, patch discussing this : https://gcc.gnu.org/ml/gcc-patches/2014-05/msg01215.html

This was discussed quite a bit and Rafael wanted something in the IR to tag globals as "extern local" is needed. For "extern local" globals compiler would not use the GOT and instead the linker would emit a warning if the global ends up undefined in the executable. For globals that are extern and not marked local, GOT would be used if copy relocations support is not available.

[tmsriram]

Ping.

[rnk]

lib/Target/TargetMachine.cpp

118–121

This should really live in MCTargetOptions, and not a global. We're trying to move away from cl::opt in library code.

[davide]

lib/Target/TargetMachine.cpp

118–121

Strongly agree. Other than that the logic seems right to me. Please upload another version.

[tmsriram]

• Removed cl::opt from library code
• Created MCTargetOptions member MCPIECopyRelocations instead.
• New llc command-line option -pie-copy-relocations to enable it.
• I will add a clang option separately to enable this.

[davide]

This is probably OK. Reid?

[rnk]

lib/Target/TargetMachine.cpp

157

GV could be a GlobalAlias to a function, so I think this would be better as isa<GlobalVariable>(GV) instead of not a function. That's worth adding as a test case too, if you could

[tmsriram]

• Check for isa<GlobalVariable> rather than !isa<Function>
• Test case for Global Alias is not required as alias implies the aliased object is defined and is hence DSO local.

[rnk]

lgtm, thanks!

[tmsriram]

Check if GV not null before checking its type.

lib/Target/TargetMachine.cpp

static TLSModel::Model getSelectedTLSModel(const GlobalValue *GV) {
   case GlobalVariable::InitialExecTLSModel:
     return TLSModel::InitialExec;
   case GlobalVariable::LocalExecTLSModel:
     return TLSModel::LocalExec;
   }
   llvm_unreachable("invalid TLS model");
 }
 
-// FIXME: make this a proper option
-static bool CanUseCopyRelocWithPIE = false;
+static cl::opt<bool>
+CanUseCopyRelocWithPIE("pie-copy-relocations", cl::init(false),
+                       cl::desc("Assume copy relocations support exists when "
+                                "generating code for PIE executables."));
 
 bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
                                          const GlobalValue *GV) const {
   Reloc::Model RM = getRelocationModel();
   const Triple &TT = getTargetTriple();
 
   // DLLImport explicitly marks the GV as external.
   if (GV && GV->hasDLLImportStorageClass())
bool TargetMachine::shouldAssumeDSOLocal(const Module &M,
   bool IsExecutable =
       RM == Reloc::Static || M.getPIELevel() != PIELevel::Default;
   if (IsExecutable) {
     // If the symbol is defined, it cannot be preempted.
     if (GV && !GV->isDeclarationForLinker())
       return true;
 
     bool IsTLS = GV && GV->isThreadLocal();
+    bool IsAccessViaCopyRelocs = (!isa<Function>(GV) && CanUseCopyRelocWithPIE);
     // Check if we can use copy relocations.
-    if (!IsTLS && (RM == Reloc::Static || CanUseCopyRelocWithPIE))
+    if (!IsTLS && (RM == Reloc::Static || IsAccessViaCopyRelocs))
       return true;
   }
 
   // ELF supports preemption of other symbols.
   return false;
 }
 
 TLSModel::Model TargetMachine::getTLSModel(const GlobalValue *GV) const {

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

+; RUN: llc < %s -march=x86-64 -mcpu=generic -mtriple=x86_64-linux-gnu -relocation-model=pic -pie-copy-relocations \
+; RUN:   | FileCheck -check-prefix=X64 %s
+; RUN: llc < %s -emulated-tls -march=x86 -mcpu=generic -mtriple=i386-linux-gnu -relocation-model=pic -pie-copy-relocations \
+; RUN:   | FileCheck -check-prefix=X32 %s
+
+; External Linkage
+@a = global i32 0, align 4
+
+define i32 @my_access_global_a() #0 {
+; X32-LABEL: my_access_global_a:
+; X32:       addl $_GLOBAL_OFFSET_TABLE_{{.*}}, %eax
+; X32-NEXT:  movl a@GOTOFF(%eax), %eax
+; X64-LABEL: my_access_global_a:
+; X64:       movl a(%rip), %eax
+
+entry:
+  %0 = load i32, i32* @a, align 4
+  ret i32 %0
+}
+
+; WeakAny Linkage
+@b = weak global i32 0, align 4
+
+define i32 @my_access_global_b() #0 {
+; X32-LABEL: my_access_global_b:
+; X32:       addl $_GLOBAL_OFFSET_TABLE_{{.*}}, %eax
+; X32-NEXT:  movl b@GOTOFF(%eax), %eax
+; X64-LABEL: my_access_global_b:
+; X64:       movl b(%rip), %eax
+
+entry:
+  %0 = load i32, i32* @b, align 4
+  ret i32 %0
+}
+
+; Internal Linkage
+@c = internal global i32 0, align 4
+
+define i32 @my_access_global_c() #0 {
+; X32-LABEL: my_access_global_c:
+; X32:       addl $_GLOBAL_OFFSET_TABLE_{{.*}}, %eax
+; X32-NEXT:  movl c@GOTOFF(%eax), %eax
+; X64-LABEL: my_access_global_c:
+; X64:       movl c(%rip), %eax
+
+entry:
+  %0 = load i32, i32* @c, align 4
+  ret i32 %0
+}
+
+; External Linkage, only declaration.
+@d = external global i32, align 4
+
+define i32 @my_access_global_load_d() #0 {
+; X32-LABEL: my_access_global_load_d:
+; X32:       addl $_GLOBAL_OFFSET_TABLE_{{.*}}, %eax
+; X32-NEXT:  movl d@GOTOFF(%eax), %eax
+; X64-LABEL: my_access_global_load_d:
+; X64:       movl d(%rip), %eax
+
+entry:
+  %0 = load i32, i32* @d, align 4
+  ret i32 %0
+}
+
+; 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)
+
+entry:
+  store i32 2, i32* @d, align 4
+  ret i32 0
+}
+
+; External Linkage, function pointer access.
+declare i32 @access_fp(i32 ()*)
+declare i32 @foo()
+
+define i32 @my_access_fp_foo() #0 {
+; X32-LABEL: my_access_fp_foo:
+; X32:       addl $_GLOBAL_OFFSET_TABLE_{{.*}}, %ebx
+; X32-NEXT:  movl foo@GOT(%ebx), %eax
+; X64-LABEL: my_access_fp_foo:
+; X64:       movq foo@GOTPCREL(%rip), %rdi
+
+entry:
+  %call = call i32 @access_fp(i32 ()* @foo)
+  ret i32 %call
+}
+
+; LinkOnceODR Linkage, function pointer access.
+
+$bar = comdat any
+
+define linkonce_odr i32 @bar() comdat {
+entry:
+  ret i32 0
+}
+
+define i32 @my_access_fp_bar() #0 {
+; X32-LABEL: my_access_fp_bar:
+; X32:       addl $_GLOBAL_OFFSET_TABLE_{{.*}}, %ebx
+; X32-NEXT:  leal bar@GOTOFF(%ebx), %eax
+; X64-LABEL: my_access_fp_bar:
+; X64:       leaq bar(%rip), %rdi
+
+entry:
+  %call = call i32 @access_fp(i32 ()* @bar)
+  ret i32 %call
+}
+
+!llvm.module.flags = !{!0, !1}
+!0 = !{i32 1, !"PIC Level", i32 1}
+!1 = !{i32 1, !"PIE Level", i32 1}