LLVM API Documentation
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 }