LLVM API Documentation
00001 //===- SPURegisterInfo.cpp - Cell SPU Register Information ----------------===// 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 Cell implementation of the TargetRegisterInfo class. 00011 // 00012 //===----------------------------------------------------------------------===// 00013 00014 #define DEBUG_TYPE "reginfo" 00015 #include "SPU.h" 00016 #include "SPURegisterInfo.h" 00017 #include "SPURegisterNames.h" 00018 #include "SPUInstrBuilder.h" 00019 #include "SPUSubtarget.h" 00020 #include "SPUMachineFunction.h" 00021 #include "SPUFrameInfo.h" 00022 #include "llvm/Constants.h" 00023 #include "llvm/Type.h" 00024 #include "llvm/CodeGen/ValueTypes.h" 00025 #include "llvm/CodeGen/MachineInstrBuilder.h" 00026 #include "llvm/CodeGen/MachineModuleInfo.h" 00027 #include "llvm/CodeGen/MachineFunction.h" 00028 #include "llvm/CodeGen/MachineFrameInfo.h" 00029 #include "llvm/CodeGen/MachineLocation.h" 00030 #include "llvm/CodeGen/MachineRegisterInfo.h" 00031 #include "llvm/CodeGen/ValueTypes.h" 00032 #include "llvm/Target/TargetFrameInfo.h" 00033 #include "llvm/Target/TargetInstrInfo.h" 00034 #include "llvm/Target/TargetMachine.h" 00035 #include "llvm/Target/TargetOptions.h" 00036 #include "llvm/Support/CommandLine.h" 00037 #include "llvm/Support/Debug.h" 00038 #include "llvm/Support/ErrorHandling.h" 00039 #include "llvm/Support/MathExtras.h" 00040 #include "llvm/Support/raw_ostream.h" 00041 #include "llvm/ADT/BitVector.h" 00042 #include "llvm/ADT/STLExtras.h" 00043 #include <cstdlib> 00044 00045 using namespace llvm; 00046 00047 /// getRegisterNumbering - Given the enum value for some register, e.g. 00048 /// PPC::F14, return the number that it corresponds to (e.g. 14). 00049 unsigned SPURegisterInfo::getRegisterNumbering(unsigned RegEnum) { 00050 using namespace SPU; 00051 switch (RegEnum) { 00052 case SPU::R0: return 0; 00053 case SPU::R1: return 1; 00054 case SPU::R2: return 2; 00055 case SPU::R3: return 3; 00056 case SPU::R4: return 4; 00057 case SPU::R5: return 5; 00058 case SPU::R6: return 6; 00059 case SPU::R7: return 7; 00060 case SPU::R8: return 8; 00061 case SPU::R9: return 9; 00062 case SPU::R10: return 10; 00063 case SPU::R11: return 11; 00064 case SPU::R12: return 12; 00065 case SPU::R13: return 13; 00066 case SPU::R14: return 14; 00067 case SPU::R15: return 15; 00068 case SPU::R16: return 16; 00069 case SPU::R17: return 17; 00070 case SPU::R18: return 18; 00071 case SPU::R19: return 19; 00072 case SPU::R20: return 20; 00073 case SPU::R21: return 21; 00074 case SPU::R22: return 22; 00075 case SPU::R23: return 23; 00076 case SPU::R24: return 24; 00077 case SPU::R25: return 25; 00078 case SPU::R26: return 26; 00079 case SPU::R27: return 27; 00080 case SPU::R28: return 28; 00081 case SPU::R29: return 29; 00082 case SPU::R30: return 30; 00083 case SPU::R31: return 31; 00084 case SPU::R32: return 32; 00085 case SPU::R33: return 33; 00086 case SPU::R34: return 34; 00087 case SPU::R35: return 35; 00088 case SPU::R36: return 36; 00089 case SPU::R37: return 37; 00090 case SPU::R38: return 38; 00091 case SPU::R39: return 39; 00092 case SPU::R40: return 40; 00093 case SPU::R41: return 41; 00094 case SPU::R42: return 42; 00095 case SPU::R43: return 43; 00096 case SPU::R44: return 44; 00097 case SPU::R45: return 45; 00098 case SPU::R46: return 46; 00099 case SPU::R47: return 47; 00100 case SPU::R48: return 48; 00101 case SPU::R49: return 49; 00102 case SPU::R50: return 50; 00103 case SPU::R51: return 51; 00104 case SPU::R52: return 52; 00105 case SPU::R53: return 53; 00106 case SPU::R54: return 54; 00107 case SPU::R55: return 55; 00108 case SPU::R56: return 56; 00109 case SPU::R57: return 57; 00110 case SPU::R58: return 58; 00111 case SPU::R59: return 59; 00112 case SPU::R60: return 60; 00113 case SPU::R61: return 61; 00114 case SPU::R62: return 62; 00115 case SPU::R63: return 63; 00116 case SPU::R64: return 64; 00117 case SPU::R65: return 65; 00118 case SPU::R66: return 66; 00119 case SPU::R67: return 67; 00120 case SPU::R68: return 68; 00121 case SPU::R69: return 69; 00122 case SPU::R70: return 70; 00123 case SPU::R71: return 71; 00124 case SPU::R72: return 72; 00125 case SPU::R73: return 73; 00126 case SPU::R74: return 74; 00127 case SPU::R75: return 75; 00128 case SPU::R76: return 76; 00129 case SPU::R77: return 77; 00130 case SPU::R78: return 78; 00131 case SPU::R79: return 79; 00132 case SPU::R80: return 80; 00133 case SPU::R81: return 81; 00134 case SPU::R82: return 82; 00135 case SPU::R83: return 83; 00136 case SPU::R84: return 84; 00137 case SPU::R85: return 85; 00138 case SPU::R86: return 86; 00139 case SPU::R87: return 87; 00140 case SPU::R88: return 88; 00141 case SPU::R89: return 89; 00142 case SPU::R90: return 90; 00143 case SPU::R91: return 91; 00144 case SPU::R92: return 92; 00145 case SPU::R93: return 93; 00146 case SPU::R94: return 94; 00147 case SPU::R95: return 95; 00148 case SPU::R96: return 96; 00149 case SPU::R97: return 97; 00150 case SPU::R98: return 98; 00151 case SPU::R99: return 99; 00152 case SPU::R100: return 100; 00153 case SPU::R101: return 101; 00154 case SPU::R102: return 102; 00155 case SPU::R103: return 103; 00156 case SPU::R104: return 104; 00157 case SPU::R105: return 105; 00158 case SPU::R106: return 106; 00159 case SPU::R107: return 107; 00160 case SPU::R108: return 108; 00161 case SPU::R109: return 109; 00162 case SPU::R110: return 110; 00163 case SPU::R111: return 111; 00164 case SPU::R112: return 112; 00165 case SPU::R113: return 113; 00166 case SPU::R114: return 114; 00167 case SPU::R115: return 115; 00168 case SPU::R116: return 116; 00169 case SPU::R117: return 117; 00170 case SPU::R118: return 118; 00171 case SPU::R119: return 119; 00172 case SPU::R120: return 120; 00173 case SPU::R121: return 121; 00174 case SPU::R122: return 122; 00175 case SPU::R123: return 123; 00176 case SPU::R124: return 124; 00177 case SPU::R125: return 125; 00178 case SPU::R126: return 126; 00179 case SPU::R127: return 127; 00180 default: 00181 llvm_report_error("Unhandled reg in SPURegisterInfo::getRegisterNumbering"); 00182 } 00183 } 00184 00185 SPURegisterInfo::SPURegisterInfo(const SPUSubtarget &subtarget, 00186 const TargetInstrInfo &tii) : 00187 SPUGenRegisterInfo(SPU::ADJCALLSTACKDOWN, SPU::ADJCALLSTACKUP), 00188 Subtarget(subtarget), 00189 TII(tii) 00190 { 00191 } 00192 00193 // SPU's 128-bit registers used for argument passing: 00194 static const unsigned SPU_ArgRegs[] = { 00195 SPU::R3, SPU::R4, SPU::R5, SPU::R6, SPU::R7, SPU::R8, SPU::R9, 00196 SPU::R10, SPU::R11, SPU::R12, SPU::R13, SPU::R14, SPU::R15, SPU::R16, 00197 SPU::R17, SPU::R18, SPU::R19, SPU::R20, SPU::R21, SPU::R22, SPU::R23, 00198 SPU::R24, SPU::R25, SPU::R26, SPU::R27, SPU::R28, SPU::R29, SPU::R30, 00199 SPU::R31, SPU::R32, SPU::R33, SPU::R34, SPU::R35, SPU::R36, SPU::R37, 00200 SPU::R38, SPU::R39, SPU::R40, SPU::R41, SPU::R42, SPU::R43, SPU::R44, 00201 SPU::R45, SPU::R46, SPU::R47, SPU::R48, SPU::R49, SPU::R50, SPU::R51, 00202 SPU::R52, SPU::R53, SPU::R54, SPU::R55, SPU::R56, SPU::R57, SPU::R58, 00203 SPU::R59, SPU::R60, SPU::R61, SPU::R62, SPU::R63, SPU::R64, SPU::R65, 00204 SPU::R66, SPU::R67, SPU::R68, SPU::R69, SPU::R70, SPU::R71, SPU::R72, 00205 SPU::R73, SPU::R74, SPU::R75, SPU::R76, SPU::R77, SPU::R78, SPU::R79 00206 }; 00207 00208 const unsigned * 00209 SPURegisterInfo::getArgRegs() 00210 { 00211 return SPU_ArgRegs; 00212 } 00213 00214 unsigned 00215 SPURegisterInfo::getNumArgRegs() 00216 { 00217 return sizeof(SPU_ArgRegs) / sizeof(SPU_ArgRegs[0]); 00218 } 00219 00220 /// getPointerRegClass - Return the register class to use to hold pointers. 00221 /// This is used for addressing modes. 00222 const TargetRegisterClass * 00223 SPURegisterInfo::getPointerRegClass(unsigned Kind) const { 00224 return &SPU::R32CRegClass; 00225 } 00226 00227 const unsigned * 00228 SPURegisterInfo::getCalleeSavedRegs(const MachineFunction *MF) const 00229 { 00230 // Cell ABI calling convention 00231 static const unsigned SPU_CalleeSaveRegs[] = { 00232 SPU::R80, SPU::R81, SPU::R82, SPU::R83, 00233 SPU::R84, SPU::R85, SPU::R86, SPU::R87, 00234 SPU::R88, SPU::R89, SPU::R90, SPU::R91, 00235 SPU::R92, SPU::R93, SPU::R94, SPU::R95, 00236 SPU::R96, SPU::R97, SPU::R98, SPU::R99, 00237 SPU::R100, SPU::R101, SPU::R102, SPU::R103, 00238 SPU::R104, SPU::R105, SPU::R106, SPU::R107, 00239 SPU::R108, SPU::R109, SPU::R110, SPU::R111, 00240 SPU::R112, SPU::R113, SPU::R114, SPU::R115, 00241 SPU::R116, SPU::R117, SPU::R118, SPU::R119, 00242 SPU::R120, SPU::R121, SPU::R122, SPU::R123, 00243 SPU::R124, SPU::R125, SPU::R126, SPU::R127, 00244 SPU::R2, /* environment pointer */ 00245 SPU::R1, /* stack pointer */ 00246 SPU::R0, /* link register */ 00247 0 /* end */ 00248 }; 00249 00250 return SPU_CalleeSaveRegs; 00251 } 00252 00253 const TargetRegisterClass* const* 00254 SPURegisterInfo::getCalleeSavedRegClasses(const MachineFunction *MF) const 00255 { 00256 // Cell ABI Calling Convention 00257 static const TargetRegisterClass * const SPU_CalleeSaveRegClasses[] = { 00258 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00259 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00260 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00261 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00262 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00263 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00264 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00265 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00266 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00267 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00268 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00269 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00270 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00271 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00272 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00273 &SPU::GPRCRegClass, &SPU::GPRCRegClass, &SPU::GPRCRegClass, 00274 &SPU::GPRCRegClass, /* environment pointer */ 00275 &SPU::GPRCRegClass, /* stack pointer */ 00276 &SPU::GPRCRegClass, /* link register */ 00277 0 /* end */ 00278 }; 00279 00280 return SPU_CalleeSaveRegClasses; 00281 } 00282 00283 /*! 00284 R0 (link register), R1 (stack pointer) and R2 (environment pointer -- this is 00285 generally unused) are the Cell's reserved registers 00286 */ 00287 BitVector SPURegisterInfo::getReservedRegs(const MachineFunction &MF) const { 00288 BitVector Reserved(getNumRegs()); 00289 Reserved.set(SPU::R0); // LR 00290 Reserved.set(SPU::R1); // SP 00291 Reserved.set(SPU::R2); // environment pointer 00292 return Reserved; 00293 } 00294 00295 //===----------------------------------------------------------------------===// 00296 // Stack Frame Processing methods 00297 //===----------------------------------------------------------------------===// 00298 00299 // needsFP - Return true if the specified function should have a dedicated frame 00300 // pointer register. This is true if the function has variable sized allocas or 00301 // if frame pointer elimination is disabled. 00302 // 00303 static bool needsFP(const MachineFunction &MF) { 00304 const MachineFrameInfo *MFI = MF.getFrameInfo(); 00305 return NoFramePointerElim || MFI->hasVarSizedObjects(); 00306 } 00307 00308 //-------------------------------------------------------------------------- 00309 // hasFP - Return true if the specified function actually has a dedicated frame 00310 // pointer register. This is true if the function needs a frame pointer and has 00311 // a non-zero stack size. 00312 bool 00313 SPURegisterInfo::hasFP(const MachineFunction &MF) const { 00314 const MachineFrameInfo *MFI = MF.getFrameInfo(); 00315 return MFI->getStackSize() && needsFP(MF); 00316 } 00317 00318 //-------------------------------------------------------------------------- 00319 void 00320 SPURegisterInfo::eliminateCallFramePseudoInstr(MachineFunction &MF, 00321 MachineBasicBlock &MBB, 00322 MachineBasicBlock::iterator I) 00323 const 00324 { 00325 // Simply discard ADJCALLSTACKDOWN, ADJCALLSTACKUP instructions. 00326 MBB.erase(I); 00327 } 00328 00329 void 00330 SPURegisterInfo::eliminateFrameIndex(MachineBasicBlock::iterator II, int SPAdj, 00331 RegScavenger *RS) const 00332 { 00333 unsigned i = 0; 00334 MachineInstr &MI = *II; 00335 MachineBasicBlock &MBB = *MI.getParent(); 00336 MachineFunction &MF = *MBB.getParent(); 00337 MachineFrameInfo *MFI = MF.getFrameInfo(); 00338 00339 while (!MI.getOperand(i).isFI()) { 00340 ++i; 00341 assert(i < MI.getNumOperands() && "Instr doesn't have FrameIndex operand!"); 00342 } 00343 00344 MachineOperand &SPOp = MI.getOperand(i); 00345 int FrameIndex = SPOp.getIndex(); 00346 00347 // Now add the frame object offset to the offset from r1. 00348 int Offset = MFI->getObjectOffset(FrameIndex); 00349 00350 // Most instructions, except for generated FrameIndex additions using AIr32 00351 // and ILAr32, have the immediate in operand 1. AIr32 and ILAr32 have the 00352 // immediate in operand 2. 00353 unsigned OpNo = 1; 00354 if (MI.getOpcode() == SPU::AIr32 || MI.getOpcode() == SPU::ILAr32) 00355 OpNo = 2; 00356 00357 MachineOperand &MO = MI.getOperand(OpNo); 00358 00359 // Offset is biased by $lr's slot at the bottom. 00360 Offset += MO.getImm() + MFI->getStackSize() + SPUFrameInfo::minStackSize(); 00361 assert((Offset & 0xf) == 0 00362 && "16-byte alignment violated in eliminateFrameIndex"); 00363 00364 // Replace the FrameIndex with base register with $sp (aka $r1) 00365 SPOp.ChangeToRegister(SPU::R1, false); 00366 if (Offset > SPUFrameInfo::maxFrameOffset() 00367 || Offset < SPUFrameInfo::minFrameOffset()) { 00368 cerr << "Large stack adjustment (" 00369 << Offset 00370 << ") in SPURegisterInfo::eliminateFrameIndex."; 00371 } else { 00372 MO.ChangeToImmediate(Offset); 00373 } 00374 } 00375 00376 /// determineFrameLayout - Determine the size of the frame and maximum call 00377 /// frame size. 00378 void 00379 SPURegisterInfo::determineFrameLayout(MachineFunction &MF) const 00380 { 00381 MachineFrameInfo *MFI = MF.getFrameInfo(); 00382 00383 // Get the number of bytes to allocate from the FrameInfo 00384 unsigned FrameSize = MFI->getStackSize(); 00385 00386 // Get the alignments provided by the target, and the maximum alignment 00387 // (if any) of the fixed frame objects. 00388 unsigned TargetAlign = MF.getTarget().getFrameInfo()->getStackAlignment(); 00389 unsigned Align = std::max(TargetAlign, MFI->getMaxAlignment()); 00390 assert(isPowerOf2_32(Align) && "Alignment is not power of 2"); 00391 unsigned AlignMask = Align - 1; 00392 00393 // Get the maximum call frame size of all the calls. 00394 unsigned maxCallFrameSize = MFI->getMaxCallFrameSize(); 00395 00396 // If we have dynamic alloca then maxCallFrameSize needs to be aligned so 00397 // that allocations will be aligned. 00398 if (MFI->hasVarSizedObjects()) 00399 maxCallFrameSize = (maxCallFrameSize + AlignMask) & ~AlignMask; 00400 00401 // Update maximum call frame size. 00402 MFI->setMaxCallFrameSize(maxCallFrameSize); 00403 00404 // Include call frame size in total. 00405 FrameSize += maxCallFrameSize; 00406 00407 // Make sure the frame is aligned. 00408 FrameSize = (FrameSize + AlignMask) & ~AlignMask; 00409 00410 // Update frame info. 00411 MFI->setStackSize(FrameSize); 00412 } 00413 00414 void SPURegisterInfo::processFunctionBeforeCalleeSavedScan(MachineFunction &MF, 00415 RegScavenger *RS) 00416 const { 00417 // Mark LR and SP unused, since the prolog spills them to stack and 00418 // we don't want anyone else to spill them for us. 00419 // 00420 // Also, unless R2 is really used someday, don't spill it automatically. 00421 MF.getRegInfo().setPhysRegUnused(SPU::R0); 00422 MF.getRegInfo().setPhysRegUnused(SPU::R1); 00423 MF.getRegInfo().setPhysRegUnused(SPU::R2); 00424 } 00425 00426 void SPURegisterInfo::emitPrologue(MachineFunction &MF) const 00427 { 00428 MachineBasicBlock &MBB = MF.front(); // Prolog goes in entry BB 00429 MachineBasicBlock::iterator MBBI = MBB.begin(); 00430 MachineFrameInfo *MFI = MF.getFrameInfo(); 00431 MachineModuleInfo *MMI = MFI->getMachineModuleInfo(); 00432 DebugLoc dl = (MBBI != MBB.end() ? 00433 MBBI->getDebugLoc() : DebugLoc::getUnknownLoc()); 00434 00435 // Prepare for debug frame info. 00436 bool hasDebugInfo = MMI && MMI->hasDebugInfo(); 00437 unsigned FrameLabelId = 0; 00438 00439 // Move MBBI back to the beginning of the function. 00440 MBBI = MBB.begin(); 00441 00442 // Work out frame sizes. 00443 determineFrameLayout(MF); 00444 int FrameSize = MFI->getStackSize(); 00445 00446 assert((FrameSize & 0xf) == 0 00447 && "SPURegisterInfo::emitPrologue: FrameSize not aligned"); 00448 00449 if (FrameSize > 0 || MFI->hasCalls()) { 00450 FrameSize = -(FrameSize + SPUFrameInfo::minStackSize()); 00451 if (hasDebugInfo) { 00452 // Mark effective beginning of when frame pointer becomes valid. 00453 FrameLabelId = MMI->NextLabelID(); 00454 BuildMI(MBB, MBBI, dl, TII.get(SPU::DBG_LABEL)).addImm(FrameLabelId); 00455 } 00456 00457 // Adjust stack pointer, spilling $lr -> 16($sp) and $sp -> -FrameSize($sp) 00458 // for the ABI 00459 BuildMI(MBB, MBBI, dl, TII.get(SPU::STQDr32), SPU::R0).addImm(16) 00460 .addReg(SPU::R1); 00461 if (isS10Constant(FrameSize)) { 00462 // Spill $sp to adjusted $sp 00463 BuildMI(MBB, MBBI, dl, TII.get(SPU::STQDr32), SPU::R1).addImm(FrameSize) 00464 .addReg(SPU::R1); 00465 // Adjust $sp by required amout 00466 BuildMI(MBB, MBBI, dl, TII.get(SPU::AIr32), SPU::R1).addReg(SPU::R1) 00467 .addImm(FrameSize); 00468 } else if (FrameSize <= (1 << 16) - 1 && FrameSize >= -(1 << 16)) { 00469 // Frame size can be loaded into ILr32n, so temporarily spill $r2 and use 00470 // $r2 to adjust $sp: 00471 BuildMI(MBB, MBBI, dl, TII.get(SPU::STQDr128), SPU::R2) 00472 .addImm(-16) 00473 .addReg(SPU::R1); 00474 BuildMI(MBB, MBBI, dl, TII.get(SPU::ILr32), SPU::R2) 00475 .addImm(FrameSize); 00476 BuildMI(MBB, MBBI, dl, TII.get(SPU::STQDr32), SPU::R1) 00477 .addReg(SPU::R2) 00478 .addReg(SPU::R1); 00479 BuildMI(MBB, MBBI, dl, TII.get(SPU::Ar32), SPU::R1) 00480 .addReg(SPU::R1) 00481 .addReg(SPU::R2); 00482 BuildMI(MBB, MBBI, dl, TII.get(SPU::SFIr32), SPU::R2) 00483 .addReg(SPU::R2) 00484 .addImm(16); 00485 BuildMI(MBB, MBBI, dl, TII.get(SPU::LQXr128), SPU::R2) 00486 .addReg(SPU::R2) 00487 .addReg(SPU::R1); 00488 } else { 00489 std::string msg; 00490 raw_string_ostream Msg(msg); 00491 Msg << "Unhandled frame size: " << FrameSize; 00492 llvm_report_error(Msg.str()); 00493 } 00494 00495 if (hasDebugInfo) { 00496 std::vector<MachineMove> &Moves = MMI->getFrameMoves(); 00497 00498 // Show update of SP. 00499 MachineLocation SPDst(MachineLocation::VirtualFP); 00500 MachineLocation SPSrc(MachineLocation::VirtualFP, -FrameSize); 00501 Moves.push_back(MachineMove(FrameLabelId, SPDst, SPSrc)); 00502 00503 // Add callee saved registers to move list. 00504 const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo(); 00505 for (unsigned I = 0, E = CSI.size(); I != E; ++I) { 00506 int Offset = MFI->getObjectOffset(CSI[I].getFrameIdx()); 00507 unsigned Reg = CSI[I].getReg(); 00508 if (Reg == SPU::R0) continue; 00509 MachineLocation CSDst(MachineLocation::VirtualFP, Offset); 00510 MachineLocation CSSrc(Reg); 00511 Moves.push_back(MachineMove(FrameLabelId, CSDst, CSSrc)); 00512 } 00513 00514 // Mark effective beginning of when frame pointer is ready. 00515 unsigned ReadyLabelId = MMI->NextLabelID(); 00516 BuildMI(MBB, MBBI, dl, TII.get(SPU::DBG_LABEL)).addImm(ReadyLabelId); 00517 00518 MachineLocation FPDst(SPU::R1); 00519 MachineLocation FPSrc(MachineLocation::VirtualFP); 00520 Moves.push_back(MachineMove(ReadyLabelId, FPDst, FPSrc)); 00521 } 00522 } else { 00523 // This is a leaf function -- insert a branch hint iff there are 00524 // sufficient number instructions in the basic block. Note that 00525 // this is just a best guess based on the basic block's size. 00526 if (MBB.size() >= (unsigned) SPUFrameInfo::branchHintPenalty()) { 00527 MachineBasicBlock::iterator MBBI = prior(MBB.end()); 00528 dl = MBBI->getDebugLoc(); 00529 00530 // Insert terminator label 00531 unsigned BranchLabelId = MMI->NextLabelID(); 00532 BuildMI(MBB, MBBI, dl, TII.get(SPU::DBG_LABEL)).addImm(BranchLabelId); 00533 } 00534 } 00535 } 00536 00537 void 00538 SPURegisterInfo::emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const 00539 { 00540 MachineBasicBlock::iterator MBBI = prior(MBB.end()); 00541 const MachineFrameInfo *MFI = MF.getFrameInfo(); 00542 int FrameSize = MFI->getStackSize(); 00543 int LinkSlotOffset = SPUFrameInfo::stackSlotSize(); 00544 DebugLoc dl = MBBI->getDebugLoc(); 00545 00546 assert(MBBI->getOpcode() == SPU::RET && 00547 "Can only insert epilog into returning blocks"); 00548 assert((FrameSize & 0xf) == 0 00549 && "SPURegisterInfo::emitEpilogue: FrameSize not aligned"); 00550 if (FrameSize > 0 || MFI->hasCalls()) { 00551 FrameSize = FrameSize + SPUFrameInfo::minStackSize(); 00552 if (isS10Constant(FrameSize + LinkSlotOffset)) { 00553 // Reload $lr, adjust $sp by required amount 00554 // Note: We do this to slightly improve dual issue -- not by much, but it 00555 // is an opportunity for dual issue. 00556 BuildMI(MBB, MBBI, dl, TII.get(SPU::LQDr128), SPU::R0) 00557 .addImm(FrameSize + LinkSlotOffset) 00558 .addReg(SPU::R1); 00559 BuildMI(MBB, MBBI, dl, TII.get(SPU::AIr32), SPU::R1) 00560 .addReg(SPU::R1) 00561 .addImm(FrameSize); 00562 } else if (FrameSize <= (1 << 16) - 1 && FrameSize >= -(1 << 16)) { 00563 // Frame size can be loaded into ILr32n, so temporarily spill $r2 and use 00564 // $r2 to adjust $sp: 00565 BuildMI(MBB, MBBI, dl, TII.get(SPU::STQDr128), SPU::R2) 00566 .addImm(16) 00567 .addReg(SPU::R1); 00568 BuildMI(MBB, MBBI, dl, TII.get(SPU::ILr32), SPU::R2) 00569 .addImm(FrameSize); 00570 BuildMI(MBB, MBBI, dl, TII.get(SPU::Ar32), SPU::R1) 00571 .addReg(SPU::R1) 00572 .addReg(SPU::R2); 00573 BuildMI(MBB, MBBI, dl, TII.get(SPU::LQDr128), SPU::R0) 00574 .addImm(16) 00575 .addReg(SPU::R2); 00576 BuildMI(MBB, MBBI, dl, TII.get(SPU::SFIr32), SPU::R2). 00577 addReg(SPU::R2) 00578 .addImm(16); 00579 BuildMI(MBB, MBBI, dl, TII.get(SPU::LQXr128), SPU::R2) 00580 .addReg(SPU::R2) 00581 .addReg(SPU::R1); 00582 } else { 00583 std::string msg; 00584 raw_string_ostream Msg(msg); 00585 Msg << "Unhandled frame size: " << FrameSize; 00586 llvm_report_error(Msg.str()); 00587 } 00588 } 00589 } 00590 00591 unsigned 00592 SPURegisterInfo::getRARegister() const 00593 { 00594 return SPU::R0; 00595 } 00596 00597 unsigned 00598 SPURegisterInfo::getFrameRegister(MachineFunction &MF) const 00599 { 00600 return SPU::R1; 00601 } 00602 00603 void 00604 SPURegisterInfo::getInitialFrameState(std::vector<MachineMove> &Moves) const 00605 { 00606 // Initial state of the frame pointer is R1. 00607 MachineLocation Dst(MachineLocation::VirtualFP); 00608 MachineLocation Src(SPU::R1, 0); 00609 Moves.push_back(MachineMove(0, Dst, Src)); 00610 } 00611 00612 00613 int 00614 SPURegisterInfo::getDwarfRegNum(unsigned RegNum, bool isEH) const { 00615 // FIXME: Most probably dwarf numbers differs for Linux and Darwin 00616 return SPUGenRegisterInfo::getDwarfRegNumFull(RegNum, 0); 00617 } 00618 00619 #include "SPUGenRegisterInfo.inc"