lib/Target/R600/R600OptimizeVectorRegisters.cpp

   1 //===--------------------- R600MergeVectorRegisters.cpp -------------------===//
   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 merges inputs of swizzeable instructions into vector sharing
  12 /// common data and/or have enough undef subreg using swizzle abilities.
  13 ///
  14 /// For instance let's consider the following pseudo code :
  15 /// vreg5<def> = REG_SEQ vreg1, sub0, vreg2, sub1, vreg3, sub2, undef, sub3
  16 /// ...
  17 /// vreg7<def> = REG_SEQ vreg1, sub0, vreg3, sub1, undef, sub2, vreg4, sub3
  18 /// (swizzable Inst) vreg7, SwizzleMask : sub0, sub1, sub2, sub3
  19 ///
  20 /// is turned into :
  21 /// vreg5<def> = REG_SEQ vreg1, sub0, vreg2, sub1, vreg3, sub2, undef, sub3
  22 /// ...
  23 /// vreg7<def> = INSERT_SUBREG vreg4, sub3
  24 /// (swizzable Inst) vreg7, SwizzleMask : sub0, sub2, sub1, sub3
  25 ///
  26 /// This allow regalloc to reduce register pressure for vector registers and
  27 /// to reduce MOV count.
  28 //===----------------------------------------------------------------------===//
  29
  30 #define DEBUG_TYPE "vec-merger"
  31 #include "llvm/Support/Debug.h"
  32 #include "AMDGPU.h"
  33 #include "R600InstrInfo.h"
  34 #include "llvm/CodeGen/DFAPacketizer.h"
  35 #include "llvm/CodeGen/MachineDominators.h"
  36 #include "llvm/CodeGen/MachineFunctionPass.h"
  37 #include "llvm/CodeGen/MachineLoopInfo.h"
  38 #include "llvm/CodeGen/Passes.h"
  39 #include "llvm/CodeGen/MachineInstrBuilder.h"
  40 #include "llvm/Support/raw_ostream.h"
  41 #include "llvm/CodeGen/MachineRegisterInfo.h"
  42
  43 using namespace llvm;
  44
  45 namespace {
  46
  47 static bool
  48 isImplicitlyDef(MachineRegisterInfo &MRI, unsigned Reg) {
  49   for (MachineRegisterInfo::def_iterator It = MRI.def_begin(Reg),
  50       E = MRI.def_end(); It != E; ++It) {
  51     return (*It).isImplicitDef();
  52   }
  53   llvm_unreachable("Reg without a def");
  54   return false;
  55 }
  56
  57 class RegSeqInfo {
  58 public:
  59   MachineInstr *Instr;
  60   DenseMap<unsigned, unsigned> RegToChan;
  61   std::vector<unsigned> UndefReg;
  62   RegSeqInfo(MachineRegisterInfo &MRI, MachineInstr *MI) : Instr(MI) {
  63     assert (MI->getOpcode() == AMDGPU::REG_SEQUENCE);
  64     for (unsigned i = 1, e = Instr->getNumOperands(); i < e; i+=2) {
  65       MachineOperand &MO = Instr->getOperand(i);
  66       unsigned Chan = Instr->getOperand(i + 1).getImm();
  67       if (isImplicitlyDef(MRI, MO.getReg()))
  68         UndefReg.push_back(Chan);
  69       else
  70         RegToChan[MO.getReg()] = Chan;
  71     }
  72   }
  73   RegSeqInfo() {}
  74
  75   bool operator==(const RegSeqInfo &RSI) const {
  76     return RSI.Instr == Instr;
  77   }
  78 };
  79
  80 class R600VectorRegMerger : public MachineFunctionPass {
  81 private:
  82   MachineRegisterInfo *MRI;
  83   const R600InstrInfo *TII;
  84   bool canSwizzle(const MachineInstr &) const;
  85   bool areAllUsesSwizzeable(unsigned Reg) const;
  86   void SwizzleInput(MachineInstr &,
  87       const std::vector<std::pair<unsigned, unsigned> > &) const;
  88   bool tryMergeVector(const RegSeqInfo *, RegSeqInfo *,
  89       std::vector<std::pair<unsigned, unsigned> > &Remap) const;
  90   bool tryMergeUsingCommonSlot(RegSeqInfo &RSI, RegSeqInfo &CompatibleRSI,
  91       std::vector<std::pair<unsigned, unsigned> > &RemapChan);
  92   bool tryMergeUsingFreeSlot(RegSeqInfo &RSI, RegSeqInfo &CompatibleRSI,
  93       std::vector<std::pair<unsigned, unsigned> > &RemapChan);
  94   MachineInstr *RebuildVector(RegSeqInfo *MI,
  95       const RegSeqInfo *BaseVec,
  96       const std::vector<std::pair<unsigned, unsigned> > &RemapChan) const;
  97   void RemoveMI(MachineInstr *);
  98   void trackRSI(const RegSeqInfo &RSI);
  99
 100   typedef DenseMap<unsigned, std::vector<MachineInstr *> > InstructionSetMap;
 101   DenseMap<MachineInstr *, RegSeqInfo> PreviousRegSeq;
 102   InstructionSetMap PreviousRegSeqByReg;
 103   InstructionSetMap PreviousRegSeqByUndefCount;
 104 public:
 105   static char ID;
 106   R600VectorRegMerger(TargetMachine &tm) : MachineFunctionPass(ID),
 107   TII (static_cast<const R600InstrInfo *>(tm.getInstrInfo())) { }
 108
 109   void getAnalysisUsage(AnalysisUsage &AU) const {
 110     AU.setPreservesCFG();
 111     AU.addRequired<MachineDominatorTree>();
 112     AU.addPreserved<MachineDominatorTree>();
 113     AU.addRequired<MachineLoopInfo>();
 114     AU.addPreserved<MachineLoopInfo>();
 115     MachineFunctionPass::getAnalysisUsage(AU);
 116   }
 117
 118   const char *getPassName() const {
 119     return "R600 Vector Registers Merge Pass";
 120   }
 121
 122   bool runOnMachineFunction(MachineFunction &Fn);
 123 };
 124
 125 char R600VectorRegMerger::ID = 0;
 126
 127 bool R600VectorRegMerger::canSwizzle(const MachineInstr &MI)
 128     const {
 129   if (TII->get(MI.getOpcode()).TSFlags & R600_InstFlag::TEX_INST)
 130     return true;
 131   switch (MI.getOpcode()) {
 132   case AMDGPU::R600_ExportSwz:
 133   case AMDGPU::EG_ExportSwz:
 134     return true;
 135   default:
 136     return false;
 137   }
 138 }
 139
 140 bool R600VectorRegMerger::tryMergeVector(const RegSeqInfo *Untouched,
 141     RegSeqInfo *ToMerge, std::vector< std::pair<unsigned, unsigned> > &Remap)
 142     const {
 143   unsigned CurrentUndexIdx = 0;
 144   for (DenseMap<unsigned, unsigned>::iterator It = ToMerge->RegToChan.begin(),
 145       E = ToMerge->RegToChan.end(); It != E; ++It) {
 146     DenseMap<unsigned, unsigned>::const_iterator PosInUntouched =
 147         Untouched->RegToChan.find((*It).first);
 148     if (PosInUntouched != Untouched->RegToChan.end()) {
 149       Remap.push_back(std::pair<unsigned, unsigned>
 150           ((*It).second, (*PosInUntouched).second));
 151       continue;
 152     }
 153     if (CurrentUndexIdx >= Untouched->UndefReg.size())
 154       return false;
 155     Remap.push_back(std::pair<unsigned, unsigned>
 156         ((*It).second, Untouched->UndefReg[CurrentUndexIdx++]));
 157   }
 158
 159   return true;
 160 }
 161
 162 MachineInstr *R600VectorRegMerger::RebuildVector(
 163     RegSeqInfo *RSI, const RegSeqInfo *BaseRSI,
 164     const std::vector<std::pair<unsigned, unsigned> > &RemapChan) const {
 165   unsigned Reg = RSI->Instr->getOperand(0).getReg();
 166   MachineBasicBlock::iterator Pos = RSI->Instr;
 167   MachineBasicBlock &MBB = *Pos->getParent();
 168   DebugLoc DL = Pos->getDebugLoc();
 169
 170   unsigned SrcVec = BaseRSI->Instr->getOperand(0).getReg();
 171   DenseMap<unsigned, unsigned> UpdatedRegToChan = BaseRSI->RegToChan;
 172   std::vector<unsigned> UpdatedUndef = BaseRSI->UndefReg;
 173   for (DenseMap<unsigned, unsigned>::iterator It = RSI->RegToChan.begin(),
 174       E = RSI->RegToChan.end(); It != E; ++It) {
 175     if (BaseRSI->RegToChan.find((*It).first) != BaseRSI->RegToChan.end()) {
 176       UpdatedRegToChan[(*It).first] = (*It).second;
 177       continue;
 178     }
 179     unsigned DstReg = MRI->createVirtualRegister(&AMDGPU::R600_Reg128RegClass);
 180     unsigned SubReg = (*It).first;
 181     unsigned Swizzle = (*It).second;
 182     unsigned Chan;
 183     for (unsigned j = 0, je = RemapChan.size(); j < je; j++) {
 184       if (RemapChan[j].first == Swizzle) {
 185         Chan = RemapChan[j].second;
 186         break;
 187       }
 188     }
 189     MachineInstr *Tmp = BuildMI(MBB, Pos, DL, TII->get(AMDGPU::INSERT_SUBREG),
 190         DstReg)
 191         .addReg(SrcVec)
 192         .addReg(SubReg)
 193         .addImm(Chan);
 194     UpdatedRegToChan[SubReg] = Chan;
 195     for (std::vector<unsigned>::iterator RemoveIt = UpdatedUndef.begin(),
 196         RemoveE = UpdatedUndef.end(); RemoveIt != RemoveE; ++ RemoveIt) {
 197       if (*RemoveIt == Chan)
 198         UpdatedUndef.erase(RemoveIt);
 199     }
 200     DEBUG(dbgs() << "    ->"; Tmp->dump(););
 201     (void)Tmp;
 202     SrcVec = DstReg;
 203   }
 204   Pos = BuildMI(MBB, Pos, DL, TII->get(AMDGPU::COPY), Reg)
 205       .addReg(SrcVec);
 206   DEBUG(dbgs() << "    ->"; Pos->dump(););
 207
 208   DEBUG(dbgs() << "  Updating Swizzle:\n");
 209   for (MachineRegisterInfo::use_iterator It = MRI->use_begin(Reg),
 210       E = MRI->use_end(); It != E; ++It) {
 211     DEBUG(dbgs() << "    ";(*It).dump(); dbgs() << "    ->");
 212     SwizzleInput(*It, RemapChan);
 213     DEBUG((*It).dump());
 214   }
 215   RSI->Instr->eraseFromParent();
 216
 217   // Update RSI
 218   RSI->Instr = Pos;
 219   RSI->RegToChan = UpdatedRegToChan;
 220   RSI->UndefReg = UpdatedUndef;
 221
 222   return Pos;
 223 }
 224
 225 void R600VectorRegMerger::RemoveMI(MachineInstr *MI) {
 226   for (InstructionSetMap::iterator It = PreviousRegSeqByReg.begin(),
 227       E = PreviousRegSeqByReg.end(); It != E; ++It) {
 228     std::vector<MachineInstr *> &MIs = (*It).second;
 229     MIs.erase(std::find(MIs.begin(), MIs.end(), MI), MIs.end());
 230   }
 231   for (InstructionSetMap::iterator It = PreviousRegSeqByUndefCount.begin(),
 232       E = PreviousRegSeqByUndefCount.end(); It != E; ++It) {
 233     std::vector<MachineInstr *> &MIs = (*It).second;
 234     MIs.erase(std::find(MIs.begin(), MIs.end(), MI), MIs.end());
 235   }
 236 }
 237
 238 void R600VectorRegMerger::SwizzleInput(MachineInstr &MI,
 239     const std::vector<std::pair<unsigned, unsigned> > &RemapChan) const {
 240   unsigned Offset;
 241   if (TII->get(MI.getOpcode()).TSFlags & R600_InstFlag::TEX_INST)
 242     Offset = 2;
 243   else
 244     Offset = 3;
 245   for (unsigned i = 0; i < 4; i++) {
 246     unsigned Swizzle = MI.getOperand(i + Offset).getImm() + 1;
 247     for (unsigned j = 0, e = RemapChan.size(); j < e; j++) {
 248       if (RemapChan[j].first == Swizzle) {
 249         MI.getOperand(i + Offset).setImm(RemapChan[j].second - 1);
 250         break;
 251       }
 252     }
 253   }
 254 }
 255
 256 bool R600VectorRegMerger::areAllUsesSwizzeable(unsigned Reg) const {
 257   for (MachineRegisterInfo::use_iterator It = MRI->use_begin(Reg),
 258       E = MRI->use_end(); It != E; ++It) {
 259     if (!canSwizzle(*It))
 260       return false;
 261   }
 262   return true;
 263 }
 264
 265 bool R600VectorRegMerger::tryMergeUsingCommonSlot(RegSeqInfo &RSI,
 266     RegSeqInfo &CompatibleRSI,
 267     std::vector<std::pair<unsigned, unsigned> > &RemapChan) {
 268   for (MachineInstr::mop_iterator MOp = RSI.Instr->operands_begin(),
 269       MOE = RSI.Instr->operands_end(); MOp != MOE; ++MOp) {
 270     if (!MOp->isReg())
 271       continue;
 272     if (PreviousRegSeqByReg[MOp->getReg()].empty())
 273       continue;
 274     std::vector<MachineInstr *> MIs = PreviousRegSeqByReg[MOp->getReg()];
 275     for (unsigned i = 0, e = MIs.size(); i < e; i++) {
 276       CompatibleRSI = PreviousRegSeq[MIs[i]];
 277       if (RSI == CompatibleRSI)
 278         continue;
 279       if (tryMergeVector(&CompatibleRSI, &RSI, RemapChan))
 280         return true;
 281     }
 282   }
 283   return false;
 284 }
 285
 286 bool R600VectorRegMerger::tryMergeUsingFreeSlot(RegSeqInfo &RSI,
 287     RegSeqInfo &CompatibleRSI,
 288     std::vector<std::pair<unsigned, unsigned> > &RemapChan) {
 289   unsigned NeededUndefs = 4 - RSI.UndefReg.size();
 290   if (PreviousRegSeqByUndefCount[NeededUndefs].empty())
 291     return false;
 292   std::vector<MachineInstr *> &MIs =
 293       PreviousRegSeqByUndefCount[NeededUndefs];
 294   CompatibleRSI = PreviousRegSeq[MIs.back()];
 295   tryMergeVector(&CompatibleRSI, &RSI, RemapChan);
 296   return true;
 297 }
 298
 299 void R600VectorRegMerger::trackRSI(const RegSeqInfo &RSI) {
 300   for (DenseMap<unsigned, unsigned>::const_iterator
 301   It = RSI.RegToChan.begin(), E = RSI.RegToChan.end(); It != E; ++It) {
 302     PreviousRegSeqByReg[(*It).first].push_back(RSI.Instr);
 303   }
 304   PreviousRegSeqByUndefCount[RSI.UndefReg.size()].push_back(RSI.Instr);
 305   PreviousRegSeq[RSI.Instr] = RSI;
 306 }
 307
 308 bool R600VectorRegMerger::runOnMachineFunction(MachineFunction &Fn) {
 309   MRI = &(Fn.getRegInfo());
 310   for (MachineFunction::iterator MBB = Fn.begin(), MBBe = Fn.end();
 311        MBB != MBBe; ++MBB) {
 312     MachineBasicBlock *MB = MBB;
 313     PreviousRegSeq.clear();
 314     PreviousRegSeqByReg.clear();
 315     PreviousRegSeqByUndefCount.clear();
 316
 317     for (MachineBasicBlock::iterator MII = MB->begin(), MIIE = MB->end();
 318          MII != MIIE; ++MII) {
 319       MachineInstr *MI = MII;
 320       if (MI->getOpcode() != AMDGPU::REG_SEQUENCE)
 321         continue;
 322
 323       RegSeqInfo RSI(*MRI, MI);
 324
 325       // All uses of MI are swizzeable ?
 326       unsigned Reg = MI->getOperand(0).getReg();
 327       if (!areAllUsesSwizzeable(Reg))
 328         continue;
 329
 330       DEBUG (dbgs() << "Trying to optimize ";
 331           MI->dump();
 332       );
 333
 334       RegSeqInfo CandidateRSI;
 335       std::vector<std::pair<unsigned, unsigned> > RemapChan;
 336       DEBUG(dbgs() << "Using common slots...\n";);
 337       if (tryMergeUsingCommonSlot(RSI, CandidateRSI, RemapChan)) {
 338         // Remove CandidateRSI mapping
 339         RemoveMI(CandidateRSI.Instr);
 340         MII = RebuildVector(&RSI, &CandidateRSI, RemapChan);
 341         trackRSI(RSI);
 342         continue;
 343       }
 344       DEBUG(dbgs() << "Using free slots...\n";);
 345       RemapChan.clear();
 346       if (tryMergeUsingFreeSlot(RSI, CandidateRSI, RemapChan)) {
 347         RemoveMI(CandidateRSI.Instr);
 348         MII = RebuildVector(&RSI, &CandidateRSI, RemapChan);
 349         trackRSI(RSI);
 350         continue;
 351       }
 352       //Failed to merge
 353       trackRSI(RSI);
 354     }
 355   }
 356   return false;
 357 }
 358
 359 }
 360
 361 llvm::FunctionPass *llvm::createR600VectorRegMerger(TargetMachine &tm) {
 362   return new R600VectorRegMerger(tm);
 363 }