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/GlobalValue.h" 17 #include "llvm/IR/GlobalVariable.h" 18 #include "llvm/IR/Mangler.h" 19 #include "llvm/MC/MCAsmInfo.h" 20 #include "llvm/MC/MCContext.h" 21 #include "llvm/MC/MCInstrInfo.h" 22 #include "llvm/MC/MCRegisterInfo.h" 23 #include "llvm/MC/MCSubtargetInfo.h" 24 #include "llvm/Support/CodeGen.h" 25 #include "llvm/Target/TargetLoweringObjectFile.h" 26 using namespace llvm; 27 28 //--------------------------------------------------------------------------- 29 // TargetMachine Class 30 // 31 32 TargetMachine::TargetMachine(const Target &T, StringRef DataLayoutString, 33 const Triple &TT, StringRef CPU, StringRef FS, 34 const TargetOptions &Options) 35 : TheTarget(T), DL(DataLayoutString), TargetTriple(TT), 36 TargetCPU(std::string(CPU)), TargetFS(std::string(FS)), AsmInfo(nullptr), 37 MRI(nullptr), MII(nullptr), STI(nullptr), RequireStructuredCFG(false), 38 O0WantsFastISel(false), DefaultOptions(Options), Options(Options) {} 39 40 TargetMachine::~TargetMachine() = default; 41 42 bool TargetMachine::isLargeData() const { 43 if (getTargetTriple().getArch() != Triple::x86_64) 44 return false; 45 // Large data under the large code model still needs to be thought about, so 46 // restrict this to medium. 47 if (getCodeModel() != CodeModel::Medium) 48 return false; 49 return true; 50 } 51 52 bool TargetMachine::isPositionIndependent() const { 53 return getRelocationModel() == Reloc::PIC_; 54 } 55 56 /// Reset the target options based on the function's attributes. 57 /// setFunctionAttributes should have made the raw attribute value consistent 58 /// with the command line flag if used. 59 // 60 // FIXME: This function needs to go away for a number of reasons: 61 // a) global state on the TargetMachine is terrible in general, 62 // b) these target options should be passed only on the function 63 // and not on the TargetMachine (via TargetOptions) at all. 64 void TargetMachine::resetTargetOptions(const Function &F) const { 65 #define RESET_OPTION(X, Y) \ 66 do { \ 67 Options.X = F.getFnAttribute(Y).getValueAsBool(); \ 68 } while (0) 69 70 RESET_OPTION(UnsafeFPMath, "unsafe-fp-math"); 71 RESET_OPTION(NoInfsFPMath, "no-infs-fp-math"); 72 RESET_OPTION(NoNaNsFPMath, "no-nans-fp-math"); 73 RESET_OPTION(NoSignedZerosFPMath, "no-signed-zeros-fp-math"); 74 RESET_OPTION(ApproxFuncFPMath, "approx-func-fp-math"); 75 } 76 77 /// Returns the code generation relocation model. The choices are static, PIC, 78 /// and dynamic-no-pic. 79 Reloc::Model TargetMachine::getRelocationModel() const { return RM; } 80 81 /// Get the IR-specified TLS model for Var. 82 static TLSModel::Model getSelectedTLSModel(const GlobalValue *GV) { 83 switch (GV->getThreadLocalMode()) { 84 case GlobalVariable::NotThreadLocal: 85 llvm_unreachable("getSelectedTLSModel for non-TLS variable"); 86 break; 87 case GlobalVariable::GeneralDynamicTLSModel: 88 return TLSModel::GeneralDynamic; 89 case GlobalVariable::LocalDynamicTLSModel: 90 return TLSModel::LocalDynamic; 91 case GlobalVariable::InitialExecTLSModel: 92 return TLSModel::InitialExec; 93 case GlobalVariable::LocalExecTLSModel: 94 return TLSModel::LocalExec; 95 } 96 llvm_unreachable("invalid TLS model"); 97 } 98 99 bool TargetMachine::shouldAssumeDSOLocal(const Module &M, 100 const GlobalValue *GV) const { 101 const Triple &TT = getTargetTriple(); 102 Reloc::Model RM = getRelocationModel(); 103 104 // According to the llvm language reference, we should be able to 105 // just return false in here if we have a GV, as we know it is 106 // dso_preemptable. At this point in time, the various IR producers 107 // have not been transitioned to always produce a dso_local when it 108 // is possible to do so. 109 // 110 // As a result we still have some logic in here to improve the quality of the 111 // generated code. 112 if (!GV) 113 return false; 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 if (TT.isOSBinFormatCOFF()) { 120 // DLLImport explicitly marks the GV as external. 121 if (GV->hasDLLImportStorageClass()) 122 return false; 123 124 // On MinGW, variables that haven't been declared with DLLImport may still 125 // end up automatically imported by the linker. To make this feasible, 126 // don't assume the variables to be DSO local unless we actually know 127 // that for sure. This only has to be done for variables; for functions 128 // the linker can insert thunks for calling functions from another DLL. 129 if (TT.isWindowsGNUEnvironment() && GV->isDeclarationForLinker() && 130 isa<GlobalVariable>(GV)) 131 return false; 132 133 // Don't mark 'extern_weak' symbols as DSO local. If these symbols remain 134 // unresolved in the link, they can be resolved to zero, which is outside 135 // the current DSO. 136 if (GV->hasExternalWeakLinkage()) 137 return false; 138 139 // Every other GV is local on COFF. 140 return true; 141 } 142 143 if (TT.isOSBinFormatGOFF()) 144 return true; 145 146 if (TT.isOSBinFormatMachO()) { 147 if (RM == Reloc::Static) 148 return true; 149 return GV->isStrongDefinitionForLinker(); 150 } 151 152 assert(TT.isOSBinFormatELF() || TT.isOSBinFormatWasm() || 153 TT.isOSBinFormatXCOFF()); 154 return false; 155 } 156 157 bool TargetMachine::useEmulatedTLS() const { return Options.EmulatedTLS; } 158 159 TLSModel::Model TargetMachine::getTLSModel(const GlobalValue *GV) const { 160 bool IsPIE = GV->getParent()->getPIELevel() != PIELevel::Default; 161 Reloc::Model RM = getRelocationModel(); 162 bool IsSharedLibrary = RM == Reloc::PIC_ && !IsPIE; 163 bool IsLocal = shouldAssumeDSOLocal(*GV->getParent(), GV); 164 165 TLSModel::Model Model; 166 if (IsSharedLibrary) { 167 if (IsLocal) 168 Model = TLSModel::LocalDynamic; 169 else 170 Model = TLSModel::GeneralDynamic; 171 } else { 172 if (IsLocal) 173 Model = TLSModel::LocalExec; 174 else 175 Model = TLSModel::InitialExec; 176 } 177 178 // If the user specified a more specific model, use that. 179 TLSModel::Model SelectedModel = getSelectedTLSModel(GV); 180 if (SelectedModel > Model) 181 return SelectedModel; 182 183 return Model; 184 } 185 186 /// Returns the optimization level: None, Less, Default, or Aggressive. 187 CodeGenOpt::Level TargetMachine::getOptLevel() const { return OptLevel; } 188 189 void TargetMachine::setOptLevel(CodeGenOpt::Level Level) { OptLevel = Level; } 190 191 TargetTransformInfo 192 TargetMachine::getTargetTransformInfo(const Function &F) const { 193 return TargetTransformInfo(F.getParent()->getDataLayout()); 194 } 195 196 void TargetMachine::getNameWithPrefix(SmallVectorImpl<char> &Name, 197 const GlobalValue *GV, Mangler &Mang, 198 bool MayAlwaysUsePrivate) const { 199 if (MayAlwaysUsePrivate || !GV->hasPrivateLinkage()) { 200 // Simple case: If GV is not private, it is not important to find out if 201 // private labels are legal in this case or not. 202 Mang.getNameWithPrefix(Name, GV, false); 203 return; 204 } 205 const TargetLoweringObjectFile *TLOF = getObjFileLowering(); 206 TLOF->getNameWithPrefix(Name, GV, *this); 207 } 208 209 MCSymbol *TargetMachine::getSymbol(const GlobalValue *GV) const { 210 const TargetLoweringObjectFile *TLOF = getObjFileLowering(); 211 // XCOFF symbols could have special naming convention. 212 if (MCSymbol *TargetSymbol = TLOF->getTargetSymbol(GV, *this)) 213 return TargetSymbol; 214 215 SmallString<128> NameStr; 216 getNameWithPrefix(NameStr, GV, TLOF->getMangler()); 217 return TLOF->getContext().getOrCreateSymbol(NameStr); 218 } 219 220 TargetIRAnalysis TargetMachine::getTargetIRAnalysis() const { 221 // Since Analysis can't depend on Target, use a std::function to invert the 222 // dependency. 223 return TargetIRAnalysis( 224 [this](const Function &F) { return this->getTargetTransformInfo(F); }); 225 } 226 227 std::pair<int, int> TargetMachine::parseBinutilsVersion(StringRef Version) { 228 if (Version == "none") 229 return {INT_MAX, INT_MAX}; // Make binutilsIsAtLeast() return true. 230 std::pair<int, int> Ret; 231 if (!Version.consumeInteger(10, Ret.first) && Version.consume_front(".")) 232 Version.consumeInteger(10, Ret.second); 233 return Ret; 234 } 235