1 //===- Thumb2RegisterInfo.cpp - Thumb-2 Register 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-2 implementation of the TargetRegisterInfo class.
12 //===----------------------------------------------------------------------===//
15 #include "ARMAddressingModes.h"
16 #include "ARMBaseInstrInfo.h"
17 #include "ARMMachineFunctionInfo.h"
18 #include "ARMSubtarget.h"
19 #include "Thumb2InstrInfo.h"
20 #include "Thumb2RegisterInfo.h"
21 #include "llvm/Constants.h"
22 #include "llvm/DerivedTypes.h"
23 #include "llvm/Function.h"
24 #include "llvm/LLVMContext.h"
25 #include "llvm/CodeGen/MachineConstantPool.h"
26 #include "llvm/CodeGen/MachineFrameInfo.h"
27 #include "llvm/CodeGen/MachineFunction.h"
28 #include "llvm/CodeGen/MachineInstrBuilder.h"
29 #include "llvm/CodeGen/MachineLocation.h"
30 #include "llvm/CodeGen/MachineRegisterInfo.h"
31 #include "llvm/Target/TargetFrameInfo.h"
32 #include "llvm/Target/TargetMachine.h"
33 #include "llvm/ADT/BitVector.h"
34 #include "llvm/ADT/SmallVector.h"
35 #include "llvm/Support/CommandLine.h"
36 #include "llvm/Support/ErrorHandling.h"
39 Thumb2RegisterInfo::Thumb2RegisterInfo(const ARMBaseInstrInfo &tii,
40 const ARMSubtarget &sti)
41 : ARMBaseRegisterInfo(tii, sti) {
44 /// emitLoadConstPool - Emits a load from constpool to materialize the
45 /// specified immediate.
46 void Thumb2RegisterInfo::emitLoadConstPool(MachineBasicBlock &MBB,
47 MachineBasicBlock::iterator &MBBI,
49 unsigned DestReg, unsigned SubIdx,
51 ARMCC::CondCodes Pred,
52 unsigned PredReg) const {
53 MachineFunction &MF = *MBB.getParent();
54 MachineConstantPool *ConstantPool = MF.getConstantPool();
56 MF.getFunction()->getContext().getConstantInt(Type::Int32Ty, Val);
57 unsigned Idx = ConstantPool->getConstantPoolIndex(C, 4);
59 BuildMI(MBB, MBBI, dl, TII.get(ARM::t2LDRpci))
60 .addReg(DestReg, getDefRegState(true), SubIdx)
61 .addConstantPoolIndex(Idx).addImm((int64_t)ARMCC::AL).addReg(0);
65 negativeOffsetOpcode(unsigned opcode)
68 case ARM::t2LDRi12: return ARM::t2LDRi8;
69 case ARM::t2LDRHi12: return ARM::t2LDRHi8;
70 case ARM::t2LDRBi12: return ARM::t2LDRBi8;
71 case ARM::t2LDRSHi12: return ARM::t2LDRSHi8;
72 case ARM::t2LDRSBi12: return ARM::t2LDRSBi8;
73 case ARM::t2STRi12: return ARM::t2STRi8;
74 case ARM::t2STRBi12: return ARM::t2STRBi8;
75 case ARM::t2STRHi12: return ARM::t2STRHi8;
95 positiveOffsetOpcode(unsigned opcode)
98 case ARM::t2LDRi8: return ARM::t2LDRi12;
99 case ARM::t2LDRHi8: return ARM::t2LDRHi12;
100 case ARM::t2LDRBi8: return ARM::t2LDRBi12;
101 case ARM::t2LDRSHi8: return ARM::t2LDRSHi12;
102 case ARM::t2LDRSBi8: return ARM::t2LDRSBi12;
103 case ARM::t2STRi8: return ARM::t2STRi12;
104 case ARM::t2STRBi8: return ARM::t2STRBi12;
105 case ARM::t2STRHi8: return ARM::t2STRHi12;
110 case ARM::t2LDRSHi12:
111 case ARM::t2LDRSBi12:
125 immediateOffsetOpcode(unsigned opcode)
128 case ARM::t2LDRs: return ARM::t2LDRi12;
129 case ARM::t2LDRHs: return ARM::t2LDRHi12;
130 case ARM::t2LDRBs: return ARM::t2LDRBi12;
131 case ARM::t2LDRSHs: return ARM::t2LDRSHi12;
132 case ARM::t2LDRSBs: return ARM::t2LDRSBi12;
133 case ARM::t2STRs: return ARM::t2STRi12;
134 case ARM::t2STRBs: return ARM::t2STRBi12;
135 case ARM::t2STRHs: return ARM::t2STRHi12;
140 case ARM::t2LDRSHi12:
141 case ARM::t2LDRSBi12:
162 bool Thumb2RegisterInfo::
163 requiresRegisterScavenging(const MachineFunction &MF) const {
167 int Thumb2RegisterInfo::
168 rewriteFrameIndex(MachineInstr &MI, unsigned FrameRegIdx,
169 unsigned FrameReg, int Offset) const
171 unsigned Opcode = MI.getOpcode();
172 const TargetInstrDesc &Desc = MI.getDesc();
173 unsigned AddrMode = (Desc.TSFlags & ARMII::AddrModeMask);
176 // Memory operands in inline assembly always use AddrModeT2_i12
177 if (Opcode == ARM::INLINEASM)
178 AddrMode = ARMII::AddrModeT2_i12; // FIXME. mode for thumb2?
180 if (Opcode == getOpcode(ARMII::ADDri)) {
181 Offset += MI.getOperand(FrameRegIdx+1).getImm();
183 // Turn it into a move.
184 MI.setDesc(TII.get(getOpcode(ARMII::MOVr)));
185 MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
186 MI.RemoveOperand(FrameRegIdx+1);
188 } else if (Offset < 0) {
191 MI.setDesc(TII.get(getOpcode(ARMII::SUBri)));
194 // Common case: small offset, fits into instruction.
195 if (ARM_AM::getT2SOImmVal(Offset) != -1) {
196 // Replace the FrameIndex with sp / fp
197 MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
198 MI.getOperand(FrameRegIdx+1).ChangeToImmediate(Offset);
202 // Otherwise, extract 8 adjacent bits from the immediate into this
204 unsigned RotAmt = CountLeadingZeros_32(Offset);
207 unsigned ThisImmVal = Offset & ARM_AM::rotr32(0xff000000U, RotAmt);
209 // We will handle these bits from offset, clear them.
210 Offset &= ~ThisImmVal;
212 assert(ARM_AM::getT2SOImmVal(ThisImmVal) != -1 &&
213 "Bit extraction didn't work?");
214 MI.getOperand(FrameRegIdx+1).ChangeToImmediate(ThisImmVal);
216 // AddrModeT2_so cannot handle any offset. If there is no offset
217 // register then we change to an immediate version.
218 if (AddrMode == ARMII::AddrModeT2_so) {
219 unsigned OffsetReg = MI.getOperand(FrameRegIdx+1).getReg();
220 if (OffsetReg != 0) {
221 MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
225 MI.RemoveOperand(FrameRegIdx+1);
226 MI.getOperand(FrameRegIdx+1).ChangeToImmediate(0);
227 Opcode = immediateOffsetOpcode(Opcode);
228 AddrMode = ARMII::AddrModeT2_i12;
231 // Neon and FP address modes are handled by the base ARM version...
232 if ((AddrMode != ARMII::AddrModeT2_i8) &&
233 (AddrMode != ARMII::AddrModeT2_i12)) {
234 return ARMBaseRegisterInfo::rewriteFrameIndex(MI, FrameRegIdx,
238 unsigned NumBits = 0;
239 Offset += MI.getOperand(FrameRegIdx+1).getImm();
241 // i8 supports only negative, and i12 supports only positive, so
242 // based on Offset sign convert Opcode to the appropriate
245 Opcode = negativeOffsetOpcode(Opcode);
251 Opcode = positiveOffsetOpcode(Opcode);
256 MI.setDesc(TII.get(Opcode));
257 MachineOperand &ImmOp = MI.getOperand(FrameRegIdx+1);
259 // Attempt to fold address computation
260 // Common case: small offset, fits into instruction.
261 unsigned Mask = (1 << NumBits) - 1;
262 if ((unsigned)Offset <= Mask) {
263 // Replace the FrameIndex with fp/sp
264 MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
265 ImmOp.ChangeToImmediate((isSub) ? -Offset : Offset);
269 // Otherwise, offset doesn't fit. Pull in what we can to simplify
270 unsigned ImmedOffset = Offset & Mask;
271 ImmOp.ChangeToImmediate((isSub) ? -ImmedOffset : ImmedOffset);
276 return (isSub) ? -Offset : Offset;