1 //===- MBlazeFrameLowering.cpp - MBlaze Frame Information ------*- C++ -*-====// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file contains the MBlaze implementation of TargetFrameLowering class. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #define DEBUG_TYPE "mblaze-frame-lowering" 15 16 #include "MBlazeFrameLowering.h" 17 #include "MBlazeInstrInfo.h" 18 #include "MBlazeMachineFunction.h" 19 #include "InstPrinter/MBlazeInstPrinter.h" 20 #include "llvm/Function.h" 21 #include "llvm/CodeGen/MachineFrameInfo.h" 22 #include "llvm/CodeGen/MachineFunction.h" 23 #include "llvm/CodeGen/MachineInstrBuilder.h" 24 #include "llvm/CodeGen/MachineModuleInfo.h" 25 #include "llvm/CodeGen/MachineRegisterInfo.h" 26 #include "llvm/Target/TargetData.h" 27 #include "llvm/Target/TargetOptions.h" 28 #include "llvm/Support/CommandLine.h" 29 #include "llvm/Support/Debug.h" 30 #include "llvm/Support/ErrorHandling.h" 31 #include "llvm/Support/raw_ostream.h" 32 33 using namespace llvm; 34 35 namespace llvm { 36 cl::opt<bool> DisableStackAdjust( 37 "disable-mblaze-stack-adjust", 38 cl::init(false), 39 cl::desc("Disable MBlaze stack layout adjustment."), 40 cl::Hidden); 41 } 42 43 static void replaceFrameIndexes(MachineFunction &MF, 44 SmallVector<std::pair<int,int64_t>, 16> &FR) { 45 MachineFrameInfo *MFI = MF.getFrameInfo(); 46 MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); 47 const SmallVector<std::pair<int,int64_t>, 16>::iterator FRB = FR.begin(); 48 const SmallVector<std::pair<int,int64_t>, 16>::iterator FRE = FR.end(); 49 50 SmallVector<std::pair<int,int64_t>, 16>::iterator FRI = FRB; 51 for (; FRI != FRE; ++FRI) { 52 MFI->RemoveStackObject(FRI->first); 53 int NFI = MFI->CreateFixedObject(4, FRI->second, true); 54 MBlazeFI->recordReplacement(FRI->first, NFI); 55 56 for (MachineFunction::iterator MB=MF.begin(), ME=MF.end(); MB!=ME; ++MB) { 57 MachineBasicBlock::iterator MBB = MB->begin(); 58 const MachineBasicBlock::iterator MBE = MB->end(); 59 60 for (; MBB != MBE; ++MBB) { 61 MachineInstr::mop_iterator MIB = MBB->operands_begin(); 62 const MachineInstr::mop_iterator MIE = MBB->operands_end(); 63 64 for (MachineInstr::mop_iterator MII = MIB; MII != MIE; ++MII) { 65 if (!MII->isFI() || MII->getIndex() != FRI->first) continue; 66 DEBUG(dbgs() << "FOUND FI#" << MII->getIndex() << "\n"); 67 MII->setIndex(NFI); 68 } 69 } 70 } 71 } 72 } 73 74 //===----------------------------------------------------------------------===// 75 // 76 // Stack Frame Processing methods 77 // +----------------------------+ 78 // 79 // The stack is allocated decrementing the stack pointer on 80 // the first instruction of a function prologue. Once decremented, 81 // all stack references are are done through a positive offset 82 // from the stack/frame pointer, so the stack is considered 83 // to grow up. 84 // 85 //===----------------------------------------------------------------------===// 86 87 static void analyzeFrameIndexes(MachineFunction &MF) { 88 if (DisableStackAdjust) return; 89 90 MachineFrameInfo *MFI = MF.getFrameInfo(); 91 MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); 92 const MachineRegisterInfo &MRI = MF.getRegInfo(); 93 94 MachineRegisterInfo::livein_iterator LII = MRI.livein_begin(); 95 MachineRegisterInfo::livein_iterator LIE = MRI.livein_end(); 96 const SmallVector<int, 16> &LiveInFI = MBlazeFI->getLiveIn(); 97 SmallVector<MachineInstr*, 16> EraseInstr; 98 SmallVector<std::pair<int,int64_t>, 16> FrameRelocate; 99 100 MachineBasicBlock *MBB = MF.getBlockNumbered(0); 101 MachineBasicBlock::iterator MIB = MBB->begin(); 102 MachineBasicBlock::iterator MIE = MBB->end(); 103 104 int StackAdjust = 0; 105 int StackOffset = -28; 106 107 // In this loop we are searching frame indexes that corrospond to incoming 108 // arguments that are already in the stack. We look for instruction sequences 109 // like the following: 110 // 111 // LWI REG, FI1, 0 112 // ... 113 // SWI REG, FI2, 0 114 // 115 // As long as there are no defs of REG in the ... part, we can eliminate 116 // the SWI instruction because the value has already been stored to the 117 // stack by the caller. All we need to do is locate FI at the correct 118 // stack location according to the calling convensions. 119 // 120 // Additionally, if the SWI operation kills the def of REG then we don't 121 // need the LWI operation so we can erase it as well. 122 for (unsigned i = 0, e = LiveInFI.size(); i < e; ++i) { 123 for (MachineBasicBlock::iterator I=MIB; I != MIE; ++I) { 124 if (I->getOpcode() != MBlaze::LWI || I->getNumOperands() != 3 || 125 !I->getOperand(1).isFI() || !I->getOperand(0).isReg() || 126 I->getOperand(1).getIndex() != LiveInFI[i]) continue; 127 128 unsigned FIReg = I->getOperand(0).getReg(); 129 MachineBasicBlock::iterator SI = I; 130 for (SI++; SI != MIE; ++SI) { 131 if (!SI->getOperand(0).isReg() || 132 !SI->getOperand(1).isFI() || 133 SI->getOpcode() != MBlaze::SWI) continue; 134 135 int FI = SI->getOperand(1).getIndex(); 136 if (SI->getOperand(0).getReg() != FIReg || 137 MFI->isFixedObjectIndex(FI) || 138 MFI->getObjectSize(FI) != 4) continue; 139 140 if (SI->getOperand(0).isDef()) break; 141 142 if (SI->getOperand(0).isKill()) { 143 DEBUG(dbgs() << "LWI for FI#" << I->getOperand(1).getIndex() 144 << " removed\n"); 145 EraseInstr.push_back(I); 146 } 147 148 EraseInstr.push_back(SI); 149 DEBUG(dbgs() << "SWI for FI#" << FI << " removed\n"); 150 151 FrameRelocate.push_back(std::make_pair(FI,StackOffset)); 152 DEBUG(dbgs() << "FI#" << FI << " relocated to " << StackOffset << "\n"); 153 154 StackOffset -= 4; 155 StackAdjust += 4; 156 break; 157 } 158 } 159 } 160 161 // In this loop we are searching for frame indexes that corrospond to 162 // incoming arguments that are in registers. We look for instruction 163 // sequences like the following: 164 // 165 // ... SWI REG, FI, 0 166 // 167 // As long as the ... part does not define REG and if REG is an incoming 168 // parameter register then we know that, according to ABI convensions, the 169 // caller has allocated stack space for it already. Instead of allocating 170 // stack space on our frame, we record the correct location in the callers 171 // frame. 172 for (MachineRegisterInfo::livein_iterator LI = LII; LI != LIE; ++LI) { 173 for (MachineBasicBlock::iterator I=MIB; I != MIE; ++I) { 174 if (I->definesRegister(LI->first)) 175 break; 176 177 if (I->getOpcode() != MBlaze::SWI || I->getNumOperands() != 3 || 178 !I->getOperand(1).isFI() || !I->getOperand(0).isReg() || 179 I->getOperand(1).getIndex() < 0) continue; 180 181 if (I->getOperand(0).getReg() == LI->first) { 182 int FI = I->getOperand(1).getIndex(); 183 MBlazeFI->recordLiveIn(FI); 184 185 int FILoc = 0; 186 switch (LI->first) { 187 default: llvm_unreachable("invalid incoming parameter!"); 188 case MBlaze::R5: FILoc = -4; break; 189 case MBlaze::R6: FILoc = -8; break; 190 case MBlaze::R7: FILoc = -12; break; 191 case MBlaze::R8: FILoc = -16; break; 192 case MBlaze::R9: FILoc = -20; break; 193 case MBlaze::R10: FILoc = -24; break; 194 } 195 196 StackAdjust += 4; 197 FrameRelocate.push_back(std::make_pair(FI,FILoc)); 198 DEBUG(dbgs() << "FI#" << FI << " relocated to " << FILoc << "\n"); 199 break; 200 } 201 } 202 } 203 204 // Go ahead and erase all of the instructions that we determined were 205 // no longer needed. 206 for (int i = 0, e = EraseInstr.size(); i < e; ++i) 207 MBB->erase(EraseInstr[i]); 208 209 // Replace all of the frame indexes that we have relocated with new 210 // fixed object frame indexes. 211 replaceFrameIndexes(MF, FrameRelocate); 212 } 213 214 static void interruptFrameLayout(MachineFunction &MF) { 215 const Function *F = MF.getFunction(); 216 llvm::CallingConv::ID CallConv = F->getCallingConv(); 217 218 // If this function is not using either the interrupt_handler 219 // calling convention or the save_volatiles calling convention 220 // then we don't need to do any additional frame layout. 221 if (CallConv != llvm::CallingConv::MBLAZE_INTR && 222 CallConv != llvm::CallingConv::MBLAZE_SVOL) 223 return; 224 225 MachineFrameInfo *MFI = MF.getFrameInfo(); 226 const MachineRegisterInfo &MRI = MF.getRegInfo(); 227 const MBlazeInstrInfo &TII = 228 *static_cast<const MBlazeInstrInfo*>(MF.getTarget().getInstrInfo()); 229 230 // Determine if the calling convention is the interrupt_handler 231 // calling convention. Some pieces of the prologue and epilogue 232 // only need to be emitted if we are lowering and interrupt handler. 233 bool isIntr = CallConv == llvm::CallingConv::MBLAZE_INTR; 234 235 // Determine where to put prologue and epilogue additions 236 MachineBasicBlock &MENT = MF.front(); 237 MachineBasicBlock &MEXT = MF.back(); 238 239 MachineBasicBlock::iterator MENTI = MENT.begin(); 240 MachineBasicBlock::iterator MEXTI = prior(MEXT.end()); 241 242 DebugLoc ENTDL = MENTI != MENT.end() ? MENTI->getDebugLoc() : DebugLoc(); 243 DebugLoc EXTDL = MEXTI != MEXT.end() ? MEXTI->getDebugLoc() : DebugLoc(); 244 245 // Store the frame indexes generated during prologue additions for use 246 // when we are generating the epilogue additions. 247 SmallVector<int, 10> VFI; 248 249 // Build the prologue SWI for R3 - R12 if needed. Note that R11 must 250 // always have a SWI because it is used when processing RMSR. 251 for (unsigned r = MBlaze::R3; r <= MBlaze::R12; ++r) { 252 if (!MRI.isPhysRegUsed(r) && !(isIntr && r == MBlaze::R11)) continue; 253 254 int FI = MFI->CreateStackObject(4,4,false,false); 255 VFI.push_back(FI); 256 257 BuildMI(MENT, MENTI, ENTDL, TII.get(MBlaze::SWI), r) 258 .addFrameIndex(FI).addImm(0); 259 } 260 261 // Build the prologue SWI for R17, R18 262 int R17FI = MFI->CreateStackObject(4,4,false,false); 263 int R18FI = MFI->CreateStackObject(4,4,false,false); 264 265 BuildMI(MENT, MENTI, ENTDL, TII.get(MBlaze::SWI), MBlaze::R17) 266 .addFrameIndex(R17FI).addImm(0); 267 268 BuildMI(MENT, MENTI, ENTDL, TII.get(MBlaze::SWI), MBlaze::R18) 269 .addFrameIndex(R18FI).addImm(0); 270 271 // Buid the prologue SWI and the epilogue LWI for RMSR if needed 272 if (isIntr) { 273 int MSRFI = MFI->CreateStackObject(4,4,false,false); 274 BuildMI(MENT, MENTI, ENTDL, TII.get(MBlaze::MFS), MBlaze::R11) 275 .addReg(MBlaze::RMSR); 276 BuildMI(MENT, MENTI, ENTDL, TII.get(MBlaze::SWI), MBlaze::R11) 277 .addFrameIndex(MSRFI).addImm(0); 278 279 BuildMI(MEXT, MEXTI, EXTDL, TII.get(MBlaze::LWI), MBlaze::R11) 280 .addFrameIndex(MSRFI).addImm(0); 281 BuildMI(MEXT, MEXTI, EXTDL, TII.get(MBlaze::MTS), MBlaze::RMSR) 282 .addReg(MBlaze::R11); 283 } 284 285 // Build the epilogue LWI for R17, R18 286 BuildMI(MEXT, MEXTI, EXTDL, TII.get(MBlaze::LWI), MBlaze::R18) 287 .addFrameIndex(R18FI).addImm(0); 288 289 BuildMI(MEXT, MEXTI, EXTDL, TII.get(MBlaze::LWI), MBlaze::R17) 290 .addFrameIndex(R17FI).addImm(0); 291 292 // Build the epilogue LWI for R3 - R12 if needed 293 for (unsigned r = MBlaze::R12, i = VFI.size(); r >= MBlaze::R3; --r) { 294 if (!MRI.isPhysRegUsed(r)) continue; 295 BuildMI(MEXT, MEXTI, EXTDL, TII.get(MBlaze::LWI), r) 296 .addFrameIndex(VFI[--i]).addImm(0); 297 } 298 } 299 300 static void determineFrameLayout(MachineFunction &MF) { 301 MachineFrameInfo *MFI = MF.getFrameInfo(); 302 MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); 303 304 // Replace the dummy '0' SPOffset by the negative offsets, as explained on 305 // LowerFORMAL_ARGUMENTS. Leaving '0' for while is necessary to avoid 306 // the approach done by calculateFrameObjectOffsets to the stack frame. 307 MBlazeFI->adjustLoadArgsFI(MFI); 308 MBlazeFI->adjustStoreVarArgsFI(MFI); 309 310 // Get the number of bytes to allocate from the FrameInfo 311 unsigned FrameSize = MFI->getStackSize(); 312 DEBUG(dbgs() << "Original Frame Size: " << FrameSize << "\n" ); 313 314 // Get the alignments provided by the target, and the maximum alignment 315 // (if any) of the fixed frame objects. 316 // unsigned MaxAlign = MFI->getMaxAlignment(); 317 unsigned TargetAlign = MF.getTarget().getFrameLowering()->getStackAlignment(); 318 unsigned AlignMask = TargetAlign - 1; 319 320 // Make sure the frame is aligned. 321 FrameSize = (FrameSize + AlignMask) & ~AlignMask; 322 MFI->setStackSize(FrameSize); 323 DEBUG(dbgs() << "Aligned Frame Size: " << FrameSize << "\n" ); 324 } 325 326 int MBlazeFrameLowering::getFrameIndexOffset(const MachineFunction &MF, int FI) 327 const { 328 const MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); 329 if (MBlazeFI->hasReplacement(FI)) 330 FI = MBlazeFI->getReplacement(FI); 331 return TargetFrameLowering::getFrameIndexOffset(MF,FI); 332 } 333 334 // hasFP - Return true if the specified function should have a dedicated frame 335 // pointer register. This is true if the function has variable sized allocas or 336 // if frame pointer elimination is disabled. 337 bool MBlazeFrameLowering::hasFP(const MachineFunction &MF) const { 338 const MachineFrameInfo *MFI = MF.getFrameInfo(); 339 return DisableFramePointerElim(MF) || MFI->hasVarSizedObjects(); 340 } 341 342 void MBlazeFrameLowering::emitPrologue(MachineFunction &MF) const { 343 MachineBasicBlock &MBB = MF.front(); 344 MachineFrameInfo *MFI = MF.getFrameInfo(); 345 const MBlazeInstrInfo &TII = 346 *static_cast<const MBlazeInstrInfo*>(MF.getTarget().getInstrInfo()); 347 MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); 348 MachineBasicBlock::iterator MBBI = MBB.begin(); 349 DebugLoc DL = MBBI != MBB.end() ? MBBI->getDebugLoc() : DebugLoc(); 350 351 llvm::CallingConv::ID CallConv = MF.getFunction()->getCallingConv(); 352 bool requiresRA = CallConv == llvm::CallingConv::MBLAZE_INTR; 353 354 // Determine the correct frame layout 355 determineFrameLayout(MF); 356 357 // Get the number of bytes to allocate from the FrameInfo. 358 unsigned StackSize = MFI->getStackSize(); 359 360 // No need to allocate space on the stack. 361 if (StackSize == 0 && !MFI->adjustsStack() && !requiresRA) return; 362 363 int FPOffset = MBlazeFI->getFPStackOffset(); 364 int RAOffset = MBlazeFI->getRAStackOffset(); 365 366 // Adjust stack : addi R1, R1, -imm 367 BuildMI(MBB, MBBI, DL, TII.get(MBlaze::ADDIK), MBlaze::R1) 368 .addReg(MBlaze::R1).addImm(-StackSize); 369 370 // swi R15, R1, stack_loc 371 if (MFI->adjustsStack() || requiresRA) { 372 BuildMI(MBB, MBBI, DL, TII.get(MBlaze::SWI)) 373 .addReg(MBlaze::R15).addReg(MBlaze::R1).addImm(RAOffset); 374 } 375 376 if (hasFP(MF)) { 377 // swi R19, R1, stack_loc 378 BuildMI(MBB, MBBI, DL, TII.get(MBlaze::SWI)) 379 .addReg(MBlaze::R19).addReg(MBlaze::R1).addImm(FPOffset); 380 381 // add R19, R1, R0 382 BuildMI(MBB, MBBI, DL, TII.get(MBlaze::ADD), MBlaze::R19) 383 .addReg(MBlaze::R1).addReg(MBlaze::R0); 384 } 385 } 386 387 void MBlazeFrameLowering::emitEpilogue(MachineFunction &MF, 388 MachineBasicBlock &MBB) const { 389 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr(); 390 MachineFrameInfo *MFI = MF.getFrameInfo(); 391 MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); 392 const MBlazeInstrInfo &TII = 393 *static_cast<const MBlazeInstrInfo*>(MF.getTarget().getInstrInfo()); 394 395 DebugLoc dl = MBBI->getDebugLoc(); 396 397 llvm::CallingConv::ID CallConv = MF.getFunction()->getCallingConv(); 398 bool requiresRA = CallConv == llvm::CallingConv::MBLAZE_INTR; 399 400 // Get the FI's where RA and FP are saved. 401 int FPOffset = MBlazeFI->getFPStackOffset(); 402 int RAOffset = MBlazeFI->getRAStackOffset(); 403 404 if (hasFP(MF)) { 405 // add R1, R19, R0 406 BuildMI(MBB, MBBI, dl, TII.get(MBlaze::ADD), MBlaze::R1) 407 .addReg(MBlaze::R19).addReg(MBlaze::R0); 408 409 // lwi R19, R1, stack_loc 410 BuildMI(MBB, MBBI, dl, TII.get(MBlaze::LWI), MBlaze::R19) 411 .addReg(MBlaze::R1).addImm(FPOffset); 412 } 413 414 // lwi R15, R1, stack_loc 415 if (MFI->adjustsStack() || requiresRA) { 416 BuildMI(MBB, MBBI, dl, TII.get(MBlaze::LWI), MBlaze::R15) 417 .addReg(MBlaze::R1).addImm(RAOffset); 418 } 419 420 // Get the number of bytes from FrameInfo 421 int StackSize = (int) MFI->getStackSize(); 422 423 // addi R1, R1, imm 424 if (StackSize) { 425 BuildMI(MBB, MBBI, dl, TII.get(MBlaze::ADDIK), MBlaze::R1) 426 .addReg(MBlaze::R1).addImm(StackSize); 427 } 428 } 429 430 void MBlazeFrameLowering:: 431 processFunctionBeforeCalleeSavedScan(MachineFunction &MF, 432 RegScavenger *RS) const { 433 MachineFrameInfo *MFI = MF.getFrameInfo(); 434 MBlazeFunctionInfo *MBlazeFI = MF.getInfo<MBlazeFunctionInfo>(); 435 llvm::CallingConv::ID CallConv = MF.getFunction()->getCallingConv(); 436 bool requiresRA = CallConv == llvm::CallingConv::MBLAZE_INTR; 437 438 if (MFI->adjustsStack() || requiresRA) { 439 MBlazeFI->setRAStackOffset(0); 440 MFI->CreateFixedObject(4,0,true); 441 } 442 443 if (hasFP(MF)) { 444 MBlazeFI->setFPStackOffset(4); 445 MFI->CreateFixedObject(4,4,true); 446 } 447 448 interruptFrameLayout(MF); 449 analyzeFrameIndexes(MF); 450 } 451
