LLVM API Documentation
00001 //===- Thumb1InstrInfo.cpp - Thumb-1 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-1 implementation of the TargetInstrInfo class. 00011 // 00012 //===----------------------------------------------------------------------===// 00013 00014 #include "ARMInstrInfo.h" 00015 #include "ARM.h" 00016 #include "ARMGenInstrInfo.inc" 00017 #include "ARMMachineFunctionInfo.h" 00018 #include "llvm/CodeGen/MachineFrameInfo.h" 00019 #include "llvm/CodeGen/MachineInstrBuilder.h" 00020 #include "llvm/ADT/SmallVector.h" 00021 #include "Thumb1InstrInfo.h" 00022 00023 using namespace llvm; 00024 00025 Thumb1InstrInfo::Thumb1InstrInfo(const ARMSubtarget &STI) : RI(*this, STI) { 00026 } 00027 00028 unsigned Thumb1InstrInfo::getUnindexedOpcode(unsigned Opc) const { 00029 return 0; 00030 } 00031 00032 bool 00033 Thumb1InstrInfo::BlockHasNoFallThrough(const MachineBasicBlock &MBB) const { 00034 if (MBB.empty()) return false; 00035 00036 switch (MBB.back().getOpcode()) { 00037 case ARM::tBX_RET: 00038 case ARM::tBX_RET_vararg: 00039 case ARM::tPOP_RET: 00040 case ARM::tB: 00041 case ARM::tBR_JTr: 00042 return true; 00043 default: 00044 break; 00045 } 00046 00047 return false; 00048 } 00049 00050 bool Thumb1InstrInfo::copyRegToReg(MachineBasicBlock &MBB, 00051 MachineBasicBlock::iterator I, 00052 unsigned DestReg, unsigned SrcReg, 00053 const TargetRegisterClass *DestRC, 00054 const TargetRegisterClass *SrcRC) const { 00055 DebugLoc DL = DebugLoc::getUnknownLoc(); 00056 if (I != MBB.end()) DL = I->getDebugLoc(); 00057 00058 if (DestRC == ARM::GPRRegisterClass) { 00059 if (SrcRC == ARM::GPRRegisterClass) { 00060 BuildMI(MBB, I, DL, get(ARM::tMOVgpr2gpr), DestReg).addReg(SrcReg); 00061 return true; 00062 } else if (SrcRC == ARM::tGPRRegisterClass) { 00063 BuildMI(MBB, I, DL, get(ARM::tMOVtgpr2gpr), DestReg).addReg(SrcReg); 00064 return true; 00065 } 00066 } else if (DestRC == ARM::tGPRRegisterClass) { 00067 if (SrcRC == ARM::GPRRegisterClass) { 00068 BuildMI(MBB, I, DL, get(ARM::tMOVgpr2tgpr), DestReg).addReg(SrcReg); 00069 return true; 00070 } else if (SrcRC == ARM::tGPRRegisterClass) { 00071 BuildMI(MBB, I, DL, get(ARM::tMOVr), DestReg).addReg(SrcReg); 00072 return true; 00073 } 00074 } 00075 00076 return false; 00077 } 00078 00079 bool Thumb1InstrInfo:: 00080 canFoldMemoryOperand(const MachineInstr *MI, 00081 const SmallVectorImpl<unsigned> &Ops) const { 00082 if (Ops.size() != 1) return false; 00083 00084 unsigned OpNum = Ops[0]; 00085 unsigned Opc = MI->getOpcode(); 00086 switch (Opc) { 00087 default: break; 00088 case ARM::tMOVr: 00089 case ARM::tMOVtgpr2gpr: 00090 case ARM::tMOVgpr2tgpr: 00091 case ARM::tMOVgpr2gpr: { 00092 if (OpNum == 0) { // move -> store 00093 unsigned SrcReg = MI->getOperand(1).getReg(); 00094 if (TargetRegisterInfo::isPhysicalRegister(SrcReg) && 00095 !isARMLowRegister(SrcReg)) 00096 // tSpill cannot take a high register operand. 00097 return false; 00098 } else { // move -> load 00099 unsigned DstReg = MI->getOperand(0).getReg(); 00100 if (TargetRegisterInfo::isPhysicalRegister(DstReg) && 00101 !isARMLowRegister(DstReg)) 00102 // tRestore cannot target a high register operand. 00103 return false; 00104 } 00105 return true; 00106 } 00107 } 00108 00109 return false; 00110 } 00111 00112 void Thumb1InstrInfo:: 00113 storeRegToStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I, 00114 unsigned SrcReg, bool isKill, int FI, 00115 const TargetRegisterClass *RC) const { 00116 DebugLoc DL = DebugLoc::getUnknownLoc(); 00117 if (I != MBB.end()) DL = I->getDebugLoc(); 00118 00119 assert((RC == ARM::tGPRRegisterClass || 00120 (TargetRegisterInfo::isPhysicalRegister(SrcReg) && 00121 isARMLowRegister(SrcReg))) && "Unknown regclass!"); 00122 00123 if (RC == ARM::tGPRRegisterClass) { 00124 AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::tSpill)) 00125 .addReg(SrcReg, getKillRegState(isKill)) 00126 .addFrameIndex(FI).addImm(0)); 00127 } 00128 } 00129 00130 void Thumb1InstrInfo:: 00131 loadRegFromStackSlot(MachineBasicBlock &MBB, MachineBasicBlock::iterator I, 00132 unsigned DestReg, int FI, 00133 const TargetRegisterClass *RC) const { 00134 DebugLoc DL = DebugLoc::getUnknownLoc(); 00135 if (I != MBB.end()) DL = I->getDebugLoc(); 00136 00137 assert((RC == ARM::tGPRRegisterClass || 00138 (TargetRegisterInfo::isPhysicalRegister(DestReg) && 00139 isARMLowRegister(DestReg))) && "Unknown regclass!"); 00140 00141 if (RC == ARM::tGPRRegisterClass) { 00142 AddDefaultPred(BuildMI(MBB, I, DL, get(ARM::tRestore), DestReg) 00143 .addFrameIndex(FI).addImm(0)); 00144 } 00145 } 00146 00147 bool Thumb1InstrInfo:: 00148 spillCalleeSavedRegisters(MachineBasicBlock &MBB, 00149 MachineBasicBlock::iterator MI, 00150 const std::vector<CalleeSavedInfo> &CSI) const { 00151 if (CSI.empty()) 00152 return false; 00153 00154 DebugLoc DL = DebugLoc::getUnknownLoc(); 00155 if (MI != MBB.end()) DL = MI->getDebugLoc(); 00156 00157 MachineInstrBuilder MIB = BuildMI(MBB, MI, DL, get(ARM::tPUSH)); 00158 AddDefaultPred(MIB); 00159 for (unsigned i = CSI.size(); i != 0; --i) { 00160 unsigned Reg = CSI[i-1].getReg(); 00161 // Add the callee-saved register as live-in. It's killed at the spill. 00162 MBB.addLiveIn(Reg); 00163 MIB.addReg(Reg, RegState::Kill); 00164 } 00165 return true; 00166 } 00167 00168 bool Thumb1InstrInfo:: 00169 restoreCalleeSavedRegisters(MachineBasicBlock &MBB, 00170 MachineBasicBlock::iterator MI, 00171 const std::vector<CalleeSavedInfo> &CSI) const { 00172 MachineFunction &MF = *MBB.getParent(); 00173 ARMFunctionInfo *AFI = MF.getInfo<ARMFunctionInfo>(); 00174 if (CSI.empty()) 00175 return false; 00176 00177 bool isVarArg = AFI->getVarArgsRegSaveSize() > 0; 00178 DebugLoc DL = MI->getDebugLoc(); 00179 MachineInstrBuilder MIB = BuildMI(MF, DL, get(ARM::tPOP)); 00180 AddDefaultPred(MIB); 00181 00182 bool NumRegs = 0; 00183 for (unsigned i = CSI.size(); i != 0; --i) { 00184 unsigned Reg = CSI[i-1].getReg(); 00185 if (Reg == ARM::LR) { 00186 // Special epilogue for vararg functions. See emitEpilogue 00187 if (isVarArg) 00188 continue; 00189 Reg = ARM::PC; 00190 (*MIB).setDesc(get(ARM::tPOP_RET)); 00191 MI = MBB.erase(MI); 00192 } 00193 MIB.addReg(Reg, getDefRegState(true)); 00194 ++NumRegs; 00195 } 00196 00197 // It's illegal to emit pop instruction without operands. 00198 if (NumRegs) 00199 MBB.insert(MI, &*MIB); 00200 00201 return true; 00202 } 00203 00204 MachineInstr *Thumb1InstrInfo:: 00205 foldMemoryOperandImpl(MachineFunction &MF, MachineInstr *MI, 00206 const SmallVectorImpl<unsigned> &Ops, int FI) const { 00207 if (Ops.size() != 1) return NULL; 00208 00209 unsigned OpNum = Ops[0]; 00210 unsigned Opc = MI->getOpcode(); 00211 MachineInstr *NewMI = NULL; 00212 switch (Opc) { 00213 default: break; 00214 case ARM::tMOVr: 00215 case ARM::tMOVtgpr2gpr: 00216 case ARM::tMOVgpr2tgpr: 00217 case ARM::tMOVgpr2gpr: { 00218 if (OpNum == 0) { // move -> store 00219 unsigned SrcReg = MI->getOperand(1).getReg(); 00220 bool isKill = MI->getOperand(1).isKill(); 00221 if (TargetRegisterInfo::isPhysicalRegister(SrcReg) && 00222 !isARMLowRegister(SrcReg)) 00223 // tSpill cannot take a high register operand. 00224 break; 00225 NewMI = AddDefaultPred(BuildMI(MF, MI->getDebugLoc(), get(ARM::tSpill)) 00226 .addReg(SrcReg, getKillRegState(isKill)) 00227 .addFrameIndex(FI).addImm(0)); 00228 } else { // move -> load 00229 unsigned DstReg = MI->getOperand(0).getReg(); 00230 if (TargetRegisterInfo::isPhysicalRegister(DstReg) && 00231 !isARMLowRegister(DstReg)) 00232 // tRestore cannot target a high register operand. 00233 break; 00234 bool isDead = MI->getOperand(0).isDead(); 00235 NewMI = AddDefaultPred(BuildMI(MF, MI->getDebugLoc(), get(ARM::tRestore)) 00236 .addReg(DstReg, 00237 RegState::Define | getDeadRegState(isDead)) 00238 .addFrameIndex(FI).addImm(0)); 00239 } 00240 break; 00241 } 00242 } 00243 00244 return NewMI; 00245 }