1 //===-- TargetMachine.cpp - General Target 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 describes the general parts of a Target machine. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "llvm/Target/TargetMachine.h" 15 #include "llvm/Analysis/TargetTransformInfo.h" 16 #include "llvm/IR/Function.h" 17 #include "llvm/IR/GlobalAlias.h" 18 #include "llvm/IR/GlobalValue.h" 19 #include "llvm/IR/GlobalVariable.h" 20 #include "llvm/IR/LegacyPassManager.h" 21 #include "llvm/IR/Mangler.h" 22 #include "llvm/MC/MCAsmInfo.h" 23 #include "llvm/MC/MCContext.h" 24 #include "llvm/MC/MCInstrInfo.h" 25 #include "llvm/MC/MCSectionMachO.h" 26 #include "llvm/MC/MCTargetOptions.h" 27 #include "llvm/MC/SectionKind.h" 28 #include "llvm/Target/TargetLoweringObjectFile.h" 29 using namespace llvm; 30 31 //--------------------------------------------------------------------------- 32 // TargetMachine Class 33 // 34 35 TargetMachine::TargetMachine(const Target &T, StringRef DataLayoutString, 36 const Triple &TT, StringRef CPU, StringRef FS, 37 const TargetOptions &Options) 38 : TheTarget(T), DL(DataLayoutString), TargetTriple(TT), TargetCPU(CPU), 39 TargetFS(FS), AsmInfo(nullptr), MRI(nullptr), MII(nullptr), STI(nullptr), 40 RequireStructuredCFG(false), DefaultOptions(Options), Options(Options) { 41 } 42 43 TargetMachine::~TargetMachine() { 44 delete AsmInfo; 45 delete MRI; 46 delete MII; 47 delete STI; 48 } 49 50 bool TargetMachine::isPositionIndependent() const { 51 return getRelocationModel() == Reloc::PIC_; 52 } 53 54 /// Reset the target options based on the function's attributes. 55 // FIXME: This function needs to go away for a number of reasons: 56 // a) global state on the TargetMachine is terrible in general, 57 // b) these target options should be passed only on the function 58 // and not on the TargetMachine (via TargetOptions) at all. 59 void TargetMachine::resetTargetOptions(const Function &F) const { 60 #define RESET_OPTION(X, Y) \ 61 do { \ 62 if (F.hasFnAttribute(Y)) \ 63 Options.X = (F.getFnAttribute(Y).getValueAsString() == "true"); \ 64 else \ 65 Options.X = DefaultOptions.X; \ 66 } while (0) 67 68 RESET_OPTION(UnsafeFPMath, "unsafe-fp-math"); 69 RESET_OPTION(NoInfsFPMath, "no-infs-fp-math"); 70 RESET_OPTION(NoNaNsFPMath, "no-nans-fp-math"); 71 RESET_OPTION(NoSignedZerosFPMath, "no-signed-zeros-fp-math"); 72 RESET_OPTION(NoTrappingFPMath, "no-trapping-math"); 73 74 StringRef Denormal = 75 F.getFnAttribute("denormal-fp-math").getValueAsString(); 76 if (Denormal == "ieee") 77 Options.FPDenormalMode = FPDenormal::IEEE; 78 else if (Denormal == "preserve-sign") 79 Options.FPDenormalMode = FPDenormal::PreserveSign; 80 else if (Denormal == "positive-zero") 81 Options.FPDenormalMode = FPDenormal::PositiveZero; 82 else 83 Options.FPDenormalMode = DefaultOptions.FPDenormalMode; 84 } 85 86 /// Returns the code generation relocation model. The choices are static, PIC, 87 /// and dynamic-no-pic. 88 Reloc::Model TargetMachine::getRelocationModel() const { return RM; } 89 90 /// Returns the code model. The choices are small, kernel, medium, large, and 91 /// target default. 92 CodeModel::Model TargetMachine::getCodeModel() const { return CMModel; } 93 94 /// Get the IR-specified TLS model for Var. 95 static TLSModel::Model getSelectedTLSModel(const GlobalValue *GV) { 96 switch (GV->getThreadLocalMode()) { 97 case GlobalVariable::NotThreadLocal: 98 llvm_unreachable("getSelectedTLSModel for non-TLS variable"); 99 break; 100 case GlobalVariable::GeneralDynamicTLSModel: 101 return TLSModel::GeneralDynamic; 102 case GlobalVariable::LocalDynamicTLSModel: 103 return TLSModel::LocalDynamic; 104 case GlobalVariable::InitialExecTLSModel: 105 return TLSModel::InitialExec; 106 case GlobalVariable::LocalExecTLSModel: 107 return TLSModel::LocalExec; 108 } 109 llvm_unreachable("invalid TLS model"); 110 } 111 112 bool TargetMachine::shouldAssumeDSOLocal(const Module &M, 113 const GlobalValue *GV) const { 114 // If the IR producer requested that this GV be treated as dso local, obey. 115 if (GV && GV->isDSOLocal()) 116 return true; 117 118 // If we are not supossed to use a PLT, we cannot assume that intrinsics are 119 // local since the linker can convert some direct access to access via plt. 120 if (M.getRtLibUseGOT() && !GV) 121 return false; 122 123 // According to the llvm language reference, we should be able to 124 // just return false in here if we have a GV, as we know it is 125 // dso_preemptable. At this point in time, the various IR producers 126 // have not been transitioned to always produce a dso_local when it 127 // is possible to do so. 128 // In the case of intrinsics, GV is null and there is nowhere to put 129 // dso_local. Returning false for those will produce worse code in some 130 // architectures. For example, on x86 the caller has to set ebx before calling 131 // a plt. 132 // As a result we still have some logic in here to improve the quality of the 133 // generated code. 134 // FIXME: Add a module level metadata for whether intrinsics should be assumed 135 // local. 136 137 Reloc::Model RM = getRelocationModel(); 138 const Triple &TT = getTargetTriple(); 139 140 // DLLImport explicitly marks the GV as external. 141 if (GV && GV->hasDLLImportStorageClass()) 142 return false; 143 144 // Every other GV is local on COFF. 145 // Make an exception for windows OS in the triple: Some firmware builds use 146 // *-win32-macho triples. This (accidentally?) produced windows relocations 147 // without GOT tables in older clang versions; Keep this behaviour. 148 if (TT.isOSBinFormatCOFF() || (TT.isOSWindows() && TT.isOSBinFormatMachO())) 149 return true; 150 151 // Most PIC code sequences that assume that a symbol is local cannot 152 // produce a 0 if it turns out the symbol is undefined. While this 153 // is ABI and relocation depended, it seems worth it to handle it 154 // here. 155 if (GV && isPositionIndependent() && GV->hasExternalWeakLinkage()) 156 return false; 157 158 if (GV && !GV->hasDefaultVisibility()) 159 return true; 160 161 if (TT.isOSBinFormatMachO()) { 162 if (RM == Reloc::Static) 163 return true; 164 return GV && GV->isStrongDefinitionForLinker(); 165 } 166 167 assert(TT.isOSBinFormatELF()); 168 assert(RM != Reloc::DynamicNoPIC); 169 170 bool IsExecutable = 171 RM == Reloc::Static || M.getPIELevel() != PIELevel::Default; 172 if (IsExecutable) { 173 // If the symbol is defined, it cannot be preempted. 174 if (GV && !GV->isDeclarationForLinker()) 175 return true; 176 177 // A symbol marked nonlazybind should not be accessed with a plt. If the 178 // symbol turns out to be external, the linker will convert a direct 179 // access to an access via the plt, so don't assume it is local. 180 const Function *F = dyn_cast_or_null<Function>(GV); 181 if (F && F->hasFnAttribute(Attribute::NonLazyBind)) 182 return false; 183 184 bool IsTLS = GV && GV->isThreadLocal(); 185 bool IsAccessViaCopyRelocs = 186 GV && Options.MCOptions.MCPIECopyRelocations && isa<GlobalVariable>(GV); 187 Triple::ArchType Arch = TT.getArch(); 188 bool IsPPC = 189 Arch == Triple::ppc || Arch == Triple::ppc64 || Arch == Triple::ppc64le; 190 // Check if we can use copy relocations. PowerPC has no copy relocations. 191 if (!IsTLS && !IsPPC && (RM == Reloc::Static || IsAccessViaCopyRelocs)) 192 return true; 193 } 194 195 // ELF supports preemption of other symbols. 196 return false; 197 } 198 199 bool TargetMachine::useEmulatedTLS() const { 200 // Returns Options.EmulatedTLS if the -emulated-tls or -no-emulated-tls 201 // was specified explicitly; otherwise uses target triple to decide default. 202 if (Options.ExplicitEmulatedTLS) 203 return Options.EmulatedTLS; 204 return getTargetTriple().hasDefaultEmulatedTLS(); 205 } 206 207 TLSModel::Model TargetMachine::getTLSModel(const GlobalValue *GV) const { 208 bool IsPIE = GV->getParent()->getPIELevel() != PIELevel::Default; 209 Reloc::Model RM = getRelocationModel(); 210 bool IsSharedLibrary = RM == Reloc::PIC_ && !IsPIE; 211 bool IsLocal = shouldAssumeDSOLocal(*GV->getParent(), GV); 212 213 TLSModel::Model Model; 214 if (IsSharedLibrary) { 215 if (IsLocal) 216 Model = TLSModel::LocalDynamic; 217 else 218 Model = TLSModel::GeneralDynamic; 219 } else { 220 if (IsLocal) 221 Model = TLSModel::LocalExec; 222 else 223 Model = TLSModel::InitialExec; 224 } 225 226 // If the user specified a more specific model, use that. 227 TLSModel::Model SelectedModel = getSelectedTLSModel(GV); 228 if (SelectedModel > Model) 229 return SelectedModel; 230 231 return Model; 232 } 233 234 /// Returns the optimization level: None, Less, Default, or Aggressive. 235 CodeGenOpt::Level TargetMachine::getOptLevel() const { return OptLevel; } 236 237 void TargetMachine::setOptLevel(CodeGenOpt::Level Level) { OptLevel = Level; } 238 239 TargetTransformInfo TargetMachine::getTargetTransformInfo(const Function &F) { 240 return TargetTransformInfo(F.getParent()->getDataLayout()); 241 } 242 243 void TargetMachine::getNameWithPrefix(SmallVectorImpl<char> &Name, 244 const GlobalValue *GV, Mangler &Mang, 245 bool MayAlwaysUsePrivate) const { 246 if (MayAlwaysUsePrivate || !GV->hasPrivateLinkage()) { 247 // Simple case: If GV is not private, it is not important to find out if 248 // private labels are legal in this case or not. 249 Mang.getNameWithPrefix(Name, GV, false); 250 return; 251 } 252 const TargetLoweringObjectFile *TLOF = getObjFileLowering(); 253 TLOF->getNameWithPrefix(Name, GV, *this); 254 } 255 256 MCSymbol *TargetMachine::getSymbol(const GlobalValue *GV) const { 257 const TargetLoweringObjectFile *TLOF = getObjFileLowering(); 258 SmallString<128> NameStr; 259 getNameWithPrefix(NameStr, GV, TLOF->getMangler()); 260 return TLOF->getContext().getOrCreateSymbol(NameStr); 261 } 262 263 TargetIRAnalysis TargetMachine::getTargetIRAnalysis() { 264 // Since Analysis can't depend on Target, use a std::function to invert the 265 // dependency. 266 return TargetIRAnalysis( 267 [this](const Function &F) { return this->getTargetTransformInfo(F); }); 268 } 269