LLVM API Documentation
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 }