Home | History | Annotate | Download | only in X86 
      1 //===-- X86Subtarget.cpp - X86 Subtarget Information ----------------------===//
      2 //
      3 //                     The LLVM Compiler Infrastructure
      4 //
      5 // This file is distributed under the University of Illinois Open Source
      6 // License. See LICENSE.TXT for details.
      7 //
      8 //===----------------------------------------------------------------------===//
      9 //
     10 // This file implements the X86 specific subclass of TargetSubtargetInfo.
     11 //
     12 //===----------------------------------------------------------------------===//
     13 
     14 #include "X86Subtarget.h"
     15 #include "X86InstrInfo.h"
     16 #include "X86TargetMachine.h"
     17 #include "llvm/IR/Attributes.h"
     18 #include "llvm/IR/Function.h"
     19 #include "llvm/IR/GlobalValue.h"
     20 #include "llvm/Support/CommandLine.h"
     21 #include "llvm/Support/Debug.h"
     22 #include "llvm/Support/ErrorHandling.h"
     23 #include "llvm/Support/Host.h"
     24 #include "llvm/Support/raw_ostream.h"
     25 #include "llvm/Target/TargetMachine.h"
     26 #include "llvm/Target/TargetOptions.h"
     27 
     28 #if defined(_MSC_VER)
     29 #include <intrin.h>
     30 #endif
     31 
     32 using namespace llvm;
     33 
     34 #define DEBUG_TYPE "subtarget"
     35 
     36 #define GET_SUBTARGETINFO_TARGET_DESC
     37 #define GET_SUBTARGETINFO_CTOR
     38 #include "X86GenSubtargetInfo.inc"
     39 
     40 // Temporary option to control early if-conversion for x86 while adding machine
     41 // models.
     42 static cl::opt<bool>
     43 X86EarlyIfConv("x86-early-ifcvt", cl::Hidden,
     44                cl::desc("Enable early if-conversion on X86"));
     45 
     46 
     47 /// Classify a blockaddress reference for the current subtarget according to how
     48 /// we should reference it in a non-pcrel context.
     49 unsigned char X86Subtarget::ClassifyBlockAddressReference() const {
     50   if (isPICStyleGOT())    // 32-bit ELF targets.
     51     return X86II::MO_GOTOFF;
     52 
     53   if (isPICStyleStubPIC())   // Darwin/32 in PIC mode.
     54     return X86II::MO_PIC_BASE_OFFSET;
     55 
     56   // Direct static reference to label.
     57   return X86II::MO_NO_FLAG;
     58 }
     59 
     60 /// Classify a global variable reference for the current subtarget according to
     61 /// how we should reference it in a non-pcrel context.
     62 unsigned char X86Subtarget::
     63 ClassifyGlobalReference(const GlobalValue *GV, const TargetMachine &TM) const {
     64   // DLLImport only exists on windows, it is implemented as a load from a
     65   // DLLIMPORT stub.
     66   if (GV->hasDLLImportStorageClass())
     67     return X86II::MO_DLLIMPORT;
     68 
     69   bool isDef = GV->isStrongDefinitionForLinker();
     70 
     71   // X86-64 in PIC mode.
     72   if (isPICStyleRIPRel()) {
     73     // Large model never uses stubs.
     74     if (TM.getCodeModel() == CodeModel::Large)
     75       return X86II::MO_NO_FLAG;
     76 
     77     if (isTargetDarwin()) {
     78       // If symbol visibility is hidden, the extra load is not needed if
     79       // target is x86-64 or the symbol is definitely defined in the current
     80       // translation unit.
     81       if (GV->hasDefaultVisibility() && !isDef)
     82         return X86II::MO_GOTPCREL;
     83     } else if (!isTargetWin64()) {
     84       assert(isTargetELF() && "Unknown rip-relative target");
     85 
     86       // Extra load is needed for all externally visible.
     87       if (!GV->hasLocalLinkage() && GV->hasDefaultVisibility())
     88         return X86II::MO_GOTPCREL;
     89     }
     90 
     91     return X86II::MO_NO_FLAG;
     92   }
     93 
     94   if (isPICStyleGOT()) {   // 32-bit ELF targets.
     95     // Extra load is needed for all externally visible.
     96     if (GV->hasLocalLinkage() || GV->hasHiddenVisibility())
     97       return X86II::MO_GOTOFF;
     98     return X86II::MO_GOT;
     99   }
    100 
    101   if (isPICStyleStubPIC()) {  // Darwin/32 in PIC mode.
    102     // Determine whether we have a stub reference and/or whether the reference
    103     // is relative to the PIC base or not.
    104 
    105     // If this is a strong reference to a definition, it is definitely not
    106     // through a stub.
    107     if (isDef)
    108       return X86II::MO_PIC_BASE_OFFSET;
    109 
    110     // Unless we have a symbol with hidden visibility, we have to go through a
    111     // normal $non_lazy_ptr stub because this symbol might be resolved late.
    112     if (!GV->hasHiddenVisibility())  // Non-hidden $non_lazy_ptr reference.
    113       return X86II::MO_DARWIN_NONLAZY_PIC_BASE;
    114 
    115     // If symbol visibility is hidden, we have a stub for common symbol
    116     // references and external declarations.
    117     if (GV->isDeclarationForLinker() || GV->hasCommonLinkage()) {
    118       // Hidden $non_lazy_ptr reference.
    119       return X86II::MO_DARWIN_HIDDEN_NONLAZY_PIC_BASE;
    120     }
    121 
    122     // Otherwise, no stub.
    123     return X86II::MO_PIC_BASE_OFFSET;
    124   }
    125 
    126   if (isPICStyleStubNoDynamic()) {  // Darwin/32 in -mdynamic-no-pic mode.
    127     // Determine whether we have a stub reference.
    128 
    129     // If this is a strong reference to a definition, it is definitely not
    130     // through a stub.
    131     if (isDef)
    132       return X86II::MO_NO_FLAG;
    133 
    134     // Unless we have a symbol with hidden visibility, we have to go through a
    135     // normal $non_lazy_ptr stub because this symbol might be resolved late.
    136     if (!GV->hasHiddenVisibility())  // Non-hidden $non_lazy_ptr reference.
    137       return X86II::MO_DARWIN_NONLAZY;
    138 
    139     // Otherwise, no stub.
    140     return X86II::MO_NO_FLAG;
    141   }
    142 
    143   // Direct static reference to global.
    144   return X86II::MO_NO_FLAG;
    145 }
    146 
    147 
    148 /// This function returns the name of a function which has an interface like
    149 /// the non-standard bzero function, if such a function exists on the
    150 /// current subtarget and it is considered preferable over memset with zero
    151 /// passed as the second argument. Otherwise it returns null.
    152 const char *X86Subtarget::getBZeroEntry() const {
    153   // Darwin 10 has a __bzero entry point for this purpose.
    154   if (getTargetTriple().isMacOSX() &&
    155       !getTargetTriple().isMacOSXVersionLT(10, 6))
    156     return "__bzero";
    157 
    158   return nullptr;
    159 }
    160 
    161 bool X86Subtarget::hasSinCos() const {
    162   return getTargetTriple().isMacOSX() &&
    163     !getTargetTriple().isMacOSXVersionLT(10, 9) &&
    164     is64Bit();
    165 }
    166 
    167 /// Return true if the subtarget allows calls to immediate address.
    168 bool X86Subtarget::IsLegalToCallImmediateAddr(const TargetMachine &TM) const {
    169   // FIXME: I386 PE/COFF supports PC relative calls using IMAGE_REL_I386_REL32
    170   // but WinCOFFObjectWriter::RecordRelocation cannot emit them.  Once it does,
    171   // the following check for Win32 should be removed.
    172   if (In64BitMode || isTargetWin32())
    173     return false;
    174   return isTargetELF() || TM.getRelocationModel() == Reloc::Static;
    175 }
    176 
    177 void X86Subtarget::initSubtargetFeatures(StringRef CPU, StringRef FS) {
    178   std::string CPUName = CPU;
    179   if (CPUName.empty())
    180     CPUName = "generic";
    181 
    182   // Make sure 64-bit features are available in 64-bit mode. (But make sure
    183   // SSE2 can be turned off explicitly.)
    184   std::string FullFS = FS;
    185   if (In64BitMode) {
    186     if (!FullFS.empty())
    187       FullFS = "+64bit,+sse2," + FullFS;
    188     else
    189       FullFS = "+64bit,+sse2";
    190   }
    191 
    192   // LAHF/SAHF are always supported in non-64-bit mode.
    193   if (!In64BitMode) {
    194     if (!FullFS.empty())
    195       FullFS = "+sahf," + FullFS;
    196     else
    197       FullFS = "+sahf";
    198   }
    199 
    200 
    201   // Parse features string and set the CPU.
    202   ParseSubtargetFeatures(CPUName, FullFS);
    203 
    204   // All CPUs that implement SSE4.2 or SSE4A support unaligned accesses of
    205   // 16-bytes and under that are reasonably fast. These features were
    206   // introduced with Intel's Nehalem/Silvermont and AMD's Family10h
    207   // micro-architectures respectively.
    208   if (hasSSE42() || hasSSE4A())
    209     IsUAMem16Slow = false;
    210 
    211   InstrItins = getInstrItineraryForCPU(CPUName);
    212 
    213   // It's important to keep the MCSubtargetInfo feature bits in sync with
    214   // target data structure which is shared with MC code emitter, etc.
    215   if (In64BitMode)
    216     ToggleFeature(X86::Mode64Bit);
    217   else if (In32BitMode)
    218     ToggleFeature(X86::Mode32Bit);
    219   else if (In16BitMode)
    220     ToggleFeature(X86::Mode16Bit);
    221   else
    222     llvm_unreachable("Not 16-bit, 32-bit or 64-bit mode!");
    223 
    224   DEBUG(dbgs() << "Subtarget features: SSELevel " << X86SSELevel
    225                << ", 3DNowLevel " << X863DNowLevel
    226                << ", 64bit " << HasX86_64 << "\n");
    227   assert((!In64BitMode || HasX86_64) &&
    228          "64-bit code requested on a subtarget that doesn't support it!");
    229 
    230   // Stack alignment is 16 bytes on Darwin, Linux and Solaris (both
    231   // 32 and 64 bit) and for all 64-bit targets.
    232   if (StackAlignOverride)
    233     stackAlignment = StackAlignOverride;
    234   else if (isTargetDarwin() || isTargetLinux() || isTargetSolaris() ||
    235            In64BitMode)
    236     stackAlignment = 16;
    237 }
    238 
    239 void X86Subtarget::initializeEnvironment() {
    240   X86SSELevel = NoSSE;
    241   X863DNowLevel = NoThreeDNow;
    242   HasCMov = false;
    243   HasX86_64 = false;
    244   HasPOPCNT = false;
    245   HasSSE4A = false;
    246   HasAES = false;
    247   HasFXSR = false;
    248   HasXSAVE = false;
    249   HasXSAVEOPT = false;
    250   HasXSAVEC = false;
    251   HasXSAVES = false;
    252   HasPCLMUL = false;
    253   HasFMA = false;
    254   HasFMA4 = false;
    255   HasXOP = false;
    256   HasTBM = false;
    257   HasMOVBE = false;
    258   HasRDRAND = false;
    259   HasF16C = false;
    260   HasFSGSBase = false;
    261   HasLZCNT = false;
    262   HasBMI = false;
    263   HasBMI2 = false;
    264   HasRTM = false;
    265   HasHLE = false;
    266   HasERI = false;
    267   HasCDI = false;
    268   HasPFI = false;
    269   HasDQI = false;
    270   HasBWI = false;
    271   HasVLX = false;
    272   HasADX = false;
    273   HasPKU = false;
    274   HasSHA = false;
    275   HasPRFCHW = false;
    276   HasRDSEED = false;
    277   HasLAHFSAHF = false;
    278   HasMPX = false;
    279   IsBTMemSlow = false;
    280   IsSHLDSlow = false;
    281   IsUAMem16Slow = false;
    282   IsUAMem32Slow = false;
    283   HasSSEUnalignedMem = false;
    284   HasCmpxchg16b = false;
    285   UseLeaForSP = false;
    286   HasSlowDivide32 = false;
    287   HasSlowDivide64 = false;
    288   PadShortFunctions = false;
    289   CallRegIndirect = false;
    290   LEAUsesAG = false;
    291   SlowLEA = false;
    292   SlowIncDec = false;
    293   stackAlignment = 4;
    294   // FIXME: this is a known good value for Yonah. How about others?
    295   MaxInlineSizeThreshold = 128;
    296   UseSoftFloat = false;
    297 }
    298 
    299 X86Subtarget &X86Subtarget::initializeSubtargetDependencies(StringRef CPU,
    300                                                             StringRef FS) {
    301   initializeEnvironment();
    302   initSubtargetFeatures(CPU, FS);
    303   return *this;
    304 }
    305 
    306 X86Subtarget::X86Subtarget(const Triple &TT, const std::string &CPU,
    307                            const std::string &FS, const X86TargetMachine &TM,
    308                            unsigned StackAlignOverride)
    309     : X86GenSubtargetInfo(TT, CPU, FS), X86ProcFamily(Others),
    310       PICStyle(PICStyles::None), TargetTriple(TT),
    311       StackAlignOverride(StackAlignOverride),
    312       In64BitMode(TargetTriple.getArch() == Triple::x86_64),
    313       In32BitMode(TargetTriple.getArch() == Triple::x86 &&
    314                   TargetTriple.getEnvironment() != Triple::CODE16),
    315       In16BitMode(TargetTriple.getArch() == Triple::x86 &&
    316                   TargetTriple.getEnvironment() == Triple::CODE16),
    317       TSInfo(), InstrInfo(initializeSubtargetDependencies(CPU, FS)),
    318       TLInfo(TM, *this), FrameLowering(*this, getStackAlignment()) {
    319   // Determine the PICStyle based on the target selected.
    320   if (TM.getRelocationModel() == Reloc::Static) {
    321     // Unless we're in PIC or DynamicNoPIC mode, set the PIC style to None.
    322     setPICStyle(PICStyles::None);
    323   } else if (is64Bit()) {
    324     // PIC in 64 bit mode is always rip-rel.
    325     setPICStyle(PICStyles::RIPRel);
    326   } else if (isTargetCOFF()) {
    327     setPICStyle(PICStyles::None);
    328   } else if (isTargetDarwin()) {
    329     if (TM.getRelocationModel() == Reloc::PIC_)
    330       setPICStyle(PICStyles::StubPIC);
    331     else {
    332       assert(TM.getRelocationModel() == Reloc::DynamicNoPIC);
    333       setPICStyle(PICStyles::StubDynamicNoPIC);
    334     }
    335   } else if (isTargetELF()) {
    336     setPICStyle(PICStyles::GOT);
    337   }
    338 }
    339 
    340 bool X86Subtarget::enableEarlyIfConversion() const {
    341   return hasCMov() && X86EarlyIfConv;
    342 }
    343 
    344