Merge isLoadFromStackSlot into one since it behaves the same regardless of sub-target.
[oota-llvm.git] / 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 }