lib/Target/R600/AMDGPUTargetMachine.cpp

   1 //===-- AMDGPUTargetMachine.cpp - TargetMachine for hw codegen targets-----===//
   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 /// \file
  11 /// \brief The AMDGPU target machine contains all of the hardware specific
  12 /// information  needed to emit code for R600 and SI GPUs.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "AMDGPUTargetMachine.h"
  17 #include "AMDGPU.h"
  18 #include "R600ISelLowering.h"
  19 #include "R600InstrInfo.h"
  20 #include "SIISelLowering.h"
  21 #include "SIInstrInfo.h"
  22 #include "llvm/Analysis/Passes.h"
  23 #include "llvm/Analysis/Verifier.h"
  24 #include "llvm/CodeGen/MachineFunctionAnalysis.h"
  25 #include "llvm/CodeGen/MachineModuleInfo.h"
  26 #include "llvm/CodeGen/Passes.h"
  27 #include "llvm/MC/MCAsmInfo.h"
  28 #include "llvm/PassManager.h"
  29 #include "llvm/Support/TargetRegistry.h"
  30 #include "llvm/Support/raw_os_ostream.h"
  31 #include "llvm/Transforms/IPO.h"
  32 #include "llvm/Transforms/Scalar.h"
  33 #include <llvm/CodeGen/Passes.h>
  34
  35 using namespace llvm;
  36
  37 extern "C" void LLVMInitializeR600Target() {
  38   // Register the target
  39   RegisterTargetMachine<AMDGPUTargetMachine> X(TheAMDGPUTarget);
  40 }
  41
  42 AMDGPUTargetMachine::AMDGPUTargetMachine(const Target &T, StringRef TT,
  43     StringRef CPU, StringRef FS,
  44   TargetOptions Options,
  45   Reloc::Model RM, CodeModel::Model CM,
  46   CodeGenOpt::Level OptLevel
  47 )
  48 :
  49   LLVMTargetMachine(T, TT, CPU, FS, Options, RM, CM, OptLevel),
  50   Subtarget(TT, CPU, FS),
  51   Layout(Subtarget.getDataLayout()),
  52   FrameLowering(TargetFrameLowering::StackGrowsUp,
  53       Subtarget.device()->getStackAlignment(), 0),
  54   IntrinsicInfo(this),
  55   InstrItins(&Subtarget.getInstrItineraryData()) {
  56   // TLInfo uses InstrInfo so it must be initialized after.
  57   if (Subtarget.device()->getGeneration() <= AMDGPUDeviceInfo::HD6XXX) {
  58     InstrInfo = new R600InstrInfo(*this);
  59     TLInfo = new R600TargetLowering(*this);
  60   } else {
  61     InstrInfo = new SIInstrInfo(*this);
  62     TLInfo = new SITargetLowering(*this);
  63   }
  64 }
  65
  66 AMDGPUTargetMachine::~AMDGPUTargetMachine() {
  67 }
  68
  69 namespace {
  70 class AMDGPUPassConfig : public TargetPassConfig {
  71 public:
  72   AMDGPUPassConfig(AMDGPUTargetMachine *TM, PassManagerBase &PM)
  73     : TargetPassConfig(TM, PM) {}
  74
  75   AMDGPUTargetMachine &getAMDGPUTargetMachine() const {
  76     return getTM<AMDGPUTargetMachine>();
  77   }
  78
  79   virtual bool addPreISel();
  80   virtual bool addInstSelector();
  81   virtual bool addPreRegAlloc();
  82   virtual bool addPostRegAlloc();
  83   virtual bool addPreSched2();
  84   virtual bool addPreEmitPass();
  85 };
  86 } // End of anonymous namespace
  87
  88 TargetPassConfig *AMDGPUTargetMachine::createPassConfig(PassManagerBase &PM) {
  89   return new AMDGPUPassConfig(this, PM);
  90 }
  91
  92 bool
  93 AMDGPUPassConfig::addPreISel() {
  94   const AMDGPUSubtarget &ST = TM->getSubtarget<AMDGPUSubtarget>();
  95   if (ST.device()->getGeneration() > AMDGPUDeviceInfo::HD6XXX) {
  96     addPass(createAMDGPUStructurizeCFGPass());
  97     addPass(createSIAnnotateControlFlowPass());
  98   }
  99   return false;
 100 }
 101
 102 bool AMDGPUPassConfig::addInstSelector() {
 103   addPass(createAMDGPUPeepholeOpt(*TM));
 104   addPass(createAMDGPUISelDag(getAMDGPUTargetMachine()));
 105
 106   const AMDGPUSubtarget &ST = TM->getSubtarget<AMDGPUSubtarget>();
 107   if (ST.device()->getGeneration() <= AMDGPUDeviceInfo::HD6XXX) {
 108     // This callbacks this pass uses are not implemented yet on SI.
 109     addPass(createAMDGPUIndirectAddressingPass(*TM));
 110   }
 111   return false;
 112 }
 113
 114 bool AMDGPUPassConfig::addPreRegAlloc() {
 115   const AMDGPUSubtarget &ST = TM->getSubtarget<AMDGPUSubtarget>();
 116
 117   if (ST.device()->getGeneration() > AMDGPUDeviceInfo::HD6XXX) {
 118     addPass(createSIAssignInterpRegsPass(*TM));
 119   }
 120   addPass(createAMDGPUConvertToISAPass(*TM));
 121   return false;
 122 }
 123
 124 bool AMDGPUPassConfig::addPostRegAlloc() {
 125   const AMDGPUSubtarget &ST = TM->getSubtarget<AMDGPUSubtarget>();
 126
 127   if (ST.device()->getGeneration() > AMDGPUDeviceInfo::HD6XXX) {
 128     addPass(createSIInsertWaits(*TM));
 129   }
 130   return false;
 131 }
 132
 133 bool AMDGPUPassConfig::addPreSched2() {
 134
 135   addPass(&IfConverterID);
 136   return false;
 137 }
 138
 139 bool AMDGPUPassConfig::addPreEmitPass() {
 140   const AMDGPUSubtarget &ST = TM->getSubtarget<AMDGPUSubtarget>();
 141   if (ST.device()->getGeneration() <= AMDGPUDeviceInfo::HD6XXX) {
 142     addPass(createAMDGPUCFGPreparationPass(*TM));
 143     addPass(createAMDGPUCFGStructurizerPass(*TM));
 144     addPass(createR600ExpandSpecialInstrsPass(*TM));
 145     addPass(&FinalizeMachineBundlesID);
 146     addPass(createR600LowerConstCopy(*TM));
 147   } else {
 148     addPass(createSILowerLiteralConstantsPass(*TM));
 149     addPass(createSILowerControlFlowPass(*TM));
 150   }
 151
 152   return false;
 153 }
 154