lib/Target/AMDGPU/SIFixSGPRCopies.cpp

   1 //===-- SIFixSGPRCopies.cpp - Remove potential VGPR => SGPR copies --------===//
   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 /// Copies from VGPR to SGPR registers are illegal and the register coalescer
  12 /// will sometimes generate these illegal copies in situations like this:
  13 ///
  14 ///  Register Class <vsrc> is the union of <vgpr> and <sgpr>
  15 ///
  16 /// BB0:
  17 ///   %vreg0 <sgpr> = SCALAR_INST
  18 ///   %vreg1 <vsrc> = COPY %vreg0 <sgpr>
  19 ///    ...
  20 ///    BRANCH %cond BB1, BB2
  21 ///  BB1:
  22 ///    %vreg2 <vgpr> = VECTOR_INST
  23 ///    %vreg3 <vsrc> = COPY %vreg2 <vgpr>
  24 ///  BB2:
  25 ///    %vreg4 <vsrc> = PHI %vreg1 <vsrc>, <BB#0>, %vreg3 <vrsc>, <BB#1>
  26 ///    %vreg5 <vgpr> = VECTOR_INST %vreg4 <vsrc>
  27 ///
  28 ///
  29 /// The coalescer will begin at BB0 and eliminate its copy, then the resulting
  30 /// code will look like this:
  31 ///
  32 /// BB0:
  33 ///   %vreg0 <sgpr> = SCALAR_INST
  34 ///    ...
  35 ///    BRANCH %cond BB1, BB2
  36 /// BB1:
  37 ///   %vreg2 <vgpr> = VECTOR_INST
  38 ///   %vreg3 <vsrc> = COPY %vreg2 <vgpr>
  39 /// BB2:
  40 ///   %vreg4 <sgpr> = PHI %vreg0 <sgpr>, <BB#0>, %vreg3 <vsrc>, <BB#1>
  41 ///   %vreg5 <vgpr> = VECTOR_INST %vreg4 <sgpr>
  42 ///
  43 /// Now that the result of the PHI instruction is an SGPR, the register
  44 /// allocator is now forced to constrain the register class of %vreg3 to
  45 /// <sgpr> so we end up with final code like this:
  46 ///
  47 /// BB0:
  48 ///   %vreg0 <sgpr> = SCALAR_INST
  49 ///    ...
  50 ///    BRANCH %cond BB1, BB2
  51 /// BB1:
  52 ///   %vreg2 <vgpr> = VECTOR_INST
  53 ///   %vreg3 <sgpr> = COPY %vreg2 <vgpr>
  54 /// BB2:
  55 ///   %vreg4 <sgpr> = PHI %vreg0 <sgpr>, <BB#0>, %vreg3 <sgpr>, <BB#1>
  56 ///   %vreg5 <vgpr> = VECTOR_INST %vreg4 <sgpr>
  57 ///
  58 /// Now this code contains an illegal copy from a VGPR to an SGPR.
  59 ///
  60 /// In order to avoid this problem, this pass searches for PHI instructions
  61 /// which define a <vsrc> register and constrains its definition class to
  62 /// <vgpr> if the user of the PHI's definition register is a vector instruction.
  63 /// If the PHI's definition class is constrained to <vgpr> then the coalescer
  64 /// will be unable to perform the COPY removal from the above example  which
  65 /// ultimately led to the creation of an illegal COPY.
  66 //===----------------------------------------------------------------------===//
  67
  68 #include "AMDGPU.h"
  69 #include "AMDGPUSubtarget.h"
  70 #include "SIInstrInfo.h"
  71 #include "llvm/CodeGen/MachineFunctionPass.h"
  72 #include "llvm/CodeGen/MachineInstrBuilder.h"
  73 #include "llvm/CodeGen/MachineRegisterInfo.h"
  74 #include "llvm/Support/Debug.h"
  75 #include "llvm/Support/raw_ostream.h"
  76 #include "llvm/Target/TargetMachine.h"
  77
  78 using namespace llvm;
  79
  80 #define DEBUG_TYPE "sgpr-copies"
  81
  82 namespace {
  83
  84 class SIFixSGPRCopies : public MachineFunctionPass {
  85
  86 private:
  87   static char ID;
  88   const TargetRegisterClass *inferRegClassFromUses(const SIRegisterInfo *TRI,
  89                                            const MachineRegisterInfo &MRI,
  90                                            unsigned Reg,
  91                                            unsigned SubReg) const;
  92   const TargetRegisterClass *inferRegClassFromDef(const SIRegisterInfo *TRI,
  93                                                  const MachineRegisterInfo &MRI,
  94                                                  unsigned Reg,
  95                                                  unsigned SubReg) const;
  96   bool isVGPRToSGPRCopy(const MachineInstr &Copy, const SIRegisterInfo *TRI,
  97                         const MachineRegisterInfo &MRI) const;
  98
  99 public:
 100   SIFixSGPRCopies(TargetMachine &tm) : MachineFunctionPass(ID) { }
 101
 102   bool runOnMachineFunction(MachineFunction &MF) override;
 103
 104   const char *getPassName() const override {
 105     return "SI Fix SGPR copies";
 106   }
 107
 108   void getAnalysisUsage(AnalysisUsage &AU) const override {
 109     AU.setPreservesCFG();
 110     MachineFunctionPass::getAnalysisUsage(AU);
 111   }
 112 };
 113
 114 } // End anonymous namespace
 115
 116 char SIFixSGPRCopies::ID = 0;
 117
 118 FunctionPass *llvm::createSIFixSGPRCopiesPass(TargetMachine &tm) {
 119   return new SIFixSGPRCopies(tm);
 120 }
 121
 122 static bool hasVGPROperands(const MachineInstr &MI, const SIRegisterInfo *TRI) {
 123   const MachineRegisterInfo &MRI = MI.getParent()->getParent()->getRegInfo();
 124   for (unsigned i = 0, e = MI.getNumOperands(); i != e; ++i) {
 125     if (!MI.getOperand(i).isReg() ||
 126         !TargetRegisterInfo::isVirtualRegister(MI.getOperand(i).getReg()))
 127       continue;
 128
 129     if (TRI->hasVGPRs(MRI.getRegClass(MI.getOperand(i).getReg())))
 130       return true;
 131   }
 132   return false;
 133 }
 134
 135 /// This functions walks the use list of Reg until it finds an Instruction
 136 /// that isn't a COPY returns the register class of that instruction.
 137 /// \return The register defined by the first non-COPY instruction.
 138 const TargetRegisterClass *SIFixSGPRCopies::inferRegClassFromUses(
 139                                                  const SIRegisterInfo *TRI,
 140                                                  const MachineRegisterInfo &MRI,
 141                                                  unsigned Reg,
 142                                                  unsigned SubReg) const {
 143
 144   const TargetRegisterClass *RC
 145     = TargetRegisterInfo::isVirtualRegister(Reg) ?
 146     MRI.getRegClass(Reg) :
 147     TRI->getPhysRegClass(Reg);
 148
 149   RC = TRI->getSubRegClass(RC, SubReg);
 150   for (MachineRegisterInfo::use_instr_iterator
 151        I = MRI.use_instr_begin(Reg), E = MRI.use_instr_end(); I != E; ++I) {
 152     switch (I->getOpcode()) {
 153     case AMDGPU::COPY:
 154       RC = TRI->getCommonSubClass(RC, inferRegClassFromUses(TRI, MRI,
 155                                   I->getOperand(0).getReg(),
 156                                   I->getOperand(0).getSubReg()));
 157       break;
 158     }
 159   }
 160
 161   return RC;
 162 }
 163
 164 const TargetRegisterClass *SIFixSGPRCopies::inferRegClassFromDef(
 165                                                  const SIRegisterInfo *TRI,
 166                                                  const MachineRegisterInfo &MRI,
 167                                                  unsigned Reg,
 168                                                  unsigned SubReg) const {
 169   if (!TargetRegisterInfo::isVirtualRegister(Reg)) {
 170     const TargetRegisterClass *RC = TRI->getPhysRegClass(Reg);
 171     return TRI->getSubRegClass(RC, SubReg);
 172   }
 173   MachineInstr *Def = MRI.getVRegDef(Reg);
 174   if (Def->getOpcode() != AMDGPU::COPY) {
 175     return TRI->getSubRegClass(MRI.getRegClass(Reg), SubReg);
 176   }
 177
 178   return inferRegClassFromDef(TRI, MRI, Def->getOperand(1).getReg(),
 179                                    Def->getOperand(1).getSubReg());
 180 }
 181
 182 bool SIFixSGPRCopies::isVGPRToSGPRCopy(const MachineInstr &Copy,
 183                                       const SIRegisterInfo *TRI,
 184                                       const MachineRegisterInfo &MRI) const {
 185
 186   unsigned DstReg = Copy.getOperand(0).getReg();
 187   unsigned SrcReg = Copy.getOperand(1).getReg();
 188   unsigned SrcSubReg = Copy.getOperand(1).getSubReg();
 189
 190   if (!TargetRegisterInfo::isVirtualRegister(DstReg)) {
 191     // If the destination register is a physical register there isn't really
 192     // much we can do to fix this.
 193     return false;
 194   }
 195
 196   const TargetRegisterClass *DstRC = MRI.getRegClass(DstReg);
 197
 198   const TargetRegisterClass *SrcRC;
 199
 200   if (!TargetRegisterInfo::isVirtualRegister(SrcReg) ||
 201       MRI.getRegClass(SrcReg) == &AMDGPU::VReg_1RegClass)
 202     return false;
 203
 204   SrcRC = TRI->getSubRegClass(MRI.getRegClass(SrcReg), SrcSubReg);
 205   return TRI->isSGPRClass(DstRC) && TRI->hasVGPRs(SrcRC);
 206 }
 207
 208 bool SIFixSGPRCopies::runOnMachineFunction(MachineFunction &MF) {
 209   MachineRegisterInfo &MRI = MF.getRegInfo();
 210   const SIRegisterInfo *TRI =
 211       static_cast<const SIRegisterInfo *>(MF.getSubtarget().getRegisterInfo());
 212   const SIInstrInfo *TII =
 213       static_cast<const SIInstrInfo *>(MF.getSubtarget().getInstrInfo());
 214   for (MachineFunction::iterator BI = MF.begin(), BE = MF.end();
 215                                                   BI != BE; ++BI) {
 216
 217     MachineBasicBlock &MBB = *BI;
 218     for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end();
 219                                                       I != E; ++I) {
 220       MachineInstr &MI = *I;
 221
 222       switch (MI.getOpcode()) {
 223       default:
 224         continue;
 225       case AMDGPU::COPY: {
 226         if (isVGPRToSGPRCopy(MI, TRI, MRI)) {
 227           DEBUG(dbgs() << "Fixing VGPR -> SGPR copy: " << MI);
 228           TII->moveToVALU(MI);
 229         }
 230
 231         break;
 232       }
 233       case AMDGPU::PHI: {
 234         DEBUG(dbgs() << "Fixing PHI: " << MI);
 235
 236         for (unsigned i = 1; i < MI.getNumOperands(); i += 2) {
 237           const MachineOperand &Op = MI.getOperand(i);
 238           unsigned Reg = Op.getReg();
 239           const TargetRegisterClass *RC
 240             = inferRegClassFromDef(TRI, MRI, Reg, Op.getSubReg());
 241
 242           MRI.constrainRegClass(Op.getReg(), RC);
 243         }
 244         unsigned Reg = MI.getOperand(0).getReg();
 245         const TargetRegisterClass *RC = inferRegClassFromUses(TRI, MRI, Reg,
 246                                                   MI.getOperand(0).getSubReg());
 247         if (TRI->getCommonSubClass(RC, &AMDGPU::VGPR_32RegClass)) {
 248           MRI.constrainRegClass(Reg, &AMDGPU::VGPR_32RegClass);
 249         }
 250
 251         if (!TRI->isSGPRClass(MRI.getRegClass(Reg)))
 252           break;
 253
 254         // If a PHI node defines an SGPR and any of its operands are VGPRs,
 255         // then we need to move it to the VALU.
 256         //
 257         // Also, if a PHI node defines an SGPR and has all SGPR operands
 258         // we must move it to the VALU, because the SGPR operands will
 259         // all end up being assigned the same register, which means
 260         // there is a potential for a conflict if different threads take
 261         // different control flow paths.
 262         //
 263         // For Example:
 264         //
 265         // sgpr0 = def;
 266         // ...
 267         // sgpr1 = def;
 268         // ...
 269         // sgpr2 = PHI sgpr0, sgpr1
 270         // use sgpr2;
 271         //
 272         // Will Become:
 273         //
 274         // sgpr2 = def;
 275         // ...
 276         // sgpr2 = def;
 277         // ...
 278         // use sgpr2
 279         //
 280         // FIXME: This is OK if the branching decision is made based on an
 281         // SGPR value.
 282         bool SGPRBranch = false;
 283
 284         // The one exception to this rule is when one of the operands
 285         // is defined by a SI_BREAK, SI_IF_BREAK, or SI_ELSE_BREAK
 286         // instruction.  In this case, there we know the program will
 287         // never enter the second block (the loop) without entering
 288         // the first block (where the condition is computed), so there
 289         // is no chance for values to be over-written.
 290
 291         bool HasBreakDef = false;
 292         for (unsigned i = 1; i < MI.getNumOperands(); i+=2) {
 293           unsigned Reg = MI.getOperand(i).getReg();
 294           if (TRI->hasVGPRs(MRI.getRegClass(Reg))) {
 295             TII->moveToVALU(MI);
 296             break;
 297           }
 298           MachineInstr *DefInstr = MRI.getUniqueVRegDef(Reg);
 299           assert(DefInstr);
 300           switch(DefInstr->getOpcode()) {
 301
 302           case AMDGPU::SI_BREAK:
 303           case AMDGPU::SI_IF_BREAK:
 304           case AMDGPU::SI_ELSE_BREAK:
 305           // If we see a PHI instruction that defines an SGPR, then that PHI
 306           // instruction has already been considered and should have
 307           // a *_BREAK as an operand.
 308           case AMDGPU::PHI:
 309             HasBreakDef = true;
 310             break;
 311           }
 312         }
 313
 314         if (!SGPRBranch && !HasBreakDef)
 315           TII->moveToVALU(MI);
 316         break;
 317       }
 318       case AMDGPU::REG_SEQUENCE: {
 319         if (TRI->hasVGPRs(TII->getOpRegClass(MI, 0)) ||
 320             !hasVGPROperands(MI, TRI))
 321           continue;
 322
 323         DEBUG(dbgs() << "Fixing REG_SEQUENCE: " << MI);
 324
 325         TII->moveToVALU(MI);
 326         break;
 327       }
 328       case AMDGPU::INSERT_SUBREG: {
 329         const TargetRegisterClass *DstRC, *Src0RC, *Src1RC;
 330         DstRC = MRI.getRegClass(MI.getOperand(0).getReg());
 331         Src0RC = MRI.getRegClass(MI.getOperand(1).getReg());
 332         Src1RC = MRI.getRegClass(MI.getOperand(2).getReg());
 333         if (TRI->isSGPRClass(DstRC) &&
 334             (TRI->hasVGPRs(Src0RC) || TRI->hasVGPRs(Src1RC))) {
 335           DEBUG(dbgs() << " Fixing INSERT_SUBREG: " << MI);
 336           TII->moveToVALU(MI);
 337         }
 338         break;
 339       }
 340       }
 341     }
 342   }
 343
 344   return true;
 345 }