1 //===- Thumb1InstrInfo.cpp - Thumb-1 Instruction Information --------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file contains the Thumb-1 implementation of the TargetInstrInfo class.
12 //===----------------------------------------------------------------------===//
14 #include "ARMInstrInfo.h"
16 #include "ARMGenInstrInfo.inc"
17 #include "ARMMachineFunctionInfo.h"
18 #include "llvm/CodeGen/MachineFrameInfo.h"
19 #include "llvm/CodeGen/MachineInstrBuilder.h"
20 #include "llvm/ADT/SmallVector.h"
21 #include "Thumb1InstrInfo.h"
26 const MachineInstrBuilder &AddDefaultPred(const MachineInstrBuilder &MIB) {
27 return MIB.addImm((int64_t)ARMCC::AL).addReg(0);
30 Thumb1InstrInfo::Thumb1InstrInfo(const ARMSubtarget &STI)
31 : ARMBaseInstrInfo(STI), RI(*this, STI) {
34 unsigned Thumb1InstrInfo::getUnindexedOpcode(unsigned Opc) const {
38 unsigned Thumb1InstrInfo::getOpcode(ARMII::Op Op) const {
40 case ARMII::ADDri: return ARM::tADDi8;
41 case ARMII::ADDrs: return 0;
42 case ARMII::ADDrr: return ARM::tADDrr;
43 case ARMII::B: return ARM::tB;
44 case ARMII::Bcc: return ARM::tBcc;
45 case ARMII::BR_JTr: return ARM::tBR_JTr;
46 case ARMII::BR_JTm: return 0;
47 case ARMII::BR_JTadd: return 0;
48 case ARMII::BX_RET: return ARM::tBX_RET;
49 case ARMII::FCPYS: return 0;
50 case ARMII::FCPYD: return 0;
51 case ARMII::FLDD: return 0;
52 case ARMII::FLDS: return 0;
53 case ARMII::FSTD: return 0;
54 case ARMII::FSTS: return 0;
55 case ARMII::LDR: return ARM::tLDR;
56 case ARMII::MOVr: return ARM::tMOVr;
57 case ARMII::STR: return ARM::tSTR;
58 case ARMII::SUBri: return ARM::tSUBi8;
59 case ARMII::SUBrs: return 0;
60 case ARMII::SUBrr: return ARM::tSUBrr;
61 case ARMII::VMOVD: return 0;
62 case ARMII::VMOVQ: return 0;
71 Thumb1InstrInfo::BlockHasNoFallThrough(const MachineBasicBlock &MBB) const {
72 if (MBB.empty()) return false;
74 switch (MBB.back().getOpcode()) {
76 case ARM::tBX_RET_vararg:
88 bool Thumb1InstrInfo::isMoveInstr(const MachineInstr &MI,
89 unsigned &SrcReg, unsigned &DstReg,
90 unsigned& SrcSubIdx, unsigned& DstSubIdx) const {
91 SrcSubIdx = DstSubIdx = 0; // No sub-registers.
93 unsigned oc = MI.getOpcode();
98 case ARM::tMOVhir2lor:
99 case ARM::tMOVlor2hir:
100 case ARM::tMOVhir2hir:
101 assert(MI.getDesc().getNumOperands() >= 2 &&
102 MI.getOperand(0).isReg() &&
103 MI.getOperand(1).isReg() &&
104 "Invalid Thumb MOV instruction");
105 SrcReg = MI.getOperand(1).getReg();
106 DstReg = MI.getOperand(0).getReg();
111 unsigned Thumb1InstrInfo::isLoadFromStackSlot(const MachineInstr *MI,
112 int &FrameIndex) const {
113 switch (MI->getOpcode()) {
116 if (MI->getOperand(1).isFI() &&
117 MI->getOperand(2).isImm() &&
118 MI->getOperand(2).getImm() == 0) {
119 FrameIndex = MI->getOperand(1).getIndex();
120 return MI->getOperand(0).getReg();
127 unsigned Thumb1InstrInfo::isStoreToStackSlot(const MachineInstr *MI,
128 int &FrameIndex) const {
129 switch (MI->getOpcode()) {
132 if (MI->getOperand(1).isFI() &&
133 MI->getOperand(2).isImm() &&
134 MI->getOperand(2).getImm() == 0) {
135 FrameIndex = MI->getOperand(1).getIndex();
136 return MI->getOperand(0).getReg();
143 bool Thumb1InstrInfo::copyRegToReg(MachineBasicBlock &MBB,
144 MachineBasicBlock::iterator I,
145 unsigned DestReg, unsigned SrcReg,
146 const TargetRegisterClass *DestRC,
147 const TargetRegisterClass *SrcRC) const {
148 DebugLoc DL = DebugLoc::getUnknownLoc();
149 if (I != MBB.end()) DL = I->getDebugLoc();
151 if (DestRC == ARM::GPRRegisterClass) {
152 if (SrcRC == ARM::GPRRegisterClass) {
153 BuildMI(MBB, I, DL, get(ARM::tMOVhir2hir), DestReg).addReg(SrcReg);
155 } else if (SrcRC == ARM::tGPRRegisterClass) {
156 BuildMI(MBB, I, DL, get(ARM::tMOVlor2hir), DestReg).addReg(SrcReg);
159 } else if (DestRC == ARM::tGPRRegisterClass) {
160 if (SrcRC == ARM::GPRRegisterClass) {
161 BuildMI(MBB, I, DL, get(ARM::tMOVhir2lor), DestReg).addReg(SrcReg);
163 } else if (SrcRC == ARM::tGPRRegisterClass) {
164 BuildMI(MBB, I, DL, get(ARM::tMOVr), DestReg).addReg(SrcReg);
172 bool Thumb1InstrInfo::
173 canFoldMemoryOperand(const MachineInstr *MI,
174 const SmallVectorImpl<unsigned> &Ops) const {
175 if (Ops.size() != 1) return false;
177 unsigned OpNum = Ops[0];
178 unsigned Opc = MI->getOpcode();
182 case ARM::tMOVlor2hir:
183 case ARM::tMOVhir2lor:
184 case ARM::tMOVhir2hir: {
185 if (OpNum == 0) { // move -> store
186 unsigned SrcReg = MI->getOperand(1).getReg();
187 if (RI.isPhysicalRegister(SrcReg) && !isARMLowRegister(SrcReg))
188 // tSpill cannot take a high register operand.
190 } else { // move -> load
191 unsigned DstReg = MI->getOperand(0).getReg();
192 if (RI.isPhysicalRegister(DstReg) && !isARMLowRegister(DstReg))
193 // tRestore cannot target a high register operand.
203 void Thumb1InstrInfo::
204 storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
205 unsigned SrcReg, bool isKill, int FI,
206 const TargetRegisterClass *RC) const {
207 DebugLoc DL = DebugLoc::getUnknownLoc();
208 if (I != MBB.end()) DL = I->getDebugLoc();
210 assert(RC == ARM::tGPRRegisterClass && "Unknown regclass!");
212 if (RC == ARM::tGPRRegisterClass) {
213 AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::tSpill))
214 .addReg(SrcReg, getKillRegState(isKill))
215 .addFrameIndex(FI).addImm(0));
219 void Thumb1InstrInfo::storeRegToAddr(MachineFunction &MF, unsigned SrcReg,
221 SmallVectorImpl<MachineOperand> &Addr,
222 const TargetRegisterClass *RC,
223 SmallVectorImpl<MachineInstr*> &NewMIs) const{
224 DebugLoc DL = DebugLoc::getUnknownLoc();
227 assert(RC == ARM::GPRRegisterClass && "Unknown regclass!");
228 if (RC == ARM::GPRRegisterClass) {
229 Opc = Addr[0].isFI() ? ARM::tSpill : ARM::tSTR;
232 MachineInstrBuilder MIB =
233 BuildMI(MF, DL, get(Opc)).addReg(SrcReg, getKillRegState(isKill));
234 for (unsigned i = 0, e = Addr.size(); i != e; ++i)
235 MIB.addOperand(Addr[i]);
237 NewMIs.push_back(MIB);
241 void Thumb1InstrInfo::
242 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
243 unsigned DestReg, int FI,
244 const TargetRegisterClass *RC) const {
245 DebugLoc DL = DebugLoc::getUnknownLoc();
246 if (I != MBB.end()) DL = I->getDebugLoc();
248 assert(RC == ARM::tGPRRegisterClass && "Unknown regclass!");
250 if (RC == ARM::tGPRRegisterClass) {
251 AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::tRestore), DestReg)
252 .addFrameIndex(FI).addImm(0));
256 void Thumb1InstrInfo::
257 loadRegFromAddr(MachineFunction &MF, unsigned DestReg,
258 SmallVectorImpl<MachineOperand> &Addr,
259 const TargetRegisterClass *RC,
260 SmallVectorImpl<MachineInstr*> &NewMIs) const {
261 DebugLoc DL = DebugLoc::getUnknownLoc();
264 if (RC == ARM::GPRRegisterClass) {
265 Opc = Addr[0].isFI() ? ARM::tRestore : ARM::tLDR;
268 MachineInstrBuilder MIB = BuildMI(MF, DL, get(Opc), DestReg);
269 for (unsigned i = 0, e = Addr.size(); i != e; ++i)
270 MIB.addOperand(Addr[i]);
272 NewMIs.push_back(MIB);
276 bool Thumb1InstrInfo::
277 spillCalleeSavedRegisters(MachineBasicBlock &MBB,
278 MachineBasicBlock::iterator MI,
279 const std::vector<CalleeSavedInfo> &CSI) const {
283 DebugLoc DL = DebugLoc::getUnknownLoc();
284 if (MI != MBB.end()) DL = MI->getDebugLoc();
286 MachineInstrBuilder MIB = BuildMI(MBB, MI, DL, get(ARM::tPUSH));
287 for (unsigned i = CSI.size(); i != 0; --i) {
288 unsigned Reg = CSI[i-1].getReg();
289 // Add the callee-saved register as live-in. It's killed at the spill.
291 MIB.addReg(Reg, RegState::Kill);
296 bool Thumb1InstrInfo::
297 restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
298 MachineBasicBlock::iterator MI,
299 const std::vector<CalleeSavedInfo> &CSI) const {
300 MachineFunction &MF = *MBB.getParent();
301 ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>();
305 bool isVarArg = AFI->getVarArgsRegSaveSize() > 0;
306 MachineInstr *PopMI = MF.CreateMachineInstr(get(ARM::tPOP),MI->getDebugLoc());
307 for (unsigned i = CSI.size(); i != 0; --i) {
308 unsigned Reg = CSI[i-1].getReg();
309 if (Reg == ARM::LR) {
310 // Special epilogue for vararg functions. See emitEpilogue
314 PopMI->setDesc(get(ARM::tPOP_RET));
317 PopMI->addOperand(MachineOperand::CreateReg(Reg, true));
320 // It's illegal to emit pop instruction without operands.
321 if (PopMI->getNumOperands() > 0)
322 MBB.insert(MI, PopMI);
327 MachineInstr *Thumb1InstrInfo::
328 foldMemoryOperandImpl(MachineFunction &MF, MachineInstr *MI,
329 const SmallVectorImpl<unsigned> &Ops, int FI) const {
330 if (Ops.size() != 1) return NULL;
332 unsigned OpNum = Ops[0];
333 unsigned Opc = MI->getOpcode();
334 MachineInstr *NewMI = NULL;
338 case ARM::tMOVlor2hir:
339 case ARM::tMOVhir2lor:
340 case ARM::tMOVhir2hir: {
341 if (OpNum == 0) { // move -> store
342 unsigned SrcReg = MI->getOperand(1).getReg();
343 bool isKill = MI->getOperand(1).isKill();
344 if (RI.isPhysicalRegister(SrcReg) && !isARMLowRegister(SrcReg))
345 // tSpill cannot take a high register operand.
347 NewMI = AddDefaultPred(BuildMI(MF, MI->getDebugLoc(), get(ARM::tSpill))
348 .addReg(SrcReg, getKillRegState(isKill))
349 .addFrameIndex(FI).addImm(0));
350 } else { // move -> load
351 unsigned DstReg = MI->getOperand(0).getReg();
352 if (RI.isPhysicalRegister(DstReg) && !isARMLowRegister(DstReg))
353 // tRestore cannot target a high register operand.
355 bool isDead = MI->getOperand(0).isDead();
356 NewMI = AddDefaultPred(BuildMI(MF, MI->getDebugLoc(), get(ARM::tRestore))
358 RegState::Define | getDeadRegState(isDead))
359 .addFrameIndex(FI).addImm(0));