PrologEpilogInserter.cpp revision 33b350bf24be396a127c81af045468765731afc7
158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner//===-- PrologEpilogInserter.cpp - Insert Prolog/Epilog code in function --===// 2edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner// 1058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner// This pass is responsible for finalizing the functions frame layout, saving 1158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner// callee saved registers, and for emitting prolog & epilog code for the 1258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner// function. 1358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner// 1458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner// This pass must be run after register allocation. After this pass is 1558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner// executed, it is illegal to construct MO_FrameIndex operands. 1658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner// 17378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby// This pass provides an optional shrink wrapping variant of prolog/epilog 18378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby// insertion, enabled via --shrink-wrap. See ShrinkWrapping.cpp. 19ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby// 2058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner//===----------------------------------------------------------------------===// 2158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 22752c1df73949438ef6fa86a86363ee7091aa2532John Mosby#include "PrologEpilogInserter.h" 23ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby#include "llvm/CodeGen/MachineDominators.h" 24ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby#include "llvm/CodeGen/MachineLoopInfo.h" 2558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner#include "llvm/CodeGen/MachineInstr.h" 26eb24db9727a7babe863d5afe70c7bda3a460da18Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.h" 2784bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineModuleInfo.h" 2884bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner#include "llvm/CodeGen/MachineRegisterInfo.h" 2949dd06461a7e027a6c938f0570297d46f2f34218Evan Cheng#include "llvm/CodeGen/RegisterScavenging.h" 3058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner#include "llvm/Target/TargetMachine.h" 316f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman#include "llvm/Target/TargetRegisterInfo.h" 328bd66e690779c838db51f55cf0b31d7206b3b659Chris Lattner#include "llvm/Target/TargetFrameInfo.h" 333501feab811c86c9659248a4875fc31a3165f84dChris Lattner#include "llvm/Target/TargetInstrInfo.h" 34a4f0b3a084d120cfc5b5bb06f64b222f5cb72740Chris Lattner#include "llvm/Support/Compiler.h" 358e3347332120956538a6d882b02719e34b57f0cdEvan Cheng#include "llvm/ADT/STLExtras.h" 36c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng#include <climits> 37ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 3805d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattnerusing namespace llvm; 39d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 40378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosbychar PEI::ID = 0; 41b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 42378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosbystatic RegisterPass<PEI> 43378553cb079aba2b8dee5d52b5166316d4132d5aJohn MosbyX("prologepilog", "Prologue/Epilogue Insertion"); 44b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 4558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// createPrologEpilogCodeInserter - This function returns a pass that inserts 4658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// prolog and epilog code, and eliminates abstract frame references. 4758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// 4805d8350c12d8d81de1d8af6f7da155bc1c1da50eChris LattnerFunctionPass *llvm::createPrologEpilogCodeInserter() { return new PEI(); } 4958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 50378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby/// runOnMachineFunction - Insert prolog/epilog code and replace abstract 51378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby/// frame indexes with appropriate references. 52b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby/// 53378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosbybool PEI::runOnMachineFunction(MachineFunction &Fn) { 54b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby const TargetRegisterInfo *TRI = Fn.getTarget().getRegisterInfo(); 55378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby RS = TRI->requiresRegisterScavenging(Fn) ? new RegScavenger() : NULL; 56378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 57378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Get MachineModuleInfo so that we can track the construction of the 58378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // frame. 59378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby if (MachineModuleInfo *MMI = getAnalysisIfAvailable<MachineModuleInfo>()) 60378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby Fn.getFrameInfo()->setMachineModuleInfo(MMI); 61378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 6233b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Calculate the MaxCallFrameSize and HasCalls variables for the function's 6333b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // frame information. Also eliminates call frame pseudo instructions. 6433b350bf24be396a127c81af045468765731afc7Anton Korobeynikov calculateCallsInformation(Fn); 6533b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 66378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Allow the target machine to make some adjustments to the function 67378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // e.g. UsedPhysRegs before calculateCalleeSavedRegisters. 68378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby TRI->processFunctionBeforeCalleeSavedScan(Fn, RS); 69378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 7033b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Scan the function for modified callee saved registers and insert spill code 7133b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // for any callee saved registers that are modified. 72378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby calculateCalleeSavedRegisters(Fn); 73378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 74378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Determine placement of CSR spill/restore code: 75378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // - with shrink wrapping, place spills and restores to tightly 76378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // enclose regions in the Machine CFG of the function where 77378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // they are used. Without shrink wrapping 78378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // - default (no shrink wrapping), place all spills in the 79378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // entry block, all restores in return blocks. 80378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby placeCSRSpillsAndRestores(Fn); 81378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 82378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Add the code to save and restore the callee saved registers 83378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby insertCSRSpillsAndRestores(Fn); 84378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 85378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Allow the target machine to make final modifications to the function 86378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // before the frame layout is finalized. 87378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby TRI->processFunctionBeforeFrameFinalized(Fn); 88378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 89378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Calculate actual frame offsets for all abstract stack objects... 90378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby calculateFrameObjectOffsets(Fn); 91378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 92378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Add prolog and epilog code to the function. This function is required 93378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // to align the stack frame as necessary for any stack variables or 94378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // called functions. Because of this, calculateCalleeSavedRegisters 95378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // must be called before this function in order to set the HasCalls 96378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // and MaxCallFrameSize variables. 97378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby insertPrologEpilogCode(Fn); 98378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 99378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Replace all MO_FrameIndex operands with physical register references 100378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // and actual offsets. 101378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // 102378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby replaceFrameIndices(Fn); 103b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 104378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby delete RS; 105378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby clearAllSets(); 106b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby return true; 107ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby} 108ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 109378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby#if 0 110378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosbyvoid PEI::getAnalysisUsage(AnalysisUsage &AU) const { 111378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby AU.setPreservesCFG(); 112378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby if (ShrinkWrapping || ShrinkWrapFunc != "") { 113378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby AU.addRequired<MachineLoopInfo>(); 114378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby AU.addRequired<MachineDominatorTree>(); 115b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 116378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby AU.addPreserved<MachineLoopInfo>(); 117378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby AU.addPreserved<MachineDominatorTree>(); 118378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby MachineFunctionPass::getAnalysisUsage(AU); 119ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby} 120378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby#endif 121ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 12233b350bf24be396a127c81af045468765731afc7Anton Korobeynikov/// calculateCallsInformation - Calculate the MaxCallFrameSize and HasCalls 12333b350bf24be396a127c81af045468765731afc7Anton Korobeynikov/// variables for the function's frame information and eliminate call frame 12433b350bf24be396a127c81af045468765731afc7Anton Korobeynikov/// pseudo instructions. 12533b350bf24be396a127c81af045468765731afc7Anton Korobeynikovvoid PEI::calculateCallsInformation(MachineFunction &Fn) { 1266f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo(); 12758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 12833b350bf24be396a127c81af045468765731afc7Anton Korobeynikov unsigned MaxCallFrameSize = 0; 12933b350bf24be396a127c81af045468765731afc7Anton Korobeynikov bool HasCalls = false; 13058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 13158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner // Get the function call frame set-up and tear-down instruction opcode 13258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner int FrameSetupOpcode = RegInfo->getCallFrameSetupOpcode(); 13358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner int FrameDestroyOpcode = RegInfo->getCallFrameDestroyOpcode(); 13458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 13533b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Early exit for targets which have no call frame setup/destroy pseudo 13633b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // instructions. 13733b350bf24be396a127c81af045468765731afc7Anton Korobeynikov if (FrameSetupOpcode == -1 && FrameDestroyOpcode == -1) 13858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner return; 13958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 1405c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng std::vector<MachineBasicBlock::iterator> FrameSDOps; 14158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) 1425c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ++I) 143c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos if (I->getOpcode() == FrameSetupOpcode || 144d555da52f4301f0a221845d5a549848f5ae84577Chris Lattner I->getOpcode() == FrameDestroyOpcode) { 1452a82ef317c39ac436f80854c7ddbb06bfddeada1Chris Lattner assert(I->getNumOperands() >= 1 && "Call Frame Setup/Destroy Pseudo" 146d555da52f4301f0a221845d5a549848f5ae84577Chris Lattner " instructions should have a single immediate argument!"); 1479e3304900ff69c4920fea7369c9c36916c4a6a6aChris Lattner unsigned Size = I->getOperand(0).getImm(); 148d555da52f4301f0a221845d5a549848f5ae84577Chris Lattner if (Size > MaxCallFrameSize) MaxCallFrameSize = Size; 149d555da52f4301f0a221845d5a549848f5ae84577Chris Lattner HasCalls = true; 1505c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng FrameSDOps.push_back(I); 15158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 15258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 153eb24db9727a7babe863d5afe70c7bda3a460da18Chris Lattner MachineFrameInfo *FFI = Fn.getFrameInfo(); 15458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner FFI->setHasCalls(HasCalls); 15558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner FFI->setMaxCallFrameSize(MaxCallFrameSize); 1568e3347332120956538a6d882b02719e34b57f0cdEvan Cheng 157058a024eb7265239d527680b0a448cdb48102a46Bill Wendling for (std::vector<MachineBasicBlock::iterator>::iterator 158058a024eb7265239d527680b0a448cdb48102a46Bill Wendling i = FrameSDOps.begin(), e = FrameSDOps.end(); i != e; ++i) { 159058a024eb7265239d527680b0a448cdb48102a46Bill Wendling MachineBasicBlock::iterator I = *i; 160058a024eb7265239d527680b0a448cdb48102a46Bill Wendling 161058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // If call frames are not being included as part of the stack frame, and 162058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // there is no dynamic allocation (therefore referencing frame slots off 163058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // sp), leave the pseudo ops alone. We'll eliminate them later. 1648e3347332120956538a6d882b02719e34b57f0cdEvan Cheng if (RegInfo->hasReservedCallFrame(Fn) || RegInfo->hasFP(Fn)) 1658e3347332120956538a6d882b02719e34b57f0cdEvan Cheng RegInfo->eliminateCallFramePseudoInstr(Fn, *I->getParent(), I); 1665c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng } 16733b350bf24be396a127c81af045468765731afc7Anton Korobeynikov} 16833b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 16933b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 17033b350bf24be396a127c81af045468765731afc7Anton Korobeynikov/// calculateCalleeSavedRegisters - Scan the function for modified callee saved 17133b350bf24be396a127c81af045468765731afc7Anton Korobeynikov/// registers. 17233b350bf24be396a127c81af045468765731afc7Anton Korobeynikovvoid PEI::calculateCalleeSavedRegisters(MachineFunction &Fn) { 17333b350bf24be396a127c81af045468765731afc7Anton Korobeynikov const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo(); 17433b350bf24be396a127c81af045468765731afc7Anton Korobeynikov const TargetFrameInfo *TFI = Fn.getTarget().getFrameInfo(); 17533b350bf24be396a127c81af045468765731afc7Anton Korobeynikov MachineFrameInfo *FFI = Fn.getFrameInfo(); 17633b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 17733b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Get the callee saved register list... 17833b350bf24be396a127c81af045468765731afc7Anton Korobeynikov const unsigned *CSRegs = RegInfo->getCalleeSavedRegs(&Fn); 17933b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 18033b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // These are used to keep track the callee-save area. Initialize them. 18133b350bf24be396a127c81af045468765731afc7Anton Korobeynikov MinCSFrameIndex = INT_MAX; 18233b350bf24be396a127c81af045468765731afc7Anton Korobeynikov MaxCSFrameIndex = 0; 18333b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 18433b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Early exit for targets which have no callee saved registers. 18533b350bf24be396a127c81af045468765731afc7Anton Korobeynikov if (CSRegs == 0 || CSRegs[0] == 0) 18633b350bf24be396a127c81af045468765731afc7Anton Korobeynikov return; 18758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 18833b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Figure out which *callee saved* registers are modified by the current 18958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner // function, thus needing to be saved and restored in the prolog/epilog. 190058a024eb7265239d527680b0a448cdb48102a46Bill Wendling const TargetRegisterClass * const *CSRegClasses = 1912365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov RegInfo->getCalleeSavedRegClasses(&Fn); 192058a024eb7265239d527680b0a448cdb48102a46Bill Wendling 19308ede262a744f99429658fadb43662441bdcb42dJim Laskey std::vector<CalleeSavedInfo> CSI; 19458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner for (unsigned i = 0; CSRegs[i]; ++i) { 19558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner unsigned Reg = CSRegs[i]; 1962afb3b7251dbcfadef7a8126e9516bde78fc13bbJim Grosbach if (Fn.getRegInfo().isPhysRegUsed(Reg)) { 197058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // If the reg is modified, save it! 198f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey CSI.push_back(CalleeSavedInfo(Reg, CSRegClasses[i])); 19973ff5120eb8b8c0ccbfed8a17f1024c67a75f319Alkis Evlogimenos } else { 20073ff5120eb8b8c0ccbfed8a17f1024c67a75f319Alkis Evlogimenos for (const unsigned *AliasSet = RegInfo->getAliasSet(Reg); 2013563015b0df358cfc4ec310eb0df195015ea54a5Chris Lattner *AliasSet; ++AliasSet) { // Check alias registers too. 20284bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner if (Fn.getRegInfo().isPhysRegUsed(*AliasSet)) { 203f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey CSI.push_back(CalleeSavedInfo(Reg, CSRegClasses[i])); 204d555da52f4301f0a221845d5a549848f5ae84577Chris Lattner break; 205ecf8afdc2065dec1ca739e2b6a96f8e72dc34533Chris Lattner } 20673ff5120eb8b8c0ccbfed8a17f1024c67a75f319Alkis Evlogimenos } 20773ff5120eb8b8c0ccbfed8a17f1024c67a75f319Alkis Evlogimenos } 20858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 20958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 210f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey if (CSI.empty()) 211c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng return; // Early exit if no callee saved registers are modified! 21258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 213c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner unsigned NumFixedSpillSlots; 2148c9b4de5744ea6c4ce8b79e8a55130df268761cdAlkis Evlogimenos const std::pair<unsigned,int> *FixedSpillSlots = 215ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng TFI->getCalleeSavedSpillSlots(NumFixedSpillSlots); 216c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 21758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner // Now that we know which registers need to be saved and restored, allocate 21858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner // stack slots for them. 219058a024eb7265239d527680b0a448cdb48102a46Bill Wendling for (std::vector<CalleeSavedInfo>::iterator 220058a024eb7265239d527680b0a448cdb48102a46Bill Wendling I = CSI.begin(), E = CSI.end(); I != E; ++I) { 221058a024eb7265239d527680b0a448cdb48102a46Bill Wendling unsigned Reg = I->getReg(); 222058a024eb7265239d527680b0a448cdb48102a46Bill Wendling const TargetRegisterClass *RC = I->getRegClass(); 223c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 224910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng int FrameIdx; 225910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng if (RegInfo->hasReservedSpillSlot(Fn, Reg, FrameIdx)) { 226910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng I->setFrameIdx(FrameIdx); 227910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng continue; 228910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng } 229910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng 230c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner // Check to see if this physreg must be spilled to a particular stack slot 231c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner // on this target. 2328c9b4de5744ea6c4ce8b79e8a55130df268761cdAlkis Evlogimenos const std::pair<unsigned,int> *FixedSlot = FixedSpillSlots; 233c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner while (FixedSlot != FixedSpillSlots+NumFixedSpillSlots && 234c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner FixedSlot->first != Reg) 235c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner ++FixedSlot; 236c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 237058a024eb7265239d527680b0a448cdb48102a46Bill Wendling if (FixedSlot == FixedSpillSlots + NumFixedSpillSlots) { 238c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner // Nope, just spill it anywhere convenient. 2395feaa9a70716e9181a9b940236bc461f2a75334aEvan Cheng unsigned Align = RC->getAlignment(); 2405feaa9a70716e9181a9b940236bc461f2a75334aEvan Cheng unsigned StackAlign = TFI->getStackAlignment(); 241058a024eb7265239d527680b0a448cdb48102a46Bill Wendling 242058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // We may not be able to satisfy the desired alignment specification of 243058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // the TargetRegisterClass if the stack alignment is smaller. Use the 244058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // min. 2455feaa9a70716e9181a9b940236bc461f2a75334aEvan Cheng Align = std::min(Align, StackAlign); 2465feaa9a70716e9181a9b940236bc461f2a75334aEvan Cheng FrameIdx = FFI->CreateStackObject(RC->getSize(), Align); 247c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng if ((unsigned)FrameIdx < MinCSFrameIndex) MinCSFrameIndex = FrameIdx; 248c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng if ((unsigned)FrameIdx > MaxCSFrameIndex) MaxCSFrameIndex = FrameIdx; 249c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner } else { 250c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner // Spill it to the stack where we must. 2518fb040e584606f048b85d87363a52baf5ff9c1c7Chris Lattner FrameIdx = FFI->CreateFixedObject(RC->getSize(), FixedSlot->second); 252c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner } 253058a024eb7265239d527680b0a448cdb48102a46Bill Wendling 254058a024eb7265239d527680b0a448cdb48102a46Bill Wendling I->setFrameIdx(FrameIdx); 25558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 25608ede262a744f99429658fadb43662441bdcb42dJim Laskey 25708ede262a744f99429658fadb43662441bdcb42dJim Laskey FFI->setCalleeSavedInfo(CSI); 258c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner} 259c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 260ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby/// insertCSRSpillsAndRestores - Insert spill and restore code for 261ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby/// callee saved registers used in the function, handling shrink wrapping. 262c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner/// 263ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosbyvoid PEI::insertCSRSpillsAndRestores(MachineFunction &Fn) { 264f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey // Get callee saved register information. 265f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey MachineFrameInfo *FFI = Fn.getFrameInfo(); 26608ede262a744f99429658fadb43662441bdcb42dJim Laskey const std::vector<CalleeSavedInfo> &CSI = FFI->getCalleeSavedInfo(); 267ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 268c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // Early exit if no callee saved registers are modified! 269f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey if (CSI.empty()) 270edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman return; 271c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 272f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson const TargetInstrInfo &TII = *Fn.getTarget().getInstrInfo(); 273ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby MachineBasicBlock::iterator I; 27400dff8dda29b5a249cd99405ce26e84cef13ba53Evan Cheng 275b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (! ShrinkWrapThisFunction) { 276b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Spill using target interface. 277b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = EntryBlock->begin(); 278b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (!TII.spillCalleeSavedRegisters(*EntryBlock, I, CSI)) { 279b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 280ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // Add the callee-saved register as live-in. 281ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // It's killed at the spill. 282b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby EntryBlock->addLiveIn(CSI[i].getReg()); 283ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 284ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // Insert the spill to the stack frame. 285b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby TII.storeRegToStackSlot(*EntryBlock, I, CSI[i].getReg(), true, 286b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby CSI[i].getFrameIdx(), CSI[i].getRegClass()); 287ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } 288ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng } 289ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 290b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Restore using target interface. 291b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (unsigned ri = 0, re = ReturnBlocks.size(); ri != re; ++ri) { 292b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock* MBB = ReturnBlocks[ri]; 293c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos I = MBB->end(); --I; 29458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 295f7c094000f4baf094b1d60ba68a5b4e0193c502aBill Wendling // Skip over all terminator instructions, which are part of the return 2964fc997941dde5c11e91a28c9b5b8fa331d053a18Chris Lattner // sequence. 2974fc997941dde5c11e91a28c9b5b8fa331d053a18Chris Lattner MachineBasicBlock::iterator I2 = I; 298f7c094000f4baf094b1d60ba68a5b4e0193c502aBill Wendling while (I2 != MBB->begin() && (--I2)->getDesc().isTerminator()) 2994fc997941dde5c11e91a28c9b5b8fa331d053a18Chris Lattner I = I2; 3004fc997941dde5c11e91a28c9b5b8fa331d053a18Chris Lattner 301dfd58709cc78e841ef4a50ba75d940473031617eChris Lattner bool AtStart = I == MBB->begin(); 302ed461e0fafbd0b905cb716df108000bcd6ecf3d4Chris Lattner MachineBasicBlock::iterator BeforeI = I; 303ed461e0fafbd0b905cb716df108000bcd6ecf3d4Chris Lattner if (!AtStart) 304ed461e0fafbd0b905cb716df108000bcd6ecf3d4Chris Lattner --BeforeI; 305ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 306ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // Restore all registers immediately before the return and any 307ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // terminators that preceed it. 308a393cd3306b865e8e5d82dc4e6cfabcdf5d8dc44Owen Anderson if (!TII.restoreCalleeSavedRegisters(*MBB, I, CSI)) { 309ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 310f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson TII.loadRegFromStackSlot(*MBB, I, CSI[i].getReg(), 311ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby CSI[i].getFrameIdx(), 312ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby CSI[i].getRegClass()); 313ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng assert(I != MBB->begin() && 314ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng "loadRegFromStackSlot didn't insert any code!"); 315ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // Insert in reverse order. loadRegFromStackSlot can insert 316ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // multiple instructions. 317ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng if (AtStart) 318ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng I = MBB->begin(); 319ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng else { 320ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng I = BeforeI; 321ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng ++I; 322ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng } 323ed461e0fafbd0b905cb716df108000bcd6ecf3d4Chris Lattner } 32458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 325b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 326b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby return; 327b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 328ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 329b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Insert spills. 330b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby std::vector<CalleeSavedInfo> blockCSI; 331b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (CSRegBlockMap::iterator BI = CSRSave.begin(), 332b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby BE = CSRSave.end(); BI != BE; ++BI) { 333b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock* MBB = BI->first; 334b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby CSRegSet save = BI->second; 335ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 336b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (save.empty()) 337b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby continue; 338ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 339b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI.clear(); 340b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (CSRegSet::iterator RI = save.begin(), 341b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby RE = save.end(); RI != RE; ++RI) { 342b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI.push_back(CSI[*RI]); 343b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 344b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby assert(blockCSI.size() > 0 && 345b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby "Could not collect callee saved register info"); 346b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 347b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = MBB->begin(); 348b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 349b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // When shrink wrapping, use stack slot stores/loads. 350b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (unsigned i = 0, e = blockCSI.size(); i != e; ++i) { 351b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Add the callee-saved register as live-in. 352b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // It's killed at the spill. 353b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MBB->addLiveIn(blockCSI[i].getReg()); 354b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 355b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Insert the spill to the stack frame. 356b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby TII.storeRegToStackSlot(*MBB, I, blockCSI[i].getReg(), 357b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby true, 358b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI[i].getFrameIdx(), 359b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI[i].getRegClass()); 360b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 361b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 362b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 363b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (CSRegBlockMap::iterator BI = CSRRestore.begin(), 364b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby BE = CSRRestore.end(); BI != BE; ++BI) { 365b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock* MBB = BI->first; 366b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby CSRegSet restore = BI->second; 367b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 368b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (restore.empty()) 369b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby continue; 370b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 371b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI.clear(); 372b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (CSRegSet::iterator RI = restore.begin(), 373b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby RE = restore.end(); RI != RE; ++RI) { 374b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI.push_back(CSI[*RI]); 375b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 376b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby assert(blockCSI.size() > 0 && 377b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby "Could not find callee saved register info"); 378b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 379b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // If MBB is empty and needs restores, insert at the _beginning_. 380b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (MBB->empty()) { 381b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = MBB->begin(); 382b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } else { 383b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = MBB->end(); 384b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby --I; 385b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 386b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Skip over all terminator instructions, which are part of the 387b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // return sequence. 388b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (! I->getDesc().isTerminator()) { 389b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby ++I; 390ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } else { 391b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock::iterator I2 = I; 392b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby while (I2 != MBB->begin() && (--I2)->getDesc().isTerminator()) 393b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = I2; 394ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } 395b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 396ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 397b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby bool AtStart = I == MBB->begin(); 398b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock::iterator BeforeI = I; 399b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (!AtStart) 400b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby --BeforeI; 401b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 402b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Restore all registers immediately before the return and any 403b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // terminators that preceed it. 404b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (unsigned i = 0, e = blockCSI.size(); i != e; ++i) { 405b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby TII.loadRegFromStackSlot(*MBB, I, blockCSI[i].getReg(), 406b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI[i].getFrameIdx(), 407b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI[i].getRegClass()); 408b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby assert(I != MBB->begin() && 409b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby "loadRegFromStackSlot didn't insert any code!"); 410b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Insert in reverse order. loadRegFromStackSlot can insert 411b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // multiple instructions. 412b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (AtStart) 413b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = MBB->begin(); 414b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby else { 415b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = BeforeI; 416b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby ++I; 417ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } 41858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 419ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } 42058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner} 42158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 422cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling/// AdjustStackOffset - Helper function used to adjust the stack frame offset. 423cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendlingstatic inline void 424cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill WendlingAdjustStackOffset(MachineFrameInfo *FFI, int FrameIdx, 425cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling bool StackGrowsDown, int64_t &Offset, 426cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling unsigned &MaxAlign) { 427cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling // If stack grows down, we need to add size of find the lowest address of the 428cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling // object. 429cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling if (StackGrowsDown) 430cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling Offset += FFI->getObjectSize(FrameIdx); 431cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling 432cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling unsigned Align = FFI->getObjectAlignment(FrameIdx); 433cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling 434cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling // If the alignment of this object is greater than that of the stack, then 435cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling // increase the stack alignment to match. 436cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling MaxAlign = std::max(MaxAlign, Align); 437cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling 438cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling // Adjust to alignment boundary. 439cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling Offset = (Offset + Align - 1) / Align * Align; 440cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling 441cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling if (StackGrowsDown) { 442cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling FFI->setObjectOffset(FrameIdx, -Offset); // Set the computed offset 443cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling } else { 444cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling FFI->setObjectOffset(FrameIdx, Offset); 445cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling Offset += FFI->getObjectSize(FrameIdx); 446cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling } 447cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling} 44858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 44958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the 45092b9fcea7b3180ed18f379212d14bd5cea7a1954Chris Lattner/// abstract stack objects. 45158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// 45258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattnervoid PEI::calculateFrameObjectOffsets(MachineFunction &Fn) { 4539bcdcd17c7219dbc68de2f11ca2de86471c8c390Chris Lattner const TargetFrameInfo &TFI = *Fn.getTarget().getFrameInfo(); 454edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 45558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner bool StackGrowsDown = 45658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner TFI.getStackGrowthDirection() == TargetFrameInfo::StackGrowsDown; 457edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 45858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner // Loop over all of the stack objects, assigning sequential addresses... 459eb24db9727a7babe863d5afe70c7bda3a460da18Chris Lattner MachineFrameInfo *FFI = Fn.getFrameInfo(); 46058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 461aadc780a56820c263dca141b2b9f9e39355f6991Anton Korobeynikov unsigned MaxAlign = FFI->getMaxAlignment(); 46278d6db5627bdf41ab3ffd96133821647dbc60d53Chris Lattner 46305d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattner // Start at the beginning of the local area. 464577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // The Offset is the distance from the stack top in the direction 465c0d6012b31afa2220306afa27db1b02e18427776Dan Gohman // of stack growth -- so it's always nonnegative. 466a401b1e1c5eb9563617db8a2477b4c5f8b239521Chris Lattner int64_t Offset = TFI.getOffsetOfLocalArea(); 467577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner if (StackGrowsDown) 4687f7bbc2fdb833485ac3d865a405fd948e58e8ddbChris Lattner Offset = -Offset; 469edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman assert(Offset >= 0 470577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner && "Local area offset should be in direction of stack growth"); 471577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner 472577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // If there are fixed sized objects that are preallocated in the local area, 473577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // non-fixed objects can't be allocated right at the start of local area. 474ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // We currently don't support filling in holes in between fixed sized 475ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // objects, so we adjust 'Offset' to point to the end of last fixed sized 47605d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattner // preallocated object. 47705d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattner for (int i = FFI->getObjectIndexBegin(); i != 0; ++i) { 478a401b1e1c5eb9563617db8a2477b4c5f8b239521Chris Lattner int64_t FixedOff; 479577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner if (StackGrowsDown) { 480577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // The maximum distance from the stack pointer is at lower address of 481577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // the object -- which is given by offset. For down growing stack 482577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // the offset is negative, so we negate the offset to get the distance. 483577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner FixedOff = -FFI->getObjectOffset(i); 484577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner } else { 485edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman // The maximum distance from the start pointer is at the upper 486577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // address of the object. 487577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner FixedOff = FFI->getObjectOffset(i) + FFI->getObjectSize(i); 488edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman } 489edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman if (FixedOff > Offset) Offset = FixedOff; 49005d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattner } 49105d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattner 492c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // First assign frame offsets to stack objects that are used to spill 493ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng // callee saved registers. 494c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng if (StackGrowsDown) { 4955c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng for (unsigned i = MinCSFrameIndex; i <= MaxCSFrameIndex; ++i) { 496c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // If stack grows down, we need to add size of find the lowest 497c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // address of the object. 498c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng Offset += FFI->getObjectSize(i); 499c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 500c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng unsigned Align = FFI->getObjectAlignment(i); 501ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // If the alignment of this object is greater than that of the stack, 502ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // then increase the stack alignment to match. 503c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng MaxAlign = std::max(MaxAlign, Align); 504c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // Adjust to alignment boundary 505c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng Offset = (Offset+Align-1)/Align*Align; 506c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 507c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng FFI->setObjectOffset(i, -Offset); // Set the computed offset 508c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng } 509c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng } else { 510a8c63f0fc9feb48f17d702a907f065959c41e337Bruno Cardoso Lopes int MaxCSFI = MaxCSFrameIndex, MinCSFI = MinCSFrameIndex; 511a8c63f0fc9feb48f17d702a907f065959c41e337Bruno Cardoso Lopes for (int i = MaxCSFI; i >= MinCSFI ; --i) { 512c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng unsigned Align = FFI->getObjectAlignment(i); 513ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // If the alignment of this object is greater than that of the stack, 514ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // then increase the stack alignment to match. 515c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng MaxAlign = std::max(MaxAlign, Align); 516c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // Adjust to alignment boundary 517c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng Offset = (Offset+Align-1)/Align*Align; 518c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 519c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng FFI->setObjectOffset(i, Offset); 520c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng Offset += FFI->getObjectSize(i); 521c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng } 522c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng } 523c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 52487f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng // Make sure the special register scavenging spill slot is closest to the 52587f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng // frame pointer if a frame pointer is required. 5266f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo(); 52787f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng if (RS && RegInfo->hasFP(Fn)) { 52887f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng int SFI = RS->getScavengingFrameIndex(); 529cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling if (SFI >= 0) 530cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling AdjustStackOffset(FFI, SFI, StackGrowsDown, Offset, MaxAlign); 53187f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng } 53287f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng 533b2a4298ce41e7ef80cd75a3c1dfa6433f0759a1aBill Wendling // Make sure that the stack protector comes before the local variables on the 534b2a4298ce41e7ef80cd75a3c1dfa6433f0759a1aBill Wendling // stack. 535cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling if (FFI->getStackProtectorIndex() >= 0) 536cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling AdjustStackOffset(FFI, FFI->getStackProtectorIndex(), StackGrowsDown, 537cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling Offset, MaxAlign); 538b2a4298ce41e7ef80cd75a3c1dfa6433f0759a1aBill Wendling 539c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // Then assign frame offsets to stack objects that are not used to spill 540ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng // callee saved registers. 54158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner for (unsigned i = 0, e = FFI->getObjectIndexEnd(); i != e; ++i) { 542c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex) 543c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng continue; 54487f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng if (RS && (int)i == RS->getScavengingFrameIndex()) 54587f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng continue; 546d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng if (FFI->isDeadObjectIndex(i)) 547d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng continue; 54844cf38c01ff610139d2e8dbbdc4e6123a3debcddBill Wendling if (FFI->getStackProtectorIndex() == (int)i) 54944cf38c01ff610139d2e8dbbdc4e6123a3debcddBill Wendling continue; 550c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 551cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling AdjustStackOffset(FFI, i, StackGrowsDown, Offset, MaxAlign); 55258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 55358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 55487f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng // Make sure the special register scavenging spill slot is closest to the 55587f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng // stack pointer. 5568d410b69384ae4e178b3b522ef3357290a714de5Lauro Ramos Venancio if (RS && !RegInfo->hasFP(Fn)) { 55787f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng int SFI = RS->getScavengingFrameIndex(); 558cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling if (SFI >= 0) 559cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling AdjustStackOffset(FFI, SFI, StackGrowsDown, Offset, MaxAlign); 56087f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng } 56187f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng 562367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng // Round up the size to a multiple of the alignment, but only if there are 563367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng // calls or alloca's in the function. This ensures that any calls to 564367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng // subroutines have their stack frames suitable aligned. 565b5dae003252d8e650a32bfdf33cba5aed8e41e40Dale Johannesen // Also do this if we need runtime alignment of the stack. In this case 566b5dae003252d8e650a32bfdf33cba5aed8e41e40Dale Johannesen // offsets will be relative to SP not FP; round up the stack size so this 567b5dae003252d8e650a32bfdf33cba5aed8e41e40Dale Johannesen // works. 56802a20291410a6814c657b69901a57103d4861a07Evan Cheng if (!RegInfo->targetHandlesStackFrameRounding() && 569ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby (FFI->hasCalls() || FFI->hasVarSizedObjects() || 570edec8d89dfaebd7050df4acafe3d01fa755ffd0dDale Johannesen (RegInfo->needsStackRealignment(Fn) && 571edec8d89dfaebd7050df4acafe3d01fa755ffd0dDale Johannesen FFI->getObjectIndexEnd() != 0))) { 5725c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng // If we have reserved argument space for call sites in the function 5735c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng // immediately on entry to the current function, count it as part of the 5745c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng // overall stack size. 5755c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng if (RegInfo->hasReservedCallFrame(Fn)) 576367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng Offset += FFI->getMaxCallFrameSize(); 577367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng 578b5dae003252d8e650a32bfdf33cba5aed8e41e40Dale Johannesen unsigned AlignMask = std::max(TFI.getStackAlignment(),MaxAlign) - 1; 579ea84c5ee952c62dd0c703c9852d7a60715e4a435Chris Lattner Offset = (Offset + AlignMask) & ~uint64_t(AlignMask); 580367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng } 581367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng 582367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng // Update frame info to pretend that this is part of the stack... 5837f7bbc2fdb833485ac3d865a405fd948e58e8ddbChris Lattner FFI->setStackSize(Offset+TFI.getOffsetOfLocalArea()); 584cbef8ba5f959b3c4f932005ceef5cf2e0d899f9bChris Lattner 585cbef8ba5f959b3c4f932005ceef5cf2e0d899f9bChris Lattner // Remember the required stack alignment in case targets need it to perform 586cbef8ba5f959b3c4f932005ceef5cf2e0d899f9bChris Lattner // dynamic stack alignment. 587be680dcea6858c438c6615326ae1c098ff448ae1Evan Cheng FFI->setMaxAlignment(MaxAlign); 5884ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner} 5894ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner 5904ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner 591c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng/// insertPrologEpilogCode - Scan the function for modified callee saved 592c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng/// registers, insert spill code for these callee saved registers, then add 5934ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner/// prolog and epilog code to the function. 5944ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner/// 5954ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattnervoid PEI::insertPrologEpilogCode(MachineFunction &Fn) { 596874384e20f618d6ac932628db64e048757213fcdAnton Korobeynikov const TargetRegisterInfo *TRI = Fn.getTarget().getRegisterInfo(); 597874384e20f618d6ac932628db64e048757213fcdAnton Korobeynikov 5984ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner // Add prologue to the function... 599874384e20f618d6ac932628db64e048757213fcdAnton Korobeynikov TRI->emitPrologue(Fn); 6004ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner 6014ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner // Add epilogue to restore the callee-save registers in each exiting block 6024ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner for (MachineFunction::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) { 6034ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner // If last instruction is a return instruction, add an epilogue 604749c6f6b5ed301c84aac562e414486549d7b98ebChris Lattner if (!I->empty() && I->back().getDesc().isReturn()) 605874384e20f618d6ac932628db64e048757213fcdAnton Korobeynikov TRI->emitEpilogue(Fn, *I); 6064ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner } 60758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner} 60858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 60958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 61058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// replaceFrameIndices - Replace all MO_FrameIndex operands with physical 61158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// register references and actual offsets. 61258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// 61358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattnervoid PEI::replaceFrameIndices(MachineFunction &Fn) { 61458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner if (!Fn.getFrameInfo()->hasStackObjects()) return; // Nothing to do? 61558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 61658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner const TargetMachine &TM = Fn.getTarget(); 61758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner assert(TM.getRegisterInfo() && "TM::getRegisterInfo() must be implemented!"); 6186f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman const TargetRegisterInfo &TRI = *TM.getRegisterInfo(); 6198e3347332120956538a6d882b02719e34b57f0cdEvan Cheng const TargetFrameInfo *TFI = TM.getFrameInfo(); 6208e3347332120956538a6d882b02719e34b57f0cdEvan Cheng bool StackGrowsDown = 6218e3347332120956538a6d882b02719e34b57f0cdEvan Cheng TFI->getStackGrowthDirection() == TargetFrameInfo::StackGrowsDown; 6226f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman int FrameSetupOpcode = TRI.getCallFrameSetupOpcode(); 6236f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman int FrameDestroyOpcode = TRI.getCallFrameDestroyOpcode(); 62458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 625ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby for (MachineFunction::iterator BB = Fn.begin(), 626ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby E = Fn.end(); BB != E; ++BB) { 6278e3347332120956538a6d882b02719e34b57f0cdEvan Cheng int SPAdj = 0; // SP offset due to call frame setup / destroy. 62823322d1427e319089f5098d02cefbc7d8446d746Evan Cheng if (RS) RS->enterBasicBlock(BB); 629ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 6300ebe9c132c6b9c74b334f0c7503e702b499575d5Chris Lattner for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ) { 631405abffd5eb1ad1841491e51943b598c935f309bBill Wendling if (I->getOpcode() == TargetInstrInfo::DECLARE) { 632a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng // Ignore it. 633988a5782d3ce3cddc65d57d6aac7312d33ed59abBill Wendling ++I; 63471a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner continue; 635405abffd5eb1ad1841491e51943b598c935f309bBill Wendling } 636405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 637405abffd5eb1ad1841491e51943b598c935f309bBill Wendling if (I->getOpcode() == FrameSetupOpcode || 638405abffd5eb1ad1841491e51943b598c935f309bBill Wendling I->getOpcode() == FrameDestroyOpcode) { 639405abffd5eb1ad1841491e51943b598c935f309bBill Wendling // Remember how much SP has been adjusted to create the call 640405abffd5eb1ad1841491e51943b598c935f309bBill Wendling // frame. 64171a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner int Size = I->getOperand(0).getImm(); 642405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 64371a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner if ((!StackGrowsDown && I->getOpcode() == FrameSetupOpcode) || 64471a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner (StackGrowsDown && I->getOpcode() == FrameDestroyOpcode)) 64571a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner Size = -Size; 646988a5782d3ce3cddc65d57d6aac7312d33ed59abBill Wendling 64771a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner SPAdj += Size; 648405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 6495e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner MachineBasicBlock::iterator PrevI = BB->end(); 6505e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner if (I != BB->begin()) PrevI = prior(I); 65171a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner TRI.eliminateCallFramePseudoInstr(Fn, *BB, I); 652405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 65371a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // Visit the instructions created by eliminateCallFramePseudoInstr(). 6545e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner if (PrevI == BB->end()) 6555e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner I = BB->begin(); // The replaced instr was the first in the block. 6565e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner else 6575e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner I = next(PrevI); 65871a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner continue; 6598e3347332120956538a6d882b02719e34b57f0cdEvan Cheng } 660988a5782d3ce3cddc65d57d6aac7312d33ed59abBill Wendling 66178a5bd5dbd4d99d916c69d89ceaabd83c0e52469Evan Cheng MachineInstr *MI = I; 662405abffd5eb1ad1841491e51943b598c935f309bBill Wendling bool DoIncr = true; 663405abffd5eb1ad1841491e51943b598c935f309bBill Wendling for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) 664d735b8019b0f297d7c14b55adcd887af24d8e602Dan Gohman if (MI->getOperand(i).isFI()) { 66571a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // Some instructions (e.g. inline asm instructions) can have 66671a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // multiple frame indices and/or cause eliminateFrameIndex 66771a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // to insert more than one instruction. We need the register 66871a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // scavenger to go through all of these instructions so that 66971a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // it can update its register information. We keep the 67071a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // iterator at the point before insertion so that we can 67171a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // revisit them in full. 67271a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner bool AtBeginning = (I == BB->begin()); 67371a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner if (!AtBeginning) --I; 67471a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner 67571a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // If this instruction has a FrameIndex operand, we need to 67671a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // use that target machine register info object to eliminate 67771a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // it. 678ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 67971a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner TRI.eliminateFrameIndex(MI, SPAdj, RS); 68071a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner 68171a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // Reset the iterator if we were at the beginning of the BB. 68271a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner if (AtBeginning) { 68371a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner I = BB->begin(); 68471a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner DoIncr = false; 68571a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner } 68671a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner 68771a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner MI = 0; 68871a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner break; 68971a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner } 690405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 6918fc2d0ee8dd4e077ee90a1fcc36fd0101c2947a2Chris Lattner if (DoIncr && I != BB->end()) ++I; 692405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 69349dd06461a7e027a6c938f0570297d46f2f34218Evan Cheng // Update register states. 6940ebe9c132c6b9c74b334f0c7503e702b499575d5Chris Lattner if (RS && MI) RS->forward(MI); 69549dd06461a7e027a6c938f0570297d46f2f34218Evan Cheng } 696988a5782d3ce3cddc65d57d6aac7312d33ed59abBill Wendling 6978e3347332120956538a6d882b02719e34b57f0cdEvan Cheng assert(SPAdj == 0 && "Unbalanced call frame setup / destroy pairs?"); 69849dd06461a7e027a6c938f0570297d46f2f34218Evan Cheng } 69958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner} 700b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 701