lib/Target/PowerPC/PPCInstrInfo.cpp

   1 //===-- PPCInstrInfo.cpp - PowerPC Instruction Information ----------------===//
   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 // This file contains the PowerPC implementation of the TargetInstrInfo class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "PPCInstrInfo.h"
  15 #include "MCTargetDesc/PPCPredicates.h"
  16 #include "PPC.h"
  17 #include "PPCHazardRecognizers.h"
  18 #include "PPCInstrBuilder.h"
  19 #include "PPCMachineFunctionInfo.h"
  20 #include "PPCTargetMachine.h"
  21 #include "llvm/ADT/Statistic.h"
  22 #include "llvm/ADT/STLExtras.h"
  23 #include "llvm/CodeGen/MachineFrameInfo.h"
  24 #include "llvm/CodeGen/MachineFunctionPass.h"
  25 #include "llvm/CodeGen/MachineInstrBuilder.h"
  26 #include "llvm/CodeGen/MachineMemOperand.h"
  27 #include "llvm/CodeGen/MachineRegisterInfo.h"
  28 #include "llvm/CodeGen/PseudoSourceValue.h"
  29 #include "llvm/MC/MCAsmInfo.h"
  30 #include "llvm/Support/CommandLine.h"
  31 #include "llvm/Support/ErrorHandling.h"
  32 #include "llvm/Support/TargetRegistry.h"
  33 #include "llvm/Support/raw_ostream.h"
  34
  35 #define GET_INSTRINFO_CTOR
  36 #include "PPCGenInstrInfo.inc"
  37
  38 using namespace llvm;
  39
  40 static cl::
  41 opt<bool> DisableCTRLoopAnal("disable-ppc-ctrloop-analysis", cl::Hidden,
  42             cl::desc("Disable analysis for CTR loops"));
  43
  44 PPCInstrInfo::PPCInstrInfo(PPCTargetMachine &tm)
  45   : PPCGenInstrInfo(PPC::ADJCALLSTACKDOWN, PPC::ADJCALLSTACKUP),
  46     TM(tm), RI(*TM.getSubtargetImpl(), *this) {}
  47
  48 /// CreateTargetHazardRecognizer - Return the hazard recognizer to use for
  49 /// this target when scheduling the DAG.
  50 ScheduleHazardRecognizer *PPCInstrInfo::CreateTargetHazardRecognizer(
  51   const TargetMachine *TM,
  52   const ScheduleDAG *DAG) const {
  53   unsigned Directive = TM->getSubtarget<PPCSubtarget>().getDarwinDirective();
  54   if (Directive == PPC::DIR_440 || Directive == PPC::DIR_A2 ||
  55       Directive == PPC::DIR_E500mc || Directive == PPC::DIR_E5500) {
  56     const InstrItineraryData *II = TM->getInstrItineraryData();
  57     return new PPCScoreboardHazardRecognizer(II, DAG);
  58   }
  59
  60   return TargetInstrInfo::CreateTargetHazardRecognizer(TM, DAG);
  61 }
  62
  63 /// CreateTargetPostRAHazardRecognizer - Return the postRA hazard recognizer
  64 /// to use for this target when scheduling the DAG.
  65 ScheduleHazardRecognizer *PPCInstrInfo::CreateTargetPostRAHazardRecognizer(
  66   const InstrItineraryData *II,
  67   const ScheduleDAG *DAG) const {
  68   unsigned Directive = TM.getSubtarget<PPCSubtarget>().getDarwinDirective();
  69
  70   // Most subtargets use a PPC970 recognizer.
  71   if (Directive != PPC::DIR_440 && Directive != PPC::DIR_A2 &&
  72       Directive != PPC::DIR_E500mc && Directive != PPC::DIR_E5500) {
  73     const TargetInstrInfo *TII = TM.getInstrInfo();
  74     assert(TII && "No InstrInfo?");
  75
  76     return new PPCHazardRecognizer970(*TII);
  77   }
  78
  79   return new PPCScoreboardHazardRecognizer(II, DAG);
  80 }
  81
  82 // Detect 32 -> 64-bit extensions where we may reuse the low sub-register.
  83 bool PPCInstrInfo::isCoalescableExtInstr(const MachineInstr &MI,
  84                                          unsigned &SrcReg, unsigned &DstReg,
  85                                          unsigned &SubIdx) const {
  86   switch (MI.getOpcode()) {
  87   default: return false;
  88   case PPC::EXTSW:
  89   case PPC::EXTSW_32_64:
  90     SrcReg = MI.getOperand(1).getReg();
  91     DstReg = MI.getOperand(0).getReg();
  92     SubIdx = PPC::sub_32;
  93     return true;
  94   }
  95 }
  96
  97 unsigned PPCInstrInfo::isLoadFromStackSlot(const MachineInstr *MI,
  98                                            int &FrameIndex) const {
  99   // Note: This list must be kept consistent with LoadRegFromStackSlot.
 100   switch (MI->getOpcode()) {
 101   default: break;
 102   case PPC::LD:
 103   case PPC::LWZ:
 104   case PPC::LFS:
 105   case PPC::LFD:
 106   case PPC::RESTORE_CR:
 107   case PPC::LVX:
 108   case PPC::RESTORE_VRSAVE:
 109     // Check for the operands added by addFrameReference (the immediate is the
 110     // offset which defaults to 0).
 111     if (MI->getOperand(1).isImm() && !MI->getOperand(1).getImm() &&
 112         MI->getOperand(2).isFI()) {
 113       FrameIndex = MI->getOperand(2).getIndex();
 114       return MI->getOperand(0).getReg();
 115     }
 116     break;
 117   }
 118   return 0;
 119 }
 120
 121 unsigned PPCInstrInfo::isStoreToStackSlot(const MachineInstr *MI,
 122                                           int &FrameIndex) const {
 123   // Note: This list must be kept consistent with StoreRegToStackSlot.
 124   switch (MI->getOpcode()) {
 125   default: break;
 126   case PPC::STD:
 127   case PPC::STW:
 128   case PPC::STFS:
 129   case PPC::STFD:
 130   case PPC::SPILL_CR:
 131   case PPC::STVX:
 132   case PPC::SPILL_VRSAVE:
 133     // Check for the operands added by addFrameReference (the immediate is the
 134     // offset which defaults to 0).
 135     if (MI->getOperand(1).isImm() && !MI->getOperand(1).getImm() &&
 136         MI->getOperand(2).isFI()) {
 137       FrameIndex = MI->getOperand(2).getIndex();
 138       return MI->getOperand(0).getReg();
 139     }
 140     break;
 141   }
 142   return 0;
 143 }
 144
 145 // commuteInstruction - We can commute rlwimi instructions, but only if the
 146 // rotate amt is zero.  We also have to munge the immediates a bit.
 147 MachineInstr *
 148 PPCInstrInfo::commuteInstruction(MachineInstr *MI, bool NewMI) const {
 149   MachineFunction &MF = *MI->getParent()->getParent();
 150
 151   // Normal instructions can be commuted the obvious way.
 152   if (MI->getOpcode() != PPC::RLWIMI)
 153     return TargetInstrInfo::commuteInstruction(MI, NewMI);
 154
 155   // Cannot commute if it has a non-zero rotate count.
 156   if (MI->getOperand(3).getImm() != 0)
 157     return 0;
 158
 159   // If we have a zero rotate count, we have:
 160   //   M = mask(MB,ME)
 161   //   Op0 = (Op1 & ~M) | (Op2 & M)
 162   // Change this to:
 163   //   M = mask((ME+1)&31, (MB-1)&31)
 164   //   Op0 = (Op2 & ~M) | (Op1 & M)
 165
 166   // Swap op1/op2
 167   unsigned Reg0 = MI->getOperand(0).getReg();
 168   unsigned Reg1 = MI->getOperand(1).getReg();
 169   unsigned Reg2 = MI->getOperand(2).getReg();
 170   bool Reg1IsKill = MI->getOperand(1).isKill();
 171   bool Reg2IsKill = MI->getOperand(2).isKill();
 172   bool ChangeReg0 = false;
 173   // If machine instrs are no longer in two-address forms, update
 174   // destination register as well.
 175   if (Reg0 == Reg1) {
 176     // Must be two address instruction!
 177     assert(MI->getDesc().getOperandConstraint(0, MCOI::TIED_TO) &&
 178            "Expecting a two-address instruction!");
 179     Reg2IsKill = false;
 180     ChangeReg0 = true;
 181   }
 182
 183   // Masks.
 184   unsigned MB = MI->getOperand(4).getImm();
 185   unsigned ME = MI->getOperand(5).getImm();
 186
 187   if (NewMI) {
 188     // Create a new instruction.
 189     unsigned Reg0 = ChangeReg0 ? Reg2 : MI->getOperand(0).getReg();
 190     bool Reg0IsDead = MI->getOperand(0).isDead();
 191     return BuildMI(MF, MI->getDebugLoc(), MI->getDesc())
 192       .addReg(Reg0, RegState::Define | getDeadRegState(Reg0IsDead))
 193       .addReg(Reg2, getKillRegState(Reg2IsKill))
 194       .addReg(Reg1, getKillRegState(Reg1IsKill))
 195       .addImm((ME+1) & 31)
 196       .addImm((MB-1) & 31);
 197   }
 198
 199   if (ChangeReg0)
 200     MI->getOperand(0).setReg(Reg2);
 201   MI->getOperand(2).setReg(Reg1);
 202   MI->getOperand(1).setReg(Reg2);
 203   MI->getOperand(2).setIsKill(Reg1IsKill);
 204   MI->getOperand(1).setIsKill(Reg2IsKill);
 205
 206   // Swap the mask around.
 207   MI->getOperand(4).setImm((ME+1) & 31);
 208   MI->getOperand(5).setImm((MB-1) & 31);
 209   return MI;
 210 }
 211
 212 void PPCInstrInfo::insertNoop(MachineBasicBlock &MBB,
 213                               MachineBasicBlock::iterator MI) const {
 214   DebugLoc DL;
 215   BuildMI(MBB, MI, DL, get(PPC::NOP));
 216 }
 217
 218
 219 // Branch analysis.
 220 // Note: If the condition register is set to CTR or CTR8 then this is a
 221 // BDNZ (imm == 1) or BDZ (imm == 0) branch.
 222 bool PPCInstrInfo::AnalyzeBranch(MachineBasicBlock &MBB,MachineBasicBlock *&TBB,
 223                                  MachineBasicBlock *&FBB,
 224                                  SmallVectorImpl<MachineOperand> &Cond,
 225                                  bool AllowModify) const {
 226   bool isPPC64 = TM.getSubtargetImpl()->isPPC64();
 227
 228   // If the block has no terminators, it just falls into the block after it.
 229   MachineBasicBlock::iterator I = MBB.end();
 230   if (I == MBB.begin())
 231     return false;
 232   --I;
 233   while (I->isDebugValue()) {
 234     if (I == MBB.begin())
 235       return false;
 236     --I;
 237   }
 238   if (!isUnpredicatedTerminator(I))
 239     return false;
 240
 241   // Get the last instruction in the block.
 242   MachineInstr *LastInst = I;
 243
 244   // If there is only one terminator instruction, process it.
 245   if (I == MBB.begin() || !isUnpredicatedTerminator(--I)) {
 246     if (LastInst->getOpcode() == PPC::B) {
 247       if (!LastInst->getOperand(0).isMBB())
 248         return true;
 249       TBB = LastInst->getOperand(0).getMBB();
 250       return false;
 251     } else if (LastInst->getOpcode() == PPC::BCC) {
 252       if (!LastInst->getOperand(2).isMBB())
 253         return true;
 254       // Block ends with fall-through condbranch.
 255       TBB = LastInst->getOperand(2).getMBB();
 256       Cond.push_back(LastInst->getOperand(0));
 257       Cond.push_back(LastInst->getOperand(1));
 258       return false;
 259     } else if (LastInst->getOpcode() == PPC::BDNZ8 ||
 260                LastInst->getOpcode() == PPC::BDNZ) {
 261       if (!LastInst->getOperand(0).isMBB())
 262         return true;
 263       if (DisableCTRLoopAnal)
 264         return true;
 265       TBB = LastInst->getOperand(0).getMBB();
 266       Cond.push_back(MachineOperand::CreateImm(1));
 267       Cond.push_back(MachineOperand::CreateReg(isPPC64 ? PPC::CTR8 : PPC::CTR,
 268                                                true));
 269       return false;
 270     } else if (LastInst->getOpcode() == PPC::BDZ8 ||
 271                LastInst->getOpcode() == PPC::BDZ) {
 272       if (!LastInst->getOperand(0).isMBB())
 273         return true;
 274       if (DisableCTRLoopAnal)
 275         return true;
 276       TBB = LastInst->getOperand(0).getMBB();
 277       Cond.push_back(MachineOperand::CreateImm(0));
 278       Cond.push_back(MachineOperand::CreateReg(isPPC64 ? PPC::CTR8 : PPC::CTR,
 279                                                true));
 280       return false;
 281     }
 282
 283     // Otherwise, don't know what this is.
 284     return true;
 285   }
 286
 287   // Get the instruction before it if it's a terminator.
 288   MachineInstr *SecondLastInst = I;
 289
 290   // If there are three terminators, we don't know what sort of block this is.
 291   if (SecondLastInst && I != MBB.begin() &&
 292       isUnpredicatedTerminator(--I))
 293     return true;
 294
 295   // If the block ends with PPC::B and PPC:BCC, handle it.
 296   if (SecondLastInst->getOpcode() == PPC::BCC &&
 297       LastInst->getOpcode() == PPC::B) {
 298     if (!SecondLastInst->getOperand(2).isMBB() ||
 299         !LastInst->getOperand(0).isMBB())
 300       return true;
 301     TBB =  SecondLastInst->getOperand(2).getMBB();
 302     Cond.push_back(SecondLastInst->getOperand(0));
 303     Cond.push_back(SecondLastInst->getOperand(1));
 304     FBB = LastInst->getOperand(0).getMBB();
 305     return false;
 306   } else if ((SecondLastInst->getOpcode() == PPC::BDNZ8 ||
 307               SecondLastInst->getOpcode() == PPC::BDNZ) &&
 308       LastInst->getOpcode() == PPC::B) {
 309     if (!SecondLastInst->getOperand(0).isMBB() ||
 310         !LastInst->getOperand(0).isMBB())
 311       return true;
 312     if (DisableCTRLoopAnal)
 313       return true;
 314     TBB = SecondLastInst->getOperand(0).getMBB();
 315     Cond.push_back(MachineOperand::CreateImm(1));
 316     Cond.push_back(MachineOperand::CreateReg(isPPC64 ? PPC::CTR8 : PPC::CTR,
 317                                              true));
 318     FBB = LastInst->getOperand(0).getMBB();
 319     return false;
 320   } else if ((SecondLastInst->getOpcode() == PPC::BDZ8 ||
 321               SecondLastInst->getOpcode() == PPC::BDZ) &&
 322       LastInst->getOpcode() == PPC::B) {
 323     if (!SecondLastInst->getOperand(0).isMBB() ||
 324         !LastInst->getOperand(0).isMBB())
 325       return true;
 326     if (DisableCTRLoopAnal)
 327       return true;
 328     TBB = SecondLastInst->getOperand(0).getMBB();
 329     Cond.push_back(MachineOperand::CreateImm(0));
 330     Cond.push_back(MachineOperand::CreateReg(isPPC64 ? PPC::CTR8 : PPC::CTR,
 331                                              true));
 332     FBB = LastInst->getOperand(0).getMBB();
 333     return false;
 334   }
 335
 336   // If the block ends with two PPC:Bs, handle it.  The second one is not
 337   // executed, so remove it.
 338   if (SecondLastInst->getOpcode() == PPC::B &&
 339       LastInst->getOpcode() == PPC::B) {
 340     if (!SecondLastInst->getOperand(0).isMBB())
 341       return true;
 342     TBB = SecondLastInst->getOperand(0).getMBB();
 343     I = LastInst;
 344     if (AllowModify)
 345       I->eraseFromParent();
 346     return false;
 347   }
 348
 349   // Otherwise, can't handle this.
 350   return true;
 351 }
 352
 353 unsigned PPCInstrInfo::RemoveBranch(MachineBasicBlock &MBB) const {
 354   MachineBasicBlock::iterator I = MBB.end();
 355   if (I == MBB.begin()) return 0;
 356   --I;
 357   while (I->isDebugValue()) {
 358     if (I == MBB.begin())
 359       return 0;
 360     --I;
 361   }
 362   if (I->getOpcode() != PPC::B && I->getOpcode() != PPC::BCC &&
 363       I->getOpcode() != PPC::BDNZ8 && I->getOpcode() != PPC::BDNZ &&
 364       I->getOpcode() != PPC::BDZ8  && I->getOpcode() != PPC::BDZ)
 365     return 0;
 366
 367   // Remove the branch.
 368   I->eraseFromParent();
 369
 370   I = MBB.end();
 371
 372   if (I == MBB.begin()) return 1;
 373   --I;
 374   if (I->getOpcode() != PPC::BCC &&
 375       I->getOpcode() != PPC::BDNZ8 && I->getOpcode() != PPC::BDNZ &&
 376       I->getOpcode() != PPC::BDZ8  && I->getOpcode() != PPC::BDZ)
 377     return 1;
 378
 379   // Remove the branch.
 380   I->eraseFromParent();
 381   return 2;
 382 }
 383
 384 unsigned
 385 PPCInstrInfo::InsertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
 386                            MachineBasicBlock *FBB,
 387                            const SmallVectorImpl<MachineOperand> &Cond,
 388                            DebugLoc DL) const {
 389   // Shouldn't be a fall through.
 390   assert(TBB && "InsertBranch must not be told to insert a fallthrough");
 391   assert((Cond.size() == 2 || Cond.size() == 0) &&
 392          "PPC branch conditions have two components!");
 393
 394   bool isPPC64 = TM.getSubtargetImpl()->isPPC64();
 395
 396   // One-way branch.
 397   if (FBB == 0) {
 398     if (Cond.empty())   // Unconditional branch
 399       BuildMI(&MBB, DL, get(PPC::B)).addMBB(TBB);
 400     else if (Cond[1].getReg() == PPC::CTR || Cond[1].getReg() == PPC::CTR8)
 401       BuildMI(&MBB, DL, get(Cond[0].getImm() ?
 402                               (isPPC64 ? PPC::BDNZ8 : PPC::BDNZ) :
 403                               (isPPC64 ? PPC::BDZ8  : PPC::BDZ))).addMBB(TBB);
 404     else                // Conditional branch
 405       BuildMI(&MBB, DL, get(PPC::BCC))
 406         .addImm(Cond[0].getImm()).addReg(Cond[1].getReg()).addMBB(TBB);
 407     return 1;
 408   }
 409
 410   // Two-way Conditional Branch.
 411   if (Cond[1].getReg() == PPC::CTR || Cond[1].getReg() == PPC::CTR8)
 412     BuildMI(&MBB, DL, get(Cond[0].getImm() ?
 413                             (isPPC64 ? PPC::BDNZ8 : PPC::BDNZ) :
 414                             (isPPC64 ? PPC::BDZ8  : PPC::BDZ))).addMBB(TBB);
 415   else
 416     BuildMI(&MBB, DL, get(PPC::BCC))
 417       .addImm(Cond[0].getImm()).addReg(Cond[1].getReg()).addMBB(TBB);
 418   BuildMI(&MBB, DL, get(PPC::B)).addMBB(FBB);
 419   return 2;
 420 }
 421
 422 // Select analysis.
 423 bool PPCInstrInfo::canInsertSelect(const MachineBasicBlock &MBB,
 424                 const SmallVectorImpl<MachineOperand> &Cond,
 425                 unsigned TrueReg, unsigned FalseReg,
 426                 int &CondCycles, int &TrueCycles, int &FalseCycles) const {
 427   if (!TM.getSubtargetImpl()->hasISEL())
 428     return false;
 429
 430   if (Cond.size() != 2)
 431     return false;
 432
 433   // If this is really a bdnz-like condition, then it cannot be turned into a
 434   // select.
 435   if (Cond[1].getReg() == PPC::CTR || Cond[1].getReg() == PPC::CTR8)
 436     return false;
 437
 438   // Check register classes.
 439   const MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
 440   const TargetRegisterClass *RC =
 441     RI.getCommonSubClass(MRI.getRegClass(TrueReg), MRI.getRegClass(FalseReg));
 442   if (!RC)
 443     return false;
 444
 445   // isel is for regular integer GPRs only.
 446   if (!PPC::GPRCRegClass.hasSubClassEq(RC) &&
 447       !PPC::G8RCRegClass.hasSubClassEq(RC))
 448     return false;
 449
 450   // FIXME: These numbers are for the A2, how well they work for other cores is
 451   // an open question. On the A2, the isel instruction has a 2-cycle latency
 452   // but single-cycle throughput. These numbers are used in combination with
 453   // the MispredictPenalty setting from the active SchedMachineModel.
 454   CondCycles = 1;
 455   TrueCycles = 1;
 456   FalseCycles = 1;
 457
 458   return true;
 459 }
 460
 461 void PPCInstrInfo::insertSelect(MachineBasicBlock &MBB,
 462                                 MachineBasicBlock::iterator MI, DebugLoc dl,
 463                                 unsigned DestReg,
 464                                 const SmallVectorImpl<MachineOperand> &Cond,
 465                                 unsigned TrueReg, unsigned FalseReg) const {
 466   assert(Cond.size() == 2 &&
 467          "PPC branch conditions have two components!");
 468
 469   assert(TM.getSubtargetImpl()->hasISEL() &&
 470          "Cannot insert select on target without ISEL support");
 471
 472   // Get the register classes.
 473   MachineRegisterInfo &MRI = MBB.getParent()->getRegInfo();
 474   const TargetRegisterClass *RC =
 475     RI.getCommonSubClass(MRI.getRegClass(TrueReg), MRI.getRegClass(FalseReg));
 476   assert(RC && "TrueReg and FalseReg must have overlapping register classes");
 477   assert((PPC::GPRCRegClass.hasSubClassEq(RC) ||
 478           PPC::G8RCRegClass.hasSubClassEq(RC)) &&
 479          "isel is for regular integer GPRs only");
 480
 481   unsigned OpCode =
 482     PPC::GPRCRegClass.hasSubClassEq(RC) ? PPC::ISEL : PPC::ISEL8;
 483   unsigned SelectPred = Cond[0].getImm();
 484
 485   unsigned SubIdx;
 486   bool SwapOps;
 487   switch (SelectPred) {
 488   default: llvm_unreachable("invalid predicate for isel");
 489   case PPC::PRED_EQ: SubIdx = PPC::sub_eq; SwapOps = false; break;
 490   case PPC::PRED_NE: SubIdx = PPC::sub_eq; SwapOps = true; break;
 491   case PPC::PRED_LT: SubIdx = PPC::sub_lt; SwapOps = false; break;
 492   case PPC::PRED_GE: SubIdx = PPC::sub_lt; SwapOps = true; break;
 493   case PPC::PRED_GT: SubIdx = PPC::sub_gt; SwapOps = false; break;
 494   case PPC::PRED_LE: SubIdx = PPC::sub_gt; SwapOps = true; break;
 495   case PPC::PRED_UN: SubIdx = PPC::sub_un; SwapOps = false; break;
 496   case PPC::PRED_NU: SubIdx = PPC::sub_un; SwapOps = true; break;
 497   }
 498
 499   unsigned FirstReg =  SwapOps ? FalseReg : TrueReg,
 500            SecondReg = SwapOps ? TrueReg  : FalseReg;
 501
 502   // The first input register of isel cannot be r0. If it is a member
 503   // of a register class that can be r0, then copy it first (the
 504   // register allocator should eliminate the copy).
 505   if (MRI.getRegClass(FirstReg)->contains(PPC::R0) ||
 506       MRI.getRegClass(FirstReg)->contains(PPC::X0)) {
 507     const TargetRegisterClass *FirstRC =
 508       MRI.getRegClass(FirstReg)->contains(PPC::X0) ?
 509         &PPC::G8RC_NOX0RegClass : &PPC::GPRC_NOR0RegClass;
 510     unsigned OldFirstReg = FirstReg;
 511     FirstReg = MRI.createVirtualRegister(FirstRC);
 512     BuildMI(MBB, MI, dl, get(TargetOpcode::COPY), FirstReg)
 513       .addReg(OldFirstReg);
 514   }
 515
 516   BuildMI(MBB, MI, dl, get(OpCode), DestReg)
 517     .addReg(FirstReg).addReg(SecondReg)
 518     .addReg(Cond[1].getReg(), 0, SubIdx);
 519 }
 520
 521 void PPCInstrInfo::copyPhysReg(MachineBasicBlock &MBB,
 522                                MachineBasicBlock::iterator I, DebugLoc DL,
 523                                unsigned DestReg, unsigned SrcReg,
 524                                bool KillSrc) const {
 525   unsigned Opc;
 526   if (PPC::GPRCRegClass.contains(DestReg, SrcReg))
 527     Opc = PPC::OR;
 528   else if (PPC::G8RCRegClass.contains(DestReg, SrcReg))
 529     Opc = PPC::OR8;
 530   else if (PPC::F4RCRegClass.contains(DestReg, SrcReg))
 531     Opc = PPC::FMR;
 532   else if (PPC::CRRCRegClass.contains(DestReg, SrcReg))
 533     Opc = PPC::MCRF;
 534   else if (PPC::VRRCRegClass.contains(DestReg, SrcReg))
 535     Opc = PPC::VOR;
 536   else if (PPC::CRBITRCRegClass.contains(DestReg, SrcReg))
 537     Opc = PPC::CROR;
 538   else
 539     llvm_unreachable("Impossible reg-to-reg copy");
 540
 541   const MCInstrDesc &MCID = get(Opc);
 542   if (MCID.getNumOperands() == 3)
 543     BuildMI(MBB, I, DL, MCID, DestReg)
 544       .addReg(SrcReg).addReg(SrcReg, getKillRegState(KillSrc));
 545   else
 546     BuildMI(MBB, I, DL, MCID, DestReg).addReg(SrcReg, getKillRegState(KillSrc));
 547 }
 548
 549 // This function returns true if a CR spill is necessary and false otherwise.
 550 bool
 551 PPCInstrInfo::StoreRegToStackSlot(MachineFunction &MF,
 552                                   unsigned SrcReg, bool isKill,
 553                                   int FrameIdx,
 554                                   const TargetRegisterClass *RC,
 555                                   SmallVectorImpl<MachineInstr*> &NewMIs,
 556                                   bool &NonRI, bool &SpillsVRS) const{
 557   // Note: If additional store instructions are added here,
 558   // update isStoreToStackSlot.
 559
 560   DebugLoc DL;
 561   if (PPC::GPRCRegClass.hasSubClassEq(RC)) {
 562     NewMIs.push_back(addFrameReference(BuildMI(MF, DL, get(PPC::STW))
 563                                        .addReg(SrcReg,
 564                                                getKillRegState(isKill)),
 565                                        FrameIdx));
 566   } else if (PPC::G8RCRegClass.hasSubClassEq(RC)) {
 567     NewMIs.push_back(addFrameReference(BuildMI(MF, DL, get(PPC::STD))
 568                                        .addReg(SrcReg,
 569                                                getKillRegState(isKill)),
 570                                        FrameIdx));
 571   } else if (PPC::F8RCRegClass.hasSubClassEq(RC)) {
 572     NewMIs.push_back(addFrameReference(BuildMI(MF, DL, get(PPC::STFD))
 573                                        .addReg(SrcReg,
 574                                                getKillRegState(isKill)),
 575                                        FrameIdx));
 576   } else if (PPC::F4RCRegClass.hasSubClassEq(RC)) {
 577     NewMIs.push_back(addFrameReference(BuildMI(MF, DL, get(PPC::STFS))
 578                                        .addReg(SrcReg,
 579                                                getKillRegState(isKill)),
 580                                        FrameIdx));
 581   } else if (PPC::CRRCRegClass.hasSubClassEq(RC)) {
 582     NewMIs.push_back(addFrameReference(BuildMI(MF, DL, get(PPC::SPILL_CR))
 583                                        .addReg(SrcReg,
 584                                                getKillRegState(isKill)),
 585                                        FrameIdx));
 586     return true;
 587   } else if (PPC::CRBITRCRegClass.hasSubClassEq(RC)) {
 588     // FIXME: We use CRi here because there is no mtcrf on a bit. Since the
 589     // backend currently only uses CR1EQ as an individual bit, this should
 590     // not cause any bug. If we need other uses of CR bits, the following
 591     // code may be invalid.
 592     unsigned Reg = 0;
 593     if (SrcReg == PPC::CR0LT || SrcReg == PPC::CR0GT ||
 594         SrcReg == PPC::CR0EQ || SrcReg == PPC::CR0UN)
 595       Reg = PPC::CR0;
 596     else if (SrcReg == PPC::CR1LT || SrcReg == PPC::CR1GT ||
 597              SrcReg == PPC::CR1EQ || SrcReg == PPC::CR1UN)
 598       Reg = PPC::CR1;
 599     else if (SrcReg == PPC::CR2LT || SrcReg == PPC::CR2GT ||
 600              SrcReg == PPC::CR2EQ || SrcReg == PPC::CR2UN)
 601       Reg = PPC::CR2;
 602     else if (SrcReg == PPC::CR3LT || SrcReg == PPC::CR3GT ||
 603              SrcReg == PPC::CR3EQ || SrcReg == PPC::CR3UN)
 604       Reg = PPC::CR3;
 605     else if (SrcReg == PPC::CR4LT || SrcReg == PPC::CR4GT ||
 606              SrcReg == PPC::CR4EQ || SrcReg == PPC::CR4UN)
 607       Reg = PPC::CR4;
 608     else if (SrcReg == PPC::CR5LT || SrcReg == PPC::CR5GT ||
 609              SrcReg == PPC::CR5EQ || SrcReg == PPC::CR5UN)
 610       Reg = PPC::CR5;
 611     else if (SrcReg == PPC::CR6LT || SrcReg == PPC::CR6GT ||
 612              SrcReg == PPC::CR6EQ || SrcReg == PPC::CR6UN)
 613       Reg = PPC::CR6;
 614     else if (SrcReg == PPC::CR7LT || SrcReg == PPC::CR7GT ||
 615              SrcReg == PPC::CR7EQ || SrcReg == PPC::CR7UN)
 616       Reg = PPC::CR7;
 617
 618     return StoreRegToStackSlot(MF, Reg, isKill, FrameIdx,
 619                                &PPC::CRRCRegClass, NewMIs, NonRI, SpillsVRS);
 620
 621   } else if (PPC::VRRCRegClass.hasSubClassEq(RC)) {
 622     NewMIs.push_back(addFrameReference(BuildMI(MF, DL, get(PPC::STVX))
 623                                        .addReg(SrcReg,
 624                                                getKillRegState(isKill)),
 625                                        FrameIdx));
 626     NonRI = true;
 627   } else if (PPC::VRSAVERCRegClass.hasSubClassEq(RC)) {
 628     assert(TM.getSubtargetImpl()->isDarwin() &&
 629            "VRSAVE only needs spill/restore on Darwin");
 630     NewMIs.push_back(addFrameReference(BuildMI(MF, DL, get(PPC::SPILL_VRSAVE))
 631                                        .addReg(SrcReg,
 632                                                getKillRegState(isKill)),
 633                                        FrameIdx));
 634     SpillsVRS = true;
 635   } else {
 636     llvm_unreachable("Unknown regclass!");
 637   }
 638
 639   return false;
 640 }
 641
 642 void
 643 PPCInstrInfo::storeRegToStackSlot(MachineBasicBlock &MBB,
 644                                   MachineBasicBlock::iterator MI,
 645                                   unsigned SrcReg, bool isKill, int FrameIdx,
 646                                   const TargetRegisterClass *RC,
 647                                   const TargetRegisterInfo *TRI) const {
 648   MachineFunction &MF = *MBB.getParent();
 649   SmallVector<MachineInstr*, 4> NewMIs;
 650
 651   PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
 652   FuncInfo->setHasSpills();
 653
 654   bool NonRI = false, SpillsVRS = false;
 655   if (StoreRegToStackSlot(MF, SrcReg, isKill, FrameIdx, RC, NewMIs,
 656                           NonRI, SpillsVRS))
 657     FuncInfo->setSpillsCR();
 658
 659   if (SpillsVRS)
 660     FuncInfo->setSpillsVRSAVE();
 661
 662   if (NonRI)
 663     FuncInfo->setHasNonRISpills();
 664
 665   for (unsigned i = 0, e = NewMIs.size(); i != e; ++i)
 666     MBB.insert(MI, NewMIs[i]);
 667
 668   const MachineFrameInfo &MFI = *MF.getFrameInfo();
 669   MachineMemOperand *MMO =
 670     MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(FrameIdx),
 671                             MachineMemOperand::MOStore,
 672                             MFI.getObjectSize(FrameIdx),
 673                             MFI.getObjectAlignment(FrameIdx));
 674   NewMIs.back()->addMemOperand(MF, MMO);
 675 }
 676
 677 bool
 678 PPCInstrInfo::LoadRegFromStackSlot(MachineFunction &MF, DebugLoc DL,
 679                                    unsigned DestReg, int FrameIdx,
 680                                    const TargetRegisterClass *RC,
 681                                    SmallVectorImpl<MachineInstr*> &NewMIs,
 682                                    bool &NonRI, bool &SpillsVRS) const{
 683   // Note: If additional load instructions are added here,
 684   // update isLoadFromStackSlot.
 685
 686   if (PPC::GPRCRegClass.hasSubClassEq(RC)) {
 687     NewMIs.push_back(addFrameReference(BuildMI(MF, DL, get(PPC::LWZ),
 688                                                DestReg), FrameIdx));
 689   } else if (PPC::G8RCRegClass.hasSubClassEq(RC)) {
 690     NewMIs.push_back(addFrameReference(BuildMI(MF, DL, get(PPC::LD), DestReg),
 691                                        FrameIdx));
 692   } else if (PPC::F8RCRegClass.hasSubClassEq(RC)) {
 693     NewMIs.push_back(addFrameReference(BuildMI(MF, DL, get(PPC::LFD), DestReg),
 694                                        FrameIdx));
 695   } else if (PPC::F4RCRegClass.hasSubClassEq(RC)) {
 696     NewMIs.push_back(addFrameReference(BuildMI(MF, DL, get(PPC::LFS), DestReg),
 697                                        FrameIdx));
 698   } else if (PPC::CRRCRegClass.hasSubClassEq(RC)) {
 699     NewMIs.push_back(addFrameReference(BuildMI(MF, DL,
 700                                                get(PPC::RESTORE_CR), DestReg),
 701                                        FrameIdx));
 702     return true;
 703   } else if (PPC::CRBITRCRegClass.hasSubClassEq(RC)) {
 704
 705     unsigned Reg = 0;
 706     if (DestReg == PPC::CR0LT || DestReg == PPC::CR0GT ||
 707         DestReg == PPC::CR0EQ || DestReg == PPC::CR0UN)
 708       Reg = PPC::CR0;
 709     else if (DestReg == PPC::CR1LT || DestReg == PPC::CR1GT ||
 710              DestReg == PPC::CR1EQ || DestReg == PPC::CR1UN)
 711       Reg = PPC::CR1;
 712     else if (DestReg == PPC::CR2LT || DestReg == PPC::CR2GT ||
 713              DestReg == PPC::CR2EQ || DestReg == PPC::CR2UN)
 714       Reg = PPC::CR2;
 715     else if (DestReg == PPC::CR3LT || DestReg == PPC::CR3GT ||
 716              DestReg == PPC::CR3EQ || DestReg == PPC::CR3UN)
 717       Reg = PPC::CR3;
 718     else if (DestReg == PPC::CR4LT || DestReg == PPC::CR4GT ||
 719              DestReg == PPC::CR4EQ || DestReg == PPC::CR4UN)
 720       Reg = PPC::CR4;
 721     else if (DestReg == PPC::CR5LT || DestReg == PPC::CR5GT ||
 722              DestReg == PPC::CR5EQ || DestReg == PPC::CR5UN)
 723       Reg = PPC::CR5;
 724     else if (DestReg == PPC::CR6LT || DestReg == PPC::CR6GT ||
 725              DestReg == PPC::CR6EQ || DestReg == PPC::CR6UN)
 726       Reg = PPC::CR6;
 727     else if (DestReg == PPC::CR7LT || DestReg == PPC::CR7GT ||
 728              DestReg == PPC::CR7EQ || DestReg == PPC::CR7UN)
 729       Reg = PPC::CR7;
 730
 731     return LoadRegFromStackSlot(MF, DL, Reg, FrameIdx,
 732                                 &PPC::CRRCRegClass, NewMIs, NonRI, SpillsVRS);
 733
 734   } else if (PPC::VRRCRegClass.hasSubClassEq(RC)) {
 735     NewMIs.push_back(addFrameReference(BuildMI(MF, DL, get(PPC::LVX), DestReg),
 736                                        FrameIdx));
 737     NonRI = true;
 738   } else if (PPC::VRSAVERCRegClass.hasSubClassEq(RC)) {
 739     assert(TM.getSubtargetImpl()->isDarwin() &&
 740            "VRSAVE only needs spill/restore on Darwin");
 741     NewMIs.push_back(addFrameReference(BuildMI(MF, DL,
 742                                                get(PPC::RESTORE_VRSAVE),
 743                                                DestReg),
 744                                        FrameIdx));
 745     SpillsVRS = true;
 746   } else {
 747     llvm_unreachable("Unknown regclass!");
 748   }
 749
 750   return false;
 751 }
 752
 753 void
 754 PPCInstrInfo::loadRegFromStackSlot(MachineBasicBlock &MBB,
 755                                    MachineBasicBlock::iterator MI,
 756                                    unsigned DestReg, int FrameIdx,
 757                                    const TargetRegisterClass *RC,
 758                                    const TargetRegisterInfo *TRI) const {
 759   MachineFunction &MF = *MBB.getParent();
 760   SmallVector<MachineInstr*, 4> NewMIs;
 761   DebugLoc DL;
 762   if (MI != MBB.end()) DL = MI->getDebugLoc();
 763
 764   PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>();
 765   FuncInfo->setHasSpills();
 766
 767   bool NonRI = false, SpillsVRS = false;
 768   if (LoadRegFromStackSlot(MF, DL, DestReg, FrameIdx, RC, NewMIs,
 769                            NonRI, SpillsVRS))
 770     FuncInfo->setSpillsCR();
 771
 772   if (SpillsVRS)
 773     FuncInfo->setSpillsVRSAVE();
 774
 775   if (NonRI)
 776     FuncInfo->setHasNonRISpills();
 777
 778   for (unsigned i = 0, e = NewMIs.size(); i != e; ++i)
 779     MBB.insert(MI, NewMIs[i]);
 780
 781   const MachineFrameInfo &MFI = *MF.getFrameInfo();
 782   MachineMemOperand *MMO =
 783     MF.getMachineMemOperand(MachinePointerInfo::getFixedStack(FrameIdx),
 784                             MachineMemOperand::MOLoad,
 785                             MFI.getObjectSize(FrameIdx),
 786                             MFI.getObjectAlignment(FrameIdx));
 787   NewMIs.back()->addMemOperand(MF, MMO);
 788 }
 789
 790 MachineInstr*
 791 PPCInstrInfo::emitFrameIndexDebugValue(MachineFunction &MF,
 792                                        int FrameIx, uint64_t Offset,
 793                                        const MDNode *MDPtr,
 794                                        DebugLoc DL) const {
 795   MachineInstrBuilder MIB = BuildMI(MF, DL, get(PPC::DBG_VALUE));
 796   addFrameReference(MIB, FrameIx, 0, false).addImm(Offset).addMetadata(MDPtr);
 797   return &*MIB;
 798 }
 799
 800 bool PPCInstrInfo::
 801 ReverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const {
 802   assert(Cond.size() == 2 && "Invalid PPC branch opcode!");
 803   if (Cond[1].getReg() == PPC::CTR8 || Cond[1].getReg() == PPC::CTR)
 804     Cond[0].setImm(Cond[0].getImm() == 0 ? 1 : 0);
 805   else
 806     // Leave the CR# the same, but invert the condition.
 807     Cond[0].setImm(PPC::InvertPredicate((PPC::Predicate)Cond[0].getImm()));
 808   return false;
 809 }
 810
 811 bool PPCInstrInfo::FoldImmediate(MachineInstr *UseMI, MachineInstr *DefMI,
 812                              unsigned Reg, MachineRegisterInfo *MRI) const {
 813   // For some instructions, it is legal to fold ZERO into the RA register field.
 814   // A zero immediate should always be loaded with a single li.
 815   unsigned DefOpc = DefMI->getOpcode();
 816   if (DefOpc != PPC::LI && DefOpc != PPC::LI8)
 817     return false;
 818   if (!DefMI->getOperand(1).isImm())
 819     return false;
 820   if (DefMI->getOperand(1).getImm() != 0)
 821     return false;
 822
 823   // Note that we cannot here invert the arguments of an isel in order to fold
 824   // a ZERO into what is presented as the second argument. All we have here
 825   // is the condition bit, and that might come from a CR-logical bit operation.
 826
 827   const MCInstrDesc &UseMCID = UseMI->getDesc();
 828
 829   // Only fold into real machine instructions.
 830   if (UseMCID.isPseudo())
 831     return false;
 832
 833   unsigned UseIdx;
 834   for (UseIdx = 0; UseIdx < UseMI->getNumOperands(); ++UseIdx)
 835     if (UseMI->getOperand(UseIdx).isReg() &&
 836         UseMI->getOperand(UseIdx).getReg() == Reg)
 837       break;
 838
 839   assert(UseIdx < UseMI->getNumOperands() && "Cannot find Reg in UseMI");
 840   assert(UseIdx < UseMCID.getNumOperands() && "No operand description for Reg");
 841
 842   const MCOperandInfo *UseInfo = &UseMCID.OpInfo[UseIdx];
 843
 844   // We can fold the zero if this register requires a GPRC_NOR0/G8RC_NOX0
 845   // register (which might also be specified as a pointer class kind).
 846   if (UseInfo->isLookupPtrRegClass()) {
 847     if (UseInfo->RegClass /* Kind */ != 1)
 848       return false;
 849   } else {
 850     if (UseInfo->RegClass != PPC::GPRC_NOR0RegClassID &&
 851         UseInfo->RegClass != PPC::G8RC_NOX0RegClassID)
 852       return false;
 853   }
 854
 855   // Make sure this is not tied to an output register (or otherwise
 856   // constrained). This is true for ST?UX registers, for example, which
 857   // are tied to their output registers.
 858   if (UseInfo->Constraints != 0)
 859     return false;
 860
 861   unsigned ZeroReg;
 862   if (UseInfo->isLookupPtrRegClass()) {
 863     bool isPPC64 = TM.getSubtargetImpl()->isPPC64();
 864     ZeroReg = isPPC64 ? PPC::ZERO8 : PPC::ZERO;
 865   } else {
 866     ZeroReg = UseInfo->RegClass == PPC::G8RC_NOX0RegClassID ?
 867               PPC::ZERO8 : PPC::ZERO;
 868   }
 869
 870   bool DeleteDef = MRI->hasOneNonDBGUse(Reg);
 871   UseMI->getOperand(UseIdx).setReg(ZeroReg);
 872
 873   if (DeleteDef)
 874     DefMI->eraseFromParent();
 875
 876   return true;
 877 }
 878
 879 bool PPCInstrInfo::isPredicated(const MachineInstr *MI) const {
 880   unsigned OpC = MI->getOpcode();
 881   switch (OpC) {
 882   default:
 883     return false;
 884   case PPC::BCC:
 885   case PPC::BCLR:
 886   case PPC::BDZLR:
 887   case PPC::BDZLR8:
 888   case PPC::BDNZLR:
 889   case PPC::BDNZLR8:
 890     return true;
 891   }
 892 }
 893
 894 bool PPCInstrInfo::isUnpredicatedTerminator(const MachineInstr *MI) const {
 895   if (!MI->isTerminator())
 896     return false;
 897
 898   // Conditional branch is a special case.
 899   if (MI->isBranch() && !MI->isBarrier())
 900     return true;
 901
 902   return !isPredicated(MI);
 903 }
 904
 905 bool PPCInstrInfo::PredicateInstruction(
 906                      MachineInstr *MI,
 907                      const SmallVectorImpl<MachineOperand> &Pred) const {
 908   unsigned OpC = MI->getOpcode();
 909   if (OpC == PPC::BLR) {
 910     if (Pred[1].getReg() == PPC::CTR8 || Pred[1].getReg() == PPC::CTR) {
 911       bool isPPC64 = TM.getSubtargetImpl()->isPPC64();
 912       MI->setDesc(get(Pred[0].getImm() ?
 913                       (isPPC64 ? PPC::BDNZLR8 : PPC::BDNZLR) :
 914                       (isPPC64 ? PPC::BDZLR8  : PPC::BDZLR)));
 915     } else {
 916       MI->setDesc(get(PPC::BCLR));
 917       MachineInstrBuilder(*MI->getParent()->getParent(), MI)
 918         .addImm(Pred[0].getImm())
 919         .addReg(Pred[1].getReg());
 920     }
 921
 922     return true;
 923   } else if (OpC == PPC::B) {
 924     if (Pred[1].getReg() == PPC::CTR8 || Pred[1].getReg() == PPC::CTR) {
 925       bool isPPC64 = TM.getSubtargetImpl()->isPPC64();
 926       MI->setDesc(get(Pred[0].getImm() ?
 927                       (isPPC64 ? PPC::BDNZ8 : PPC::BDNZ) :
 928                       (isPPC64 ? PPC::BDZ8  : PPC::BDZ)));
 929     } else {
 930       MachineBasicBlock *MBB = MI->getOperand(0).getMBB();
 931       MI->RemoveOperand(0);
 932
 933       MI->setDesc(get(PPC::BCC));
 934       MachineInstrBuilder(*MI->getParent()->getParent(), MI)
 935         .addImm(Pred[0].getImm())
 936         .addReg(Pred[1].getReg())
 937         .addMBB(MBB);
 938     }
 939
 940     return true;
 941   }
 942
 943   return false;
 944 }
 945
 946 bool PPCInstrInfo::SubsumesPredicate(
 947                      const SmallVectorImpl<MachineOperand> &Pred1,
 948                      const SmallVectorImpl<MachineOperand> &Pred2) const {
 949   assert(Pred1.size() == 2 && "Invalid PPC first predicate");
 950   assert(Pred2.size() == 2 && "Invalid PPC second predicate");
 951
 952   if (Pred1[1].getReg() == PPC::CTR8 || Pred1[1].getReg() == PPC::CTR)
 953     return false;
 954   if (Pred2[1].getReg() == PPC::CTR8 || Pred2[1].getReg() == PPC::CTR)
 955     return false;
 956
 957   PPC::Predicate P1 = (PPC::Predicate) Pred1[0].getImm();
 958   PPC::Predicate P2 = (PPC::Predicate) Pred2[0].getImm();
 959
 960   if (P1 == P2)
 961     return true;
 962
 963   // Does P1 subsume P2, e.g. GE subsumes GT.
 964   if (P1 == PPC::PRED_LE &&
 965       (P2 == PPC::PRED_LT || P2 == PPC::PRED_EQ))
 966     return true;
 967   if (P1 == PPC::PRED_GE &&
 968       (P2 == PPC::PRED_GT || P2 == PPC::PRED_EQ))
 969     return true;
 970
 971   return false;
 972 }
 973
 974 bool PPCInstrInfo::DefinesPredicate(MachineInstr *MI,
 975                                     std::vector<MachineOperand> &Pred) const {
 976   // Note: At the present time, the contents of Pred from this function is
 977   // unused by IfConversion. This implementation follows ARM by pushing the
 978   // CR-defining operand. Because the 'DZ' and 'DNZ' count as types of
 979   // predicate, instructions defining CTR or CTR8 are also included as
 980   // predicate-defining instructions.
 981
 982   const TargetRegisterClass *RCs[] =
 983     { &PPC::CRRCRegClass, &PPC::CRBITRCRegClass,
 984       &PPC::CTRRCRegClass, &PPC::CTRRC8RegClass };
 985
 986   bool Found = false;
 987   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
 988     const MachineOperand &MO = MI->getOperand(i);
 989     for (int c = 0; c < 2 && !Found; ++c) {
 990       const TargetRegisterClass *RC = RCs[c];
 991       for (TargetRegisterClass::iterator I = RC->begin(),
 992            IE = RC->end(); I != IE; ++I) {
 993         if ((MO.isRegMask() && MO.clobbersPhysReg(*I)) ||
 994             (MO.isReg() && MO.isDef() && MO.getReg() == *I)) {
 995           Pred.push_back(MO);
 996           Found = true;
 997         }
 998       }
 999     }
1000   }
1001
1002   return Found;
1003 }
1004
1005 bool PPCInstrInfo::isPredicable(MachineInstr *MI) const {
1006   unsigned OpC = MI->getOpcode();
1007   switch (OpC) {
1008   default:
1009     return false;
1010   case PPC::B:
1011   case PPC::BLR:
1012     return true;
1013   }
1014 }
1015
1016 /// GetInstSize - Return the number of bytes of code the specified
1017 /// instruction may be.  This returns the maximum number of bytes.
1018 ///
1019 unsigned PPCInstrInfo::GetInstSizeInBytes(const MachineInstr *MI) const {
1020   switch (MI->getOpcode()) {
1021   case PPC::INLINEASM: {       // Inline Asm: Variable size.
1022     const MachineFunction *MF = MI->getParent()->getParent();
1023     const char *AsmStr = MI->getOperand(0).getSymbolName();
1024     return getInlineAsmLength(AsmStr, *MF->getTarget().getMCAsmInfo());
1025   }
1026   case PPC::PROLOG_LABEL:
1027   case PPC::EH_LABEL:
1028   case PPC::GC_LABEL:
1029   case PPC::DBG_VALUE:
1030     return 0;
1031   case PPC::BL8_NOP:
1032   case PPC::BLA8_NOP:
1033     return 8;
1034   default:
1035     return 4; // PowerPC instructions are all 4 bytes
1036   }
1037 }
1038
1039 #undef DEBUG_TYPE
1040 #define DEBUG_TYPE "ppc-early-ret"
1041 STATISTIC(NumBCLR, "Number of early conditional returns");
1042 STATISTIC(NumBLR,  "Number of early returns");
1043
1044 namespace llvm {
1045   void initializePPCEarlyReturnPass(PassRegistry&);
1046 }
1047
1048 namespace {
1049   // PPCEarlyReturn pass - For simple functions without epilogue code, move
1050   // returns up, and create conditional returns, to avoid unnecessary
1051   // branch-to-blr sequences.
1052   struct PPCEarlyReturn : public MachineFunctionPass {
1053     static char ID;
1054     PPCEarlyReturn() : MachineFunctionPass(ID) {
1055       initializePPCEarlyReturnPass(*PassRegistry::getPassRegistry());
1056     }
1057
1058     const PPCTargetMachine *TM;
1059     const PPCInstrInfo *TII;
1060
1061 protected:
1062     bool processBlock(MachineBasicBlock &ReturnMBB) {
1063       bool Changed = false;
1064
1065       MachineBasicBlock::iterator I = ReturnMBB.begin();
1066       I = ReturnMBB.SkipPHIsAndLabels(I);
1067
1068       // The block must be essentially empty except for the blr.
1069       if (I == ReturnMBB.end() || I->getOpcode() != PPC::BLR ||
1070           I != ReturnMBB.getLastNonDebugInstr())
1071         return Changed;
1072
1073       SmallVector<MachineBasicBlock*, 8> PredToRemove;
1074       for (MachineBasicBlock::pred_iterator PI = ReturnMBB.pred_begin(),
1075            PIE = ReturnMBB.pred_end(); PI != PIE; ++PI) {
1076         bool OtherReference = false, BlockChanged = false;
1077         for (MachineBasicBlock::iterator J = (*PI)->getLastNonDebugInstr();;) {
1078           if (J->getOpcode() == PPC::B) {
1079             if (J->getOperand(0).getMBB() == &ReturnMBB) {
1080               // This is an unconditional branch to the return. Replace the
1081               // branch with a blr.
1082               BuildMI(**PI, J, J->getDebugLoc(), TII->get(PPC::BLR));
1083               MachineBasicBlock::iterator K = J--;
1084               K->eraseFromParent();
1085               BlockChanged = true;
1086               ++NumBLR;
1087               continue;
1088             }
1089           } else if (J->getOpcode() == PPC::BCC) {
1090             if (J->getOperand(2).getMBB() == &ReturnMBB) {
1091               // This is a conditional branch to the return. Replace the branch
1092               // with a bclr.
1093               BuildMI(**PI, J, J->getDebugLoc(), TII->get(PPC::BCLR))
1094                 .addImm(J->getOperand(0).getImm())
1095                 .addReg(J->getOperand(1).getReg());
1096               MachineBasicBlock::iterator K = J--;
1097               K->eraseFromParent();
1098               BlockChanged = true;
1099               ++NumBCLR;
1100               continue;
1101             }
1102           } else if (J->isBranch()) {
1103             if (J->isIndirectBranch()) {
1104               if (ReturnMBB.hasAddressTaken())
1105                 OtherReference = true;
1106             } else
1107               for (unsigned i = 0; i < J->getNumOperands(); ++i)
1108                 if (J->getOperand(i).isMBB() &&
1109                     J->getOperand(i).getMBB() == &ReturnMBB)
1110                   OtherReference = true;
1111           } else if (!J->isTerminator() && !J->isDebugValue())
1112             break;
1113
1114           if (J == (*PI)->begin())
1115             break;
1116
1117           --J;
1118         }
1119
1120         if ((*PI)->canFallThrough() && (*PI)->isLayoutSuccessor(&ReturnMBB))
1121           OtherReference = true;
1122
1123         // Predecessors are stored in a vector and can't be removed here.
1124         if (!OtherReference && BlockChanged) {
1125           PredToRemove.push_back(*PI);
1126         }
1127
1128         if (BlockChanged)
1129           Changed = true;
1130       }
1131
1132       for (unsigned i = 0, ie = PredToRemove.size(); i != ie; ++i)
1133         PredToRemove[i]->removeSuccessor(&ReturnMBB);
1134
1135       if (Changed && !ReturnMBB.hasAddressTaken()) {
1136         // We now might be able to merge this blr-only block into its
1137         // by-layout predecessor.
1138         if (ReturnMBB.pred_size() == 1 &&
1139             (*ReturnMBB.pred_begin())->isLayoutSuccessor(&ReturnMBB)) {
1140           // Move the blr into the preceding block.
1141           MachineBasicBlock &PrevMBB = **ReturnMBB.pred_begin();
1142           PrevMBB.splice(PrevMBB.end(), &ReturnMBB, I);
1143           PrevMBB.removeSuccessor(&ReturnMBB);
1144         }
1145
1146         if (ReturnMBB.pred_empty())
1147           ReturnMBB.eraseFromParent();
1148       }
1149
1150       return Changed;
1151     }
1152
1153 public:
1154     virtual bool runOnMachineFunction(MachineFunction &MF) {
1155       TM = static_cast<const PPCTargetMachine *>(&MF.getTarget());
1156       TII = TM->getInstrInfo();
1157
1158       bool Changed = false;
1159
1160       // If the function does not have at least two blocks, then there is
1161       // nothing to do.
1162       if (MF.size() < 2)
1163         return Changed;
1164
1165       for (MachineFunction::iterator I = MF.begin(); I != MF.end();) {
1166         MachineBasicBlock &B = *I++;
1167         if (processBlock(B))
1168           Changed = true;
1169       }
1170
1171       return Changed;
1172     }
1173
1174     virtual void getAnalysisUsage(AnalysisUsage &AU) const {
1175       MachineFunctionPass::getAnalysisUsage(AU);
1176     }
1177   };
1178 }
1179
1180 INITIALIZE_PASS(PPCEarlyReturn, DEBUG_TYPE,
1181                 "PowerPC Early-Return Creation", false, false)
1182
1183 char PPCEarlyReturn::ID = 0;
1184 FunctionPass*
1185 llvm::createPPCEarlyReturnPass() { return new PPCEarlyReturn(); }
1186