LLVM API Documentation
00001 //===- Thumb1RegisterInfo.cpp - Thumb-1 Register Information -------*- C++ -*-===// 00002 // 00003 // The LLVM Compiler Infrastructure 00004 // 00005 // This file is distributed under the University of Illinois Open Source 00006 // License. See LICENSE.TXT for details. 00007 // 00008 //===----------------------------------------------------------------------===// 00009 // 00010 // This file contains the Thumb-1 implementation of the TargetRegisterInfo class. 00011 // 00012 //===----------------------------------------------------------------------===// 00013 00014 #include "ARM.h" 00015 #include "ARMAddressingModes.h" 00016 #include "ARMBaseInstrInfo.h" 00017 #include "ARMMachineFunctionInfo.h" 00018 #include "ARMSubtarget.h" 00019 #include "Thumb1InstrInfo.h" 00020 #include "Thumb1RegisterInfo.h" 00021 #include "llvm/Constants.h" 00022 #include "llvm/DerivedTypes.h" 00023 #include "llvm/Function.h" 00024 #include "llvm/LLVMContext.h" 00025 #include "llvm/CodeGen/MachineConstantPool.h" 00026 #include "llvm/CodeGen/MachineFrameInfo.h" 00027 #include "llvm/CodeGen/MachineFunction.h" 00028 #include "llvm/CodeGen/MachineInstrBuilder.h" 00029 #include "llvm/CodeGen/MachineLocation.h" 00030 #include "llvm/CodeGen/MachineRegisterInfo.h" 00031 #include "llvm/Target/TargetFrameInfo.h" 00032 #include "llvm/Target/TargetMachine.h" 00033 #include "llvm/ADT/BitVector.h" 00034 #include "llvm/ADT/SmallVector.h" 00035 #include "llvm/Support/CommandLine.h" 00036 #include "llvm/Support/ErrorHandling.h" 00037 #include "llvm/Support/raw_ostream.h" 00038 using namespace llvm; 00039 00040 static cl::opt<bool> 00041 ThumbRegScavenging("enable-thumb-reg-scavenging", 00042 cl::Hidden, 00043 cl::desc("Enable register scavenging on Thumb")); 00044 00045 Thumb1RegisterInfo::Thumb1RegisterInfo(const ARMBaseInstrInfo &tii, 00046 const ARMSubtarget &sti) 00047 : ARMBaseRegisterInfo(tii, sti) { 00048 } 00049 00050 /// emitLoadConstPool - Emits a load from constpool to materialize the 00051 /// specified immediate. 00052 void Thumb1RegisterInfo::emitLoadConstPool(MachineBasicBlock &MBB, 00053 MachineBasicBlock::iterator &MBBI, 00054 DebugLoc dl, 00055 unsigned DestReg, unsigned SubIdx, 00056 int Val, 00057 ARMCC::CondCodes Pred, 00058 unsigned PredReg) const { 00059 MachineFunction &MF = *MBB.getParent(); 00060 MachineConstantPool *ConstantPool = MF.getConstantPool(); 00061 Constant *C = ConstantInt::get( 00062 Type::getInt32Ty(MBB.getParent()->getFunction()->getContext()), Val); 00063 unsigned Idx = ConstantPool->getConstantPoolIndex(C, 4); 00064 00065 BuildMI(MBB, MBBI, dl, TII.get(ARM::tLDRcp)) 00066 .addReg(DestReg, getDefRegState(true), SubIdx) 00067 .addConstantPoolIndex(Idx).addImm(Pred).addReg(PredReg); 00068 } 00069 00070 const TargetRegisterClass* 00071 Thumb1RegisterInfo::getPhysicalRegisterRegClass(unsigned Reg, EVT VT) const { 00072 if (isARMLowRegister(Reg)) 00073 return ARM::tGPRRegisterClass; 00074 switch (Reg) { 00075 default: 00076 break; 00077 case ARM::R8: case ARM::R9: case ARM::R10: case ARM::R11: 00078 case ARM::R12: case ARM::SP: case ARM::LR: case ARM::PC: 00079 return ARM::GPRRegisterClass; 00080 } 00081 00082 return TargetRegisterInfo::getPhysicalRegisterRegClass(Reg, VT); 00083 } 00084 00085 bool 00086 Thumb1RegisterInfo::requiresRegisterScavenging(const MachineFunction &MF) const { 00087 return ThumbRegScavenging; 00088 } 00089 00090 bool Thumb1RegisterInfo::hasReservedCallFrame(MachineFunction &MF) const { 00091 const MachineFrameInfo *FFI = MF.getFrameInfo(); 00092 unsigned CFSize = FFI->getMaxCallFrameSize(); 00093 // It's not always a good idea to include the call frame as part of the 00094 // stack frame. ARM (especially Thumb) has small immediate offset to 00095 // address the stack frame. So a large call frame can cause poor codegen 00096 // and may even makes it impossible to scavenge a register. 00097 if (CFSize >= ((1 << 8) - 1) * 4 / 2) // Half of imm8 * 4 00098 return false; 00099 00100 return !MF.getFrameInfo()->hasVarSizedObjects(); 00101 } 00102 00103 00104 /// emitThumbRegPlusImmInReg - Emits a series of instructions to materialize 00105 /// a destreg = basereg + immediate in Thumb code. Materialize the immediate 00106 /// in a register using mov / mvn sequences or load the immediate from a 00107 /// constpool entry. 00108 static 00109 void emitThumbRegPlusImmInReg(MachineBasicBlock &MBB, 00110 MachineBasicBlock::iterator &MBBI, 00111 unsigned DestReg, unsigned BaseReg, 00112 int NumBytes, bool CanChangeCC, 00113 const TargetInstrInfo &TII, 00114 const Thumb1RegisterInfo& MRI, 00115 DebugLoc dl) { 00116 bool isHigh = !isARMLowRegister(DestReg) || 00117 (BaseReg != 0 && !isARMLowRegister(BaseReg)); 00118 bool isSub = false; 00119 // Subtract doesn't have high register version. Load the negative value 00120 // if either base or dest register is a high register. Also, if do not 00121 // issue sub as part of the sequence if condition register is to be 00122 // preserved. 00123 if (NumBytes < 0 && !isHigh && CanChangeCC) { 00124 isSub = true; 00125 NumBytes = -NumBytes; 00126 } 00127 unsigned LdReg = DestReg; 00128 if (DestReg == ARM::SP) { 00129 assert(BaseReg == ARM::SP && "Unexpected!"); 00130 LdReg = ARM::R3; 00131 BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVtgpr2gpr), ARM::R12) 00132 .addReg(ARM::R3, RegState::Kill); 00133 } 00134 00135 if (NumBytes <= 255 && NumBytes >= 0) 00136 AddDefaultT1CC(BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVi8), LdReg)) 00137 .addImm(NumBytes); 00138 else if (NumBytes < 0 && NumBytes >= -255) { 00139 AddDefaultT1CC(BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVi8), LdReg)) 00140 .addImm(NumBytes); 00141 AddDefaultT1CC(BuildMI(MBB, MBBI, dl, TII.get(ARM::tRSB), LdReg)) 00142 .addReg(LdReg, RegState::Kill); 00143 } else 00144 MRI.emitLoadConstPool(MBB, MBBI, dl, LdReg, 0, NumBytes); 00145 00146 // Emit add / sub. 00147 int Opc = (isSub) ? ARM::tSUBrr : (isHigh ? ARM::tADDhirr : ARM::tADDrr); 00148 MachineInstrBuilder MIB = 00149 BuildMI(MBB, MBBI, dl, TII.get(Opc), DestReg); 00150 if (Opc != ARM::tADDhirr) 00151 MIB = AddDefaultT1CC(MIB); 00152 if (DestReg == ARM::SP || isSub) 00153 MIB.addReg(BaseReg).addReg(LdReg, RegState::Kill); 00154 else 00155 MIB.addReg(LdReg).addReg(BaseReg, RegState::Kill); 00156 AddDefaultPred(MIB); 00157 00158 if (DestReg == ARM::SP) 00159 BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVgpr2tgpr), ARM::R3) 00160 .addReg(ARM::R12, RegState::Kill); 00161 } 00162 00163 /// calcNumMI - Returns the number of instructions required to materialize 00164 /// the specific add / sub r, c instruction. 00165 static unsigned calcNumMI(int Opc, int ExtraOpc, unsigned Bytes, 00166 unsigned NumBits, unsigned Scale) { 00167 unsigned NumMIs = 0; 00168 unsigned Chunk = ((1 << NumBits) - 1) * Scale; 00169 00170 if (Opc == ARM::tADDrSPi) { 00171 unsigned ThisVal = (Bytes > Chunk) ? Chunk : Bytes; 00172 Bytes -= ThisVal; 00173 NumMIs++; 00174 NumBits = 8; 00175 Scale = 1; // Followed by a number of tADDi8. 00176 Chunk = ((1 << NumBits) - 1) * Scale; 00177 } 00178 00179 NumMIs += Bytes / Chunk; 00180 if ((Bytes % Chunk) != 0) 00181 NumMIs++; 00182 if (ExtraOpc) 00183 NumMIs++; 00184 return NumMIs; 00185 } 00186 00187 /// emitThumbRegPlusImmediate - Emits a series of instructions to materialize 00188 /// a destreg = basereg + immediate in Thumb code. 00189 static 00190 void emitThumbRegPlusImmediate(MachineBasicBlock &MBB, 00191 MachineBasicBlock::iterator &MBBI, 00192 unsigned DestReg, unsigned BaseReg, 00193 int NumBytes, const TargetInstrInfo &TII, 00194 const Thumb1RegisterInfo& MRI, 00195 DebugLoc dl) { 00196 bool isSub = NumBytes < 0; 00197 unsigned Bytes = (unsigned)NumBytes; 00198 if (isSub) Bytes = -NumBytes; 00199 bool isMul4 = (Bytes & 3) == 0; 00200 bool isTwoAddr = false; 00201 bool DstNotEqBase = false; 00202 unsigned NumBits = 1; 00203 unsigned Scale = 1; 00204 int Opc = 0; 00205 int ExtraOpc = 0; 00206 bool NeedCC = false; 00207 bool NeedPred = false; 00208 00209 if (DestReg == BaseReg && BaseReg == ARM::SP) { 00210 assert(isMul4 && "Thumb sp inc / dec size must be multiple of 4!"); 00211 NumBits = 7; 00212 Scale = 4; 00213 Opc = isSub ? ARM::tSUBspi : ARM::tADDspi; 00214 isTwoAddr = true; 00215 } else if (!isSub && BaseReg == ARM::SP) { 00216 // r1 = add sp, 403 00217 // => 00218 // r1 = add sp, 100 * 4 00219 // r1 = add r1, 3 00220 if (!isMul4) { 00221 Bytes &= ~3; 00222 ExtraOpc = ARM::tADDi3; 00223 } 00224 NumBits = 8; 00225 Scale = 4; 00226 Opc = ARM::tADDrSPi; 00227 } else { 00228 // sp = sub sp, c 00229 // r1 = sub sp, c 00230 // r8 = sub sp, c 00231 if (DestReg != BaseReg) 00232 DstNotEqBase = true; 00233 NumBits = 8; 00234 if (DestReg == ARM::SP) { 00235 Opc = isSub ? ARM::tSUBspi : ARM::tADDspi; 00236 assert(isMul4 && "Thumb sp inc / dec size must be multiple of 4!"); 00237 NumBits = 7; 00238 Scale = 4; 00239 } else { 00240 Opc = isSub ? ARM::tSUBi8 : ARM::tADDi8; 00241 NumBits = 8; 00242 NeedPred = NeedCC = true; 00243 } 00244 isTwoAddr = true; 00245 } 00246 00247 unsigned NumMIs = calcNumMI(Opc, ExtraOpc, Bytes, NumBits, Scale); 00248 unsigned Threshold = (DestReg == ARM::SP) ? 3 : 2; 00249 if (NumMIs > Threshold) { 00250 // This will expand into too many instructions. Load the immediate from a 00251 // constpool entry. 00252 emitThumbRegPlusImmInReg(MBB, MBBI, DestReg, BaseReg, NumBytes, true, TII, 00253 MRI, dl); 00254 return; 00255 } 00256 00257 if (DstNotEqBase) { 00258 if (isARMLowRegister(DestReg) && isARMLowRegister(BaseReg)) { 00259 // If both are low registers, emit DestReg = add BaseReg, max(Imm, 7) 00260 unsigned Chunk = (1 << 3) - 1; 00261 unsigned ThisVal = (Bytes > Chunk) ? Chunk : Bytes; 00262 Bytes -= ThisVal; 00263 const TargetInstrDesc &TID = TII.get(isSub ? ARM::tSUBi3 : ARM::tADDi3); 00264 const MachineInstrBuilder MIB = 00265 AddDefaultT1CC(BuildMI(MBB, MBBI, dl, TID, DestReg)); 00266 AddDefaultPred(MIB.addReg(BaseReg, RegState::Kill).addImm(ThisVal)); 00267 } else { 00268 BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVr), DestReg) 00269 .addReg(BaseReg, RegState::Kill); 00270 } 00271 BaseReg = DestReg; 00272 } 00273 00274 unsigned Chunk = ((1 << NumBits) - 1) * Scale; 00275 while (Bytes) { 00276 unsigned ThisVal = (Bytes > Chunk) ? Chunk : Bytes; 00277 Bytes -= ThisVal; 00278 ThisVal /= Scale; 00279 // Build the new tADD / tSUB. 00280 if (isTwoAddr) { 00281 MachineInstrBuilder MIB = BuildMI(MBB, MBBI, dl, TII.get(Opc), DestReg); 00282 if (NeedCC) 00283 MIB = AddDefaultT1CC(MIB); 00284 MIB .addReg(DestReg).addImm(ThisVal); 00285 if (NeedPred) 00286 MIB = AddDefaultPred(MIB); 00287 } 00288 else { 00289 bool isKill = BaseReg != ARM::SP; 00290 MachineInstrBuilder MIB = BuildMI(MBB, MBBI, dl, TII.get(Opc), DestReg); 00291 if (NeedCC) 00292 MIB = AddDefaultT1CC(MIB); 00293 MIB.addReg(BaseReg, getKillRegState(isKill)).addImm(ThisVal); 00294 if (NeedPred) 00295 MIB = AddDefaultPred(MIB); 00296 BaseReg = DestReg; 00297 00298 if (Opc == ARM::tADDrSPi) { 00299 // r4 = add sp, imm 00300 // r4 = add r4, imm 00301 // ... 00302 NumBits = 8; 00303 Scale = 1; 00304 Chunk = ((1 << NumBits) - 1) * Scale; 00305 Opc = isSub ? ARM::tSUBi8 : ARM::tADDi8; 00306 NeedPred = NeedCC = isTwoAddr = true; 00307 } 00308 } 00309 } 00310 00311 if (ExtraOpc) { 00312 const TargetInstrDesc &TID = TII.get(ExtraOpc); 00313 AddDefaultPred(AddDefaultT1CC(BuildMI(MBB, MBBI, dl, TID, DestReg)) 00314 .addReg(DestReg, RegState::Kill) 00315 .addImm(((unsigned)NumBytes) & 3)); 00316 } 00317 } 00318 00319 static void emitSPUpdate(MachineBasicBlock &MBB, 00320 MachineBasicBlock::iterator &MBBI, 00321 const TargetInstrInfo &TII, DebugLoc dl, 00322 const Thumb1RegisterInfo &MRI, 00323 int NumBytes) { 00324 emitThumbRegPlusImmediate(MBB, MBBI, ARM::SP, ARM::SP, NumBytes, TII, 00325 MRI, dl); 00326 } 00327 00328 void Thumb1RegisterInfo:: 00329 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, 00330 MachineBasicBlock::iterator I) const { 00331 if (!hasReservedCallFrame(MF)) { 00332 // If we have alloca, convert as follows: 00333 // ADJCALLSTACKDOWN -> sub, sp, sp, amount 00334 // ADJCALLSTACKUP -> add, sp, sp, amount 00335 MachineInstr *Old = I; 00336 DebugLoc dl = Old->getDebugLoc(); 00337 unsigned Amount = Old->getOperand(0).getImm(); 00338 if (Amount != 0) { 00339 // We need to keep the stack aligned properly. To do this, we round the 00340 // amount of space needed for the outgoing arguments up to the next 00341 // alignment boundary. 00342 unsigned Align = MF.getTarget().getFrameInfo()->getStackAlignment(); 00343 Amount = (Amount+Align-1)/Align*Align; 00344 00345 // Replace the pseudo instruction with a new instruction... 00346 unsigned Opc = Old->getOpcode(); 00347 if (Opc == ARM::ADJCALLSTACKDOWN || Opc == ARM::tADJCALLSTACKDOWN) { 00348 emitSPUpdate(MBB, I, TII, dl, *this, -Amount); 00349 } else { 00350 assert(Opc == ARM::ADJCALLSTACKUP || Opc == ARM::tADJCALLSTACKUP); 00351 emitSPUpdate(MBB, I, TII, dl, *this, Amount); 00352 } 00353 } 00354 } 00355 MBB.erase(I); 00356 } 00357 00358 /// emitThumbConstant - Emit a series of instructions to materialize a 00359 /// constant. 00360 static void emitThumbConstant(MachineBasicBlock &MBB, 00361 MachineBasicBlock::iterator &MBBI, 00362 unsigned DestReg, int Imm, 00363 const TargetInstrInfo &TII, 00364 const Thumb1RegisterInfo& MRI, 00365 DebugLoc dl) { 00366 bool isSub = Imm < 0; 00367 if (isSub) Imm = -Imm; 00368 00369 int Chunk = (1 << 8) - 1; 00370 int ThisVal = (Imm > Chunk) ? Chunk : Imm; 00371 Imm -= ThisVal; 00372 AddDefaultPred(AddDefaultT1CC(BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVi8), 00373 DestReg)) 00374 .addImm(ThisVal)); 00375 if (Imm > 0) 00376 emitThumbRegPlusImmediate(MBB, MBBI, DestReg, DestReg, Imm, TII, MRI, dl); 00377 if (isSub) { 00378 const TargetInstrDesc &TID = TII.get(ARM::tRSB); 00379 AddDefaultPred(AddDefaultT1CC(BuildMI(MBB, MBBI, dl, TID, DestReg)) 00380 .addReg(DestReg, RegState::Kill)); 00381 } 00382 } 00383 00384 static void removeOperands(MachineInstr &MI, unsigned i) { 00385 unsigned Op = i; 00386 for (unsigned e = MI.getNumOperands(); i != e; ++i) 00387 MI.RemoveOperand(Op); 00388 } 00389 00390 int Thumb1RegisterInfo:: 00391 rewriteFrameIndex(MachineInstr &MI, unsigned FrameRegIdx, 00392 unsigned FrameReg, int Offset, 00393 unsigned MOVOpc, unsigned ADDriOpc, unsigned SUBriOpc) const 00394 { 00395 // if/when eliminateFrameIndex() conforms with ARMBaseRegisterInfo 00396 // version then can pull out Thumb1 specific parts here 00397 return 0; 00398 } 00399 00400 void Thumb1RegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II, 00401 int SPAdj, RegScavenger *RS) const{ 00402 unsigned i = 0; 00403 MachineInstr &MI = *II; 00404 MachineBasicBlock &MBB = *MI.getParent(); 00405 MachineFunction &MF = *MBB.getParent(); 00406 ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>(); 00407 DebugLoc dl = MI.getDebugLoc(); 00408 00409 while (!MI.getOperand(i).isFI()) { 00410 ++i; 00411 assert(i < MI.getNumOperands() && "Instr doesn't have FrameIndex operand!"); 00412 } 00413 00414 unsigned FrameReg = ARM::SP; 00415 int FrameIndex = MI.getOperand(i).getIndex(); 00416 int Offset = MF.getFrameInfo()->getObjectOffset(FrameIndex) + 00417 MF.getFrameInfo()->getStackSize() + SPAdj; 00418 00419 if (AFI->isGPRCalleeSavedArea1Frame(FrameIndex)) 00420 Offset -= AFI->getGPRCalleeSavedArea1Offset(); 00421 else if (AFI->isGPRCalleeSavedArea2Frame(FrameIndex)) 00422 Offset -= AFI->getGPRCalleeSavedArea2Offset(); 00423 else if (hasFP(MF)) { 00424 assert(SPAdj == 0 && "Unexpected"); 00425 // There is alloca()'s in this function, must reference off the frame 00426 // pointer instead. 00427 FrameReg = getFrameRegister(MF); 00428 Offset -= AFI->getFramePtrSpillOffset(); 00429 } 00430 00431 unsigned Opcode = MI.getOpcode(); 00432 const TargetInstrDesc &Desc = MI.getDesc(); 00433 unsigned AddrMode = (Desc.TSFlags & ARMII::AddrModeMask); 00434 00435 if (Opcode == ARM::tADDrSPi) { 00436 Offset += MI.getOperand(i+1).getImm(); 00437 00438 // Can't use tADDrSPi if it's based off the frame pointer. 00439 unsigned NumBits = 0; 00440 unsigned Scale = 1; 00441 if (FrameReg != ARM::SP) { 00442 Opcode = ARM::tADDi3; 00443 MI.setDesc(TII.get(Opcode)); 00444 NumBits = 3; 00445 } else { 00446 NumBits = 8; 00447 Scale = 4; 00448 assert((Offset & 3) == 0 && 00449 "Thumb add/sub sp, #imm immediate must be multiple of 4!"); 00450 } 00451 00452 if (Offset == 0) { 00453 // Turn it into a move. 00454 MI.setDesc(TII.get(ARM::tMOVgpr2tgpr)); 00455 MI.getOperand(i).ChangeToRegister(FrameReg, false); 00456 MI.RemoveOperand(i+1); 00457 return; 00458 } 00459 00460 // Common case: small offset, fits into instruction. 00461 unsigned Mask = (1 << NumBits) - 1; 00462 if (((Offset / Scale) & ~Mask) == 0) { 00463 // Replace the FrameIndex with sp / fp 00464 if (Opcode == ARM::tADDi3) { 00465 removeOperands(MI, i); 00466 MachineInstrBuilder MIB(&MI); 00467 AddDefaultPred(AddDefaultT1CC(MIB).addReg(FrameReg) 00468 .addImm(Offset / Scale)); 00469 } else { 00470 MI.getOperand(i).ChangeToRegister(FrameReg, false); 00471 MI.getOperand(i+1).ChangeToImmediate(Offset / Scale); 00472 } 00473 return; 00474 } 00475 00476 unsigned DestReg = MI.getOperand(0).getReg(); 00477 unsigned Bytes = (Offset > 0) ? Offset : -Offset; 00478 unsigned NumMIs = calcNumMI(Opcode, 0, Bytes, NumBits, Scale); 00479 // MI would expand into a large number of instructions. Don't try to 00480 // simplify the immediate. 00481 if (NumMIs > 2) { 00482 emitThumbRegPlusImmediate(MBB, II, DestReg, FrameReg, Offset, TII, 00483 *this, dl); 00484 MBB.erase(II); 00485 return; 00486 } 00487 00488 if (Offset > 0) { 00489 // Translate r0 = add sp, imm to 00490 // r0 = add sp, 255*4 00491 // r0 = add r0, (imm - 255*4) 00492 if (Opcode == ARM::tADDi3) { 00493 removeOperands(MI, i); 00494 MachineInstrBuilder MIB(&MI); 00495 AddDefaultPred(AddDefaultT1CC(MIB).addReg(FrameReg).addImm(Mask)); 00496 } else { 00497 MI.getOperand(i).ChangeToRegister(FrameReg, false); 00498 MI.getOperand(i+1).ChangeToImmediate(Mask); 00499 } 00500 Offset = (Offset - Mask * Scale); 00501 MachineBasicBlock::iterator NII = next(II); 00502 emitThumbRegPlusImmediate(MBB, NII, DestReg, DestReg, Offset, TII, 00503 *this, dl); 00504 } else { 00505 // Translate r0 = add sp, -imm to 00506 // r0 = -imm (this is then translated into a series of instructons) 00507 // r0 = add r0, sp 00508 emitThumbConstant(MBB, II, DestReg, Offset, TII, *this, dl); 00509 00510 MI.setDesc(TII.get(ARM::tADDhirr)); 00511 MI.getOperand(i).ChangeToRegister(DestReg, false, false, true); 00512 MI.getOperand(i+1).ChangeToRegister(FrameReg, false); 00513 if (Opcode == ARM::tADDi3) { 00514 MachineInstrBuilder MIB(&MI); 00515 AddDefaultPred(MIB); 00516 } 00517 } 00518 return; 00519 } else { 00520 unsigned ImmIdx = 0; 00521 int InstrOffs = 0; 00522 unsigned NumBits = 0; 00523 unsigned Scale = 1; 00524 switch (AddrMode) { 00525 case ARMII::AddrModeT1_s: { 00526 ImmIdx = i+1; 00527 InstrOffs = MI.getOperand(ImmIdx).getImm(); 00528 NumBits = (FrameReg == ARM::SP) ? 8 : 5; 00529 Scale = 4; 00530 break; 00531 } 00532 default: 00533 llvm_unreachable("Unsupported addressing mode!"); 00534 break; 00535 } 00536 00537 Offset += InstrOffs * Scale; 00538 assert((Offset & (Scale-1)) == 0 && "Can't encode this offset!"); 00539 00540 // Common case: small offset, fits into instruction. 00541 MachineOperand &ImmOp = MI.getOperand(ImmIdx); 00542 int ImmedOffset = Offset / Scale; 00543 unsigned Mask = (1 << NumBits) - 1; 00544 if ((unsigned)Offset <= Mask * Scale) { 00545 // Replace the FrameIndex with sp 00546 MI.getOperand(i).ChangeToRegister(FrameReg, false); 00547 ImmOp.ChangeToImmediate(ImmedOffset); 00548 return; 00549 } 00550 00551 bool isThumSpillRestore = Opcode == ARM::tRestore || Opcode == ARM::tSpill; 00552 if (AddrMode == ARMII::AddrModeT1_s) { 00553 // Thumb tLDRspi, tSTRspi. These will change to instructions that use 00554 // a different base register. 00555 NumBits = 5; 00556 Mask = (1 << NumBits) - 1; 00557 } 00558 // If this is a thumb spill / restore, we will be using a constpool load to 00559 // materialize the offset. 00560 if (AddrMode == ARMII::AddrModeT1_s && isThumSpillRestore) 00561 ImmOp.ChangeToImmediate(0); 00562 else { 00563 // Otherwise, it didn't fit. Pull in what we can to simplify the immed. 00564 ImmedOffset = ImmedOffset & Mask; 00565 ImmOp.ChangeToImmediate(ImmedOffset); 00566 Offset &= ~(Mask*Scale); 00567 } 00568 } 00569 00570 // If we get here, the immediate doesn't fit into the instruction. We folded 00571 // as much as possible above, handle the rest, providing a register that is 00572 // SP+LargeImm. 00573 assert(Offset && "This code isn't needed if offset already handled!"); 00574 00575 // Remove predicate first. 00576 int PIdx = MI.findFirstPredOperandIdx(); 00577 if (PIdx != -1) 00578 removeOperands(MI, PIdx); 00579 00580 if (Desc.mayLoad()) { 00581 // Use the destination register to materialize sp + offset. 00582 unsigned TmpReg = MI.getOperand(0).getReg(); 00583 bool UseRR = false; 00584 if (Opcode == ARM::tRestore) { 00585 if (FrameReg == ARM::SP) 00586 emitThumbRegPlusImmInReg(MBB, II, TmpReg, FrameReg, 00587 Offset, false, TII, *this, dl); 00588 else { 00589 emitLoadConstPool(MBB, II, dl, TmpReg, 0, Offset); 00590 UseRR = true; 00591 } 00592 } else { 00593 emitThumbRegPlusImmediate(MBB, II, TmpReg, FrameReg, Offset, TII, 00594 *this, dl); 00595 } 00596 00597 MI.setDesc(TII.get(ARM::tLDR)); 00598 MI.getOperand(i).ChangeToRegister(TmpReg, false, false, true); 00599 if (UseRR) 00600 // Use [reg, reg] addrmode. 00601 MI.addOperand(MachineOperand::CreateReg(FrameReg, false)); 00602 else // tLDR has an extra register operand. 00603 MI.addOperand(MachineOperand::CreateReg(0, false)); 00604 } else if (Desc.mayStore()) { 00605 // FIXME! This is horrific!!! We need register scavenging. 00606 // Our temporary workaround has marked r3 unavailable. Of course, r3 is 00607 // also a ABI register so it's possible that is is the register that is 00608 // being storing here. If that's the case, we do the following: 00609 // r12 = r2 00610 // Use r2 to materialize sp + offset 00611 // str r3, r2 00612 // r2 = r12 00613 unsigned ValReg = MI.getOperand(0).getReg(); 00614 unsigned TmpReg = ARM::R3; 00615 bool UseRR = false; 00616 if (ValReg == ARM::R3) { 00617 BuildMI(MBB, II, dl, TII.get(ARM::tMOVtgpr2gpr), ARM::R12) 00618 .addReg(ARM::R2, RegState::Kill); 00619 TmpReg = ARM::R2; 00620 } 00621 if (TmpReg == ARM::R3 && AFI->isR3LiveIn()) 00622 BuildMI(MBB, II, dl, TII.get(ARM::tMOVtgpr2gpr), ARM::R12) 00623 .addReg(ARM::R3, RegState::Kill); 00624 if (Opcode == ARM::tSpill) { 00625 if (FrameReg == ARM::SP) 00626 emitThumbRegPlusImmInReg(MBB, II, TmpReg, FrameReg, 00627 Offset, false, TII, *this, dl); 00628 else { 00629 emitLoadConstPool(MBB, II, dl, TmpReg, 0, Offset); 00630 UseRR = true; 00631 } 00632 } else 00633 emitThumbRegPlusImmediate(MBB, II, TmpReg, FrameReg, Offset, TII, 00634 *this, dl); 00635 MI.setDesc(TII.get(ARM::tSTR)); 00636 MI.getOperand(i).ChangeToRegister(TmpReg, false, false, true); 00637 if (UseRR) // Use [reg, reg] addrmode. 00638 MI.addOperand(MachineOperand::CreateReg(FrameReg, false)); 00639 else // tSTR has an extra register operand. 00640 MI.addOperand(MachineOperand::CreateReg(0, false)); 00641 00642 MachineBasicBlock::iterator NII = next(II); 00643 if (ValReg == ARM::R3) 00644 BuildMI(MBB, NII, dl, TII.get(ARM::tMOVgpr2tgpr), ARM::R2) 00645 .addReg(ARM::R12, RegState::Kill); 00646 if (TmpReg == ARM::R3 && AFI->isR3LiveIn()) 00647 BuildMI(MBB, NII, dl, TII.get(ARM::tMOVgpr2tgpr), ARM::R3) 00648 .addReg(ARM::R12, RegState::Kill); 00649 } else 00650 assert(false && "Unexpected opcode!"); 00651 00652 // Add predicate back if it's needed. 00653 if (MI.getDesc().isPredicable()) { 00654 MachineInstrBuilder MIB(&MI); 00655 AddDefaultPred(MIB); 00656 } 00657 } 00658 00659 void Thumb1RegisterInfo::emitPrologue(MachineFunction &MF) const { 00660 MachineBasicBlock &MBB = MF.front(); 00661 MachineBasicBlock::iterator MBBI = MBB.begin(); 00662 MachineFrameInfo *MFI = MF.getFrameInfo(); 00663 ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>(); 00664 unsigned VARegSaveSize = AFI->getVarArgsRegSaveSize(); 00665 unsigned NumBytes = MFI->getStackSize(); 00666 const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo(); 00667 DebugLoc dl = (MBBI != MBB.end() ? 00668 MBBI->getDebugLoc() : DebugLoc::getUnknownLoc()); 00669 00670 // Check if R3 is live in. It might have to be used as a scratch register. 00671 for (MachineRegisterInfo::livein_iterator I =MF.getRegInfo().livein_begin(), 00672 E = MF.getRegInfo().livein_end(); I != E; ++I) { 00673 if (I->first == ARM::R3) { 00674 AFI->setR3IsLiveIn(true); 00675 break; 00676 } 00677 } 00678 00679 // Thumb add/sub sp, imm8 instructions implicitly multiply the offset by 4. 00680 NumBytes = (NumBytes + 3) & ~3; 00681 MFI->setStackSize(NumBytes); 00682 00683 // Determine the sizes of each callee-save spill areas and record which frame 00684 // belongs to which callee-save spill areas. 00685 unsigned GPRCS1Size = 0, GPRCS2Size = 0, DPRCSSize = 0; 00686 int FramePtrSpillFI = 0; 00687 00688 if (VARegSaveSize) 00689 emitSPUpdate(MBB, MBBI, TII, dl, *this, -VARegSaveSize); 00690 00691 if (!AFI->hasStackFrame()) { 00692 if (NumBytes != 0) 00693 emitSPUpdate(MBB, MBBI, TII, dl, *this, -NumBytes); 00694 return; 00695 } 00696 00697 for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 00698 unsigned Reg = CSI[i].getReg(); 00699 int FI = CSI[i].getFrameIdx(); 00700 switch (Reg) { 00701 case ARM::R4: 00702 case ARM::R5: 00703 case ARM::R6: 00704 case ARM::R7: 00705 case ARM::LR: 00706 if (Reg == FramePtr) 00707 FramePtrSpillFI = FI; 00708 AFI->addGPRCalleeSavedArea1Frame(FI); 00709 GPRCS1Size += 4; 00710 break; 00711 case ARM::R8: 00712 case ARM::R9: 00713 case ARM::R10: 00714 case ARM::R11: 00715 if (Reg == FramePtr) 00716 FramePtrSpillFI = FI; 00717 if (STI.isTargetDarwin()) { 00718 AFI->addGPRCalleeSavedArea2Frame(FI); 00719 GPRCS2Size += 4; 00720 } else { 00721 AFI->addGPRCalleeSavedArea1Frame(FI); 00722 GPRCS1Size += 4; 00723 } 00724 break; 00725 default: 00726 AFI->addDPRCalleeSavedAreaFrame(FI); 00727 DPRCSSize += 8; 00728 } 00729 } 00730 00731 if (MBBI != MBB.end() && MBBI->getOpcode() == ARM::tPUSH) { 00732 ++MBBI; 00733 if (MBBI != MBB.end()) 00734 dl = MBBI->getDebugLoc(); 00735 } 00736 00737 // Darwin ABI requires FP to point to the stack slot that contains the 00738 // previous FP. 00739 if (STI.isTargetDarwin() || hasFP(MF)) { 00740 MachineInstrBuilder MIB = 00741 BuildMI(MBB, MBBI, dl, TII.get(ARM::tADDrSPi), FramePtr) 00742 .addFrameIndex(FramePtrSpillFI).addImm(0); 00743 } 00744 00745 // Determine starting offsets of spill areas. 00746 unsigned DPRCSOffset = NumBytes - (GPRCS1Size + GPRCS2Size + DPRCSSize); 00747 unsigned GPRCS2Offset = DPRCSOffset + DPRCSSize; 00748 unsigned GPRCS1Offset = GPRCS2Offset + GPRCS2Size; 00749 AFI->setFramePtrSpillOffset(MFI->getObjectOffset(FramePtrSpillFI) + NumBytes); 00750 AFI->setGPRCalleeSavedArea1Offset(GPRCS1Offset); 00751 AFI->setGPRCalleeSavedArea2Offset(GPRCS2Offset); 00752 AFI->setDPRCalleeSavedAreaOffset(DPRCSOffset); 00753 00754 NumBytes = DPRCSOffset; 00755 if (NumBytes) { 00756 // Insert it after all the callee-save spills. 00757 emitSPUpdate(MBB, MBBI, TII, dl, *this, -NumBytes); 00758 } 00759 00760 if (STI.isTargetELF() && hasFP(MF)) { 00761 MFI->setOffsetAdjustment(MFI->getOffsetAdjustment() - 00762 AFI->getFramePtrSpillOffset()); 00763 } 00764 00765 AFI->setGPRCalleeSavedArea1Size(GPRCS1Size); 00766 AFI->setGPRCalleeSavedArea2Size(GPRCS2Size); 00767 AFI->setDPRCalleeSavedAreaSize(DPRCSSize); 00768 } 00769 00770 static bool isCalleeSavedRegister(unsigned Reg, const unsigned *CSRegs) { 00771 for (unsigned i = 0; CSRegs[i]; ++i) 00772 if (Reg == CSRegs[i]) 00773 return true; 00774 return false; 00775 } 00776 00777 static bool isCSRestore(MachineInstr *MI, const unsigned *CSRegs) { 00778 return (MI->getOpcode() == ARM::tRestore && 00779 MI->getOperand(1).isFI() && 00780 isCalleeSavedRegister(MI->getOperand(0).getReg(), CSRegs)); 00781 } 00782 00783 void Thumb1RegisterInfo::emitEpilogue(MachineFunction &MF, 00784 MachineBasicBlock &MBB) const { 00785 MachineBasicBlock::iterator MBBI = prior(MBB.end()); 00786 assert((MBBI->getOpcode() == ARM::tBX_RET || 00787 MBBI->getOpcode() == ARM::tPOP_RET) && 00788 "Can only insert epilog into returning blocks"); 00789 DebugLoc dl = MBBI->getDebugLoc(); 00790 MachineFrameInfo *MFI = MF.getFrameInfo(); 00791 ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>(); 00792 unsigned VARegSaveSize = AFI->getVarArgsRegSaveSize(); 00793 int NumBytes = (int)MFI->getStackSize(); 00794 00795 if (!AFI->hasStackFrame()) { 00796 if (NumBytes != 0) 00797 emitSPUpdate(MBB, MBBI, TII, dl, *this, NumBytes); 00798 } else { 00799 // Unwind MBBI to point to first LDR / FLDD. 00800 const unsigned *CSRegs = getCalleeSavedRegs(); 00801 if (MBBI != MBB.begin()) { 00802 do 00803 --MBBI; 00804 while (MBBI != MBB.begin() && isCSRestore(MBBI, CSRegs)); 00805 if (!isCSRestore(MBBI, CSRegs)) 00806 ++MBBI; 00807 } 00808 00809 // Move SP to start of FP callee save spill area. 00810 NumBytes -= (AFI->getGPRCalleeSavedArea1Size() + 00811 AFI->getGPRCalleeSavedArea2Size() + 00812 AFI->getDPRCalleeSavedAreaSize()); 00813 00814 if (hasFP(MF)) { 00815 NumBytes = AFI->getFramePtrSpillOffset() - NumBytes; 00816 // Reset SP based on frame pointer only if the stack frame extends beyond 00817 // frame pointer stack slot or target is ELF and the function has FP. 00818 if (NumBytes) 00819 emitThumbRegPlusImmediate(MBB, MBBI, ARM::SP, FramePtr, -NumBytes, 00820 TII, *this, dl); 00821 else 00822 BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVtgpr2gpr), ARM::SP) 00823 .addReg(FramePtr); 00824 } else { 00825 if (MBBI->getOpcode() == ARM::tBX_RET && 00826 &MBB.front() != MBBI && 00827 prior(MBBI)->getOpcode() == ARM::tPOP) { 00828 MachineBasicBlock::iterator PMBBI = prior(MBBI); 00829 emitSPUpdate(MBB, PMBBI, TII, dl, *this, NumBytes); 00830 } else 00831 emitSPUpdate(MBB, MBBI, TII, dl, *this, NumBytes); 00832 } 00833 } 00834 00835 if (VARegSaveSize) { 00836 // Epilogue for vararg functions: pop LR to R3 and branch off it. 00837 // FIXME: Verify this is still ok when R3 is no longer being reserved. 00838 AddDefaultPred(BuildMI(MBB, MBBI, dl, TII.get(ARM::tPOP))).addReg(ARM::R3); 00839 00840 emitSPUpdate(MBB, MBBI, TII, dl, *this, VARegSaveSize); 00841 00842 BuildMI(MBB, MBBI, dl, TII.get(ARM::tBX_RET_vararg)).addReg(ARM::R3); 00843 MBB.erase(MBBI); 00844 } 00845 }