LLVM API Documentation

Thumb2InstrInfo.cpp

Go to the documentation of this file.
00001 //===- Thumb2InstrInfo.cpp - Thumb-2 Instruction 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-2 implementation of the TargetInstrInfo class.
00011 //
00012 //===----------------------------------------------------------------------===//
00013 
00014 #include "ARMInstrInfo.h"
00015 #include "ARM.h"
00016 #include "ARMAddressingModes.h"
00017 #include "ARMGenInstrInfo.inc"
00018 #include "ARMMachineFunctionInfo.h"
00019 #include "llvm/CodeGen/MachineFrameInfo.h"
00020 #include "llvm/CodeGen/MachineInstrBuilder.h"
00021 #include "llvm/ADT/SmallVector.h"
00022 #include "Thumb2InstrInfo.h"
00023 
00024 using namespace llvm;
00025 
00026 Thumb2InstrInfo::Thumb2InstrInfo(const ARMSubtarget &STI) : RI(*this, STI) {
00027 }
00028 
00029 unsigned Thumb2InstrInfo::getUnindexedOpcode(unsigned Opc) const {
00030   // FIXME
00031   return 0;
00032 }
00033 
00034 bool
00035 Thumb2InstrInfo::BlockHasNoFallThrough(const MachineBasicBlock &MBB) const {
00036   if (MBB.empty()) return false;
00037 
00038   switch (MBB.back().getOpcode()) {
00039   case ARM::t2LDM_RET:
00040   case ARM::t2B:        // Uncond branch.
00041   case ARM::t2BR_JT:    // Jumptable branch.
00042   case ARM::t2TBB:      // Table branch byte.
00043   case ARM::t2TBH:      // Table branch halfword.
00044   case ARM::tBR_JTr:    // Jumptable branch (16-bit version).
00045   case ARM::tBX_RET:
00046   case ARM::tBX_RET_vararg:
00047   case ARM::tPOP_RET:
00048   case ARM::tB:
00049     return true;
00050   default:
00051     break;
00052   }
00053 
00054   return false;
00055 }
00056 
00057 bool
00058 Thumb2InstrInfo::copyRegToReg(MachineBasicBlock &MBB,
00059                               MachineBasicBlock::iterator I,
00060                               unsigned DestReg, unsigned SrcReg,
00061                               const TargetRegisterClass *DestRC,
00062                               const TargetRegisterClass *SrcRC) const {
00063   DebugLoc DL = DebugLoc::getUnknownLoc();
00064   if (I != MBB.end()) DL = I->getDebugLoc();
00065 
00066   if (DestRC == ARM::GPRRegisterClass &&
00067       SrcRC == ARM::GPRRegisterClass) {
00068     BuildMI(MBB, I, DL, get(ARM::tMOVgpr2gpr), DestReg).addReg(SrcReg);
00069     return true;
00070   } else if (DestRC == ARM::GPRRegisterClass &&
00071              SrcRC == ARM::tGPRRegisterClass) {
00072     BuildMI(MBB, I, DL, get(ARM::tMOVtgpr2gpr), DestReg).addReg(SrcReg);
00073     return true;
00074   } else if (DestRC == ARM::tGPRRegisterClass &&
00075              SrcRC == ARM::GPRRegisterClass) {
00076     BuildMI(MBB, I, DL, get(ARM::tMOVgpr2tgpr), DestReg).addReg(SrcReg);
00077     return true;
00078   }
00079 
00080   // Handle SPR, DPR, and QPR copies.
00081   return ARMBaseInstrInfo::copyRegToReg(MBB, I, DestReg, SrcReg, DestRC, SrcRC);
00082 }
00083 
00084 void Thumb2InstrInfo::
00085 storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
00086                     unsigned SrcReg, bool isKill, int FI,
00087                     const TargetRegisterClass *RC) const {
00088   DebugLoc DL = DebugLoc::getUnknownLoc();
00089   if (I != MBB.end()) DL = I->getDebugLoc();
00090 
00091   if (RC == ARM::GPRRegisterClass) {
00092     AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::t2STRi12))
00093                    .addReg(SrcReg, getKillRegState(isKill))
00094                    .addFrameIndex(FI).addImm(0));
00095     return;
00096   }
00097 
00098   ARMBaseInstrInfo::storeRegToStackSlot(MBB, I, SrcReg, isKill, FI, RC);
00099 }
00100 
00101 void Thumb2InstrInfo::
00102 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I,
00103                      unsigned DestReg, int FI,
00104                      const TargetRegisterClass *RC) const {
00105   DebugLoc DL = DebugLoc::getUnknownLoc();
00106   if (I != MBB.end()) DL = I->getDebugLoc();
00107 
00108   if (RC == ARM::GPRRegisterClass) {
00109     AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::t2LDRi12), DestReg)
00110                    .addFrameIndex(FI).addImm(0));
00111     return;
00112   }
00113 
00114   ARMBaseInstrInfo::loadRegFromStackSlot(MBB, I, DestReg, FI, RC);
00115 }
00116 
00117 
00118 void llvm::emitT2RegPlusImmediate(MachineBasicBlock &MBB,
00119                                MachineBasicBlock::iterator &MBBI, DebugLoc dl,
00120                                unsigned DestReg, unsigned BaseReg, int NumBytes,
00121                                ARMCC::CondCodes Pred, unsigned PredReg,
00122                                const ARMBaseInstrInfo &TII) {
00123   bool isSub = NumBytes < 0;
00124   if (isSub) NumBytes = -NumBytes;
00125 
00126   // If profitable, use a movw or movt to materialize the offset.
00127   // FIXME: Use the scavenger to grab a scratch register.
00128   if (DestReg != ARM::SP && DestReg != BaseReg &&
00129       NumBytes >= 4096 &&
00130       ARM_AM::getT2SOImmVal(NumBytes) == -1) {
00131     bool Fits = false;
00132     if (NumBytes < 65536) {
00133       // Use a movw to materialize the 16-bit constant.
00134       BuildMI(MBB, MBBI, dl, TII.get(ARM::t2MOVi16), DestReg)
00135         .addImm(NumBytes)
00136         .addImm((unsigned)Pred).addReg(PredReg).addReg(0);
00137       Fits = true;
00138     } else if ((NumBytes & 0xffff) == 0) {
00139       // Use a movt to materialize the 32-bit constant.
00140       BuildMI(MBB, MBBI, dl, TII.get(ARM::t2MOVTi16), DestReg)
00141         .addReg(DestReg)
00142         .addImm(NumBytes >> 16)
00143         .addImm((unsigned)Pred).addReg(PredReg).addReg(0);
00144       Fits = true;
00145     }
00146 
00147     if (Fits) {
00148       if (isSub) {
00149         BuildMI(MBB, MBBI, dl, TII.get(ARM::t2SUBrr), DestReg)
00150           .addReg(BaseReg, RegState::Kill)
00151           .addReg(DestReg, RegState::Kill)
00152           .addImm((unsigned)Pred).addReg(PredReg).addReg(0);
00153       } else {
00154         BuildMI(MBB, MBBI, dl, TII.get(ARM::t2ADDrr), DestReg)
00155           .addReg(DestReg, RegState::Kill)
00156           .addReg(BaseReg, RegState::Kill)
00157         .addImm((unsigned)Pred).addReg(PredReg).addReg(0);
00158       }
00159       return;
00160     }
00161   }
00162 
00163   while (NumBytes) {
00164     unsigned ThisVal = NumBytes;
00165     unsigned Opc = 0;
00166     if (DestReg == ARM::SP && BaseReg != ARM::SP) {
00167       // mov sp, rn. Note t2MOVr cannot be used.
00168       BuildMI(MBB, MBBI, dl, TII.get(ARM::tMOVgpr2gpr),DestReg).addReg(BaseReg);
00169       BaseReg = ARM::SP;
00170       continue;
00171     }
00172 
00173     if (BaseReg == ARM::SP) {
00174       // sub sp, sp, #imm7
00175       if (DestReg == ARM::SP && (ThisVal < ((1 << 7)-1) * 4)) {
00176         assert((ThisVal & 3) == 0 && "Stack update is not multiple of 4?");
00177         Opc = isSub ? ARM::tSUBspi : ARM::tADDspi;
00178         // FIXME: Fix Thumb1 immediate encoding.
00179         BuildMI(MBB, MBBI, dl, TII.get(Opc), DestReg)
00180           .addReg(BaseReg).addImm(ThisVal/4);
00181         NumBytes = 0;
00182         continue;
00183       }
00184 
00185       // sub rd, sp, so_imm
00186       Opc = isSub ? ARM::t2SUBrSPi : ARM::t2ADDrSPi;
00187       if (ARM_AM::getT2SOImmVal(NumBytes) != -1) {
00188         NumBytes = 0;
00189       } else {
00190         // FIXME: Move this to ARMAddressingModes.h?
00191         unsigned RotAmt = CountLeadingZeros_32(ThisVal);
00192         ThisVal = ThisVal & ARM_AM::rotr32(0xff000000U, RotAmt);
00193         NumBytes &= ~ThisVal;
00194         assert(ARM_AM::getT2SOImmVal(ThisVal) != -1 &&
00195                "Bit extraction didn't work?");
00196       }
00197     } else {
00198       assert(DestReg != ARM::SP && BaseReg != ARM::SP);
00199       Opc = isSub ? ARM::t2SUBri : ARM::t2ADDri;
00200       if (ARM_AM::getT2SOImmVal(NumBytes) != -1) {
00201         NumBytes = 0;
00202       } else if (ThisVal < 4096) {
00203         Opc = isSub ? ARM::t2SUBri12 : ARM::t2ADDri12;
00204         NumBytes = 0;
00205       } else {
00206         // FIXME: Move this to ARMAddressingModes.h?
00207         unsigned RotAmt = CountLeadingZeros_32(ThisVal);
00208         ThisVal = ThisVal & ARM_AM::rotr32(0xff000000U, RotAmt);
00209         NumBytes &= ~ThisVal;
00210         assert(ARM_AM::getT2SOImmVal(ThisVal) != -1 &&
00211                "Bit extraction didn't work?");
00212       }
00213     }
00214 
00215     // Build the new ADD / SUB.
00216     AddDefaultCC(AddDefaultPred(BuildMI(MBB, MBBI, dl, TII.get(Opc), DestReg)
00217                                 .addReg(BaseReg, RegState::Kill)
00218                                 .addImm(ThisVal)));
00219 
00220     BaseReg = DestReg;
00221   }
00222 }
00223 
00224 static unsigned
00225 negativeOffsetOpcode(unsigned opcode)
00226 {
00227   switch (opcode) {
00228   case ARM::t2LDRi12:   return ARM::t2LDRi8;
00229   case ARM::t2LDRHi12:  return ARM::t2LDRHi8;
00230   case ARM::t2LDRBi12:  return ARM::t2LDRBi8;
00231   case ARM::t2LDRSHi12: return ARM::t2LDRSHi8;
00232   case ARM::t2LDRSBi12: return ARM::t2LDRSBi8;
00233   case ARM::t2STRi12:   return ARM::t2STRi8;
00234   case ARM::t2STRBi12:  return ARM::t2STRBi8;
00235   case ARM::t2STRHi12:  return ARM::t2STRHi8;
00236 
00237   case ARM::t2LDRi8:
00238   case ARM::t2LDRHi8:
00239   case ARM::t2LDRBi8:
00240   case ARM::t2LDRSHi8:
00241   case ARM::t2LDRSBi8:
00242   case ARM::t2STRi8:
00243   case ARM::t2STRBi8:
00244   case ARM::t2STRHi8:
00245     return opcode;
00246 
00247   default:
00248     break;
00249   }
00250 
00251   return 0;
00252 }
00253 
00254 static unsigned
00255 positiveOffsetOpcode(unsigned opcode)
00256 {
00257   switch (opcode) {
00258   case ARM::t2LDRi8:   return ARM::t2LDRi12;
00259   case ARM::t2LDRHi8:  return ARM::t2LDRHi12;
00260   case ARM::t2LDRBi8:  return ARM::t2LDRBi12;
00261   case ARM::t2LDRSHi8: return ARM::t2LDRSHi12;
00262   case ARM::t2LDRSBi8: return ARM::t2LDRSBi12;
00263   case ARM::t2STRi8:   return ARM::t2STRi12;
00264   case ARM::t2STRBi8:  return ARM::t2STRBi12;
00265   case ARM::t2STRHi8:  return ARM::t2STRHi12;
00266 
00267   case ARM::t2LDRi12:
00268   case ARM::t2LDRHi12:
00269   case ARM::t2LDRBi12:
00270   case ARM::t2LDRSHi12:
00271   case ARM::t2LDRSBi12:
00272   case ARM::t2STRi12:
00273   case ARM::t2STRBi12:
00274   case ARM::t2STRHi12:
00275     return opcode;
00276 
00277   default:
00278     break;
00279   }
00280 
00281   return 0;
00282 }
00283 
00284 static unsigned
00285 immediateOffsetOpcode(unsigned opcode)
00286 {
00287   switch (opcode) {
00288   case ARM::t2LDRs:   return ARM::t2LDRi12;
00289   case ARM::t2LDRHs:  return ARM::t2LDRHi12;
00290   case ARM::t2LDRBs:  return ARM::t2LDRBi12;
00291   case ARM::t2LDRSHs: return ARM::t2LDRSHi12;
00292   case ARM::t2LDRSBs: return ARM::t2LDRSBi12;
00293   case ARM::t2STRs:   return ARM::t2STRi12;
00294   case ARM::t2STRBs:  return ARM::t2STRBi12;
00295   case ARM::t2STRHs:  return ARM::t2STRHi12;
00296 
00297   case ARM::t2LDRi12:
00298   case ARM::t2LDRHi12:
00299   case ARM::t2LDRBi12:
00300   case ARM::t2LDRSHi12:
00301   case ARM::t2LDRSBi12:
00302   case ARM::t2STRi12:
00303   case ARM::t2STRBi12:
00304   case ARM::t2STRHi12:
00305   case ARM::t2LDRi8:
00306   case ARM::t2LDRHi8:
00307   case ARM::t2LDRBi8:
00308   case ARM::t2LDRSHi8:
00309   case ARM::t2LDRSBi8:
00310   case ARM::t2STRi8:
00311   case ARM::t2STRBi8:
00312   case ARM::t2STRHi8:
00313     return opcode;
00314 
00315   default:
00316     break;
00317   }
00318 
00319   return 0;
00320 }
00321 
00322 int llvm::rewriteT2FrameIndex(MachineInstr &MI, unsigned FrameRegIdx,
00323                               unsigned FrameReg, int Offset,
00324                               const ARMBaseInstrInfo &TII) {
00325   unsigned Opcode = MI.getOpcode();
00326   const TargetInstrDesc &Desc = MI.getDesc();
00327   unsigned AddrMode = (Desc.TSFlags & ARMII::AddrModeMask);
00328   bool isSub = false;
00329 
00330   // Memory operands in inline assembly always use AddrModeT2_i12.
00331   if (Opcode == ARM::INLINEASM)
00332     AddrMode = ARMII::AddrModeT2_i12; // FIXME. mode for thumb2?
00333 
00334   if (Opcode == ARM::t2ADDri || Opcode == ARM::t2ADDri12) {
00335     Offset += MI.getOperand(FrameRegIdx+1).getImm();
00336 
00337     bool isSP = FrameReg == ARM::SP;
00338     if (Offset == 0) {
00339       // Turn it into a move.
00340       MI.setDesc(TII.get(ARM::tMOVgpr2gpr));
00341       MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
00342       MI.RemoveOperand(FrameRegIdx+1);
00343       return 0;
00344     }
00345 
00346     if (Offset < 0) {
00347       Offset = -Offset;
00348       isSub = true;
00349       MI.setDesc(TII.get(isSP ? ARM::t2SUBrSPi : ARM::t2SUBri));
00350     } else {
00351       MI.setDesc(TII.get(isSP ? ARM::t2ADDrSPi : ARM::t2ADDri));
00352     }
00353 
00354     // Common case: small offset, fits into instruction.
00355     if (ARM_AM::getT2SOImmVal(Offset) != -1) {
00356       MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
00357       MI.getOperand(FrameRegIdx+1).ChangeToImmediate(Offset);
00358       return 0;
00359     }
00360     // Another common case: imm12.
00361     if (Offset < 4096) {
00362       unsigned NewOpc = isSP
00363         ? (isSub ? ARM::t2SUBrSPi12 : ARM::t2ADDrSPi12)
00364         : (isSub ? ARM::t2SUBri12   : ARM::t2ADDri12);
00365       MI.setDesc(TII.get(NewOpc));
00366       MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
00367       MI.getOperand(FrameRegIdx+1).ChangeToImmediate(Offset);
00368       return 0;
00369     }
00370 
00371     // Otherwise, extract 8 adjacent bits from the immediate into this
00372     // t2ADDri/t2SUBri.
00373     unsigned RotAmt = CountLeadingZeros_32(Offset);
00374     unsigned ThisImmVal = Offset & ARM_AM::rotr32(0xff000000U, RotAmt);
00375 
00376     // We will handle these bits from offset, clear them.
00377     Offset &= ~ThisImmVal;
00378 
00379     assert(ARM_AM::getT2SOImmVal(ThisImmVal) != -1 &&
00380            "Bit extraction didn't work?");
00381     MI.getOperand(FrameRegIdx+1).ChangeToImmediate(ThisImmVal);
00382   } else {
00383     // AddrModeT2_so cannot handle any offset. If there is no offset
00384     // register then we change to an immediate version.
00385     unsigned NewOpc = Opcode;
00386     if (AddrMode == ARMII::AddrModeT2_so) {
00387       unsigned OffsetReg = MI.getOperand(FrameRegIdx+1).getReg();
00388       if (OffsetReg != 0) {
00389         MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
00390         return Offset;
00391       }
00392 
00393       MI.RemoveOperand(FrameRegIdx+1);
00394       MI.getOperand(FrameRegIdx+1).ChangeToImmediate(0);
00395       NewOpc = immediateOffsetOpcode(Opcode);
00396       AddrMode = ARMII::AddrModeT2_i12;
00397     }
00398 
00399     unsigned NumBits = 0;
00400     unsigned Scale = 1;
00401     if (AddrMode == ARMII::AddrModeT2_i8 || AddrMode == ARMII::AddrModeT2_i12) {
00402       // i8 supports only negative, and i12 supports only positive, so
00403       // based on Offset sign convert Opcode to the appropriate
00404       // instruction
00405       Offset += MI.getOperand(FrameRegIdx+1).getImm();
00406       if (Offset < 0) {
00407         NewOpc = negativeOffsetOpcode(Opcode);
00408         NumBits = 8;
00409         isSub = true;
00410         Offset = -Offset;
00411       } else {
00412         NewOpc = positiveOffsetOpcode(Opcode);
00413         NumBits = 12;
00414       }
00415     } else {
00416       // VFP address modes.
00417       assert(AddrMode == ARMII::AddrMode5);
00418       int InstrOffs=ARM_AM::getAM5Offset(MI.getOperand(FrameRegIdx+1).getImm());
00419       if (ARM_AM::getAM5Op(MI.getOperand(FrameRegIdx+1).getImm()) ==ARM_AM::sub)
00420         InstrOffs *= -1;
00421       NumBits = 8;
00422       Scale = 4;
00423       Offset += InstrOffs * 4;
00424       assert((Offset & (Scale-1)) == 0 && "Can't encode this offset!");
00425       if (Offset < 0) {
00426         Offset = -Offset;
00427         isSub = true;
00428       }
00429     }
00430 
00431     if (NewOpc != Opcode)
00432       MI.setDesc(TII.get(NewOpc));
00433 
00434     MachineOperand &ImmOp = MI.getOperand(FrameRegIdx+1);
00435 
00436     // Attempt to fold address computation
00437     // Common case: small offset, fits into instruction.
00438     int ImmedOffset = Offset / Scale;
00439     unsigned Mask = (1 << NumBits) - 1;
00440     if ((unsigned)Offset <= Mask * Scale) {
00441       // Replace the FrameIndex with fp/sp
00442       MI.getOperand(FrameRegIdx).ChangeToRegister(FrameReg, false);
00443       if (isSub) {
00444         if (AddrMode == ARMII::AddrMode5)
00445           // FIXME: Not consistent.
00446           ImmedOffset |= 1 << NumBits;
00447         else
00448           ImmedOffset = -ImmedOffset;
00449       }
00450       ImmOp.ChangeToImmediate(ImmedOffset);
00451       return 0;
00452     }
00453 
00454     // Otherwise, offset doesn't fit. Pull in what we can to simplify
00455     ImmedOffset = ImmedOffset & Mask;
00456     if (isSub) {
00457       if (AddrMode == ARMII::AddrMode5)
00458         // FIXME: Not consistent.
00459         ImmedOffset |= 1 << NumBits;
00460       else {
00461         ImmedOffset = -ImmedOffset;
00462         if (ImmedOffset == 0)
00463           // Change the opcode back if the encoded offset is zero.
00464           MI.setDesc(TII.get(positiveOffsetOpcode(NewOpc)));
00465       }
00466     }
00467     ImmOp.ChangeToImmediate(ImmedOffset);
00468     Offset &= ~(Mask*Scale);
00469   }
00470 
00471   return (isSub) ? -Offset : Offset;
00472 }