LLVM API Documentation

SPUInstrInfo.cpp

Go to the documentation of this file.
00001 //===- SPUInstrInfo.cpp - Cell SPU Instruction Information ----------------===//
00002 //
00003 //                     The LLVM Compiler Infrastructure
00004 //
00005 // This file is distributed under the University of Illinois Open Source
00006 // License. See LICENSE.TXT for details.
00007 //
00008 //===----------------------------------------------------------------------===//
00009 //
00010 // This file contains the Cell SPU implementation of the TargetInstrInfo class.
00011 //
00012 //===----------------------------------------------------------------------===//
00013 
00014 #include "SPURegisterNames.h"
00015 #include "SPUInstrInfo.h"
00016 #include "SPUInstrBuilder.h"
00017 #include "SPUTargetMachine.h"
00018 #include "SPUGenInstrInfo.inc"
00019 #include "llvm/CodeGen/MachineInstrBuilder.h"
00020 #include "llvm/Support/Streams.h"
00021 #include "llvm/Support/Debug.h"
00022 #include "llvm/Support/ErrorHandling.h"
00023 
00024 using namespace llvm;
00025 
00026 namespace {
00027   //! Predicate for an unconditional branch instruction
00028   inline bool isUncondBranch(const MachineInstr *I) {
00029     unsigned opc = I->getOpcode();
00030 
00031     return (opc == SPU::BR
00032             || opc == SPU::BRA
00033             || opc == SPU::BI);
00034   }
00035 
00036   //! Predicate for a conditional branch instruction
00037   inline bool isCondBranch(const MachineInstr *I) {
00038     unsigned opc = I->getOpcode();
00039 
00040     return (opc == SPU::BRNZr32
00041             || opc == SPU::BRNZv4i32
00042             || opc == SPU::BRZr32
00043             || opc == SPU::BRZv4i32
00044             || opc == SPU::BRHNZr16
00045             || opc == SPU::BRHNZv8i16
00046             || opc == SPU::BRHZr16
00047             || opc == SPU::BRHZv8i16);
00048   }
00049 }
00050 
00051 SPUInstrInfo::SPUInstrInfo(SPUTargetMachine &tm)
00052   : TargetInstrInfoImpl(SPUInsts, sizeof(SPUInsts)/sizeof(SPUInsts[0])),
00053     TM(tm),
00054     RI(*TM.getSubtargetImpl(), *this)
00055 { /* NOP */ }
00056 
00057 bool
00058 SPUInstrInfo::isMoveInstr(const MachineInstr& MI,
00059                           unsigned& sourceReg,
00060                           unsigned& destReg,
00061                           unsigned& SrcSR, unsigned& DstSR) const {
00062   SrcSR = DstSR = 0;  // No sub-registers.
00063 
00064   switch (MI.getOpcode()) {
00065   default:
00066     break;
00067   case SPU::ORIv4i32:
00068   case SPU::ORIr32:
00069   case SPU::ORHIv8i16:
00070   case SPU::ORHIr16:
00071   case SPU::ORHIi8i16:
00072   case SPU::ORBIv16i8:
00073   case SPU::ORBIr8:
00074   case SPU::ORIi16i32:
00075   case SPU::ORIi8i32:
00076   case SPU::AHIvec:
00077   case SPU::AHIr16:
00078   case SPU::AIv4i32:
00079     assert(MI.getNumOperands() == 3 &&
00080            MI.getOperand(0).isReg() &&
00081            MI.getOperand(1).isReg() &&
00082            MI.getOperand(2).isImm() &&
00083            "invalid SPU ORI/ORHI/ORBI/AHI/AI/SFI/SFHI instruction!");
00084     if (MI.getOperand(2).getImm() == 0) {
00085       sourceReg = MI.getOperand(1).getReg();
00086       destReg = MI.getOperand(0).getReg();
00087       return true;
00088     }
00089     break;
00090   case SPU::AIr32:
00091     assert(MI.getNumOperands() == 3 &&
00092            "wrong number of operands to AIr32");
00093     if (MI.getOperand(0).isReg() &&
00094         MI.getOperand(1).isReg() &&
00095         (MI.getOperand(2).isImm() &&
00096          MI.getOperand(2).getImm() == 0)) {
00097       sourceReg = MI.getOperand(1).getReg();
00098       destReg = MI.getOperand(0).getReg();
00099       return true;
00100     }
00101     break;
00102   case SPU::LRr8:
00103   case SPU::LRr16:
00104   case SPU::LRr32:
00105   case SPU::LRf32:
00106   case SPU::LRr64:
00107   case SPU::LRf64:
00108   case SPU::LRr128:
00109   case SPU::LRv16i8:
00110   case SPU::LRv8i16:
00111   case SPU::LRv4i32:
00112   case SPU::LRv4f32:
00113   case SPU::LRv2i64:
00114   case SPU::LRv2f64:
00115   case SPU::ORv16i8_i8:
00116   case SPU::ORv8i16_i16:
00117   case SPU::ORv4i32_i32:
00118   case SPU::ORv2i64_i64:
00119   case SPU::ORv4f32_f32:
00120   case SPU::ORv2f64_f64:
00121   case SPU::ORi8_v16i8:
00122   case SPU::ORi16_v8i16:
00123   case SPU::ORi32_v4i32:
00124   case SPU::ORi64_v2i64:
00125   case SPU::ORf32_v4f32:
00126   case SPU::ORf64_v2f64:
00127 /*
00128   case SPU::ORi128_r64:
00129   case SPU::ORi128_f64:
00130   case SPU::ORi128_r32:
00131   case SPU::ORi128_f32:
00132   case SPU::ORi128_r16:
00133   case SPU::ORi128_r8:
00134 */
00135   case SPU::ORi128_vec:
00136 /*
00137   case SPU::ORr64_i128:
00138   case SPU::ORf64_i128:
00139   case SPU::ORr32_i128:
00140   case SPU::ORf32_i128:
00141   case SPU::ORr16_i128:
00142   case SPU::ORr8_i128:
00143 */
00144   case SPU::ORvec_i128:
00145 /*
00146   case SPU::ORr16_r32:
00147   case SPU::ORr8_r32:
00148   case SPU::ORf32_r32:
00149   case SPU::ORr32_f32:
00150   case SPU::ORr32_r16:
00151   case SPU::ORr32_r8:
00152   case SPU::ORr16_r64:
00153   case SPU::ORr8_r64:
00154   case SPU::ORr64_r16:
00155   case SPU::ORr64_r8:
00156 */
00157   case SPU::ORr64_r32:
00158   case SPU::ORr32_r64:
00159   case SPU::ORf32_r32:
00160   case SPU::ORr32_f32:
00161   case SPU::ORf64_r64:
00162   case SPU::ORr64_f64: {
00163     assert(MI.getNumOperands() == 2 &&
00164            MI.getOperand(0).isReg() &&
00165            MI.getOperand(1).isReg() &&
00166            "invalid SPU OR<type>_<vec> or LR instruction!");
00167     if (MI.getOperand(0).getReg() == MI.getOperand(1).getReg()) {
00168       sourceReg = MI.getOperand(1).getReg();
00169       destReg = MI.getOperand(0).getReg();
00170       return true;
00171     }
00172     break;
00173   }
00174   case SPU::ORv16i8:
00175   case SPU::ORv8i16:
00176   case SPU::ORv4i32:
00177   case SPU::ORv2i64:
00178   case SPU::ORr8:
00179   case SPU::ORr16:
00180   case SPU::ORr32:
00181   case SPU::ORr64:
00182   case SPU::ORr128:
00183   case SPU::ORf32:
00184   case SPU::ORf64:
00185     assert(MI.getNumOperands() == 3 &&
00186            MI.getOperand(0).isReg() &&
00187            MI.getOperand(1).isReg() &&
00188            MI.getOperand(2).isReg() &&
00189            "invalid SPU OR(vec|r32|r64|gprc) instruction!");
00190     if (MI.getOperand(1).getReg() == MI.getOperand(2).getReg()) {
00191       sourceReg = MI.getOperand(1).getReg();
00192       destReg = MI.getOperand(0).getReg();
00193       return true;
00194     }
00195     break;
00196   }
00197 
00198   return false;
00199 }
00200 
00201 unsigned
00202 SPUInstrInfo::isLoadFromStackSlot(const MachineInstr *MI,
00203                                   int &FrameIndex) const {
00204   switch (MI->getOpcode()) {
00205   default: break;
00206   case SPU::LQDv16i8:
00207   case SPU::LQDv8i16:
00208   case SPU::LQDv4i32:
00209   case SPU::LQDv4f32:
00210   case SPU::LQDv2f64:
00211   case SPU::LQDr128:
00212   case SPU::LQDr64:
00213   case SPU::LQDr32:
00214   case SPU::LQDr16: {
00215     const MachineOperand MOp1 = MI->getOperand(1);
00216     const MachineOperand MOp2 = MI->getOperand(2);
00217     if (MOp1.isImm() && MOp2.isFI()) {
00218       FrameIndex = MOp2.getIndex();
00219       return MI->getOperand(0).getReg();
00220     }
00221     break;
00222   }
00223   }
00224   return 0;
00225 }
00226 
00227 unsigned
00228 SPUInstrInfo::isStoreToStackSlot(const MachineInstr *MI,
00229                                  int &FrameIndex) const {
00230   switch (MI->getOpcode()) {
00231   default: break;
00232   case SPU::STQDv16i8:
00233   case SPU::STQDv8i16:
00234   case SPU::STQDv4i32:
00235   case SPU::STQDv4f32:
00236   case SPU::STQDv2f64:
00237   case SPU::STQDr128:
00238   case SPU::STQDr64:
00239   case SPU::STQDr32:
00240   case SPU::STQDr16:
00241   case SPU::STQDr8: {
00242     const MachineOperand MOp1 = MI->getOperand(1);
00243     const MachineOperand MOp2 = MI->getOperand(2);
00244     if (MOp1.isImm() && MOp2.isFI()) {
00245       FrameIndex = MOp2.getIndex();
00246       return MI->getOperand(0).getReg();
00247     }
00248     break;
00249   }
00250   }
00251   return 0;
00252 }
00253 
00254 bool SPUInstrInfo::copyRegToReg(MachineBasicBlock &MBB,
00255                                    MachineBasicBlock::iterator MI,
00256                                    unsigned DestReg, unsigned SrcReg,
00257                                    const TargetRegisterClass *DestRC,
00258                                    const TargetRegisterClass *SrcRC) const
00259 {
00260   // We support cross register class moves for our aliases, such as R3 in any
00261   // reg class to any other reg class containing R3.  This is required because
00262   // we instruction select bitconvert i64 -> f64 as a noop for example, so our
00263   // types have no specific meaning.
00264 
00265   DebugLoc DL = DebugLoc::getUnknownLoc();
00266   if (MI != MBB.end()) DL = MI->getDebugLoc();
00267 
00268   if (DestRC == SPU::R8CRegisterClass) {
00269     BuildMI(MBB, MI, DL, get(SPU::LRr8), DestReg).addReg(SrcReg);
00270   } else if (DestRC == SPU::R16CRegisterClass) {
00271     BuildMI(MBB, MI, DL, get(SPU::LRr16), DestReg).addReg(SrcReg);
00272   } else if (DestRC == SPU::R32CRegisterClass) {
00273     BuildMI(MBB, MI, DL, get(SPU::LRr32), DestReg).addReg(SrcReg);
00274   } else if (DestRC == SPU::R32FPRegisterClass) {
00275     BuildMI(MBB, MI, DL, get(SPU::LRf32), DestReg).addReg(SrcReg);
00276   } else if (DestRC == SPU::R64CRegisterClass) {
00277     BuildMI(MBB, MI, DL, get(SPU::LRr64), DestReg).addReg(SrcReg);
00278   } else if (DestRC == SPU::R64FPRegisterClass) {
00279     BuildMI(MBB, MI, DL, get(SPU::LRf64), DestReg).addReg(SrcReg);
00280   } else if (DestRC == SPU::GPRCRegisterClass) {
00281     BuildMI(MBB, MI, DL, get(SPU::LRr128), DestReg).addReg(SrcReg);
00282   } else if (DestRC == SPU::VECREGRegisterClass) {
00283     BuildMI(MBB, MI, DL, get(SPU::LRv16i8), DestReg).addReg(SrcReg);
00284   } else {
00285     // Attempt to copy unknown/unsupported register class!
00286     return false;
00287   }
00288 
00289   return true;
00290 }
00291 
00292 void
00293 SPUInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
00294                                      MachineBasicBlock::iterator MI,
00295                                      unsigned SrcReg, bool isKill, int FrameIdx,
00296                                      const TargetRegisterClass *RC) const
00297 {
00298   unsigned opc;
00299   bool isValidFrameIdx = (FrameIdx < SPUFrameInfo::maxFrameOffset());
00300   if (RC == SPU::GPRCRegisterClass) {
00301     opc = (isValidFrameIdx ? SPU::STQDr128 : SPU::STQXr128);
00302   } else if (RC == SPU::R64CRegisterClass) {
00303     opc = (isValidFrameIdx ? SPU::STQDr64 : SPU::STQXr64);
00304   } else if (RC == SPU::R64FPRegisterClass) {
00305     opc = (isValidFrameIdx ? SPU::STQDr64 : SPU::STQXr64);
00306   } else if (RC == SPU::R32CRegisterClass) {
00307     opc = (isValidFrameIdx ? SPU::STQDr32 : SPU::STQXr32);
00308   } else if (RC == SPU::R32FPRegisterClass) {
00309     opc = (isValidFrameIdx ? SPU::STQDr32 : SPU::STQXr32);
00310   } else if (RC == SPU::R16CRegisterClass) {
00311     opc = (isValidFrameIdx ? SPU::STQDr16 : SPU::STQXr16);
00312   } else if (RC == SPU::R8CRegisterClass) {
00313     opc = (isValidFrameIdx ? SPU::STQDr8 : SPU::STQXr8);
00314   } else if (RC == SPU::VECREGRegisterClass) {
00315     opc = (isValidFrameIdx) ? SPU::STQDv16i8 : SPU::STQXv16i8;
00316   } else {
00317     llvm_unreachable("Unknown regclass!");
00318   }
00319 
00320   DebugLoc DL = DebugLoc::getUnknownLoc();
00321   if (MI != MBB.end()) DL = MI->getDebugLoc();
00322   addFrameReference(BuildMI(MBB, MI, DL, get(opc))
00323                     .addReg(SrcReg, getKillRegState(isKill)), FrameIdx);
00324 }
00325 
00326 void
00327 SPUInstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
00328                                         MachineBasicBlock::iterator MI,
00329                                         unsigned DestReg, int FrameIdx,
00330                                         const TargetRegisterClass *RC) const
00331 {
00332   unsigned opc;
00333   bool isValidFrameIdx = (FrameIdx < SPUFrameInfo::maxFrameOffset());
00334   if (RC == SPU::GPRCRegisterClass) {
00335     opc = (isValidFrameIdx ? SPU::LQDr128 : SPU::LQXr128);
00336   } else if (RC == SPU::R64CRegisterClass) {
00337     opc = (isValidFrameIdx ? SPU::LQDr64 : SPU::LQXr64);
00338   } else if (RC == SPU::R64FPRegisterClass) {
00339     opc = (isValidFrameIdx ? SPU::LQDr64 : SPU::LQXr64);
00340   } else if (RC == SPU::R32CRegisterClass) {
00341     opc = (isValidFrameIdx ? SPU::LQDr32 : SPU::LQXr32);
00342   } else if (RC == SPU::R32FPRegisterClass) {
00343     opc = (isValidFrameIdx ? SPU::LQDr32 : SPU::LQXr32);
00344   } else if (RC == SPU::R16CRegisterClass) {
00345     opc = (isValidFrameIdx ? SPU::LQDr16 : SPU::LQXr16);
00346   } else if (RC == SPU::R8CRegisterClass) {
00347     opc = (isValidFrameIdx ? SPU::LQDr8 : SPU::LQXr8);
00348   } else if (RC == SPU::VECREGRegisterClass) {
00349     opc = (isValidFrameIdx) ? SPU::LQDv16i8 : SPU::LQXv16i8;
00350   } else {
00351     llvm_unreachable("Unknown regclass in loadRegFromStackSlot!");
00352   }
00353 
00354   DebugLoc DL = DebugLoc::getUnknownLoc();
00355   if (MI != MBB.end()) DL = MI->getDebugLoc();
00356   addFrameReference(BuildMI(MBB, MI, DL, get(opc), DestReg), FrameIdx);
00357 }
00358 
00359 //! Return true if the specified load or store can be folded
00360 bool
00361 SPUInstrInfo::canFoldMemoryOperand(const MachineInstr *MI,
00362                                    const SmallVectorImpl<unsigned> &Ops) const {
00363   if (Ops.size() != 1) return false;
00364 
00365   // Make sure this is a reg-reg copy.
00366   unsigned Opc = MI->getOpcode();
00367 
00368   switch (Opc) {
00369   case SPU::ORv16i8:
00370   case SPU::ORv8i16:
00371   case SPU::ORv4i32:
00372   case SPU::ORv2i64:
00373   case SPU::ORr8:
00374   case SPU::ORr16:
00375   case SPU::ORr32:
00376   case SPU::ORr64:
00377   case SPU::ORf32:
00378   case SPU::ORf64:
00379     if (MI->getOperand(1).getReg() == MI->getOperand(2).getReg())
00380       return true;
00381     break;
00382   }
00383 
00384   return false;
00385 }
00386 
00387 /// foldMemoryOperand - SPU, like PPC, can only fold spills into
00388 /// copy instructions, turning them into load/store instructions.
00389 MachineInstr *
00390 SPUInstrInfo::foldMemoryOperandImpl(MachineFunction &MF,
00391                                     MachineInstr *MI,
00392                                     const SmallVectorImpl<unsigned> &Ops,
00393                                     int FrameIndex) const
00394 {
00395   if (Ops.size() != 1) return 0;
00396 
00397   unsigned OpNum = Ops[0];
00398   unsigned Opc = MI->getOpcode();
00399   MachineInstr *NewMI = 0;
00400 
00401   switch (Opc) {
00402   case SPU::ORv16i8:
00403   case SPU::ORv8i16:
00404   case SPU::ORv4i32:
00405   case SPU::ORv2i64:
00406   case SPU::ORr8:
00407   case SPU::ORr16:
00408   case SPU::ORr32:
00409   case SPU::ORr64:
00410   case SPU::ORf32:
00411   case SPU::ORf64:
00412     if (OpNum == 0) {  // move -> store
00413       unsigned InReg = MI->getOperand(1).getReg();
00414       bool isKill = MI->getOperand(1).isKill();
00415       bool isUndef = MI->getOperand(1).isUndef();
00416       if (FrameIndex < SPUFrameInfo::maxFrameOffset()) {
00417         MachineInstrBuilder MIB = BuildMI(MF, MI->getDebugLoc(),
00418                                           get(SPU::STQDr32));
00419 
00420         MIB.addReg(InReg, getKillRegState(isKill) | getUndefRegState(isUndef));
00421         NewMI = addFrameReference(MIB, FrameIndex);
00422       }
00423     } else {           // move -> load
00424       unsigned OutReg = MI->getOperand(0).getReg();
00425       bool isDead = MI->getOperand(0).isDead();
00426       bool isUndef = MI->getOperand(0).isUndef();
00427       MachineInstrBuilder MIB = BuildMI(MF, MI->getDebugLoc(), get(Opc));
00428 
00429       MIB.addReg(OutReg, RegState::Define | getDeadRegState(isDead) |
00430                  getUndefRegState(isUndef));
00431       Opc = (FrameIndex < SPUFrameInfo::maxFrameOffset())
00432         ? SPU::STQDr32 : SPU::STQXr32;
00433       NewMI = addFrameReference(MIB, FrameIndex);
00434     break;
00435   }
00436   }
00437 
00438   return NewMI;
00439 }
00440 
00441 //! Branch analysis
00442 /*!
00443   \note This code was kiped from PPC. There may be more branch analysis for
00444   CellSPU than what's currently done here.
00445  */
00446 bool
00447 SPUInstrInfo::AnalyzeBranch(MachineBasicBlock &MBB, MachineBasicBlock *&TBB,
00448                             MachineBasicBlock *&FBB,
00449                             SmallVectorImpl<MachineOperand> &Cond,
00450                             bool AllowModify) const {
00451   // If the block has no terminators, it just falls into the block after it.
00452   MachineBasicBlock::iterator I = MBB.end();
00453   if (I == MBB.begin() || !isUnpredicatedTerminator(--I))
00454     return false;
00455 
00456   // Get the last instruction in the block.
00457   MachineInstr *LastInst = I;
00458 
00459   // If there is only one terminator instruction, process it.
00460   if (I == MBB.begin() || !isUnpredicatedTerminator(--I)) {
00461     if (isUncondBranch(LastInst)) {
00462       TBB = LastInst->getOperand(0).getMBB();
00463       return false;
00464     } else if (isCondBranch(LastInst)) {
00465       // Block ends with fall-through condbranch.
00466       TBB = LastInst->getOperand(1).getMBB();
00467       DEBUG(cerr << "Pushing LastInst:               ");
00468       DEBUG(LastInst->dump());
00469       Cond.push_back(MachineOperand::CreateImm(LastInst->getOpcode()));
00470       Cond.push_back(LastInst->getOperand(0));
00471       return false;
00472     }
00473     // Otherwise, don't know what this is.
00474     return true;
00475   }
00476 
00477   // Get the instruction before it if it's a terminator.
00478   MachineInstr *SecondLastInst = I;
00479 
00480   // If there are three terminators, we don't know what sort of block this is.
00481   if (SecondLastInst && I != MBB.begin() &&
00482       isUnpredicatedTerminator(--I))
00483     return true;
00484 
00485   // If the block ends with a conditional and unconditional branch, handle it.
00486   if (isCondBranch(SecondLastInst) && isUncondBranch(LastInst)) {
00487     TBB =  SecondLastInst->getOperand(1).getMBB();
00488     DEBUG(cerr << "Pushing SecondLastInst:         ");
00489     DEBUG(SecondLastInst->dump());
00490     Cond.push_back(MachineOperand::CreateImm(SecondLastInst->getOpcode()));
00491     Cond.push_back(SecondLastInst->getOperand(0));
00492     FBB = LastInst->getOperand(0).getMBB();
00493     return false;
00494   }
00495 
00496   // If the block ends with two unconditional branches, handle it.  The second
00497   // one is not executed, so remove it.
00498   if (isUncondBranch(SecondLastInst) && isUncondBranch(LastInst)) {
00499     TBB = SecondLastInst->getOperand(0).getMBB();
00500     I = LastInst;
00501     if (AllowModify)
00502       I->eraseFromParent();
00503     return false;
00504   }
00505 
00506   // Otherwise, can't handle this.
00507   return true;
00508 }
00509 
00510 unsigned
00511 SPUInstrInfo::RemoveBranch(MachineBasicBlock &MBB) const {
00512   MachineBasicBlock::iterator I = MBB.end();
00513   if (I == MBB.begin())
00514     return 0;
00515   --I;
00516   if (!isCondBranch(I) && !isUncondBranch(I))
00517     return 0;
00518 
00519   // Remove the first branch.
00520   DEBUG(cerr << "Removing branch:                ");
00521   DEBUG(I->dump());
00522   I->eraseFromParent();
00523   I = MBB.end();
00524   if (I == MBB.begin())
00525     return 1;
00526 
00527   --I;
00528   if (!(isCondBranch(I) || isUncondBranch(I)))
00529     return 1;
00530 
00531   // Remove the second branch.
00532   DEBUG(cerr << "Removing second branch:         ");
00533   DEBUG(I->dump());
00534   I->eraseFromParent();
00535   return 2;
00536 }
00537 
00538 unsigned
00539 SPUInstrInfo::InsertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
00540                            MachineBasicBlock *FBB,
00541                            const SmallVectorImpl<MachineOperand> &Cond) const {
00542   // FIXME this should probably have a DebugLoc argument
00543   DebugLoc dl = DebugLoc::getUnknownLoc();
00544   // Shouldn't be a fall through.
00545   assert(TBB && "InsertBranch must not be told to insert a fallthrough");
00546   assert((Cond.size() == 2 || Cond.size() == 0) &&
00547          "SPU branch conditions have two components!");
00548 
00549   // One-way branch.
00550   if (FBB == 0) {
00551     if (Cond.empty()) {
00552       // Unconditional branch
00553       MachineInstrBuilder MIB = BuildMI(&MBB, dl, get(SPU::BR));
00554       MIB.addMBB(TBB);
00555 
00556       DEBUG(cerr << "Inserted one-way uncond branch: ");
00557       DEBUG((*MIB).dump());
00558     } else {
00559       // Conditional branch
00560       MachineInstrBuilder  MIB = BuildMI(&MBB, dl, get(Cond[0].getImm()));
00561       MIB.addReg(Cond[1].getReg()).addMBB(TBB);
00562 
00563       DEBUG(cerr << "Inserted one-way cond branch:   ");
00564       DEBUG((*MIB).dump());
00565     }
00566     return 1;
00567   } else {
00568     MachineInstrBuilder MIB = BuildMI(&MBB, dl, get(Cond[0].getImm()));
00569     MachineInstrBuilder MIB2 = BuildMI(&MBB, dl, get(SPU::BR));
00570 
00571     // Two-way Conditional Branch.
00572     MIB.addReg(Cond[1].getReg()).addMBB(TBB);
00573     MIB2.addMBB(FBB);
00574 
00575     DEBUG(cerr << "Inserted conditional branch:    ");
00576     DEBUG((*MIB).dump());
00577     DEBUG(cerr << "part 2: ");
00578     DEBUG((*MIB2).dump());
00579    return 2;
00580   }
00581 }
00582 
00583 bool
00584 SPUInstrInfo::BlockHasNoFallThrough(const MachineBasicBlock &MBB) const {
00585   return (!MBB.empty() && isUncondBranch(&MBB.back()));
00586 }
00587 //! Reverses a branch's condition, returning false on success.
00588 bool
00589 SPUInstrInfo::ReverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond)
00590   const {
00591   // Pretty brainless way of inverting the condition, but it works, considering
00592   // there are only two conditions...
00593   static struct {
00594     unsigned Opc;               //! The incoming opcode
00595     unsigned RevCondOpc;        //! The reversed condition opcode
00596   } revconds[] = {
00597     { SPU::BRNZr32, SPU::BRZr32 },
00598     { SPU::BRNZv4i32, SPU::BRZv4i32 },
00599     { SPU::BRZr32, SPU::BRNZr32 },
00600     { SPU::BRZv4i32, SPU::BRNZv4i32 },
00601     { SPU::BRHNZr16, SPU::BRHZr16 },
00602     { SPU::BRHNZv8i16, SPU::BRHZv8i16 },
00603     { SPU::BRHZr16, SPU::BRHNZr16 },
00604     { SPU::BRHZv8i16, SPU::BRHNZv8i16 }
00605   };
00606 
00607   unsigned Opc = unsigned(Cond[0].getImm());
00608   // Pretty dull mapping between the two conditions that SPU can generate:
00609   for (int i = sizeof(revconds)/sizeof(revconds[0]) - 1; i >= 0; --i) {
00610     if (revconds[i].Opc == Opc) {
00611       Cond[0].setImm(revconds[i].RevCondOpc);
00612       return false;
00613     }
00614   }
00615 
00616   return true;
00617 }