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