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 ↗

(On Diff #72219)

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 ↗

(On Diff #72219)

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

152 ↗

(On Diff #73313)

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.

llvm/trunk/include/llvm/MC/MCTargetOptions.h

public:
 
   bool MCRelaxAll : 1;
   bool MCNoExecStack : 1;
   bool MCFatalWarnings : 1;
   bool MCNoWarn : 1;
   bool MCSaveTempLabels : 1;
   bool MCUseDwarfDirectory : 1;
   bool MCIncrementalLinkerCompatible : 1;
+  bool MCPIECopyRelocations : 1;
   bool ShowMCEncoding : 1;
   bool ShowMCInst : 1;
   bool AsmVerbose : 1;
 
   /// Preserve Comments in Assembly.
   bool PreserveAsmComments : 1;
 
   int DwarfVersion;
#define ARE_EQUAL(X) LHS.X == RHS.X
   return (ARE_EQUAL(SanitizeAddress) &&
           ARE_EQUAL(MCRelaxAll) &&
           ARE_EQUAL(MCNoExecStack) &&
           ARE_EQUAL(MCFatalWarnings) &&
           ARE_EQUAL(MCNoWarn) &&
           ARE_EQUAL(MCSaveTempLabels) &&
           ARE_EQUAL(MCUseDwarfDirectory) &&
           ARE_EQUAL(MCIncrementalLinkerCompatible) &&
+          ARE_EQUAL(MCPIECopyRelocations) &&
           ARE_EQUAL(ShowMCEncoding) &&
           ARE_EQUAL(ShowMCInst) &&
           ARE_EQUAL(AsmVerbose) &&
           ARE_EQUAL(DwarfVersion) &&
           ARE_EQUAL(ABIName));
 #undef ARE_EQUAL
 }
 
 inline bool operator!=(const MCTargetOptions &LHS, const MCTargetOptions &RHS) {
   return !(LHS == RHS);
 }
 
 } // end namespace llvm
 
 #endif

llvm/trunk/include/llvm/MC/MCTargetOptionsCommandFlags.h

cl::opt<bool> RelaxAll("mc-relax-all",
                                 "relax all fixups in the emitted object file"));
 
 cl::opt<bool> IncrementalLinkerCompatible(
     "incremental-linker-compatible",
     cl::desc(
         "When used with filetype=obj, "
         "emit an object file which can be used with an incremental linker"));
 
+cl::opt<bool> PIECopyRelocations("pie-copy-relocations", cl::desc("PIE Copy Relocations"));
+
 cl::opt<int> DwarfVersion("dwarf-version", cl::desc("Dwarf version"),
                           cl::init(0));
 
 cl::opt<bool> ShowMCInst("asm-show-inst",
                          cl::desc("Emit internal instruction representation to "
                                   "assembly file"));
 
 cl::opt<bool> FatalWarnings("fatal-warnings",
                             cl::desc("Treat warnings as errors"));
 
 cl::opt<bool> NoWarn("no-warn", cl::desc("Suppress all warnings"));
 cl::alias NoWarnW("W", cl::desc("Alias for --no-warn"), cl::aliasopt(NoWarn));
 
 cl::opt<std::string>
 ABIName("target-abi", cl::Hidden,
         cl::desc("The name of the ABI to be targeted from the backend."),
         cl::init(""));
 
 static inline MCTargetOptions InitMCTargetOptionsFromFlags() {
   MCTargetOptions Options;
   Options.SanitizeAddress =
       (AsmInstrumentation == MCTargetOptions::AsmInstrumentationAddress);
   Options.MCRelaxAll = RelaxAll;
   Options.MCIncrementalLinkerCompatible = IncrementalLinkerCompatible;
+  Options.MCPIECopyRelocations = PIECopyRelocations;
   Options.DwarfVersion = DwarfVersion;
   Options.ShowMCInst = ShowMCInst;
   Options.ABIName = ABIName;
   Options.MCFatalWarnings = FatalWarnings;
   Options.MCNoWarn = NoWarn;
   return Options;
 }
 
 #endif

llvm/trunk/lib/MC/MCTargetOptions.cpp

 #include "llvm/MC/MCTargetOptions.h"
 
 namespace llvm {
 
 MCTargetOptions::MCTargetOptions()
     : SanitizeAddress(false), MCRelaxAll(false), MCNoExecStack(false),
       MCFatalWarnings(false), MCNoWarn(false), MCSaveTempLabels(false),
       MCUseDwarfDirectory(false), MCIncrementalLinkerCompatible(false),
-      ShowMCEncoding(false), ShowMCInst(false), AsmVerbose(false),
+      MCPIECopyRelocations(false), ShowMCEncoding(false),
+      ShowMCInst(false), AsmVerbose(false),
       PreserveAsmComments(true), DwarfVersion(0), ABIName() {}
 
 StringRef MCTargetOptions::getABIName() const {
   return ABIName;
 }
 
 } // end namespace llvm

llvm/trunk/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;
-
 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())
     return false;
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 =
+        Options.MCOptions.MCPIECopyRelocations && GV && isa<GlobalVariable>(GV);
     // 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 {

llvm/trunk/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}