LLVM API Documentation

Thumb1RegisterInfo.cpp

Go to the documentation of this file.
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 }