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   default: break;
 495   case ARM::FCPYS:
 496   case ARM::FCPYD:
 497   case ARM::VMOVD:
 498   case  ARM::VMOVQ: {
 499     SrcReg = MI.getOperand(1).getReg();
 500     DstReg = MI.getOperand(0).getReg();
 501     return true;
 502   }
 503   case ARM::MOVr:
 504   case ARM::tMOVr:
 505   case ARM::tMOVgpr2tgpr:
 506   case ARM::tMOVtgpr2gpr:
 507   case ARM::tMOVgpr2gpr:
 508   case ARM::t2MOVr: {
 509     assert(MI.getDesc().getNumOperands() >= 2 &&
 510            MI.getOperand(0).isReg() &&
 511            MI.getOperand(1).isReg() &&
 512            "Invalid ARM MOV instruction");
 513     SrcReg = MI.getOperand(1).getReg();
 514     DstReg = MI.getOperand(0).getReg();
 515     return true;
 516   }
 517   }
 518
 519   return false;
 520 }
 521
 522 unsigned
 523 ARMBaseInstrInfo::isLoadFromStackSlot(const MachineInstr *MI,
 524                                       int &FrameIndex) const {
 525   switch (MI->getOpcode()) {
 526   default: break;
 527   case ARM::LDR:
 528   case ARM::t2LDRs:  // FIXME: don't use t2LDRs to access frame.
 529     if (MI->getOperand(1).isFI() &&
 530         MI->getOperand(2).isReg() &&
 531         MI->getOperand(3).isImm() &&
 532         MI->getOperand(2).getReg() == 0 &&
 533         MI->getOperand(3).getImm() == 0) {
 534       FrameIndex = MI->getOperand(1).getIndex();
 535       return MI->getOperand(0).getReg();
 536     }
 537     break;
 538   case ARM::t2LDRi12:
 539   case ARM::tRestore:
 540     if (MI->getOperand(1).isFI() &&
 541         MI->getOperand(2).isImm() &&
 542         MI->getOperand(2).getImm() == 0) {
 543       FrameIndex = MI->getOperand(1).getIndex();
 544       return MI->getOperand(0).getReg();
 545     }
 546     break;
 547   case ARM::FLDD:
 548   case ARM::FLDS:
 549     if (MI->getOperand(1).isFI() &&
 550         MI->getOperand(2).isImm() &&
 551         MI->getOperand(2).getImm() == 0) {
 552       FrameIndex = MI->getOperand(1).getIndex();
 553       return MI->getOperand(0).getReg();
 554     }
 555     break;
 556   }
 557
 558   return 0;
 559 }
 560
 561 unsigned
 562 ARMBaseInstrInfo::isStoreToStackSlot(const MachineInstr *MI,
 563                                      int &FrameIndex) const {
 564   switch (MI->getOpcode()) {
 565   default: break;
 566   case ARM::STR:
 567   case ARM::t2STRs: // FIXME: don't use t2STRs to access frame.
 568     if (MI->getOperand(1).isFI() &&
 569         MI->getOperand(2).isReg() &&
 570         MI->getOperand(3).isImm() &&
 571         MI->getOperand(2).getReg() == 0 &&
 572         MI->getOperand(3).getImm() == 0) {
 573       FrameIndex = MI->getOperand(1).getIndex();
 574       return MI->getOperand(0).getReg();
 575     }
 576     break;
 577   case ARM::t2STRi12:
 578   case ARM::tSpill:
 579     if (MI->getOperand(1).isFI() &&
 580         MI->getOperand(2).isImm() &&
 581         MI->getOperand(2).getImm() == 0) {
 582       FrameIndex = MI->getOperand(1).getIndex();
 583       return MI->getOperand(0).getReg();
 584     }
 585     break;
 586   case ARM::FSTD:
 587   case  ARM::FSTS:
 588     if (MI->getOperand(1).isFI() &&
 589         MI->getOperand(2).isImm() &&
 590         MI->getOperand(2).getImm() == 0) {
 591       FrameIndex = MI->getOperand(1).getIndex();
 592       return MI->getOperand(0).getReg();
 593     }
 594     break;
 595   }
 596
 597   return 0;
 598 }
 599
 600 bool
 601 ARMBaseInstrInfo::copyRegToReg(MachineBasicBlock &MBB,
 602                                MachineBasicBlock::iterator I,
 603                                unsigned DestReg, unsigned SrcReg,
 604                                const TargetRegisterClass *DestRC,
 605                                const TargetRegisterClass *SrcRC) const {
 606   DebugLoc DL = DebugLoc::getUnknownLoc();
 607   if (I != MBB.end()) DL = I->getDebugLoc();
 608
 609   if (DestRC != SrcRC) {
 610     // Not yet supported!
 611     return false;
 612   }
 613
 614   if (DestRC == ARM::GPRRegisterClass)
 615     AddDefaultCC(AddDefaultPred(BuildMI(MBB, I, DL, get(getOpcode(ARMII::MOVr)),
 616                                         DestReg).addReg(SrcReg)));
 617   else if (DestRC == ARM::SPRRegisterClass)
 618     AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::FCPYS), DestReg)
 619                    .addReg(SrcReg));
 620   else if (DestRC == ARM::DPRRegisterClass)
 621     AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::FCPYD), DestReg)
 622                    .addReg(SrcReg));
 623   else if (DestRC == ARM::QPRRegisterClass)
 624     BuildMI(MBB, I, DL, get(ARM::VMOVQ), DestReg).addReg(SrcReg);
 625   else
 626     return false;
 627
 628   return true;
 629 }
 630
 631 void ARMBaseInstrInfo::
 632 storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
 633                     unsigned SrcReg, bool isKill, int FI,
 634                     const TargetRegisterClass *RC) const {
 635   DebugLoc DL = DebugLoc::getUnknownLoc();
 636   if (I != MBB.end()) DL = I->getDebugLoc();
 637
 638   if (RC == ARM::GPRRegisterClass) {
 639     AddDefaultPred(BuildMI(MBB, I, DL, get(getOpcode(ARMII::STRrr)))
 640                    .addReg(SrcReg, getKillRegState(isKill))
 641                    .addFrameIndex(FI).addReg(0).addImm(0));
 642   } else if (RC == ARM::DPRRegisterClass) {
 643     AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::FSTD))
 644                    .addReg(SrcReg, getKillRegState(isKill))
 645                    .addFrameIndex(FI).addImm(0));
 646   } else {
 647     assert(RC == ARM::SPRRegisterClass && "Unknown regclass!");
 648     AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::FSTS))
 649                    .addReg(SrcReg, getKillRegState(isKill))
 650                    .addFrameIndex(FI).addImm(0));
 651   }
 652 }
 653
 654 void ARMBaseInstrInfo::
 655 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
 656                      unsigned DestReg, int FI,
 657                      const TargetRegisterClass *RC) const {
 658   DebugLoc DL = DebugLoc::getUnknownLoc();
 659   if (I != MBB.end()) DL = I->getDebugLoc();
 660
 661   if (RC == ARM::GPRRegisterClass) {
 662     AddDefaultPred(BuildMI(MBB, I, DL, get(getOpcode(ARMII::LDRrr)), DestReg)
 663                    .addFrameIndex(FI).addReg(0).addImm(0));
 664   } else if (RC == ARM::DPRRegisterClass) {
 665     AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::FLDD), DestReg)
 666                    .addFrameIndex(FI).addImm(0));
 667   } else {
 668     assert(RC == ARM::SPRRegisterClass && "Unknown regclass!");
 669     AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::FLDS), DestReg)
 670                    .addFrameIndex(FI).addImm(0));
 671   }
 672 }
 673
 674 MachineInstr *ARMBaseInstrInfo::
 675 foldMemoryOperandImpl(MachineFunction &MF, MachineInstr *MI,
 676                       const SmallVectorImpl<unsigned> &Ops, int FI) const {
 677   if (Ops.size() != 1) return NULL;
 678
 679   unsigned OpNum = Ops[0];
 680   unsigned Opc = MI->getOpcode();
 681   MachineInstr *NewMI = NULL;
 682   if (Opc == getOpcode(ARMII::MOVr)) {
 683     // If it is updating CPSR, then it cannot be folded.
 684     if (MI->getOperand(4).getReg() != ARM::CPSR) {
 685       unsigned Pred = MI->getOperand(2).getImm();
 686       unsigned PredReg = MI->getOperand(3).getReg();
 687       if (OpNum == 0) { // move -> store
 688         unsigned SrcReg = MI->getOperand(1).getReg();
 689         bool isKill = MI->getOperand(1).isKill();
 690         bool isUndef = MI->getOperand(1).isUndef();
 691         NewMI = BuildMI(MF, MI->getDebugLoc(), get(getOpcode(ARMII::STRrr)))
 692           .addReg(SrcReg, getKillRegState(isKill) | getUndefRegState(isUndef))
 693           .addFrameIndex(FI).addReg(0).addImm(0).addImm(Pred).addReg(PredReg);
 694       } else {          // move -> load
 695         unsigned DstReg = MI->getOperand(0).getReg();
 696         bool isDead = MI->getOperand(0).isDead();
 697         bool isUndef = MI->getOperand(0).isUndef();
 698         NewMI = BuildMI(MF, MI->getDebugLoc(), get(getOpcode(ARMII::LDRrr)))
 699           .addReg(DstReg,
 700                   RegState::Define |
 701                   getDeadRegState(isDead) |
 702                   getUndefRegState(isUndef))
 703           .addFrameIndex(FI).addReg(0).addImm(0).addImm(Pred).addReg(PredReg);
 704       }
 705     }
 706   }
 707   else if (Opc == ARM::FCPYS) {
 708     unsigned Pred = MI->getOperand(2).getImm();
 709     unsigned PredReg = MI->getOperand(3).getReg();
 710     if (OpNum == 0) { // move -> store
 711       unsigned SrcReg = MI->getOperand(1).getReg();
 712       bool isKill = MI->getOperand(1).isKill();
 713       bool isUndef = MI->getOperand(1).isUndef();
 714       NewMI = BuildMI(MF, MI->getDebugLoc(), get(ARM::FSTS))
 715         .addReg(SrcReg, getKillRegState(isKill) | getUndefRegState(isUndef))
 716         .addFrameIndex(FI)
 717         .addImm(0).addImm(Pred).addReg(PredReg);
 718     } else {          // move -> load
 719       unsigned DstReg = MI->getOperand(0).getReg();
 720       bool isDead = MI->getOperand(0).isDead();
 721       bool isUndef = MI->getOperand(0).isUndef();
 722       NewMI = BuildMI(MF, MI->getDebugLoc(), get(ARM::FLDS))
 723         .addReg(DstReg,
 724                 RegState::Define |
 725                 getDeadRegState(isDead) |
 726                 getUndefRegState(isUndef))
 727         .addFrameIndex(FI).addImm(0).addImm(Pred).addReg(PredReg);
 728     }
 729   }
 730   else if (Opc == ARM::FCPYD) {
 731     unsigned Pred = MI->getOperand(2).getImm();
 732     unsigned PredReg = MI->getOperand(3).getReg();
 733     if (OpNum == 0) { // move -> store
 734       unsigned SrcReg = MI->getOperand(1).getReg();
 735       bool isKill = MI->getOperand(1).isKill();
 736       bool isUndef = MI->getOperand(1).isUndef();
 737       NewMI = BuildMI(MF, MI->getDebugLoc(), get(ARM::FSTD))
 738         .addReg(SrcReg, getKillRegState(isKill) | getUndefRegState(isUndef))
 739         .addFrameIndex(FI).addImm(0).addImm(Pred).addReg(PredReg);
 740     } else {          // move -> load
 741       unsigned DstReg = MI->getOperand(0).getReg();
 742       bool isDead = MI->getOperand(0).isDead();
 743       bool isUndef = MI->getOperand(0).isUndef();
 744       NewMI = BuildMI(MF, MI->getDebugLoc(), get(ARM::FLDD))
 745         .addReg(DstReg,
 746                 RegState::Define |
 747                 getDeadRegState(isDead) |
 748                 getUndefRegState(isUndef))
 749         .addFrameIndex(FI).addImm(0).addImm(Pred).addReg(PredReg);
 750     }
 751   }
 752
 753   return NewMI;
 754 }
 755
 756 MachineInstr*
 757 ARMBaseInstrInfo::foldMemoryOperandImpl(MachineFunction &MF,
 758                                         MachineInstr* MI,
 759                                         const SmallVectorImpl<unsigned> &Ops,
 760                                         MachineInstr* LoadMI) const {
 761   return 0;
 762 }
 763
 764 bool
 765 ARMBaseInstrInfo::canFoldMemoryOperand(const MachineInstr *MI,
 766                                        const SmallVectorImpl<unsigned> &Ops) const {
 767   if (Ops.size() != 1) return false;
 768
 769   unsigned Opc = MI->getOpcode();
 770   if (Opc == getOpcode(ARMII::MOVr)) {
 771     // If it is updating CPSR, then it cannot be folded.
 772     return MI->getOperand(4).getReg() != ARM::CPSR;
 773   } else if (Opc == ARM::FCPYS || Opc == ARM::FCPYD) {
 774     return true;
 775   } else if (Opc == ARM::VMOVD || Opc == ARM::VMOVQ) {
 776     return false; // FIXME
 777   }
 778
 779   return false;
 780 }