MipsInstrInfo.cpp revision 206124
1193323Sed//===- MipsInstrInfo.cpp - Mips Instruction Information ---------*- C++ -*-===// 2193323Sed// 3193323Sed// The LLVM Compiler Infrastructure 4193323Sed// 5193323Sed// This file is distributed under the University of Illinois Open Source 6193323Sed// License. See LICENSE.TXT for details. 7193323Sed// 8193323Sed//===----------------------------------------------------------------------===// 9193323Sed// 10193323Sed// This file contains the Mips implementation of the TargetInstrInfo class. 11193323Sed// 12193323Sed//===----------------------------------------------------------------------===// 13193323Sed 14193323Sed#include "MipsInstrInfo.h" 15193323Sed#include "MipsTargetMachine.h" 16193399Sed#include "MipsMachineFunction.h" 17193323Sed#include "llvm/ADT/STLExtras.h" 18193323Sed#include "llvm/CodeGen/MachineInstrBuilder.h" 19193399Sed#include "llvm/CodeGen/MachineRegisterInfo.h" 20198090Srdivacky#include "llvm/Support/ErrorHandling.h" 21193323Sed#include "MipsGenInstrInfo.inc" 22193323Sed 23193323Sedusing namespace llvm; 24193323Sed 25193323SedMipsInstrInfo::MipsInstrInfo(MipsTargetMachine &tm) 26193323Sed : TargetInstrInfoImpl(MipsInsts, array_lengthof(MipsInsts)), 27193323Sed TM(tm), RI(*TM.getSubtargetImpl(), *this) {} 28193323Sed 29193323Sedstatic bool isZeroImm(const MachineOperand &op) { 30193323Sed return op.isImm() && op.getImm() == 0; 31193323Sed} 32193323Sed 33193323Sed/// Return true if the instruction is a register to register move and 34193323Sed/// leave the source and dest operands in the passed parameters. 35193323Sedbool MipsInstrInfo:: 36193323SedisMoveInstr(const MachineInstr &MI, unsigned &SrcReg, unsigned &DstReg, 37193323Sed unsigned &SrcSubIdx, unsigned &DstSubIdx) const 38193323Sed{ 39193323Sed SrcSubIdx = DstSubIdx = 0; // No sub-registers. 40193323Sed 41193323Sed // addu $dst, $src, $zero || addu $dst, $zero, $src 42193323Sed // or $dst, $src, $zero || or $dst, $zero, $src 43193323Sed if ((MI.getOpcode() == Mips::ADDu) || (MI.getOpcode() == Mips::OR)) { 44193323Sed if (MI.getOperand(1).getReg() == Mips::ZERO) { 45193323Sed DstReg = MI.getOperand(0).getReg(); 46193323Sed SrcReg = MI.getOperand(2).getReg(); 47193323Sed return true; 48193323Sed } else if (MI.getOperand(2).getReg() == Mips::ZERO) { 49193323Sed DstReg = MI.getOperand(0).getReg(); 50193323Sed SrcReg = MI.getOperand(1).getReg(); 51193323Sed return true; 52193323Sed } 53193323Sed } 54193323Sed 55193323Sed // mov $fpDst, $fpSrc 56193323Sed // mfc $gpDst, $fpSrc 57193323Sed // mtc $fpDst, $gpSrc 58193323Sed if (MI.getOpcode() == Mips::FMOV_S32 || 59193323Sed MI.getOpcode() == Mips::FMOV_D32 || 60193323Sed MI.getOpcode() == Mips::MFC1 || 61193323Sed MI.getOpcode() == Mips::MTC1 || 62193323Sed MI.getOpcode() == Mips::MOVCCRToCCR) { 63193323Sed DstReg = MI.getOperand(0).getReg(); 64193323Sed SrcReg = MI.getOperand(1).getReg(); 65193323Sed return true; 66193323Sed } 67193323Sed 68193323Sed // addiu $dst, $src, 0 69193323Sed if (MI.getOpcode() == Mips::ADDiu) { 70193323Sed if ((MI.getOperand(1).isReg()) && (isZeroImm(MI.getOperand(2)))) { 71193323Sed DstReg = MI.getOperand(0).getReg(); 72193323Sed SrcReg = MI.getOperand(1).getReg(); 73193323Sed return true; 74193323Sed } 75193323Sed } 76193323Sed 77193323Sed return false; 78193323Sed} 79193323Sed 80193323Sed/// isLoadFromStackSlot - If the specified machine instruction is a direct 81193323Sed/// load from a stack slot, return the virtual or physical register number of 82193323Sed/// the destination along with the FrameIndex of the loaded stack slot. If 83193323Sed/// not, return 0. This predicate must return 0 if the instruction has 84193323Sed/// any side effects other than loading from the stack slot. 85193323Sedunsigned MipsInstrInfo:: 86193323SedisLoadFromStackSlot(const MachineInstr *MI, int &FrameIndex) const 87193323Sed{ 88193323Sed if ((MI->getOpcode() == Mips::LW) || (MI->getOpcode() == Mips::LWC1) || 89193323Sed (MI->getOpcode() == Mips::LDC1)) { 90193323Sed if ((MI->getOperand(2).isFI()) && // is a stack slot 91193323Sed (MI->getOperand(1).isImm()) && // the imm is zero 92193323Sed (isZeroImm(MI->getOperand(1)))) { 93193323Sed FrameIndex = MI->getOperand(2).getIndex(); 94193323Sed return MI->getOperand(0).getReg(); 95193323Sed } 96193323Sed } 97193323Sed 98193323Sed return 0; 99193323Sed} 100193323Sed 101193323Sed/// isStoreToStackSlot - If the specified machine instruction is a direct 102193323Sed/// store to a stack slot, return the virtual or physical register number of 103193323Sed/// the source reg along with the FrameIndex of the loaded stack slot. If 104193323Sed/// not, return 0. This predicate must return 0 if the instruction has 105193323Sed/// any side effects other than storing to the stack slot. 106193323Sedunsigned MipsInstrInfo:: 107193323SedisStoreToStackSlot(const MachineInstr *MI, int &FrameIndex) const 108193323Sed{ 109193323Sed if ((MI->getOpcode() == Mips::SW) || (MI->getOpcode() == Mips::SWC1) || 110193323Sed (MI->getOpcode() == Mips::SDC1)) { 111193323Sed if ((MI->getOperand(2).isFI()) && // is a stack slot 112193323Sed (MI->getOperand(1).isImm()) && // the imm is zero 113193323Sed (isZeroImm(MI->getOperand(1)))) { 114193323Sed FrameIndex = MI->getOperand(2).getIndex(); 115193323Sed return MI->getOperand(0).getReg(); 116193323Sed } 117193323Sed } 118193323Sed return 0; 119193323Sed} 120193323Sed 121193323Sed/// insertNoop - If data hazard condition is found insert the target nop 122193323Sed/// instruction. 123193323Sedvoid MipsInstrInfo:: 124193323SedinsertNoop(MachineBasicBlock &MBB, MachineBasicBlock::iterator MI) const 125193323Sed{ 126206124Srdivacky DebugLoc DL; 127193323Sed if (MI != MBB.end()) DL = MI->getDebugLoc(); 128193323Sed BuildMI(MBB, MI, DL, get(Mips::NOP)); 129193323Sed} 130193323Sed 131193323Sedbool MipsInstrInfo:: 132193323SedcopyRegToReg(MachineBasicBlock &MBB, MachineBasicBlock::iterator I, 133193323Sed unsigned DestReg, unsigned SrcReg, 134193323Sed const TargetRegisterClass *DestRC, 135193323Sed const TargetRegisterClass *SrcRC) const { 136206124Srdivacky DebugLoc DL; 137199481Srdivacky 138193323Sed if (I != MBB.end()) DL = I->getDebugLoc(); 139193323Sed 140193323Sed if (DestRC != SrcRC) { 141193323Sed 142193323Sed // Copy to/from FCR31 condition register 143193323Sed if ((DestRC == Mips::CPURegsRegisterClass) && 144193323Sed (SrcRC == Mips::CCRRegisterClass)) 145193323Sed BuildMI(MBB, I, DL, get(Mips::CFC1), DestReg).addReg(SrcReg); 146193323Sed else if ((DestRC == Mips::CCRRegisterClass) && 147193323Sed (SrcRC == Mips::CPURegsRegisterClass)) 148193323Sed BuildMI(MBB, I, DL, get(Mips::CTC1), DestReg).addReg(SrcReg); 149193323Sed 150193323Sed // Moves between coprocessors and cpu 151193323Sed else if ((DestRC == Mips::CPURegsRegisterClass) && 152193323Sed (SrcRC == Mips::FGR32RegisterClass)) 153193323Sed BuildMI(MBB, I, DL, get(Mips::MFC1), DestReg).addReg(SrcReg); 154193323Sed else if ((DestRC == Mips::FGR32RegisterClass) && 155193323Sed (SrcRC == Mips::CPURegsRegisterClass)) 156193323Sed BuildMI(MBB, I, DL, get(Mips::MTC1), DestReg).addReg(SrcReg); 157193323Sed 158193323Sed // Move from/to Hi/Lo registers 159193323Sed else if ((DestRC == Mips::HILORegisterClass) && 160193323Sed (SrcRC == Mips::CPURegsRegisterClass)) { 161193323Sed unsigned Opc = (DestReg == Mips::HI) ? Mips::MTHI : Mips::MTLO; 162193323Sed BuildMI(MBB, I, DL, get(Opc), DestReg); 163193323Sed } else if ((SrcRC == Mips::HILORegisterClass) && 164193323Sed (DestRC == Mips::CPURegsRegisterClass)) { 165193323Sed unsigned Opc = (SrcReg == Mips::HI) ? Mips::MFHI : Mips::MFLO; 166193323Sed BuildMI(MBB, I, DL, get(Opc), DestReg); 167199481Srdivacky } else 168199481Srdivacky // Can't copy this register 169193323Sed return false; 170193323Sed 171193323Sed return true; 172193323Sed } 173193323Sed 174193323Sed if (DestRC == Mips::CPURegsRegisterClass) 175193323Sed BuildMI(MBB, I, DL, get(Mips::ADDu), DestReg).addReg(Mips::ZERO) 176193323Sed .addReg(SrcReg); 177193323Sed else if (DestRC == Mips::FGR32RegisterClass) 178193323Sed BuildMI(MBB, I, DL, get(Mips::FMOV_S32), DestReg).addReg(SrcReg); 179193323Sed else if (DestRC == Mips::AFGR64RegisterClass) 180193323Sed BuildMI(MBB, I, DL, get(Mips::FMOV_D32), DestReg).addReg(SrcReg); 181193323Sed else if (DestRC == Mips::CCRRegisterClass) 182193323Sed BuildMI(MBB, I, DL, get(Mips::MOVCCRToCCR), DestReg).addReg(SrcReg); 183193323Sed else 184193323Sed // Can't copy this register 185193323Sed return false; 186193323Sed 187193323Sed return true; 188193323Sed} 189193323Sed 190193323Sedvoid MipsInstrInfo:: 191193323SedstoreRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I, 192193323Sed unsigned SrcReg, bool isKill, int FI, 193193323Sed const TargetRegisterClass *RC) const { 194206124Srdivacky DebugLoc DL; 195193323Sed if (I != MBB.end()) DL = I->getDebugLoc(); 196193323Sed 197193323Sed if (RC == Mips::CPURegsRegisterClass) 198199989Srdivacky BuildMI(MBB, I, DL, get(Mips::SW)).addReg(SrcReg, getKillRegState(isKill)) 199199989Srdivacky .addImm(0).addFrameIndex(FI); 200193323Sed else if (RC == Mips::FGR32RegisterClass) 201199989Srdivacky BuildMI(MBB, I, DL, get(Mips::SWC1)).addReg(SrcReg, getKillRegState(isKill)) 202193323Sed .addImm(0).addFrameIndex(FI); 203199989Srdivacky else if (RC == Mips::AFGR64RegisterClass) { 204199989Srdivacky if (!TM.getSubtarget<MipsSubtarget>().isMips1()) { 205199989Srdivacky BuildMI(MBB, I, DL, get(Mips::SDC1)) 206199989Srdivacky .addReg(SrcReg, getKillRegState(isKill)) 207199989Srdivacky .addImm(0).addFrameIndex(FI); 208199989Srdivacky } else { 209199989Srdivacky const TargetRegisterInfo *TRI = 210199989Srdivacky MBB.getParent()->getTarget().getRegisterInfo(); 211199989Srdivacky const unsigned *SubSet = TRI->getSubRegisters(SrcReg); 212199989Srdivacky BuildMI(MBB, I, DL, get(Mips::SWC1)) 213199989Srdivacky .addReg(SubSet[0], getKillRegState(isKill)) 214199989Srdivacky .addImm(0).addFrameIndex(FI); 215199989Srdivacky BuildMI(MBB, I, DL, get(Mips::SWC1)) 216199989Srdivacky .addReg(SubSet[1], getKillRegState(isKill)) 217199989Srdivacky .addImm(4).addFrameIndex(FI); 218199989Srdivacky } 219199989Srdivacky } else 220199989Srdivacky llvm_unreachable("Register class not handled!"); 221193323Sed} 222193323Sed 223193323Sedvoid MipsInstrInfo:: 224193323SedloadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I, 225193323Sed unsigned DestReg, int FI, 226193323Sed const TargetRegisterClass *RC) const 227193323Sed{ 228206124Srdivacky DebugLoc DL; 229199989Srdivacky if (I != MBB.end()) DL = I->getDebugLoc(); 230199989Srdivacky 231193323Sed if (RC == Mips::CPURegsRegisterClass) 232199989Srdivacky BuildMI(MBB, I, DL, get(Mips::LW), DestReg).addImm(0).addFrameIndex(FI); 233193323Sed else if (RC == Mips::FGR32RegisterClass) 234199989Srdivacky BuildMI(MBB, I, DL, get(Mips::LWC1), DestReg).addImm(0).addFrameIndex(FI); 235199989Srdivacky else if (RC == Mips::AFGR64RegisterClass) { 236199989Srdivacky if (!TM.getSubtarget<MipsSubtarget>().isMips1()) { 237199989Srdivacky BuildMI(MBB, I, DL, get(Mips::LDC1), DestReg).addImm(0).addFrameIndex(FI); 238199989Srdivacky } else { 239199989Srdivacky const TargetRegisterInfo *TRI = 240199989Srdivacky MBB.getParent()->getTarget().getRegisterInfo(); 241199989Srdivacky const unsigned *SubSet = TRI->getSubRegisters(DestReg); 242199989Srdivacky BuildMI(MBB, I, DL, get(Mips::LWC1), SubSet[0]) 243199989Srdivacky .addImm(0).addFrameIndex(FI); 244199989Srdivacky BuildMI(MBB, I, DL, get(Mips::LWC1), SubSet[1]) 245199989Srdivacky .addImm(4).addFrameIndex(FI); 246199989Srdivacky } 247199989Srdivacky } else 248199989Srdivacky llvm_unreachable("Register class not handled!"); 249193323Sed} 250193323Sed 251193323SedMachineInstr *MipsInstrInfo:: 252193323SedfoldMemoryOperandImpl(MachineFunction &MF, 253193323Sed MachineInstr* MI, 254193323Sed const SmallVectorImpl<unsigned> &Ops, int FI) const 255193323Sed{ 256193323Sed if (Ops.size() != 1) return NULL; 257193323Sed 258193323Sed MachineInstr *NewMI = NULL; 259193323Sed 260193323Sed switch (MI->getOpcode()) { 261193323Sed case Mips::ADDu: 262193323Sed if ((MI->getOperand(0).isReg()) && 263193323Sed (MI->getOperand(1).isReg()) && 264193323Sed (MI->getOperand(1).getReg() == Mips::ZERO) && 265193323Sed (MI->getOperand(2).isReg())) { 266193323Sed if (Ops[0] == 0) { // COPY -> STORE 267193323Sed unsigned SrcReg = MI->getOperand(2).getReg(); 268193323Sed bool isKill = MI->getOperand(2).isKill(); 269195340Sed bool isUndef = MI->getOperand(2).isUndef(); 270193323Sed NewMI = BuildMI(MF, MI->getDebugLoc(), get(Mips::SW)) 271195340Sed .addReg(SrcReg, getKillRegState(isKill) | getUndefRegState(isUndef)) 272193323Sed .addImm(0).addFrameIndex(FI); 273193323Sed } else { // COPY -> LOAD 274193323Sed unsigned DstReg = MI->getOperand(0).getReg(); 275193323Sed bool isDead = MI->getOperand(0).isDead(); 276195340Sed bool isUndef = MI->getOperand(0).isUndef(); 277193323Sed NewMI = BuildMI(MF, MI->getDebugLoc(), get(Mips::LW)) 278195340Sed .addReg(DstReg, RegState::Define | getDeadRegState(isDead) | 279195340Sed getUndefRegState(isUndef)) 280193323Sed .addImm(0).addFrameIndex(FI); 281193323Sed } 282193323Sed } 283193323Sed break; 284193323Sed case Mips::FMOV_S32: 285193323Sed case Mips::FMOV_D32: 286193323Sed if ((MI->getOperand(0).isReg()) && 287193323Sed (MI->getOperand(1).isReg())) { 288193323Sed const TargetRegisterClass 289193323Sed *RC = RI.getRegClass(MI->getOperand(0).getReg()); 290193323Sed unsigned StoreOpc, LoadOpc; 291199989Srdivacky bool IsMips1 = TM.getSubtarget<MipsSubtarget>().isMips1(); 292193323Sed 293193323Sed if (RC == Mips::FGR32RegisterClass) { 294193323Sed LoadOpc = Mips::LWC1; StoreOpc = Mips::SWC1; 295193323Sed } else { 296193323Sed assert(RC == Mips::AFGR64RegisterClass); 297199989Srdivacky // Mips1 doesn't have ldc/sdc instructions. 298199989Srdivacky if (IsMips1) break; 299193323Sed LoadOpc = Mips::LDC1; StoreOpc = Mips::SDC1; 300193323Sed } 301193323Sed 302193323Sed if (Ops[0] == 0) { // COPY -> STORE 303193323Sed unsigned SrcReg = MI->getOperand(1).getReg(); 304193323Sed bool isKill = MI->getOperand(1).isKill(); 305195340Sed bool isUndef = MI->getOperand(2).isUndef(); 306193323Sed NewMI = BuildMI(MF, MI->getDebugLoc(), get(StoreOpc)) 307195340Sed .addReg(SrcReg, getKillRegState(isKill) | getUndefRegState(isUndef)) 308193323Sed .addImm(0).addFrameIndex(FI) ; 309193323Sed } else { // COPY -> LOAD 310193323Sed unsigned DstReg = MI->getOperand(0).getReg(); 311193323Sed bool isDead = MI->getOperand(0).isDead(); 312195340Sed bool isUndef = MI->getOperand(0).isUndef(); 313193323Sed NewMI = BuildMI(MF, MI->getDebugLoc(), get(LoadOpc)) 314195340Sed .addReg(DstReg, RegState::Define | getDeadRegState(isDead) | 315195340Sed getUndefRegState(isUndef)) 316193323Sed .addImm(0).addFrameIndex(FI); 317193323Sed } 318193323Sed } 319193323Sed break; 320193323Sed } 321193323Sed 322193323Sed return NewMI; 323193323Sed} 324193323Sed 325193323Sed//===----------------------------------------------------------------------===// 326193323Sed// Branch Analysis 327193323Sed//===----------------------------------------------------------------------===// 328193323Sed 329193323Sed/// GetCondFromBranchOpc - Return the Mips CC that matches 330193323Sed/// the correspondent Branch instruction opcode. 331193323Sedstatic Mips::CondCode GetCondFromBranchOpc(unsigned BrOpc) 332193323Sed{ 333193323Sed switch (BrOpc) { 334193323Sed default: return Mips::COND_INVALID; 335193323Sed case Mips::BEQ : return Mips::COND_E; 336193323Sed case Mips::BNE : return Mips::COND_NE; 337193323Sed case Mips::BGTZ : return Mips::COND_GZ; 338193323Sed case Mips::BGEZ : return Mips::COND_GEZ; 339193323Sed case Mips::BLTZ : return Mips::COND_LZ; 340193323Sed case Mips::BLEZ : return Mips::COND_LEZ; 341193323Sed 342193323Sed // We dont do fp branch analysis yet! 343193323Sed case Mips::BC1T : 344193323Sed case Mips::BC1F : return Mips::COND_INVALID; 345193323Sed } 346193323Sed} 347193323Sed 348193323Sed/// GetCondBranchFromCond - Return the Branch instruction 349193323Sed/// opcode that matches the cc. 350193323Sedunsigned Mips::GetCondBranchFromCond(Mips::CondCode CC) 351193323Sed{ 352193323Sed switch (CC) { 353198090Srdivacky default: llvm_unreachable("Illegal condition code!"); 354193323Sed case Mips::COND_E : return Mips::BEQ; 355193323Sed case Mips::COND_NE : return Mips::BNE; 356193323Sed case Mips::COND_GZ : return Mips::BGTZ; 357193323Sed case Mips::COND_GEZ : return Mips::BGEZ; 358193323Sed case Mips::COND_LZ : return Mips::BLTZ; 359193323Sed case Mips::COND_LEZ : return Mips::BLEZ; 360193323Sed 361193323Sed case Mips::FCOND_F: 362193323Sed case Mips::FCOND_UN: 363193323Sed case Mips::FCOND_EQ: 364193323Sed case Mips::FCOND_UEQ: 365193323Sed case Mips::FCOND_OLT: 366193323Sed case Mips::FCOND_ULT: 367193323Sed case Mips::FCOND_OLE: 368193323Sed case Mips::FCOND_ULE: 369193323Sed case Mips::FCOND_SF: 370193323Sed case Mips::FCOND_NGLE: 371193323Sed case Mips::FCOND_SEQ: 372193323Sed case Mips::FCOND_NGL: 373193323Sed case Mips::FCOND_LT: 374193323Sed case Mips::FCOND_NGE: 375193323Sed case Mips::FCOND_LE: 376193323Sed case Mips::FCOND_NGT: return Mips::BC1T; 377193323Sed 378193323Sed case Mips::FCOND_T: 379193323Sed case Mips::FCOND_OR: 380193323Sed case Mips::FCOND_NEQ: 381193323Sed case Mips::FCOND_OGL: 382193323Sed case Mips::FCOND_UGE: 383193323Sed case Mips::FCOND_OGE: 384193323Sed case Mips::FCOND_UGT: 385193323Sed case Mips::FCOND_OGT: 386193323Sed case Mips::FCOND_ST: 387193323Sed case Mips::FCOND_GLE: 388193323Sed case Mips::FCOND_SNE: 389193323Sed case Mips::FCOND_GL: 390193323Sed case Mips::FCOND_NLT: 391193323Sed case Mips::FCOND_GE: 392193323Sed case Mips::FCOND_NLE: 393193323Sed case Mips::FCOND_GT: return Mips::BC1F; 394193323Sed } 395193323Sed} 396193323Sed 397193323Sed/// GetOppositeBranchCondition - Return the inverse of the specified 398193323Sed/// condition, e.g. turning COND_E to COND_NE. 399193323SedMips::CondCode Mips::GetOppositeBranchCondition(Mips::CondCode CC) 400193323Sed{ 401193323Sed switch (CC) { 402198090Srdivacky default: llvm_unreachable("Illegal condition code!"); 403193323Sed case Mips::COND_E : return Mips::COND_NE; 404193323Sed case Mips::COND_NE : return Mips::COND_E; 405193323Sed case Mips::COND_GZ : return Mips::COND_LEZ; 406193323Sed case Mips::COND_GEZ : return Mips::COND_LZ; 407193323Sed case Mips::COND_LZ : return Mips::COND_GEZ; 408193323Sed case Mips::COND_LEZ : return Mips::COND_GZ; 409193323Sed case Mips::FCOND_F : return Mips::FCOND_T; 410193323Sed case Mips::FCOND_UN : return Mips::FCOND_OR; 411193323Sed case Mips::FCOND_EQ : return Mips::FCOND_NEQ; 412193323Sed case Mips::FCOND_UEQ: return Mips::FCOND_OGL; 413193323Sed case Mips::FCOND_OLT: return Mips::FCOND_UGE; 414193323Sed case Mips::FCOND_ULT: return Mips::FCOND_OGE; 415193323Sed case Mips::FCOND_OLE: return Mips::FCOND_UGT; 416193323Sed case Mips::FCOND_ULE: return Mips::FCOND_OGT; 417193323Sed case Mips::FCOND_SF: return Mips::FCOND_ST; 418193323Sed case Mips::FCOND_NGLE:return Mips::FCOND_GLE; 419193323Sed case Mips::FCOND_SEQ: return Mips::FCOND_SNE; 420193323Sed case Mips::FCOND_NGL: return Mips::FCOND_GL; 421193323Sed case Mips::FCOND_LT: return Mips::FCOND_NLT; 422193323Sed case Mips::FCOND_NGE: return Mips::FCOND_GE; 423193323Sed case Mips::FCOND_LE: return Mips::FCOND_NLE; 424193323Sed case Mips::FCOND_NGT: return Mips::FCOND_GT; 425193323Sed } 426193323Sed} 427193323Sed 428193323Sedbool MipsInstrInfo::AnalyzeBranch(MachineBasicBlock &MBB, 429193323Sed MachineBasicBlock *&TBB, 430193323Sed MachineBasicBlock *&FBB, 431193323Sed SmallVectorImpl<MachineOperand> &Cond, 432193323Sed bool AllowModify) const 433193323Sed{ 434193323Sed // If the block has no terminators, it just falls into the block after it. 435193323Sed MachineBasicBlock::iterator I = MBB.end(); 436206083Srdivacky if (I == MBB.begin()) 437193323Sed return false; 438206083Srdivacky --I; 439206083Srdivacky while (I->isDebugValue()) { 440206083Srdivacky if (I == MBB.begin()) 441206083Srdivacky return false; 442206083Srdivacky --I; 443206083Srdivacky } 444206083Srdivacky if (!isUnpredicatedTerminator(I)) 445206083Srdivacky return false; 446193323Sed 447193323Sed // Get the last instruction in the block. 448193323Sed MachineInstr *LastInst = I; 449193323Sed 450193323Sed // If there is only one terminator instruction, process it. 451193323Sed unsigned LastOpc = LastInst->getOpcode(); 452193323Sed if (I == MBB.begin() || !isUnpredicatedTerminator(--I)) { 453193323Sed if (!LastInst->getDesc().isBranch()) 454193323Sed return true; 455193323Sed 456193323Sed // Unconditional branch 457193323Sed if (LastOpc == Mips::J) { 458193323Sed TBB = LastInst->getOperand(0).getMBB(); 459193323Sed return false; 460193323Sed } 461193323Sed 462193323Sed Mips::CondCode BranchCode = GetCondFromBranchOpc(LastInst->getOpcode()); 463193323Sed if (BranchCode == Mips::COND_INVALID) 464193323Sed return true; // Can't handle indirect branch. 465193323Sed 466193323Sed // Conditional branch 467193323Sed // Block ends with fall-through condbranch. 468193323Sed if (LastOpc != Mips::COND_INVALID) { 469193323Sed int LastNumOp = LastInst->getNumOperands(); 470193323Sed 471193323Sed TBB = LastInst->getOperand(LastNumOp-1).getMBB(); 472193323Sed Cond.push_back(MachineOperand::CreateImm(BranchCode)); 473193323Sed 474193323Sed for (int i=0; i<LastNumOp-1; i++) { 475193323Sed Cond.push_back(LastInst->getOperand(i)); 476193323Sed } 477193323Sed 478193323Sed return false; 479193323Sed } 480193323Sed } 481193323Sed 482193323Sed // Get the instruction before it if it is a terminator. 483193323Sed MachineInstr *SecondLastInst = I; 484193323Sed 485193323Sed // If there are three terminators, we don't know what sort of block this is. 486193323Sed if (SecondLastInst && I != MBB.begin() && isUnpredicatedTerminator(--I)) 487193323Sed return true; 488193323Sed 489193323Sed // If the block ends with Mips::J and a Mips::BNE/Mips::BEQ, handle it. 490193323Sed unsigned SecondLastOpc = SecondLastInst->getOpcode(); 491193323Sed Mips::CondCode BranchCode = GetCondFromBranchOpc(SecondLastOpc); 492193323Sed 493193323Sed if (BranchCode != Mips::COND_INVALID && LastOpc == Mips::J) { 494193323Sed int SecondNumOp = SecondLastInst->getNumOperands(); 495193323Sed 496193323Sed TBB = SecondLastInst->getOperand(SecondNumOp-1).getMBB(); 497193323Sed Cond.push_back(MachineOperand::CreateImm(BranchCode)); 498193323Sed 499193323Sed for (int i=0; i<SecondNumOp-1; i++) { 500193323Sed Cond.push_back(SecondLastInst->getOperand(i)); 501193323Sed } 502193323Sed 503193323Sed FBB = LastInst->getOperand(0).getMBB(); 504193323Sed return false; 505193323Sed } 506193323Sed 507193323Sed // If the block ends with two unconditional branches, handle it. The last 508193323Sed // one is not executed, so remove it. 509193323Sed if ((SecondLastOpc == Mips::J) && (LastOpc == Mips::J)) { 510193323Sed TBB = SecondLastInst->getOperand(0).getMBB(); 511193323Sed I = LastInst; 512193323Sed if (AllowModify) 513193323Sed I->eraseFromParent(); 514193323Sed return false; 515193323Sed } 516193323Sed 517193323Sed // Otherwise, can't handle this. 518193323Sed return true; 519193323Sed} 520193323Sed 521193323Sedunsigned MipsInstrInfo:: 522193323SedInsertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB, 523193323Sed MachineBasicBlock *FBB, 524193323Sed const SmallVectorImpl<MachineOperand> &Cond) const { 525193323Sed // FIXME this should probably have a DebugLoc argument 526206124Srdivacky DebugLoc dl; 527193323Sed // Shouldn't be a fall through. 528193323Sed assert(TBB && "InsertBranch must not be told to insert a fallthrough"); 529193323Sed assert((Cond.size() == 3 || Cond.size() == 2 || Cond.size() == 0) && 530193323Sed "Mips branch conditions can have two|three components!"); 531193323Sed 532193323Sed if (FBB == 0) { // One way branch. 533193323Sed if (Cond.empty()) { 534193323Sed // Unconditional branch? 535193323Sed BuildMI(&MBB, dl, get(Mips::J)).addMBB(TBB); 536193323Sed } else { 537193323Sed // Conditional branch. 538193323Sed unsigned Opc = GetCondBranchFromCond((Mips::CondCode)Cond[0].getImm()); 539193323Sed const TargetInstrDesc &TID = get(Opc); 540193323Sed 541193323Sed if (TID.getNumOperands() == 3) 542193323Sed BuildMI(&MBB, dl, TID).addReg(Cond[1].getReg()) 543193323Sed .addReg(Cond[2].getReg()) 544193323Sed .addMBB(TBB); 545193323Sed else 546193323Sed BuildMI(&MBB, dl, TID).addReg(Cond[1].getReg()) 547193323Sed .addMBB(TBB); 548193323Sed 549193323Sed } 550193323Sed return 1; 551193323Sed } 552193323Sed 553193323Sed // Two-way Conditional branch. 554193323Sed unsigned Opc = GetCondBranchFromCond((Mips::CondCode)Cond[0].getImm()); 555193323Sed const TargetInstrDesc &TID = get(Opc); 556193323Sed 557193323Sed if (TID.getNumOperands() == 3) 558193323Sed BuildMI(&MBB, dl, TID).addReg(Cond[1].getReg()).addReg(Cond[2].getReg()) 559193323Sed .addMBB(TBB); 560193323Sed else 561193323Sed BuildMI(&MBB, dl, TID).addReg(Cond[1].getReg()).addMBB(TBB); 562193323Sed 563193323Sed BuildMI(&MBB, dl, get(Mips::J)).addMBB(FBB); 564193323Sed return 2; 565193323Sed} 566193323Sed 567193323Sedunsigned MipsInstrInfo:: 568193323SedRemoveBranch(MachineBasicBlock &MBB) const 569193323Sed{ 570193323Sed MachineBasicBlock::iterator I = MBB.end(); 571193323Sed if (I == MBB.begin()) return 0; 572193323Sed --I; 573206083Srdivacky while (I->isDebugValue()) { 574206083Srdivacky if (I == MBB.begin()) 575206083Srdivacky return 0; 576206083Srdivacky --I; 577206083Srdivacky } 578193323Sed if (I->getOpcode() != Mips::J && 579193323Sed GetCondFromBranchOpc(I->getOpcode()) == Mips::COND_INVALID) 580193323Sed return 0; 581193323Sed 582193323Sed // Remove the branch. 583193323Sed I->eraseFromParent(); 584193323Sed 585193323Sed I = MBB.end(); 586193323Sed 587193323Sed if (I == MBB.begin()) return 1; 588193323Sed --I; 589193323Sed if (GetCondFromBranchOpc(I->getOpcode()) == Mips::COND_INVALID) 590193323Sed return 1; 591193323Sed 592193323Sed // Remove the branch. 593193323Sed I->eraseFromParent(); 594193323Sed return 2; 595193323Sed} 596193323Sed 597193323Sed/// ReverseBranchCondition - Return the inverse opcode of the 598193323Sed/// specified Branch instruction. 599193323Sedbool MipsInstrInfo:: 600193323SedReverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const 601193323Sed{ 602193323Sed assert( (Cond.size() == 3 || Cond.size() == 2) && 603193323Sed "Invalid Mips branch condition!"); 604193323Sed Cond[0].setImm(GetOppositeBranchCondition((Mips::CondCode)Cond[0].getImm())); 605193323Sed return false; 606193323Sed} 607193399Sed 608193399Sed/// getGlobalBaseReg - Return a virtual register initialized with the 609193399Sed/// the global base register value. Output instructions required to 610193399Sed/// initialize the register in the function entry block, if necessary. 611193399Sed/// 612193399Sedunsigned MipsInstrInfo::getGlobalBaseReg(MachineFunction *MF) const { 613193399Sed MipsFunctionInfo *MipsFI = MF->getInfo<MipsFunctionInfo>(); 614193399Sed unsigned GlobalBaseReg = MipsFI->getGlobalBaseReg(); 615193399Sed if (GlobalBaseReg != 0) 616193399Sed return GlobalBaseReg; 617193399Sed 618193399Sed // Insert the set of GlobalBaseReg into the first MBB of the function 619193399Sed MachineBasicBlock &FirstMBB = MF->front(); 620193399Sed MachineBasicBlock::iterator MBBI = FirstMBB.begin(); 621193399Sed MachineRegisterInfo &RegInfo = MF->getRegInfo(); 622193399Sed const TargetInstrInfo *TII = MF->getTarget().getInstrInfo(); 623193399Sed 624193399Sed GlobalBaseReg = RegInfo.createVirtualRegister(Mips::CPURegsRegisterClass); 625193399Sed bool Ok = TII->copyRegToReg(FirstMBB, MBBI, GlobalBaseReg, Mips::GP, 626193399Sed Mips::CPURegsRegisterClass, 627193399Sed Mips::CPURegsRegisterClass); 628193399Sed assert(Ok && "Couldn't assign to global base register!"); 629195340Sed Ok = Ok; // Silence warning when assertions are turned off. 630193399Sed RegInfo.addLiveIn(Mips::GP); 631193399Sed 632193399Sed MipsFI->setGlobalBaseReg(GlobalBaseReg); 633193399Sed return GlobalBaseReg; 634193399Sed} 635