lib/Target/MBlaze/MBlazeFrameLowering.cpp

   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 }