contrib/llvm/include/llvm/Target/TargetMachine.h

   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 <string>
  24
  25 namespace llvm {
  26
  27 class Function;
  28 class GlobalValue;
  29 class MachineModuleInfo;
  30 class Mangler;
  31 class MCAsmInfo;
  32 class MCContext;
  33 class MCInstrInfo;
  34 class MCRegisterInfo;
  35 class MCSubtargetInfo;
  36 class MCSymbol;
  37 class raw_pwrite_stream;
  38 class PassManagerBuilder;
  39 class Target;
  40 class TargetIntrinsicInfo;
  41 class TargetIRAnalysis;
  42 class TargetTransformInfo;
  43 class TargetLoweringObjectFile;
  44 class TargetPassConfig;
  45 class TargetSubtargetInfo;
  46
  47 // The old pass manager infrastructure is hidden in a legacy namespace now.
  48 namespace legacy {
  49 class PassManagerBase;
  50 }
  51 using legacy::PassManagerBase;
  52
  53 //===----------------------------------------------------------------------===//
  54 ///
  55 /// Primary interface to the complete machine description for the target
  56 /// machine.  All target-specific information should be accessible through this
  57 /// interface.
  58 ///
  59 class TargetMachine {
  60 protected: // Can only create subclasses.
  61   TargetMachine(const Target &T, StringRef DataLayoutString,
  62                 const Triple &TargetTriple, StringRef CPU, StringRef FS,
  63                 const TargetOptions &Options);
  64
  65   /// The Target that this machine was created for.
  66   const Target &TheTarget;
  67
  68   /// DataLayout for the target: keep ABI type size and alignment.
  69   ///
  70   /// The DataLayout is created based on the string representation provided
  71   /// during construction. It is kept here only to avoid reparsing the string
  72   /// but should not really be used during compilation, because it has an
  73   /// internal cache that is context specific.
  74   const DataLayout DL;
  75
  76   /// Triple string, CPU name, and target feature strings the TargetMachine
  77   /// instance is created with.
  78   Triple TargetTriple;
  79   std::string TargetCPU;
  80   std::string TargetFS;
  81
  82   Reloc::Model RM = Reloc::Static;
  83   CodeModel::Model CMModel = CodeModel::Small;
  84   CodeGenOpt::Level OptLevel = CodeGenOpt::Default;
  85
  86   /// Contains target specific asm information.
  87   const MCAsmInfo *AsmInfo;
  88
  89   const MCRegisterInfo *MRI;
  90   const MCInstrInfo *MII;
  91   const MCSubtargetInfo *STI;
  92
  93   unsigned RequireStructuredCFG : 1;
  94   unsigned O0WantsFastISel : 1;
  95
  96 public:
  97   const TargetOptions DefaultOptions;
  98   mutable TargetOptions Options;
  99
 100   TargetMachine(const TargetMachine &) = delete;
 101   void operator=(const TargetMachine &) = delete;
 102   virtual ~TargetMachine();
 103
 104   const Target &getTarget() const { return TheTarget; }
 105
 106   const Triple &getTargetTriple() const { return TargetTriple; }
 107   StringRef getTargetCPU() const { return TargetCPU; }
 108   StringRef getTargetFeatureString() const { return TargetFS; }
 109
 110   /// Virtual method implemented by subclasses that returns a reference to that
 111   /// target's TargetSubtargetInfo-derived member variable.
 112   virtual const TargetSubtargetInfo *getSubtargetImpl(const Function &) const {
 113     return nullptr;
 114   }
 115   virtual TargetLoweringObjectFile *getObjFileLowering() const {
 116     return nullptr;
 117   }
 118
 119   /// This method returns a pointer to the specified type of
 120   /// TargetSubtargetInfo.  In debug builds, it verifies that the object being
 121   /// returned is of the correct type.
 122   template <typename STC> const STC &getSubtarget(const Function &F) const {
 123     return *static_cast<const STC*>(getSubtargetImpl(F));
 124   }
 125
 126   /// Create a DataLayout.
 127   const DataLayout createDataLayout() const { return DL; }
 128
 129   /// Test if a DataLayout if compatible with the CodeGen for this target.
 130   ///
 131   /// The LLVM Module owns a DataLayout that is used for the target independent
 132   /// optimizations and code generation. This hook provides a target specific
 133   /// check on the validity of this DataLayout.
 134   bool isCompatibleDataLayout(const DataLayout &Candidate) const {
 135     return DL == Candidate;
 136   }
 137
 138   /// Get the pointer size for this target.
 139   ///
 140   /// This is the only time the DataLayout in the TargetMachine is used.
 141   unsigned getPointerSize() const { return DL.getPointerSize(); }
 142
 143   /// \brief Reset the target options based on the function's attributes.
 144   // FIXME: Remove TargetOptions that affect per-function code generation
 145   // from TargetMachine.
 146   void resetTargetOptions(const Function &F) const;
 147
 148   /// Return target specific asm information.
 149   const MCAsmInfo *getMCAsmInfo() const { return AsmInfo; }
 150
 151   const MCRegisterInfo *getMCRegisterInfo() const { return MRI; }
 152   const MCInstrInfo *getMCInstrInfo() const { return MII; }
 153   const MCSubtargetInfo *getMCSubtargetInfo() const { return STI; }
 154
 155   /// If intrinsic information is available, return it.  If not, return null.
 156   virtual const TargetIntrinsicInfo *getIntrinsicInfo() const {
 157     return nullptr;
 158   }
 159
 160   bool requiresStructuredCFG() const { return RequireStructuredCFG; }
 161   void setRequiresStructuredCFG(bool Value) { RequireStructuredCFG = Value; }
 162
 163   /// Returns the code generation relocation model. The choices are static, PIC,
 164   /// and dynamic-no-pic, and target default.
 165   Reloc::Model getRelocationModel() const;
 166
 167   /// Returns the code model. The choices are small, kernel, medium, large, and
 168   /// target default.
 169   CodeModel::Model getCodeModel() const;
 170
 171   bool isPositionIndependent() const;
 172
 173   bool shouldAssumeDSOLocal(const Module &M, const GlobalValue *GV) const;
 174
 175   /// Returns the TLS model which should be used for the given global variable.
 176   TLSModel::Model getTLSModel(const GlobalValue *GV) const;
 177
 178   /// Returns the optimization level: None, Less, Default, or Aggressive.
 179   CodeGenOpt::Level getOptLevel() const;
 180
 181   /// \brief Overrides the optimization level.
 182   void setOptLevel(CodeGenOpt::Level Level);
 183
 184   void setFastISel(bool Enable) { Options.EnableFastISel = Enable; }
 185   bool getO0WantsFastISel() { return O0WantsFastISel; }
 186   void setO0WantsFastISel(bool Enable) { O0WantsFastISel = Enable; }
 187
 188   bool shouldPrintMachineCode() const { return Options.PrintMachineCode; }
 189
 190   bool getUniqueSectionNames() const { return Options.UniqueSectionNames; }
 191
 192   /// Return true if data objects should be emitted into their own section,
 193   /// corresponds to -fdata-sections.
 194   bool getDataSections() const {
 195     return Options.DataSections;
 196   }
 197
 198   /// Return true if functions should be emitted into their own section,
 199   /// corresponding to -ffunction-sections.
 200   bool getFunctionSections() const {
 201     return Options.FunctionSections;
 202   }
 203
 204   /// \brief Get a \c TargetIRAnalysis appropriate for the target.
 205   ///
 206   /// This is used to construct the new pass manager's target IR analysis pass,
 207   /// set up appropriately for this target machine. Even the old pass manager
 208   /// uses this to answer queries about the IR.
 209   TargetIRAnalysis getTargetIRAnalysis();
 210
 211   /// \brief Return a TargetTransformInfo for a given function.
 212   ///
 213   /// The returned TargetTransformInfo is specialized to the subtarget
 214   /// corresponding to \p F.
 215   virtual TargetTransformInfo getTargetTransformInfo(const Function &F);
 216
 217   /// Allow the target to modify the pass manager, e.g. by calling
 218   /// PassManagerBuilder::addExtension.
 219   virtual void adjustPassManager(PassManagerBuilder &) {}
 220
 221   /// These enums are meant to be passed into addPassesToEmitFile to indicate
 222   /// what type of file to emit, and returned by it to indicate what type of
 223   /// file could actually be made.
 224   enum CodeGenFileType {
 225     CGFT_AssemblyFile,
 226     CGFT_ObjectFile,
 227     CGFT_Null         // Do not emit any output.
 228   };
 229
 230   /// Add passes to the specified pass manager to get the specified file
 231   /// emitted.  Typically this will involve several steps of code generation.
 232   /// This method should return true if emission of this file type is not
 233   /// supported, or false on success.
 234   /// \p MMI is an optional parameter that, if set to non-nullptr,
 235   /// will be used to set the MachineModuloInfo for this PM.
 236   virtual bool addPassesToEmitFile(PassManagerBase &, raw_pwrite_stream &,
 237                                    CodeGenFileType,
 238                                    bool /*DisableVerify*/ = true,
 239                                    MachineModuleInfo *MMI = nullptr) {
 240     return true;
 241   }
 242
 243   /// Add passes to the specified pass manager to get machine code emitted with
 244   /// the MCJIT. This method returns true if machine code is not supported. It
 245   /// fills the MCContext Ctx pointer which can be used to build custom
 246   /// MCStreamer.
 247   ///
 248   virtual bool addPassesToEmitMC(PassManagerBase &, MCContext *&,
 249                                  raw_pwrite_stream &,
 250                                  bool /*DisableVerify*/ = true) {
 251     return true;
 252   }
 253
 254   /// True if subtarget inserts the final scheduling pass on its own.
 255   ///
 256   /// Branch relaxation, which must happen after block placement, can
 257   /// on some targets (e.g. SystemZ) expose additional post-RA
 258   /// scheduling opportunities.
 259   virtual bool targetSchedulesPostRAScheduling() const { return false; };
 260
 261   void getNameWithPrefix(SmallVectorImpl<char> &Name, const GlobalValue *GV,
 262                          Mangler &Mang, bool MayAlwaysUsePrivate = false) const;
 263   MCSymbol *getSymbol(const GlobalValue *GV) const;
 264
 265   /// True if the target uses physical regs at Prolog/Epilog insertion
 266   /// time. If true (most machines), all vregs must be allocated before
 267   /// PEI. If false (virtual-register machines), then callee-save register
 268   /// spilling and scavenging are not needed or used.
 269   virtual bool usesPhysRegsForPEI() const { return true; }
 270
 271   /// True if the target wants to use interprocedural register allocation by
 272   /// default. The -enable-ipra flag can be used to override this.
 273   virtual bool useIPRA() const {
 274     return false;
 275   }
 276 };
 277
 278 /// This class describes a target machine that is implemented with the LLVM
 279 /// target-independent code generator.
 280 ///
 281 class LLVMTargetMachine : public TargetMachine {
 282 protected: // Can only create subclasses.
 283   LLVMTargetMachine(const Target &T, StringRef DataLayoutString,
 284                     const Triple &TargetTriple, StringRef CPU, StringRef FS,
 285                     const TargetOptions &Options, Reloc::Model RM,
 286                     CodeModel::Model CM, CodeGenOpt::Level OL);
 287
 288   void initAsmInfo();
 289
 290 public:
 291   /// \brief Get a TargetTransformInfo implementation for the target.
 292   ///
 293   /// The TTI returned uses the common code generator to answer queries about
 294   /// the IR.
 295   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
 296
 297   /// Create a pass configuration object to be used by addPassToEmitX methods
 298   /// for generating a pipeline of CodeGen passes.
 299   virtual TargetPassConfig *createPassConfig(PassManagerBase &PM);
 300
 301   /// Add passes to the specified pass manager to get the specified file
 302   /// emitted.  Typically this will involve several steps of code generation.
 303   /// \p MMI is an optional parameter that, if set to non-nullptr,
 304   /// will be used to set the MachineModuloInfofor this PM.
 305   bool addPassesToEmitFile(PassManagerBase &PM, raw_pwrite_stream &Out,
 306                            CodeGenFileType FileType, bool DisableVerify = true,
 307                            MachineModuleInfo *MMI = nullptr) override;
 308
 309   /// Add passes to the specified pass manager to get machine code emitted with
 310   /// the MCJIT. This method returns true if machine code is not supported. It
 311   /// fills the MCContext Ctx pointer which can be used to build custom
 312   /// MCStreamer.
 313   bool addPassesToEmitMC(PassManagerBase &PM, MCContext *&Ctx,
 314                          raw_pwrite_stream &OS,
 315                          bool DisableVerify = true) override;
 316
 317   /// Returns true if the target is expected to pass all machine verifier
 318   /// checks. This is a stopgap measure to fix targets one by one. We will
 319   /// remove this at some point and always enable the verifier when
 320   /// EXPENSIVE_CHECKS is enabled.
 321   virtual bool isMachineVerifierClean() const { return true; }
 322
 323   /// \brief Adds an AsmPrinter pass to the pipeline that prints assembly or
 324   /// machine code from the MI representation.
 325   bool addAsmPrinter(PassManagerBase &PM, raw_pwrite_stream &Out,
 326                      CodeGenFileType FileTYpe, MCContext &Context);
 327 };
 328
 329 } // end namespace llvm
 330
 331 #endif // LLVM_TARGET_TARGETMACHINE_H