lib/Target/ARM/ARMInstrInfo.cpp

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