[X86SubTarget] use isPositionIndependent()

[davide]

Summary

with llvm-commits

[• rafael]

LGTM

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

public:
   bool isPICStyleStubNoDynamic() const {
     return PICStyle == PICStyles::StubDynamicNoPIC;
   }
   bool isPICStyleStubAny() const {
     return PICStyle == PICStyles::StubDynamicNoPIC ||
            PICStyle == PICStyles::StubPIC;
   }
 
+  bool isPositionIndependent() const {
+    return TM.getRelocationModel() == Reloc::PIC_;
+  }
+
   bool isCallingConvWin64(CallingConv::ID CC) const {
     switch (CC) {
     // On Win64, all these conventions just use the default convention.
     case CallingConv::C:
     case CallingConv::Fast:
     case CallingConv::X86_FastCall:
     case CallingConv::X86_StdCall:
     case CallingConv::X86_ThisCall:

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

 unsigned char
 X86Subtarget::classifyLocalReference(const GlobalValue *GV) const {
   // 64 bits can use %rip addressing for anything local.
   if (is64Bit())
     return X86II::MO_NO_FLAG;
 
   // If this is for a position dependent executable, the static linker can
   // figure it out.
-  if (TM.getRelocationModel() != Reloc::PIC_)
+  if (!isPositionIndependent())
     return X86II::MO_NO_FLAG;
 
   // The COFF dynamic linker just patches the executable sections.
   if (isTargetCOFF())
     return X86II::MO_NO_FLAG;
 
   if (isTargetDarwin()) {
     // 32 bit macho has no relocation for a-b if a is undefined, even if
unsigned char X86Subtarget::classifyGlobalReference(const GlobalValue *GV,
 
   if (isTargetCOFF())
     return X86II::MO_DLLIMPORT;
 
   if (is64Bit())
     return X86II::MO_GOTPCREL;
 
   if (isTargetDarwin()) {
-    if (RM != Reloc::PIC_)
+    if (!isPositionIndependent())
       return X86II::MO_DARWIN_NONLAZY;
     return X86II::MO_DARWIN_NONLAZY_PIC_BASE;
   }
 
   return X86II::MO_GOT;
 }
 
 unsigned char
if (TM.getRelocationModel() == Reloc::Static) {
     // Unless we're in PIC or DynamicNoPIC mode, set the PIC style to None.
     setPICStyle(PICStyles::None);
   } else if (is64Bit()) {
     // PIC in 64 bit mode is always rip-rel.
     setPICStyle(PICStyles::RIPRel);
   } else if (isTargetCOFF()) {
     setPICStyle(PICStyles::None);
   } else if (isTargetDarwin()) {
-    if (TM.getRelocationModel() == Reloc::PIC_)
+    if (isPositionIndependent())
       setPICStyle(PICStyles::StubPIC);
     else {
       assert(TM.getRelocationModel() == Reloc::DynamicNoPIC);
       setPICStyle(PICStyles::StubDynamicNoPIC);
     }
   } else if (isTargetELF()) {
     setPICStyle(PICStyles::GOT);
   }
 }
 
 bool X86Subtarget::enableEarlyIfConversion() const {
   return hasCMov() && X86EarlyIfConv;
 }