1 //===-- llvm/Target/TargetMachine.h - Target Information --------*- C++ -*-===// 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 defines the TargetMachine and LLVMTargetMachine classes. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_TARGET_TARGETMACHINE_H 15 #define LLVM_TARGET_TARGETMACHINE_H 16 17 #include "llvm/ADT/StringRef.h" 18 #include "llvm/ADT/Triple.h" 19 #include "llvm/IR/DataLayout.h" 20 #include "llvm/Pass.h" 21 #include "llvm/Support/CodeGen.h" 22 #include "llvm/Target/TargetOptions.h" 23 #include <cassert> 24 #include <string> 25 26 namespace llvm { 27 28 class InstrItineraryData; 29 class GlobalValue; 30 class Mangler; 31 class MachineFunctionInitializer; 32 class MCAsmInfo; 33 class MCCodeGenInfo; 34 class MCContext; 35 class MCInstrInfo; 36 class MCRegisterInfo; 37 class MCSubtargetInfo; 38 class MCSymbol; 39 class Target; 40 class DataLayout; 41 class TargetLibraryInfo; 42 class TargetFrameLowering; 43 class TargetIRAnalysis; 44 class TargetIntrinsicInfo; 45 class TargetLowering; 46 class TargetPassConfig; 47 class TargetRegisterInfo; 48 class TargetSelectionDAGInfo; 49 class TargetSubtargetInfo; 50 class TargetTransformInfo; 51 class formatted_raw_ostream; 52 class raw_ostream; 53 class raw_pwrite_stream; 54 class TargetLoweringObjectFile; 55 56 // The old pass manager infrastructure is hidden in a legacy namespace now. 57 namespace legacy { 58 class PassManagerBase; 59 } 60 using legacy::PassManagerBase; 61 62 //===----------------------------------------------------------------------===// 63 /// 64 /// Primary interface to the complete machine description for the target 65 /// machine. All target-specific information should be accessible through this 66 /// interface. 67 /// 68 class TargetMachine { 69 TargetMachine(const TargetMachine &) = delete; 70 void operator=(const TargetMachine &) = delete; 71 protected: // Can only create subclasses. 72 TargetMachine(const Target &T, StringRef DataLayoutString, 73 const Triple &TargetTriple, StringRef CPU, StringRef FS, 74 const TargetOptions &Options); 75 76 /// The Target that this machine was created for. 77 const Target &TheTarget; 78 79 /// For ABI type size and alignment. 80 const DataLayout DL; 81 82 /// Triple string, CPU name, and target feature strings the TargetMachine 83 /// instance is created with. 84 Triple TargetTriple; 85 std::string TargetCPU; 86 std::string TargetFS; 87 88 /// Low level target information such as relocation model. Non-const to 89 /// allow resetting optimization level per-function. 90 MCCodeGenInfo *CodeGenInfo; 91 92 /// Contains target specific asm information. 93 const MCAsmInfo *AsmInfo; 94 95 const MCRegisterInfo *MRI; 96 const MCInstrInfo *MII; 97 const MCSubtargetInfo *STI; 98 99 unsigned RequireStructuredCFG : 1; 100 101 public: 102 mutable TargetOptions Options; 103 104 virtual ~TargetMachine(); 105 getTarget()106 const Target &getTarget() const { return TheTarget; } 107 getTargetTriple()108 const Triple &getTargetTriple() const { return TargetTriple; } getTargetCPU()109 StringRef getTargetCPU() const { return TargetCPU; } getTargetFeatureString()110 StringRef getTargetFeatureString() const { return TargetFS; } 111 112 /// Virtual method implemented by subclasses that returns a reference to that 113 /// target's TargetSubtargetInfo-derived member variable. getSubtargetImpl(const Function &)114 virtual const TargetSubtargetInfo *getSubtargetImpl(const Function &) const { 115 return nullptr; 116 } getObjFileLowering()117 virtual TargetLoweringObjectFile *getObjFileLowering() const { 118 return nullptr; 119 } 120 121 /// This method returns a pointer to the specified type of 122 /// TargetSubtargetInfo. In debug builds, it verifies that the object being 123 /// returned is of the correct type. getSubtarget(const Function & F)124 template <typename STC> const STC &getSubtarget(const Function &F) const { 125 return *static_cast<const STC*>(getSubtargetImpl(F)); 126 } 127 128 /// Deprecated in 3.7, will be removed in 3.8. Use createDataLayout() instead. 129 /// 130 /// This method returns a pointer to the DataLayout for the target. It should 131 /// be unchanging for every subtarget. getDataLayout()132 const DataLayout *getDataLayout() const { return &DL; } 133 134 /// Create a DataLayout. createDataLayout()135 const DataLayout createDataLayout() const { return DL; } 136 137 /// \brief Reset the target options based on the function's attributes. 138 // FIXME: Remove TargetOptions that affect per-function code generation 139 // from TargetMachine. 140 void resetTargetOptions(const Function &F) const; 141 142 /// Return target specific asm information. getMCAsmInfo()143 const MCAsmInfo *getMCAsmInfo() const { return AsmInfo; } 144 getMCRegisterInfo()145 const MCRegisterInfo *getMCRegisterInfo() const { return MRI; } getMCInstrInfo()146 const MCInstrInfo *getMCInstrInfo() const { return MII; } getMCSubtargetInfo()147 const MCSubtargetInfo *getMCSubtargetInfo() const { return STI; } 148 149 /// If intrinsic information is available, return it. If not, return null. getIntrinsicInfo()150 virtual const TargetIntrinsicInfo *getIntrinsicInfo() const { 151 return nullptr; 152 } 153 requiresStructuredCFG()154 bool requiresStructuredCFG() const { return RequireStructuredCFG; } setRequiresStructuredCFG(bool Value)155 void setRequiresStructuredCFG(bool Value) { RequireStructuredCFG = Value; } 156 157 /// Returns the code generation relocation model. The choices are static, PIC, 158 /// and dynamic-no-pic, and target default. 159 Reloc::Model getRelocationModel() const; 160 161 /// Returns the code model. The choices are small, kernel, medium, large, and 162 /// target default. 163 CodeModel::Model getCodeModel() const; 164 165 /// Returns the TLS model which should be used for the given global variable. 166 TLSModel::Model getTLSModel(const GlobalValue *GV) const; 167 168 /// Returns the optimization level: None, Less, Default, or Aggressive. 169 CodeGenOpt::Level getOptLevel() const; 170 171 /// \brief Overrides the optimization level. 172 void setOptLevel(CodeGenOpt::Level Level) const; 173 setFastISel(bool Enable)174 void setFastISel(bool Enable) { Options.EnableFastISel = Enable; } 175 shouldPrintMachineCode()176 bool shouldPrintMachineCode() const { return Options.PrintMachineCode; } 177 178 /// Returns the default value of asm verbosity. 179 /// getAsmVerbosityDefault()180 bool getAsmVerbosityDefault() const { 181 return Options.MCOptions.AsmVerbose; 182 } 183 getUniqueSectionNames()184 bool getUniqueSectionNames() const { return Options.UniqueSectionNames; } 185 186 /// Return true if data objects should be emitted into their own section, 187 /// corresponds to -fdata-sections. getDataSections()188 bool getDataSections() const { 189 return Options.DataSections; 190 } 191 192 /// Return true if functions should be emitted into their own section, 193 /// corresponding to -ffunction-sections. getFunctionSections()194 bool getFunctionSections() const { 195 return Options.FunctionSections; 196 } 197 198 /// \brief Get a \c TargetIRAnalysis appropriate for the target. 199 /// 200 /// This is used to construct the new pass manager's target IR analysis pass, 201 /// set up appropriately for this target machine. Even the old pass manager 202 /// uses this to answer queries about the IR. 203 virtual TargetIRAnalysis getTargetIRAnalysis(); 204 205 /// These enums are meant to be passed into addPassesToEmitFile to indicate 206 /// what type of file to emit, and returned by it to indicate what type of 207 /// file could actually be made. 208 enum CodeGenFileType { 209 CGFT_AssemblyFile, 210 CGFT_ObjectFile, 211 CGFT_Null // Do not emit any output. 212 }; 213 214 /// Add passes to the specified pass manager to get the specified file 215 /// emitted. Typically this will involve several steps of code generation. 216 /// This method should return true if emission of this file type is not 217 /// supported, or false on success. 218 virtual bool addPassesToEmitFile( 219 PassManagerBase &, raw_pwrite_stream &, CodeGenFileType, 220 bool /*DisableVerify*/ = true, AnalysisID /*StartBefore*/ = nullptr, 221 AnalysisID /*StartAfter*/ = nullptr, AnalysisID /*StopAfter*/ = nullptr, 222 MachineFunctionInitializer * /*MFInitializer*/ = nullptr) { 223 return true; 224 } 225 226 /// Add passes to the specified pass manager to get machine code emitted with 227 /// the MCJIT. This method returns true if machine code is not supported. It 228 /// fills the MCContext Ctx pointer which can be used to build custom 229 /// MCStreamer. 230 /// 231 virtual bool addPassesToEmitMC(PassManagerBase &, MCContext *&, 232 raw_pwrite_stream &, 233 bool /*DisableVerify*/ = true) { 234 return true; 235 } 236 237 void getNameWithPrefix(SmallVectorImpl<char> &Name, const GlobalValue *GV, 238 Mangler &Mang, bool MayAlwaysUsePrivate = false) const; 239 MCSymbol *getSymbol(const GlobalValue *GV, Mangler &Mang) const; 240 }; 241 242 /// This class describes a target machine that is implemented with the LLVM 243 /// target-independent code generator. 244 /// 245 class LLVMTargetMachine : public TargetMachine { 246 protected: // Can only create subclasses. 247 LLVMTargetMachine(const Target &T, StringRef DataLayoutString, 248 const Triple &TargetTriple, StringRef CPU, StringRef FS, 249 TargetOptions Options, Reloc::Model RM, CodeModel::Model CM, 250 CodeGenOpt::Level OL); 251 252 void initAsmInfo(); 253 public: 254 /// \brief Get a TargetIRAnalysis implementation for the target. 255 /// 256 /// This analysis will produce a TTI result which uses the common code 257 /// generator to answer queries about the IR. 258 TargetIRAnalysis getTargetIRAnalysis() override; 259 260 /// Create a pass configuration object to be used by addPassToEmitX methods 261 /// for generating a pipeline of CodeGen passes. 262 virtual TargetPassConfig *createPassConfig(PassManagerBase &PM); 263 264 /// Add passes to the specified pass manager to get the specified file 265 /// emitted. Typically this will involve several steps of code generation. 266 bool addPassesToEmitFile( 267 PassManagerBase &PM, raw_pwrite_stream &Out, CodeGenFileType FileType, 268 bool DisableVerify = true, AnalysisID StartBefore = nullptr, 269 AnalysisID StartAfter = nullptr, AnalysisID StopAfter = nullptr, 270 MachineFunctionInitializer *MFInitializer = nullptr) override; 271 272 /// Add passes to the specified pass manager to get machine code emitted with 273 /// the MCJIT. This method returns true if machine code is not supported. It 274 /// fills the MCContext Ctx pointer which can be used to build custom 275 /// MCStreamer. 276 bool addPassesToEmitMC(PassManagerBase &PM, MCContext *&Ctx, 277 raw_pwrite_stream &OS, 278 bool DisableVerify = true) override; 279 }; 280 281 } // End llvm namespace 282 283 #endif 284