Use PIELevel module flags instead of Target option PositionIndependentExecutable

[tmsriram]

Summary

• Use PIELevel module flags instead of Target option PositionIndependentExecutable
• Remove use of -enable-pie option with llc in tests
• Add PIELevel module flag to tests where PIE should be enabled

After this, I can safely delete Target option PositionIndependentExecutable. I will send a clang patch to delete all references to this.

[rnk]

lgtm, one less TargetOption!

[tmsriram]

• Delete option -enable-pie.

llvm/trunk/include/llvm/CodeGen/CommandFlags.h

StackRealign("stackrealign",
              cl::init(false));
 
 cl::opt<std::string>
 TrapFuncName("trap-func", cl::Hidden,
         cl::desc("Emit a call to trap function rather than a trap instruction"),
         cl::init(""));
 
 cl::opt<bool>
-EnablePIE("enable-pie",
-          cl::desc("Assume the creation of a position independent executable."),
-          cl::init(false));
-
-cl::opt<bool>
 UseCtors("use-ctors",
              cl::desc("Use .ctors instead of .init_array."),
              cl::init(false));
 
 cl::opt<std::string> StopAfter("stop-after",
                             cl::desc("Stop compilation after a specific pass"),
                             cl::value_desc("pass-name"),
                                       cl::init(""));
static inline TargetOptions InitTargetOptionsFromCodeGenFlags() {
   Options.HonorSignDependentRoundingFPMathOption =
       EnableHonorSignDependentRoundingFPMath;
   if (FloatABIForCalls != FloatABI::Default)
     Options.FloatABIType = FloatABIForCalls;
   Options.NoZerosInBSS = DontPlaceZerosInBSS;
   Options.GuaranteedTailCallOpt = EnableGuaranteedTailCallOpt;
   Options.StackAlignmentOverride = OverrideStackAlignment;
   Options.StackSymbolOrdering = StackSymbolOrdering;
-  Options.PositionIndependentExecutable = EnablePIE;
   Options.UseInitArray = !UseCtors;
   Options.DataSections = DataSections;
   Options.FunctionSections = FunctionSections;
   Options.UniqueSectionNames = UniqueSectionNames;
   Options.EmulatedTLS = EmulatedTLS;
 
   Options.MCOptions = InitMCTargetOptionsFromFlags();
   Options.JTType = JTableType;

llvm/trunk/lib/Target/TargetMachine.cpp

static TLSModel::Model getSelectedTLSModel(const GlobalValue *GV) {
   }
   llvm_unreachable("invalid TLS model");
 }
 
 TLSModel::Model TargetMachine::getTLSModel(const GlobalValue *GV) const {
   bool isLocal = GV->hasLocalLinkage();
   bool isDeclaration = GV->isDeclaration();
   bool isPIC = getRelocationModel() == Reloc::PIC_;
-  bool isPIE = Options.PositionIndependentExecutable;
+  bool isPIE = GV->getParent()->getPIELevel() != PIELevel::Default;
   // FIXME: what should we do for protected and internal visibility?
   // For variables, is internal different from hidden?
   bool isHidden = GV->hasHiddenVisibility();
 
   TLSModel::Model Model;
   if (isPIC && !isPIE) {
     if (isLocal || isHidden)
       Model = TLSModel::LocalDynamic;

llvm/trunk/lib/Target/X86/X86Subtarget.h

default:
       return false;
     }
   }
 
   /// Determine if this global is defined in a Position Independent
   /// Executable (PIE) where its definition cannot be interposed.
   bool isGlobalDefinedInPIE(const GlobalValue *GV,
                             const TargetMachine &TM) const {
-    return TM.Options.PositionIndependentExecutable &&
+    return GV->getParent()->getPIELevel() != PIELevel::Default &&
            !GV->isDeclarationForLinker();
   }
 
   /// ClassifyGlobalReference - Classify a global variable reference for the
   /// current subtarget according to how we should reference it in a non-pcrel
   /// context.
   unsigned char ClassifyGlobalReference(const GlobalValue *GV,
                                         const TargetMachine &TM)const;

llvm/trunk/lib/Target/X86/X86Subtarget.cpp

 unsigned char X86Subtarget::classifyGlobalFunctionReference(
     const GlobalValue *GV, const TargetMachine &TM) const {
   // On ELF targets, in both X86-64 and X86-32 mode, direct calls to
   // external symbols most go through the PLT in PIC mode.  If the symbol
   // has hidden or protected visibility, or if it is static or local, then
   // we don't need to use the PLT - we can directly call it.
   // In PIE mode, calls to global functions don't need to go through PLT
   if (isTargetELF() && TM.getRelocationModel() == Reloc::PIC_ &&
-      (!TM.Options.PositionIndependentExecutable ||
-       GV->isDeclarationForLinker()) &&
+      !isGlobalDefinedInPIE(GV, TM) &&
       GV->hasDefaultVisibility() && !GV->hasLocalLinkage()) {
     return X86II::MO_PLT;
   } else if (isPICStyleStubAny() && !GV->isStrongDefinitionForLinker() &&
              (!getTargetTriple().isMacOSX() ||
               getTargetTriple().isMacOSXVersionLT(10, 5))) {
     // PC-relative references to external symbols should go through $stub,
     // unless we're building with the leopard linker or later, which
     // automatically synthesizes these stubs.

llvm/trunk/test/CodeGen/X86/emutls-pie.ll

-; RUN: llc < %s -emulated-tls -march=x86 -mcpu=generic -mtriple=i386-linux-gnu -relocation-model=pic -enable-pie \
+; RUN: llc < %s -emulated-tls -march=x86 -mcpu=generic -mtriple=i386-linux-gnu -relocation-model=pic \
 ; RUN:   | FileCheck -check-prefix=X32 %s
-; RUN: llc < %s -emulated-tls -march=x86-64 -mcpu=generic -mtriple=x86_64-linux-gnu -relocation-model=pic -enable-pie \
+; RUN: llc < %s -emulated-tls -march=x86-64 -mcpu=generic -mtriple=x86_64-linux-gnu -relocation-model=pic \
 ; RUN:   | FileCheck -check-prefix=X64 %s
-; RUN: llc < %s -emulated-tls -march=x86 -mcpu=generic -mtriple=i386-linux-android -relocation-model=pic -enable-pie \
+; RUN: llc < %s -emulated-tls -march=x86 -mcpu=generic -mtriple=i386-linux-android -relocation-model=pic \
 ; RUN:   | FileCheck -check-prefix=X32 %s
-; RUN: llc < %s -emulated-tls -march=x86-64 -mcpu=generic -mtriple=x86_64-linux-android -relocation-model=pic -enable-pie \
+; RUN: llc < %s -emulated-tls -march=x86-64 -mcpu=generic -mtriple=x86_64-linux-android -relocation-model=pic \
 ; RUN:   | FileCheck -check-prefix=X64 %s
 
 ; Use my_emutls_get_address like __emutls_get_address.
 @my_emutls_v_xyz = external global i8*, align 4
 declare i8* @my_emutls_get_address(i8*)
 
 define i32 @my_get_xyz() {
 ; X32-LABEL: my_get_xyz:

 ; X64-NEXT: .quad __emutls_t.i
 
 ; X64:      .section .rodata,
 ; X64-LABEL: __emutls_t.i:
 ; X64-NEXT: .long 15
 
 ; X64-NOT:   __emutls_v.i2
 ; X64-NOT:   __emutls_t.i2
+
+
+!llvm.module.flags = !{!0, !1}
+!0 = !{i32 1, !"PIC Level", i32 1}
+!1 = !{i32 1, !"PIE Level", i32 1}

llvm/trunk/test/CodeGen/X86/global-access-pie.ll

-; RUN: llc < %s -march=x86-64 -mcpu=generic -mtriple=x86_64-linux-gnu -relocation-model=pic -enable-pie \
+; RUN: llc < %s -march=x86-64 -mcpu=generic -mtriple=x86_64-linux-gnu -relocation-model=pic \
 ; RUN:   | FileCheck -check-prefix=X64 %s
-; RUN: llc < %s -emulated-tls -march=x86 -mcpu=generic -mtriple=i386-linux-gnu -relocation-model=pic -enable-pie \
+; RUN: llc < %s -emulated-tls -march=x86 -mcpu=generic -mtriple=i386-linux-gnu -relocation-model=pic \
 ; 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:  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}

llvm/trunk/test/CodeGen/X86/pie.ll

-; RUN: llc < %s -O0 -mcpu=generic -mtriple=i686-linux-gnu -relocation-model=pic -enable-pie | FileCheck %s 
-; RUN: llc < %s -O0 -mcpu=generic -mtriple=i686-linux-gnu -fast-isel -relocation-model=pic -enable-pie | FileCheck %s 
-; RUN: llc < %s -O0 -mcpu=generic -mtriple=x86_64-linux-gnu -relocation-model=pic -enable-pie | FileCheck %s 
-; RUN: llc < %s -O0 -mcpu=generic -mtriple=x86_64-linux-gnu -fast-isel -relocation-model=pic -enable-pie | FileCheck %s 
+; RUN: llc < %s -O0 -mcpu=generic -mtriple=i686-linux-gnu -relocation-model=pic | FileCheck %s 
+; RUN: llc < %s -O0 -mcpu=generic -mtriple=i686-linux-gnu -fast-isel -relocation-model=pic | FileCheck %s 
+; RUN: llc < %s -O0 -mcpu=generic -mtriple=x86_64-linux-gnu -relocation-model=pic | FileCheck %s 
+; RUN: llc < %s -O0 -mcpu=generic -mtriple=x86_64-linux-gnu -fast-isel -relocation-model=pic | FileCheck %s 
 
 ; CHECK-LABEL:  bar:
 ; CHECK:  call{{l|q}}  foo{{$}}
 ; CHECK:  call{{l|q}}  weak_odr_foo{{$}}
 ; CHECK:  call{{l|q}}  weak_foo{{$}}
 ; CHECK:  call{{l|q}}  internal_foo{{$}}
 ; CHECK:  call{{l|q}}  ext_baz@PLT
 
entry:
   call void @weak_odr_foo()
   call void @weak_foo()
   call void @internal_foo()
   call i32 @ext_baz()
   ret void
 }
 
 ; -fpie for local global data tests should be added here
+
+!llvm.module.flags = !{!0, !1}
+!0 = !{i32 1, !"PIC Level", i32 1}
+!1 = !{i32 1, !"PIE Level", i32 1}

llvm/trunk/test/CodeGen/X86/tls-pie.ll

-; RUN: llc < %s -march=x86 -mcpu=generic -mtriple=i386-linux-gnu -relocation-model=pic -enable-pie \
+; RUN: llc < %s -march=x86 -mcpu=generic -mtriple=i386-linux-gnu -relocation-model=pic \
 ; RUN:   | FileCheck -check-prefix=X32 %s
-; RUN: llc < %s -march=x86-64 -mcpu=generic -mtriple=x86_64-linux-gnu -relocation-model=pic -enable-pie \
+; RUN: llc < %s -march=x86-64 -mcpu=generic -mtriple=x86_64-linux-gnu -relocation-model=pic \
 ; RUN:   | FileCheck -check-prefix=X64 %s
 
 @i = thread_local global i32 15
 @i2 = external thread_local global i32
 
 define i32 @f1() {
 ; X32-LABEL: f1:
 ; X32:      movl %gs:i@NTPOFF, %eax

 ; X64-LABEL: f4:
 ; X64:      movq %fs:0, %rax
 ; X64-NEXT: addq i2@GOTTPOFF(%rip), %rax
 ; X64-NEXT: ret
 
 entry:
   ret i32* @i2
 }
+
+!llvm.module.flags = !{!0, !1}
+!0 = !{i32 1, !"PIC Level", i32 1}
+!1 = !{i32 1, !"PIE Level", i32 1}