lib/Target/R600/R600ControlFlowFinalizer.cpp

   1 //===-- R600ControlFlowFinalizer.cpp - Finalize Control Flow Inst----------===//
   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 /// This pass compute turns all control flow pseudo instructions into native one
  12 /// computing their address on the fly ; it also sets STACK_SIZE info.
  13 //===----------------------------------------------------------------------===//
  14
  15 #define DEBUG_TYPE "r600cf"
  16 #include "llvm/Support/Debug.h"
  17 #include "llvm/Support/raw_ostream.h"
  18
  19 #include "AMDGPU.h"
  20 #include "R600Defines.h"
  21 #include "R600InstrInfo.h"
  22 #include "R600MachineFunctionInfo.h"
  23 #include "R600RegisterInfo.h"
  24 #include "llvm/CodeGen/MachineFunctionPass.h"
  25 #include "llvm/CodeGen/MachineInstrBuilder.h"
  26 #include "llvm/CodeGen/MachineRegisterInfo.h"
  27
  28 namespace llvm {
  29
  30 class R600ControlFlowFinalizer : public MachineFunctionPass {
  31
  32 private:
  33   static char ID;
  34   const R600InstrInfo *TII;
  35   unsigned MaxFetchInst;
  36
  37   bool isFetch(const MachineInstr *MI) const {
  38     switch (MI->getOpcode()) {
  39     case AMDGPU::TEX_VTX_CONSTBUF:
  40     case AMDGPU::TEX_VTX_TEXBUF:
  41     case AMDGPU::TEX_LD:
  42     case AMDGPU::TEX_GET_TEXTURE_RESINFO:
  43     case AMDGPU::TEX_GET_GRADIENTS_H:
  44     case AMDGPU::TEX_GET_GRADIENTS_V:
  45     case AMDGPU::TEX_SET_GRADIENTS_H:
  46     case AMDGPU::TEX_SET_GRADIENTS_V:
  47     case AMDGPU::TEX_SAMPLE:
  48     case AMDGPU::TEX_SAMPLE_C:
  49     case AMDGPU::TEX_SAMPLE_L:
  50     case AMDGPU::TEX_SAMPLE_C_L:
  51     case AMDGPU::TEX_SAMPLE_LB:
  52     case AMDGPU::TEX_SAMPLE_C_LB:
  53     case AMDGPU::TEX_SAMPLE_G:
  54     case AMDGPU::TEX_SAMPLE_C_G:
  55     case AMDGPU::TXD:
  56     case AMDGPU::TXD_SHADOW:
  57      return true;
  58     default:
  59       return false;
  60     }
  61   }
  62
  63   bool IsTrivialInst(MachineInstr *MI) const {
  64     switch (MI->getOpcode()) {
  65     case AMDGPU::KILL:
  66     case AMDGPU::RETURN:
  67       return true;
  68     default:
  69       return false;
  70     }
  71   }
  72
  73   MachineBasicBlock::iterator
  74   MakeFetchClause(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
  75       unsigned CfAddress) const {
  76     MachineBasicBlock::iterator ClauseHead = I;
  77     unsigned AluInstCount = 0;
  78     for (MachineBasicBlock::iterator E = MBB.end(); I != E; ++I) {
  79       if (IsTrivialInst(I))
  80         continue;
  81       if (!isFetch(I))
  82         break;
  83       AluInstCount ++;
  84       if (AluInstCount > MaxFetchInst)
  85         break;
  86     }
  87     BuildMI(MBB, ClauseHead, MBB.findDebugLoc(ClauseHead),
  88         TII->get(AMDGPU::CF_TC))
  89         .addImm(CfAddress) // ADDR
  90         .addImm(AluInstCount); // COUNT
  91     return I;
  92   }
  93   void CounterPropagateAddr(MachineInstr *MI, unsigned Addr) const {
  94     MI->getOperand(0).setImm(Addr + MI->getOperand(0).getImm());
  95   }
  96   void CounterPropagateAddr(std::set<MachineInstr *> MIs, unsigned Addr)
  97       const {
  98     for (std::set<MachineInstr *>::iterator It = MIs.begin(), E = MIs.end();
  99         It != E; ++It) {
 100       MachineInstr *MI = *It;
 101       CounterPropagateAddr(MI, Addr);
 102     }
 103   }
 104
 105 public:
 106   R600ControlFlowFinalizer(TargetMachine &tm) : MachineFunctionPass(ID),
 107     TII (static_cast<const R600InstrInfo *>(tm.getInstrInfo())) {
 108       const AMDGPUSubtarget &ST = tm.getSubtarget<AMDGPUSubtarget>();
 109       if (ST.device()->getGeneration() <= AMDGPUDeviceInfo::HD4XXX)
 110         MaxFetchInst = 8;
 111       else
 112         MaxFetchInst = 16;
 113   }
 114
 115   virtual bool runOnMachineFunction(MachineFunction &MF) {
 116     unsigned MaxStack = 0;
 117     unsigned CurrentStack = 0;
 118     for (MachineFunction::iterator MB = MF.begin(), ME = MF.end(); MB != ME;
 119         ++MB) {
 120       MachineBasicBlock &MBB = *MB;
 121       unsigned CfCount = 0;
 122       std::vector<std::pair<unsigned, std::set<MachineInstr *> > > LoopStack;
 123       std::vector<MachineInstr * > IfThenElseStack;
 124       R600MachineFunctionInfo *MFI = MF.getInfo<R600MachineFunctionInfo>();
 125       if (MFI->ShaderType == 1) {
 126         BuildMI(MBB, MBB.begin(), MBB.findDebugLoc(MBB.begin()),
 127             TII->get(AMDGPU::CF_CALL_FS));
 128         CfCount++;
 129       }
 130       for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end();
 131           I != E;) {
 132         if (isFetch(I)) {
 133           DEBUG(dbgs() << CfCount << ":"; I->dump(););
 134           I = MakeFetchClause(MBB, I, 0);
 135           CfCount++;
 136           continue;
 137         }
 138
 139         MachineBasicBlock::iterator MI = I;
 140         I++;
 141         switch (MI->getOpcode()) {
 142         case AMDGPU::CF_ALU_PUSH_BEFORE:
 143           CurrentStack++;
 144           MaxStack = std::max(MaxStack, CurrentStack);
 145         case AMDGPU::CF_ALU:
 146           DEBUG(dbgs() << CfCount << ":"; MI->dump(););
 147           CfCount++;
 148           break;
 149         case AMDGPU::WHILELOOP: {
 150           CurrentStack++;
 151           MaxStack = std::max(MaxStack, CurrentStack);
 152           MachineInstr *MIb = BuildMI(MBB, MI, MBB.findDebugLoc(MI),
 153               TII->get(AMDGPU::WHILE_LOOP))
 154               .addImm(2);
 155           std::pair<unsigned, std::set<MachineInstr *> > Pair(CfCount,
 156               std::set<MachineInstr *>());
 157           Pair.second.insert(MIb);
 158           LoopStack.push_back(Pair);
 159           MI->eraseFromParent();
 160           CfCount++;
 161           break;
 162         }
 163         case AMDGPU::ENDLOOP: {
 164           CurrentStack--;
 165           std::pair<unsigned, std::set<MachineInstr *> > Pair =
 166               LoopStack.back();
 167           LoopStack.pop_back();
 168           CounterPropagateAddr(Pair.second, CfCount);
 169           BuildMI(MBB, MI, MBB.findDebugLoc(MI), TII->get(AMDGPU::END_LOOP))
 170               .addImm(Pair.first + 1);
 171           MI->eraseFromParent();
 172           CfCount++;
 173           break;
 174         }
 175         case AMDGPU::IF_PREDICATE_SET: {
 176           MachineInstr *MIb = BuildMI(MBB, MI, MBB.findDebugLoc(MI),
 177               TII->get(AMDGPU::CF_JUMP))
 178               .addImm(0)
 179               .addImm(0);
 180           IfThenElseStack.push_back(MIb);
 181           DEBUG(dbgs() << CfCount << ":"; MIb->dump(););
 182           MI->eraseFromParent();
 183           CfCount++;
 184           break;
 185         }
 186         case AMDGPU::ELSE: {
 187           MachineInstr * JumpInst = IfThenElseStack.back();
 188           IfThenElseStack.pop_back();
 189           CounterPropagateAddr(JumpInst, CfCount);
 190           MachineInstr *MIb = BuildMI(MBB, MI, MBB.findDebugLoc(MI),
 191               TII->get(AMDGPU::CF_ELSE))
 192               .addImm(0)
 193               .addImm(1);
 194           DEBUG(dbgs() << CfCount << ":"; MIb->dump(););
 195           IfThenElseStack.push_back(MIb);
 196           MI->eraseFromParent();
 197           CfCount++;
 198           break;
 199         }
 200         case AMDGPU::ENDIF: {
 201           CurrentStack--;
 202           MachineInstr *IfOrElseInst = IfThenElseStack.back();
 203           IfThenElseStack.pop_back();
 204           CounterPropagateAddr(IfOrElseInst, CfCount);
 205           MachineInstr *MIb = BuildMI(MBB, MI, MBB.findDebugLoc(MI),
 206               TII->get(AMDGPU::POP))
 207               .addImm(CfCount + 1)
 208               .addImm(1);
 209           DEBUG(dbgs() << CfCount << ":"; MIb->dump(););
 210           MI->eraseFromParent();
 211           CfCount++;
 212           break;
 213         }
 214         case AMDGPU::PREDICATED_BREAK: {
 215           CurrentStack--;
 216           CfCount += 3;
 217           BuildMI(MBB, MI, MBB.findDebugLoc(MI), TII->get(AMDGPU::CF_JUMP))
 218               .addImm(CfCount)
 219               .addImm(1);
 220           MachineInstr *MIb = BuildMI(MBB, MI, MBB.findDebugLoc(MI),
 221               TII->get(AMDGPU::LOOP_BREAK))
 222               .addImm(0);
 223           BuildMI(MBB, MI, MBB.findDebugLoc(MI), TII->get(AMDGPU::POP))
 224               .addImm(CfCount)
 225               .addImm(1);
 226           LoopStack.back().second.insert(MIb);
 227           MI->eraseFromParent();
 228           break;
 229         }
 230         case AMDGPU::CONTINUE: {
 231           MachineInstr *MIb = BuildMI(MBB, MI, MBB.findDebugLoc(MI),
 232               TII->get(AMDGPU::CF_CONTINUE))
 233               .addImm(0);
 234           LoopStack.back().second.insert(MIb);
 235           MI->eraseFromParent();
 236           CfCount++;
 237           break;
 238         }
 239         default:
 240           break;
 241         }
 242       }
 243       BuildMI(MBB, MBB.begin(), MBB.findDebugLoc(MBB.begin()),
 244           TII->get(AMDGPU::STACK_SIZE))
 245           .addImm(MaxStack);
 246     }
 247
 248     return false;
 249   }
 250
 251   const char *getPassName() const {
 252     return "R600 Control Flow Finalizer Pass";
 253   }
 254 };
 255
 256 char R600ControlFlowFinalizer::ID = 0;
 257
 258 }
 259
 260
 261 llvm::FunctionPass *llvm::createR600ControlFlowFinalizer(TargetMachine &TM) {
 262   return new R600ControlFlowFinalizer(TM);
 263 }
 264