lib/Target/ARM/ARMBaseInstrInfo.cpp

   1 //===- ARMBaseInstrInfo.cpp - ARM Instruction Information -----------*- C++ -*-===//
   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 Base ARM implementation of the TargetInstrInfo class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "ARMBaseInstrInfo.h"
  15 #include "ARM.h"
  16 #include "ARMAddressingModes.h"
  17 #include "ARMGenInstrInfo.inc"
  18 #include "ARMMachineFunctionInfo.h"
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/CodeGen/LiveVariables.h"
  21 #include "llvm/CodeGen/MachineFrameInfo.h"
  22 #include "llvm/CodeGen/MachineInstrBuilder.h"
  23 #include "llvm/CodeGen/MachineJumpTableInfo.h"
  24 #include "llvm/Target/TargetAsmInfo.h"
  25 #include "llvm/Support/CommandLine.h"
  26 #include "llvm/Support/ErrorHandling.h"
  27 using namespace llvm;
  28
  29 static cl::opt<bool>
  30 EnableARM3Addr("enable-arm-3-addr-conv", cl::Hidden,
  31                cl::desc("Enable ARM 2-addr to 3-addr conv"));
  32
  33 ARMBaseInstrInfo::ARMBaseInstrInfo(const ARMSubtarget &STI)
  34   : TargetInstrInfoImpl(ARMInsts, array_lengthof(ARMInsts)) {
  35 }
  36
  37 MachineInstr *
  38 ARMBaseInstrInfo::convertToThreeAddress(MachineFunction::iterator &MFI,
  39                                         MachineBasicBlock::iterator &MBBI,
  40                                         LiveVariables *LV) const {
  41   if (!EnableARM3Addr)
  42     return NULL;
  43
  44   MachineInstr *MI = MBBI;
  45   MachineFunction &MF = *MI->getParent()->getParent();
  46   unsigned TSFlags = MI->getDesc().TSFlags;
  47   bool isPre = false;
  48   switch ((TSFlags & ARMII::IndexModeMask) >> ARMII::IndexModeShift) {
  49   default: return NULL;
  50   case ARMII::IndexModePre:
  51     isPre = true;
  52     break;
  53   case ARMII::IndexModePost:
  54     break;
  55   }
  56
  57   // Try splitting an indexed load/store to an un-indexed one plus an add/sub
  58   // operation.
  59   unsigned MemOpc = getUnindexedOpcode(MI->getOpcode());
  60   if (MemOpc == 0)
  61     return NULL;
  62
  63   MachineInstr *UpdateMI = NULL;
  64   MachineInstr *MemMI = NULL;
  65   unsigned AddrMode = (TSFlags & ARMII::AddrModeMask);
  66   const TargetInstrDesc &TID = MI->getDesc();
  67   unsigned NumOps = TID.getNumOperands();
  68   bool isLoad = !TID.mayStore();
  69   const MachineOperand &WB = isLoad ? MI->getOperand(1) : MI->getOperand(0);
  70   const MachineOperand &Base = MI->getOperand(2);
  71   const MachineOperand &Offset = MI->getOperand(NumOps-3);
  72   unsigned WBReg = WB.getReg();
  73   unsigned BaseReg = Base.getReg();
  74   unsigned OffReg = Offset.getReg();
  75   unsigned OffImm = MI->getOperand(NumOps-2).getImm();
  76   ARMCC::CondCodes Pred = (ARMCC::CondCodes)MI->getOperand(NumOps-1).getImm();
  77   switch (AddrMode) {
  78   default:
  79     assert(false && "Unknown indexed op!");
  80     return NULL;
  81   case ARMII::AddrMode2: {
  82     bool isSub = ARM_AM::getAM2Op(OffImm) == ARM_AM::sub;
  83     unsigned Amt = ARM_AM::getAM2Offset(OffImm);
  84     if (OffReg == 0) {
  85       if (ARM_AM::getSOImmVal(Amt) == -1)
  86         // Can't encode it in a so_imm operand. This transformation will
  87         // add more than 1 instruction. Abandon!
  88         return NULL;
  89       UpdateMI = BuildMI(MF, MI->getDebugLoc(),
  90                          get(isSub ? getOpcode(ARMII::SUBri) :
  91                              getOpcode(ARMII::ADDri)), WBReg)
  92         .addReg(BaseReg).addImm(Amt)
  93         .addImm(Pred).addReg(0).addReg(0);
  94     } else if (Amt != 0) {
  95       ARM_AM::ShiftOpc ShOpc = ARM_AM::getAM2ShiftOpc(OffImm);
  96       unsigned SOOpc = ARM_AM::getSORegOpc(ShOpc, Amt);
  97       UpdateMI = BuildMI(MF, MI->getDebugLoc(),
  98                          get(isSub ? getOpcode(ARMII::SUBrs) :
  99                              getOpcode(ARMII::ADDrs)), WBReg)
 100         .addReg(BaseReg).addReg(OffReg).addReg(0).addImm(SOOpc)
 101         .addImm(Pred).addReg(0).addReg(0);
 102     } else
 103       UpdateMI = BuildMI(MF, MI->getDebugLoc(),
 104                          get(isSub ? getOpcode(ARMII::SUBrr) :
 105                              getOpcode(ARMII::ADDrr)), WBReg)
 106         .addReg(BaseReg).addReg(OffReg)
 107         .addImm(Pred).addReg(0).addReg(0);
 108     break;
 109   }
 110   case ARMII::AddrMode3 : {
 111     bool isSub = ARM_AM::getAM3Op(OffImm) == ARM_AM::sub;
 112     unsigned Amt = ARM_AM::getAM3Offset(OffImm);
 113     if (OffReg == 0)
 114       // Immediate is 8-bits. It's guaranteed to fit in a so_imm operand.
 115       UpdateMI = BuildMI(MF, MI->getDebugLoc(),
 116                          get(isSub ? getOpcode(ARMII::SUBri) :
 117                              getOpcode(ARMII::ADDri)), WBReg)
 118         .addReg(BaseReg).addImm(Amt)
 119         .addImm(Pred).addReg(0).addReg(0);
 120     else
 121       UpdateMI = BuildMI(MF, MI->getDebugLoc(),
 122                          get(isSub ? getOpcode(ARMII::SUBrr) :
 123                              getOpcode(ARMII::ADDrr)), WBReg)
 124         .addReg(BaseReg).addReg(OffReg)
 125         .addImm(Pred).addReg(0).addReg(0);
 126     break;
 127   }
 128   }
 129
 130   std::vector<MachineInstr*> NewMIs;
 131   if (isPre) {
 132     if (isLoad)
 133       MemMI = BuildMI(MF, MI->getDebugLoc(),
 134                       get(MemOpc), MI->getOperand(0).getReg())
 135         .addReg(WBReg).addReg(0).addImm(0).addImm(Pred);
 136     else
 137       MemMI = BuildMI(MF, MI->getDebugLoc(),
 138                       get(MemOpc)).addReg(MI->getOperand(1).getReg())
 139         .addReg(WBReg).addReg(0).addImm(0).addImm(Pred);
 140     NewMIs.push_back(MemMI);
 141     NewMIs.push_back(UpdateMI);
 142   } else {
 143     if (isLoad)
 144       MemMI = BuildMI(MF, MI->getDebugLoc(),
 145                       get(MemOpc), MI->getOperand(0).getReg())
 146         .addReg(BaseReg).addReg(0).addImm(0).addImm(Pred);
 147     else
 148       MemMI = BuildMI(MF, MI->getDebugLoc(),
 149                       get(MemOpc)).addReg(MI->getOperand(1).getReg())
 150         .addReg(BaseReg).addReg(0).addImm(0).addImm(Pred);
 151     if (WB.isDead())
 152       UpdateMI->getOperand(0).setIsDead();
 153     NewMIs.push_back(UpdateMI);
 154     NewMIs.push_back(MemMI);
 155   }
 156
 157   // Transfer LiveVariables states, kill / dead info.
 158   if (LV) {
 159     for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
 160       MachineOperand &MO = MI->getOperand(i);
 161       if (MO.isReg() && MO.getReg() &&
 162           TargetRegisterInfo::isVirtualRegister(MO.getReg())) {
 163         unsigned Reg = MO.getReg();
 164
 165         LiveVariables::VarInfo &VI = LV->getVarInfo(Reg);
 166         if (MO.isDef()) {
 167           MachineInstr *NewMI = (Reg == WBReg) ? UpdateMI : MemMI;
 168           if (MO.isDead())
 169             LV->addVirtualRegisterDead(Reg, NewMI);
 170         }
 171         if (MO.isUse() && MO.isKill()) {
 172           for (unsigned j = 0; j < 2; ++j) {
 173             // Look at the two new MI's in reverse order.
 174             MachineInstr *NewMI = NewMIs[j];
 175             if (!NewMI->readsRegister(Reg))
 176               continue;
 177             LV->addVirtualRegisterKilled(Reg, NewMI);
 178             if (VI.removeKill(MI))
 179               VI.Kills.push_back(NewMI);
 180             break;
 181           }
 182         }
 183       }
 184     }
 185   }
 186
 187   MFI->insert(MBBI, NewMIs[1]);
 188   MFI->insert(MBBI, NewMIs[0]);
 189   return NewMIs[0];
 190 }
 191
 192 // Branch analysis.
 193 bool
 194 ARMBaseInstrInfo::AnalyzeBranch(MachineBasicBlock &MBB,MachineBasicBlock *&TBB,
 195                                 MachineBasicBlock *&FBB,
 196                                 SmallVectorImpl<MachineOperand> &Cond,
 197                                 bool AllowModify) const {
 198   // If the block has no terminators, it just falls into the block after it.
 199   MachineBasicBlock::iterator I = MBB.end();
 200   if (I == MBB.begin() || !isUnpredicatedTerminator(--I))
 201     return false;
 202
 203   // Get the last instruction in the block.
 204   MachineInstr *LastInst = I;
 205
 206   // If there is only one terminator instruction, process it.
 207   unsigned LastOpc = LastInst->getOpcode();
 208   if (I == MBB.begin() || !isUnpredicatedTerminator(--I)) {
 209     if (LastOpc == getOpcode(ARMII::B)) {
 210       TBB = LastInst->getOperand(0).getMBB();
 211       return false;
 212     }
 213     if (LastOpc == getOpcode(ARMII::Bcc)) {
 214       // Block ends with fall-through condbranch.
 215       TBB = LastInst->getOperand(0).getMBB();
 216       Cond.push_back(LastInst->getOperand(1));
 217       Cond.push_back(LastInst->getOperand(2));
 218       return false;
 219     }
 220     return true;  // Can't handle indirect branch.
 221   }
 222
 223   // Get the instruction before it if it is a terminator.
 224   MachineInstr *SecondLastInst = I;
 225
 226   // If there are three terminators, we don't know what sort of block this is.
 227   if (SecondLastInst && I != MBB.begin() && isUnpredicatedTerminator(--I))
 228     return true;
 229
 230   // If the block ends with ARMII::B and a ARMII::Bcc, handle it.
 231   unsigned SecondLastOpc = SecondLastInst->getOpcode();
 232   if ((SecondLastOpc == getOpcode(ARMII::Bcc)) &&
 233       (LastOpc == getOpcode(ARMII::B))) {
 234     TBB =  SecondLastInst->getOperand(0).getMBB();
 235     Cond.push_back(SecondLastInst->getOperand(1));
 236     Cond.push_back(SecondLastInst->getOperand(2));
 237     FBB = LastInst->getOperand(0).getMBB();
 238     return false;
 239   }
 240
 241   // If the block ends with two unconditional branches, handle it.  The second
 242   // one is not executed, so remove it.
 243   if ((SecondLastOpc == getOpcode(ARMII::B)) &&
 244       (LastOpc == getOpcode(ARMII::B))) {
 245     TBB = SecondLastInst->getOperand(0).getMBB();
 246     I = LastInst;
 247     if (AllowModify)
 248       I->eraseFromParent();
 249     return false;
 250   }
 251
 252   // ...likewise if it ends with a branch table followed by an unconditional
 253   // branch. The branch folder can create these, and we must get rid of them for
 254   // correctness of Thumb constant islands.
 255   if ((SecondLastOpc == ARM::BR_JTr ||
 256        SecondLastOpc == ARM::BR_JTm ||
 257        SecondLastOpc == ARM::BR_JTadd ||
 258        SecondLastOpc == ARM::tBR_JTr ||
 259        SecondLastOpc == ARM::t2BR_JT) &&
 260       (LastOpc == getOpcode(ARMII::B))) {
 261     I = LastInst;
 262     if (AllowModify)
 263       I->eraseFromParent();
 264     return true;
 265   }
 266
 267   // Otherwise, can't handle this.
 268   return true;
 269 }
 270
 271
 272 unsigned ARMBaseInstrInfo::RemoveBranch(MachineBasicBlock &MBB) const {
 273   int BOpc   = getOpcode(ARMII::B);
 274   int BccOpc = getOpcode(ARMII::Bcc);
 275
 276   MachineBasicBlock::iterator I = MBB.end();
 277   if (I == MBB.begin()) return 0;
 278   --I;
 279   if (I->getOpcode() != BOpc && I->getOpcode() != BccOpc)
 280     return 0;
 281
 282   // Remove the branch.
 283   I->eraseFromParent();
 284
 285   I = MBB.end();
 286
 287   if (I == MBB.begin()) return 1;
 288   --I;
 289   if (I->getOpcode() != BccOpc)
 290     return 1;
 291
 292   // Remove the branch.
 293   I->eraseFromParent();
 294   return 2;
 295 }
 296
 297 unsigned
 298 ARMBaseInstrInfo::InsertBranch(MachineBasicBlock &MBB, MachineBasicBlock *TBB,
 299                                MachineBasicBlock *FBB,
 300                              const SmallVectorImpl<MachineOperand> &Cond) const {
 301   // FIXME this should probably have a DebugLoc argument
 302   DebugLoc dl = DebugLoc::getUnknownLoc();
 303   int BOpc   = getOpcode(ARMII::B);
 304   int BccOpc = getOpcode(ARMII::Bcc);
 305
 306   // Shouldn't be a fall through.
 307   assert(TBB && "InsertBranch must not be told to insert a fallthrough");
 308   assert((Cond.size() == 2 || Cond.size() == 0) &&
 309          "ARM branch conditions have two components!");
 310
 311   if (FBB == 0) {
 312     if (Cond.empty()) // Unconditional branch?
 313       BuildMI(&MBB, dl, get(BOpc)).addMBB(TBB);
 314     else
 315       BuildMI(&MBB, dl, get(BccOpc)).addMBB(TBB)
 316         .addImm(Cond[0].getImm()).addReg(Cond[1].getReg());
 317     return 1;
 318   }
 319
 320   // Two-way conditional branch.
 321   BuildMI(&MBB, dl, get(BccOpc)).addMBB(TBB)
 322     .addImm(Cond[0].getImm()).addReg(Cond[1].getReg());
 323   BuildMI(&MBB, dl, get(BOpc)).addMBB(FBB);
 324   return 2;
 325 }
 326
 327 bool ARMBaseInstrInfo::
 328 ReverseBranchCondition(SmallVectorImpl<MachineOperand> &Cond) const {
 329   ARMCC::CondCodes CC = (ARMCC::CondCodes)(int)Cond[0].getImm();
 330   Cond[0].setImm(ARMCC::getOppositeCondition(CC));
 331   return false;
 332 }
 333
 334 bool ARMBaseInstrInfo::
 335 PredicateInstruction(MachineInstr *MI,
 336                      const SmallVectorImpl<MachineOperand> &Pred) const {
 337   unsigned Opc = MI->getOpcode();
 338   if (Opc == getOpcode(ARMII::B)) {
 339     MI->setDesc(get(getOpcode(ARMII::Bcc)));
 340     MI->addOperand(MachineOperand::CreateImm(Pred[0].getImm()));
 341     MI->addOperand(MachineOperand::CreateReg(Pred[1].getReg(), false));
 342     return true;
 343   }
 344
 345   int PIdx = MI->findFirstPredOperandIdx();
 346   if (PIdx != -1) {
 347     MachineOperand &PMO = MI->getOperand(PIdx);
 348     PMO.setImm(Pred[0].getImm());
 349     MI->getOperand(PIdx+1).setReg(Pred[1].getReg());
 350     return true;
 351   }
 352   return false;
 353 }
 354
 355 bool ARMBaseInstrInfo::
 356 SubsumesPredicate(const SmallVectorImpl<MachineOperand> &Pred1,
 357                   const SmallVectorImpl<MachineOperand> &Pred2) const {
 358   if (Pred1.size() > 2 || Pred2.size() > 2)
 359     return false;
 360
 361   ARMCC::CondCodes CC1 = (ARMCC::CondCodes)Pred1[0].getImm();
 362   ARMCC::CondCodes CC2 = (ARMCC::CondCodes)Pred2[0].getImm();
 363   if (CC1 == CC2)
 364     return true;
 365
 366   switch (CC1) {
 367   default:
 368     return false;
 369   case ARMCC::AL:
 370     return true;
 371   case ARMCC::HS:
 372     return CC2 == ARMCC::HI;
 373   case ARMCC::LS:
 374     return CC2 == ARMCC::LO || CC2 == ARMCC::EQ;
 375   case ARMCC::GE:
 376     return CC2 == ARMCC::GT;
 377   case ARMCC::LE:
 378     return CC2 == ARMCC::LT;
 379   }
 380 }
 381
 382 bool ARMBaseInstrInfo::DefinesPredicate(MachineInstr *MI,
 383                                     std::vector<MachineOperand> &Pred) const {
 384   const TargetInstrDesc &TID = MI->getDesc();
 385   if (!TID.getImplicitDefs() && !TID.hasOptionalDef())
 386     return false;
 387
 388   bool Found = false;
 389   for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) {
 390     const MachineOperand &MO = MI->getOperand(i);
 391     if (MO.isReg() && MO.getReg() == ARM::CPSR) {
 392       Pred.push_back(MO);
 393       Found = true;
 394     }
 395   }
 396
 397   return Found;
 398 }
 399
 400
 401 /// FIXME: Works around a gcc miscompilation with -fstrict-aliasing
 402 static unsigned getNumJTEntries(const std::vector<MachineJumpTableEntry> &JT,
 403                                 unsigned JTI) DISABLE_INLINE;
 404 static unsigned getNumJTEntries(const std::vector<MachineJumpTableEntry> &JT,
 405                                 unsigned JTI) {
 406   return JT[JTI].MBBs.size();
 407 }
 408
 409 /// GetInstSize - Return the size of the specified MachineInstr.
 410 ///
 411 unsigned ARMBaseInstrInfo::GetInstSizeInBytes(const MachineInstr *MI) const {
 412   const MachineBasicBlock &MBB = *MI->getParent();
 413   const MachineFunction *MF = MBB.getParent();
 414   const TargetAsmInfo *TAI = MF->getTarget().getTargetAsmInfo();
 415
 416   // Basic size info comes from the TSFlags field.
 417   const TargetInstrDesc &TID = MI->getDesc();
 418   unsigned TSFlags = TID.TSFlags;
 419
 420   switch ((TSFlags & ARMII::SizeMask) >> ARMII::SizeShift) {
 421   default: {
 422     // If this machine instr is an inline asm, measure it.
 423     if (MI->getOpcode() == ARM::INLINEASM)
 424       return TAI->getInlineAsmLength(MI->getOperand(0).getSymbolName());
 425     if (MI->isLabel())
 426       return 0;
 427     switch (MI->getOpcode()) {
 428     default:
 429       llvm_unreachable("Unknown or unset size field for instr!");
 430     case TargetInstrInfo::IMPLICIT_DEF:
 431     case TargetInstrInfo::DECLARE:
 432     case TargetInstrInfo::DBG_LABEL:
 433     case TargetInstrInfo::EH_LABEL:
 434       return 0;
 435     }
 436     break;
 437   }
 438   case ARMII::Size8Bytes: return 8;          // ARM instruction x 2.
 439   case ARMII::Size4Bytes: return 4;          // ARM / Thumb2 instruction.
 440   case ARMII::Size2Bytes: return 2;          // Thumb1 instruction.
 441   case ARMII::SizeSpecial: {
 442     bool IsThumb1JT = false;
 443     switch (MI->getOpcode()) {
 444     case ARM::CONSTPOOL_ENTRY:
 445       // If this machine instr is a constant pool entry, its size is recorded as
 446       // operand #2.
 447       return MI->getOperand(2).getImm();
 448     case ARM::Int_eh_sjlj_setjmp:
 449       return 12;
 450     case ARM::tBR_JTr:
 451       IsThumb1JT = true;
 452       // Fallthrough
 453     case ARM::BR_JTr:
 454     case ARM::BR_JTm:
 455     case ARM::BR_JTadd:
 456     case ARM::t2BR_JT: {
 457       // These are jumptable branches, i.e. a branch followed by an inlined
 458       // jumptable. The size is 4 + 4 * number of entries.
 459       unsigned NumOps = TID.getNumOperands();
 460       MachineOperand JTOP =
 461         MI->getOperand(NumOps - (TID.isPredicable() ? 3 : 2));
 462       unsigned JTI = JTOP.getIndex();
 463       const MachineJumpTableInfo *MJTI = MF->getJumpTableInfo();
 464       const std::vector<MachineJumpTableEntry> &JT = MJTI->getJumpTables();
 465       assert(JTI < JT.size());
 466       // Thumb instructions are 2 byte aligned, but JT entries are 4 byte
 467       // 4 aligned. The assembler / linker may add 2 byte padding just before
 468       // the JT entries.  The size does not include this padding; the
 469       // constant islands pass does separate bookkeeping for it.
 470       // FIXME: If we know the size of the function is less than (1 << 16) *2
 471       // bytes, we can use 16-bit entries instead. Then there won't be an
 472       // alignment issue.
 473       return getNumJTEntries(JT, JTI) * 4 + (IsThumb1JT ? 2 : 4);
 474     }
 475     default:
 476       // Otherwise, pseudo-instruction sizes are zero.
 477       return 0;
 478     }
 479   }
 480   }
 481   return 0; // Not reached
 482 }
 483
 484 /// Return true if the instruction is a register to register move and
 485 /// leave the source and dest operands in the passed parameters.
 486 ///
 487 bool
 488 ARMBaseInstrInfo::isMoveInstr(const MachineInstr &MI,
 489                               unsigned &SrcReg, unsigned &DstReg,
 490                               unsigned& SrcSubIdx, unsigned& DstSubIdx) const {
 491   SrcSubIdx = DstSubIdx = 0; // No sub-registers.
 492
 493   switch (MI.getOpcode()) {
 494   case ARM::FCPYS:
 495   case ARM::FCPYD:
 496   case ARM::VMOVD:
 497   case  ARM::VMOVQ: {
 498     SrcReg = MI.getOperand(1).getReg();
 499     DstReg = MI.getOperand(0).getReg();
 500     return true;
 501   }
 502   case ARM::MOVr:
 503   case ARM::tMOVr:
 504   case ARM::tMOVgpr2tgpr:
 505   case ARM::tMOVtgpr2gpr:
 506   case ARM::tMOVgpr2gpr:
 507   case ARM::t2MOVr: {
 508     assert(MI.getDesc().getNumOperands() >= 2 &&
 509            MI.getOperand(0).isReg() &&
 510            MI.getOperand(1).isReg() &&
 511            "Invalid ARM MOV instruction");
 512     SrcReg = MI.getOperand(1).getReg();
 513     DstReg = MI.getOperand(0).getReg();
 514     return true;
 515   }
 516   }
 517
 518   return false;
 519 }
 520
 521 unsigned
 522 ARMBaseInstrInfo::isLoadFromStackSlot(const MachineInstr *MI,
 523                                       int &FrameIndex) const {
 524   unsigned oc = MI->getOpcode();
 525   if (oc == getOpcode(ARMII::LDRrr)) {
 526     if (MI->getOperand(1).isFI() &&
 527         MI->getOperand(2).isReg() &&
 528         MI->getOperand(3).isImm() &&
 529         MI->getOperand(2).getReg() == 0 &&
 530         MI->getOperand(3).getImm() == 0) {
 531       FrameIndex = MI->getOperand(1).getIndex();
 532       return MI->getOperand(0).getReg();
 533     }
 534   }
 535   else if (oc == getOpcode(ARMII::LDRri)) {
 536     if (MI->getOperand(1).isFI() &&
 537         MI->getOperand(2).isImm() &&
 538         MI->getOperand(2).getImm() == 0) {
 539       FrameIndex = MI->getOperand(1).getIndex();
 540       return MI->getOperand(0).getReg();
 541     }
 542   }
 543   else if (oc == ARM::FLDD || oc == ARM::FLDS) {
 544     if (MI->getOperand(1).isFI() &&
 545         MI->getOperand(2).isImm() &&
 546         MI->getOperand(2).getImm() == 0) {
 547       FrameIndex = MI->getOperand(1).getIndex();
 548       return MI->getOperand(0).getReg();
 549     }
 550   }
 551
 552   return 0;
 553 }
 554
 555 unsigned
 556 ARMBaseInstrInfo::isStoreToStackSlot(const MachineInstr *MI,
 557                                      int &FrameIndex) const {
 558   unsigned oc = MI->getOpcode();
 559   if (oc == getOpcode(ARMII::STRrr)) {
 560     if (MI->getOperand(1).isFI() &&
 561         MI->getOperand(2).isReg() &&
 562         MI->getOperand(3).isImm() &&
 563         MI->getOperand(2).getReg() == 0 &&
 564         MI->getOperand(3).getImm() == 0) {
 565       FrameIndex = MI->getOperand(1).getIndex();
 566       return MI->getOperand(0).getReg();
 567     }
 568   }
 569   else if (oc == getOpcode(ARMII::STRri)) {
 570     if (MI->getOperand(1).isFI() &&
 571         MI->getOperand(2).isImm() &&
 572         MI->getOperand(2).getImm() == 0) {
 573       FrameIndex = MI->getOperand(1).getIndex();
 574       return MI->getOperand(0).getReg();
 575     }
 576   }
 577   else if (oc == ARM::FSTD || oc == ARM::FSTS) {
 578     if (MI->getOperand(1).isFI() &&
 579         MI->getOperand(2).isImm() &&
 580         MI->getOperand(2).getImm() == 0) {
 581       FrameIndex = MI->getOperand(1).getIndex();
 582       return MI->getOperand(0).getReg();
 583     }
 584   }
 585
 586   return 0;
 587 }
 588
 589 bool
 590 ARMBaseInstrInfo::copyRegToReg(MachineBasicBlock &MBB,
 591                                MachineBasicBlock::iterator I,
 592                                unsigned DestReg, unsigned SrcReg,
 593                                const TargetRegisterClass *DestRC,
 594                                const TargetRegisterClass *SrcRC) const {
 595   DebugLoc DL = DebugLoc::getUnknownLoc();
 596   if (I != MBB.end()) DL = I->getDebugLoc();
 597
 598   if (DestRC != SrcRC) {
 599     // Not yet supported!
 600     return false;
 601   }
 602
 603   if (DestRC == ARM::GPRRegisterClass)
 604     AddDefaultCC(AddDefaultPred(BuildMI(MBB, I, DL, get(getOpcode(ARMII::MOVr)),
 605                                         DestReg).addReg(SrcReg)));
 606   else if (DestRC == ARM::SPRRegisterClass)
 607     AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::FCPYS), DestReg)
 608                    .addReg(SrcReg));
 609   else if (DestRC == ARM::DPRRegisterClass)
 610     AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::FCPYD), DestReg)
 611                    .addReg(SrcReg));
 612   else if (DestRC == ARM::QPRRegisterClass)
 613     BuildMI(MBB, I, DL, get(ARM::VMOVQ), DestReg).addReg(SrcReg);
 614   else
 615     return false;
 616
 617   return true;
 618 }
 619
 620 void ARMBaseInstrInfo::
 621 storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
 622                     unsigned SrcReg, bool isKill, int FI,
 623                     const TargetRegisterClass *RC) const {
 624   DebugLoc DL = DebugLoc::getUnknownLoc();
 625   if (I != MBB.end()) DL = I->getDebugLoc();
 626
 627   if (RC == ARM::GPRRegisterClass) {
 628     AddDefaultPred(BuildMI(MBB, I, DL, get(getOpcode(ARMII::STRrr)))
 629                    .addReg(SrcReg, getKillRegState(isKill))
 630                    .addFrameIndex(FI).addReg(0).addImm(0));
 631   } else if (RC == ARM::DPRRegisterClass) {
 632     AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::FSTD))
 633                    .addReg(SrcReg, getKillRegState(isKill))
 634                    .addFrameIndex(FI).addImm(0));
 635   } else {
 636     assert(RC == ARM::SPRRegisterClass && "Unknown regclass!");
 637     AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::FSTS))
 638                    .addReg(SrcReg, getKillRegState(isKill))
 639                    .addFrameIndex(FI).addImm(0));
 640   }
 641 }
 642
 643 void ARMBaseInstrInfo::
 644 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
 645                      unsigned DestReg, int FI,
 646                      const TargetRegisterClass *RC) const {
 647   DebugLoc DL = DebugLoc::getUnknownLoc();
 648   if (I != MBB.end()) DL = I->getDebugLoc();
 649
 650   if (RC == ARM::GPRRegisterClass) {
 651     AddDefaultPred(BuildMI(MBB, I, DL, get(getOpcode(ARMII::LDRrr)), DestReg)
 652                    .addFrameIndex(FI).addReg(0).addImm(0));
 653   } else if (RC == ARM::DPRRegisterClass) {
 654     AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::FLDD), DestReg)
 655                    .addFrameIndex(FI).addImm(0));
 656   } else {
 657     assert(RC == ARM::SPRRegisterClass && "Unknown regclass!");
 658     AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::FLDS), DestReg)
 659                    .addFrameIndex(FI).addImm(0));
 660   }
 661 }
 662
 663 MachineInstr *ARMBaseInstrInfo::
 664 foldMemoryOperandImpl(MachineFunction &MF, MachineInstr *MI,
 665                       const SmallVectorImpl<unsigned> &Ops, int FI) const {
 666   if (Ops.size() != 1) return NULL;
 667
 668   unsigned OpNum = Ops[0];
 669   unsigned Opc = MI->getOpcode();
 670   MachineInstr *NewMI = NULL;
 671   if (Opc == getOpcode(ARMII::MOVr)) {
 672     // If it is updating CPSR, then it cannot be folded.
 673     if (MI->getOperand(4).getReg() != ARM::CPSR) {
 674       unsigned Pred = MI->getOperand(2).getImm();
 675       unsigned PredReg = MI->getOperand(3).getReg();
 676       if (OpNum == 0) { // move -> store
 677         unsigned SrcReg = MI->getOperand(1).getReg();
 678         bool isKill = MI->getOperand(1).isKill();
 679         bool isUndef = MI->getOperand(1).isUndef();
 680         NewMI = BuildMI(MF, MI->getDebugLoc(), get(getOpcode(ARMII::STRrr)))
 681           .addReg(SrcReg, getKillRegState(isKill) | getUndefRegState(isUndef))
 682           .addFrameIndex(FI).addReg(0).addImm(0).addImm(Pred).addReg(PredReg);
 683       } else {          // move -> load
 684         unsigned DstReg = MI->getOperand(0).getReg();
 685         bool isDead = MI->getOperand(0).isDead();
 686         bool isUndef = MI->getOperand(0).isUndef();
 687         NewMI = BuildMI(MF, MI->getDebugLoc(), get(getOpcode(ARMII::LDRrr)))
 688           .addReg(DstReg,
 689                   RegState::Define |
 690                   getDeadRegState(isDead) |
 691                   getUndefRegState(isUndef))
 692           .addFrameIndex(FI).addReg(0).addImm(0).addImm(Pred).addReg(PredReg);
 693       }
 694     }
 695   }
 696   else if (Opc == ARM::FCPYS) {
 697     unsigned Pred = MI->getOperand(2).getImm();
 698     unsigned PredReg = MI->getOperand(3).getReg();
 699     if (OpNum == 0) { // move -> store
 700       unsigned SrcReg = MI->getOperand(1).getReg();
 701       bool isKill = MI->getOperand(1).isKill();
 702       bool isUndef = MI->getOperand(1).isUndef();
 703       NewMI = BuildMI(MF, MI->getDebugLoc(), get(ARM::FSTS))
 704         .addReg(SrcReg, getKillRegState(isKill) | getUndefRegState(isUndef))
 705         .addFrameIndex(FI)
 706         .addImm(0).addImm(Pred).addReg(PredReg);
 707     } else {          // move -> load
 708       unsigned DstReg = MI->getOperand(0).getReg();
 709       bool isDead = MI->getOperand(0).isDead();
 710       bool isUndef = MI->getOperand(0).isUndef();
 711       NewMI = BuildMI(MF, MI->getDebugLoc(), get(ARM::FLDS))
 712         .addReg(DstReg,
 713                 RegState::Define |
 714                 getDeadRegState(isDead) |
 715                 getUndefRegState(isUndef))
 716         .addFrameIndex(FI).addImm(0).addImm(Pred).addReg(PredReg);
 717     }
 718   }
 719   else if (Opc == ARM::FCPYD) {
 720     unsigned Pred = MI->getOperand(2).getImm();
 721     unsigned PredReg = MI->getOperand(3).getReg();
 722     if (OpNum == 0) { // move -> store
 723       unsigned SrcReg = MI->getOperand(1).getReg();
 724       bool isKill = MI->getOperand(1).isKill();
 725       bool isUndef = MI->getOperand(1).isUndef();
 726       NewMI = BuildMI(MF, MI->getDebugLoc(), get(ARM::FSTD))
 727         .addReg(SrcReg, getKillRegState(isKill) | getUndefRegState(isUndef))
 728         .addFrameIndex(FI).addImm(0).addImm(Pred).addReg(PredReg);
 729     } else {          // move -> load
 730       unsigned DstReg = MI->getOperand(0).getReg();
 731       bool isDead = MI->getOperand(0).isDead();
 732       bool isUndef = MI->getOperand(0).isUndef();
 733       NewMI = BuildMI(MF, MI->getDebugLoc(), get(ARM::FLDD))
 734         .addReg(DstReg,
 735                 RegState::Define |
 736                 getDeadRegState(isDead) |
 737                 getUndefRegState(isUndef))
 738         .addFrameIndex(FI).addImm(0).addImm(Pred).addReg(PredReg);
 739     }
 740   }
 741
 742   return NewMI;
 743 }
 744
 745 MachineInstr*
 746 ARMBaseInstrInfo::foldMemoryOperandImpl(MachineFunction &MF,
 747                                         MachineInstr* MI,
 748                                         const SmallVectorImpl<unsigned> &Ops,
 749                                         MachineInstr* LoadMI) const {
 750   return 0;
 751 }
 752
 753 bool
 754 ARMBaseInstrInfo::canFoldMemoryOperand(const MachineInstr *MI,
 755                                        const SmallVectorImpl<unsigned> &Ops) const {
 756   if (Ops.size() != 1) return false;
 757
 758   unsigned Opc = MI->getOpcode();
 759   if (Opc == getOpcode(ARMII::MOVr)) {
 760     // If it is updating CPSR, then it cannot be folded.
 761     return MI->getOperand(4).getReg() != ARM::CPSR;
 762   } else if (Opc == ARM::FCPYS || Opc == ARM::FCPYD) {
 763     return true;
 764   } else if (Opc == ARM::VMOVD || Opc == ARM::VMOVQ) {
 765     return false; // FIXME
 766   }
 767
 768   return false;
 769 }