1 //===-- TargetMachine.cpp - General Target Information ---------------------==// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file describes the general parts of a Target machine. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "llvm/Target/TargetMachine.h" 14 #include "llvm/Analysis/TargetTransformInfo.h" 15 #include "llvm/IR/Function.h" 16 #include "llvm/IR/GlobalAlias.h" 17 #include "llvm/IR/GlobalValue.h" 18 #include "llvm/IR/GlobalVariable.h" 19 #include "llvm/IR/LegacyPassManager.h" 20 #include "llvm/IR/Mangler.h" 21 #include "llvm/MC/MCAsmInfo.h" 22 #include "llvm/MC/MCContext.h" 23 #include "llvm/MC/MCInstrInfo.h" 24 #include "llvm/MC/MCSectionMachO.h" 25 #include "llvm/MC/MCTargetOptions.h" 26 #include "llvm/MC/SectionKind.h" 27 #include "llvm/Target/TargetLoweringObjectFile.h" 28 using namespace llvm; 29 30 //--------------------------------------------------------------------------- 31 // TargetMachine Class 32 // 33 34 TargetMachine::TargetMachine(const Target &T, StringRef DataLayoutString, 35 const Triple &TT, StringRef CPU, StringRef FS, 36 const TargetOptions &Options) 37 : TheTarget(T), DL(DataLayoutString), TargetTriple(TT), 38 TargetCPU(std::string(CPU)), TargetFS(std::string(FS)), AsmInfo(nullptr), 39 MRI(nullptr), MII(nullptr), STI(nullptr), RequireStructuredCFG(false), 40 O0WantsFastISel(false), DefaultOptions(Options), Options(Options) {} 41 42 TargetMachine::~TargetMachine() = default; 43 44 bool TargetMachine::isPositionIndependent() const { 45 return getRelocationModel() == Reloc::PIC_; 46 } 47 48 /// Reset the target options based on the function's attributes. 49 /// setFunctionAttributes should have made the raw attribute value consistent 50 /// with the command line flag if used. 51 // 52 // FIXME: This function needs to go away for a number of reasons: 53 // a) global state on the TargetMachine is terrible in general, 54 // b) these target options should be passed only on the function 55 // and not on the TargetMachine (via TargetOptions) at all. 56 void TargetMachine::resetTargetOptions(const Function &F) const { 57 #define RESET_OPTION(X, Y) \ 58 do { \ 59 Options.X = (F.getFnAttribute(Y).getValueAsString() == "true"); \ 60 } while (0) 61 62 RESET_OPTION(UnsafeFPMath, "unsafe-fp-math"); 63 RESET_OPTION(NoInfsFPMath, "no-infs-fp-math"); 64 RESET_OPTION(NoNaNsFPMath, "no-nans-fp-math"); 65 RESET_OPTION(NoSignedZerosFPMath, "no-signed-zeros-fp-math"); 66 } 67 68 /// Returns the code generation relocation model. The choices are static, PIC, 69 /// and dynamic-no-pic. 70 Reloc::Model TargetMachine::getRelocationModel() const { return RM; } 71 72 /// Returns the code model. The choices are small, kernel, medium, large, and 73 /// target default. 74 CodeModel::Model TargetMachine::getCodeModel() const { return CMModel; } 75 76 /// Get the IR-specified TLS model for Var. 77 static TLSModel::Model getSelectedTLSModel(const GlobalValue *GV) { 78 switch (GV->getThreadLocalMode()) { 79 case GlobalVariable::NotThreadLocal: 80 llvm_unreachable("getSelectedTLSModel for non-TLS variable"); 81 break; 82 case GlobalVariable::GeneralDynamicTLSModel: 83 return TLSModel::GeneralDynamic; 84 case GlobalVariable::LocalDynamicTLSModel: 85 return TLSModel::LocalDynamic; 86 case GlobalVariable::InitialExecTLSModel: 87 return TLSModel::InitialExec; 88 case GlobalVariable::LocalExecTLSModel: 89 return TLSModel::LocalExec; 90 } 91 llvm_unreachable("invalid TLS model"); 92 } 93 94 bool TargetMachine::shouldAssumeDSOLocal(const Module &M, 95 const GlobalValue *GV) const { 96 const Triple &TT = getTargetTriple(); 97 Reloc::Model RM = getRelocationModel(); 98 99 // According to the llvm language reference, we should be able to 100 // just return false in here if we have a GV, as we know it is 101 // dso_preemptable. At this point in time, the various IR producers 102 // have not been transitioned to always produce a dso_local when it 103 // is possible to do so. 104 // In the case of ExternalSymbolSDNode, GV is null and there is nowhere to put 105 // dso_local. Returning false for those will produce worse code in some 106 // architectures. For example, on x86 the caller has to set ebx before calling 107 // a plt. 108 // As a result we still have some logic in here to improve the quality of the 109 // generated code. 110 // FIXME: Add a module level metadata for whether intrinsics should be assumed 111 // local. 112 if (!GV) 113 return TT.isOSBinFormatCOFF(); 114 115 // If the IR producer requested that this GV be treated as dso local, obey. 116 if (GV->isDSOLocal()) 117 return true; 118 119 // DLLImport explicitly marks the GV as external. 120 if (GV->hasDLLImportStorageClass()) 121 return false; 122 123 // On MinGW, variables that haven't been declared with DLLImport may still 124 // end up automatically imported by the linker. To make this feasible, 125 // don't assume the variables to be DSO local unless we actually know 126 // that for sure. This only has to be done for variables; for functions 127 // the linker can insert thunks for calling functions from another DLL. 128 if (TT.isWindowsGNUEnvironment() && TT.isOSBinFormatCOFF() && 129 GV->isDeclarationForLinker() && isa<GlobalVariable>(GV)) 130 return false; 131 132 // On COFF, don't mark 'extern_weak' symbols as DSO local. If these symbols 133 // remain unresolved in the link, they can be resolved to zero, which is 134 // outside the current DSO. 135 if (TT.isOSBinFormatCOFF() && GV->hasExternalWeakLinkage()) 136 return false; 137 138 // Every other GV is local on COFF. 139 // Make an exception for windows OS in the triple: Some firmware builds use 140 // *-win32-macho triples. This (accidentally?) produced windows relocations 141 // without GOT tables in older clang versions; Keep this behaviour. 142 // Some JIT users use *-win32-elf triples; these shouldn't use GOT tables 143 // either. 144 if (TT.isOSBinFormatCOFF() || TT.isOSWindows()) 145 return true; 146 147 // Most PIC code sequences that assume that a symbol is local cannot 148 // produce a 0 if it turns out the symbol is undefined. While this 149 // is ABI and relocation depended, it seems worth it to handle it 150 // here. 151 if (isPositionIndependent() && GV->hasExternalWeakLinkage()) 152 return false; 153 154 if (!GV->hasDefaultVisibility()) 155 return true; 156 157 if (TT.isOSBinFormatMachO()) { 158 if (RM == Reloc::Static) 159 return true; 160 return GV->isStrongDefinitionForLinker(); 161 } 162 163 // Due to the AIX linkage model, any global with default visibility is 164 // considered non-local. 165 if (TT.isOSBinFormatXCOFF()) 166 return false; 167 168 assert(TT.isOSBinFormatELF() || TT.isOSBinFormatWasm()); 169 assert(RM != Reloc::DynamicNoPIC); 170 171 bool IsExecutable = 172 RM == Reloc::Static || M.getPIELevel() != PIELevel::Default; 173 if (IsExecutable) { 174 // If the symbol is defined, it cannot be preempted. 175 if (!GV->isDeclarationForLinker()) 176 return true; 177 178 // A symbol marked nonlazybind should not be accessed with a plt. If the 179 // symbol turns out to be external, the linker will convert a direct 180 // access to an access via the plt, so don't assume it is local. 181 const Function *F = dyn_cast<Function>(GV); 182 if (F && F->hasFnAttribute(Attribute::NonLazyBind)) 183 return false; 184 Triple::ArchType Arch = TT.getArch(); 185 186 // PowerPC64 prefers TOC indirection to avoid copy relocations. 187 if (TT.isPPC64()) 188 return false; 189 190 // dso_local is traditionally implied for Reloc::Static. Eventually we shall 191 // drop the if block entirely and respect dso_local/dso_preemptable 192 // specifiers set by the frontend. 193 if (RM == Reloc::Static) { 194 // We currently respect dso_local/dso_preemptable specifiers for 195 // variables. 196 if (F) 197 return true; 198 // TODO Remove the special case for x86-32. 199 if (Arch == Triple::x86 && !GV->isThreadLocal()) 200 return true; 201 } 202 } else if (TT.isOSBinFormatELF()) { 203 // If dso_local allows AsmPrinter::getSymbolPreferLocal to use a local 204 // alias, set the flag. We cannot set dso_local for other global values, 205 // because otherwise direct accesses to a probably interposable symbol (even 206 // if the codegen assumes not) will be rejected by the linker. 207 if (!GV->canBenefitFromLocalAlias()) 208 return false; 209 return TT.isX86() && M.noSemanticInterposition(); 210 } 211 212 // ELF & wasm support preemption of other symbols. 213 return false; 214 } 215 216 bool TargetMachine::useEmulatedTLS() const { 217 // Returns Options.EmulatedTLS if the -emulated-tls or -no-emulated-tls 218 // was specified explicitly; otherwise uses target triple to decide default. 219 if (Options.ExplicitEmulatedTLS) 220 return Options.EmulatedTLS; 221 return getTargetTriple().hasDefaultEmulatedTLS(); 222 } 223 224 TLSModel::Model TargetMachine::getTLSModel(const GlobalValue *GV) const { 225 bool IsPIE = GV->getParent()->getPIELevel() != PIELevel::Default; 226 Reloc::Model RM = getRelocationModel(); 227 bool IsSharedLibrary = RM == Reloc::PIC_ && !IsPIE; 228 bool IsLocal = shouldAssumeDSOLocal(*GV->getParent(), GV); 229 230 TLSModel::Model Model; 231 if (IsSharedLibrary) { 232 if (IsLocal) 233 Model = TLSModel::LocalDynamic; 234 else 235 Model = TLSModel::GeneralDynamic; 236 } else { 237 if (IsLocal) 238 Model = TLSModel::LocalExec; 239 else 240 Model = TLSModel::InitialExec; 241 } 242 243 // If the user specified a more specific model, use that. 244 TLSModel::Model SelectedModel = getSelectedTLSModel(GV); 245 if (SelectedModel > Model) 246 return SelectedModel; 247 248 return Model; 249 } 250 251 /// Returns the optimization level: None, Less, Default, or Aggressive. 252 CodeGenOpt::Level TargetMachine::getOptLevel() const { return OptLevel; } 253 254 void TargetMachine::setOptLevel(CodeGenOpt::Level Level) { OptLevel = Level; } 255 256 TargetTransformInfo TargetMachine::getTargetTransformInfo(const Function &F) { 257 return TargetTransformInfo(F.getParent()->getDataLayout()); 258 } 259 260 void TargetMachine::getNameWithPrefix(SmallVectorImpl<char> &Name, 261 const GlobalValue *GV, Mangler &Mang, 262 bool MayAlwaysUsePrivate) const { 263 if (MayAlwaysUsePrivate || !GV->hasPrivateLinkage()) { 264 // Simple case: If GV is not private, it is not important to find out if 265 // private labels are legal in this case or not. 266 Mang.getNameWithPrefix(Name, GV, false); 267 return; 268 } 269 const TargetLoweringObjectFile *TLOF = getObjFileLowering(); 270 TLOF->getNameWithPrefix(Name, GV, *this); 271 } 272 273 MCSymbol *TargetMachine::getSymbol(const GlobalValue *GV) const { 274 const TargetLoweringObjectFile *TLOF = getObjFileLowering(); 275 // XCOFF symbols could have special naming convention. 276 if (MCSymbol *TargetSymbol = TLOF->getTargetSymbol(GV, *this)) 277 return TargetSymbol; 278 279 SmallString<128> NameStr; 280 getNameWithPrefix(NameStr, GV, TLOF->getMangler()); 281 return TLOF->getContext().getOrCreateSymbol(NameStr); 282 } 283 284 TargetIRAnalysis TargetMachine::getTargetIRAnalysis() { 285 // Since Analysis can't depend on Target, use a std::function to invert the 286 // dependency. 287 return TargetIRAnalysis( 288 [this](const Function &F) { return this->getTargetTransformInfo(F); }); 289 } 290