PrologEpilogInserter.cpp revision 03d02d4faa6cf8ae1337f64bc83dcbd9de570372
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" 343d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach#include "llvm/Support/CommandLine.h" 35a4f0b3a084d120cfc5b5bb06f64b222f5cb72740Chris Lattner#include "llvm/Support/Compiler.h" 363d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach#include "llvm/ADT/IndexedMap.h" 378e3347332120956538a6d882b02719e34b57f0cdEvan Cheng#include "llvm/ADT/STLExtras.h" 38c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng#include <climits> 39ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 4005d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattnerusing namespace llvm; 41d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 42378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosbychar PEI::ID = 0; 43b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 44378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosbystatic RegisterPass<PEI> 45378553cb079aba2b8dee5d52b5166316d4132d5aJohn MosbyX("prologepilog", "Prologue/Epilogue Insertion"); 46b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 4758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// createPrologEpilogCodeInserter - This function returns a pass that inserts 4858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// prolog and epilog code, and eliminates abstract frame references. 4958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// 5005d8350c12d8d81de1d8af6f7da155bc1c1da50eChris LattnerFunctionPass *llvm::createPrologEpilogCodeInserter() { return new PEI(); } 5158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 52378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby/// runOnMachineFunction - Insert prolog/epilog code and replace abstract 53378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby/// frame indexes with appropriate references. 54b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby/// 55378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosbybool PEI::runOnMachineFunction(MachineFunction &Fn) { 56c5ec8a78ea898087ad361e5b755f74a76150e5fdAnton Korobeynikov const Function* F = Fn.getFunction(); 57b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby const TargetRegisterInfo *TRI = Fn.getTarget().getRegisterInfo(); 58378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby RS = TRI->requiresRegisterScavenging(Fn) ? new RegScavenger() : NULL; 5965c58daa8b8985d2116216043103009815a55e77Jim Grosbach FrameIndexVirtualScavenging = TRI->requiresFrameIndexScavenging(Fn); 60378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 61378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Get MachineModuleInfo so that we can track the construction of the 62378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // frame. 63378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby if (MachineModuleInfo *MMI = getAnalysisIfAvailable<MachineModuleInfo>()) 64378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby Fn.getFrameInfo()->setMachineModuleInfo(MMI); 65378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 6633b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Calculate the MaxCallFrameSize and HasCalls variables for the function's 6733b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // frame information. Also eliminates call frame pseudo instructions. 6833b350bf24be396a127c81af045468765731afc7Anton Korobeynikov calculateCallsInformation(Fn); 6933b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 70378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Allow the target machine to make some adjustments to the function 71378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // e.g. UsedPhysRegs before calculateCalleeSavedRegisters. 72378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby TRI->processFunctionBeforeCalleeSavedScan(Fn, RS); 73378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 7433b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Scan the function for modified callee saved registers and insert spill code 7533b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // for any callee saved registers that are modified. 76378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby calculateCalleeSavedRegisters(Fn); 77378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 78378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Determine placement of CSR spill/restore code: 79378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // - with shrink wrapping, place spills and restores to tightly 80378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // enclose regions in the Machine CFG of the function where 81378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // they are used. Without shrink wrapping 82378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // - default (no shrink wrapping), place all spills in the 83378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // entry block, all restores in return blocks. 84378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby placeCSRSpillsAndRestores(Fn); 85378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 86378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Add the code to save and restore the callee saved registers 87c5ec8a78ea898087ad361e5b755f74a76150e5fdAnton Korobeynikov if (!F->hasFnAttr(Attribute::Naked)) 88c5ec8a78ea898087ad361e5b755f74a76150e5fdAnton Korobeynikov insertCSRSpillsAndRestores(Fn); 89378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 90378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Allow the target machine to make final modifications to the function 91378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // before the frame layout is finalized. 92378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby TRI->processFunctionBeforeFrameFinalized(Fn); 93378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 94378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Calculate actual frame offsets for all abstract stack objects... 95378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby calculateFrameObjectOffsets(Fn); 96378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 97378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Add prolog and epilog code to the function. This function is required 98378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // to align the stack frame as necessary for any stack variables or 99378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // called functions. Because of this, calculateCalleeSavedRegisters 100378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // must be called before this function in order to set the HasCalls 101378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // and MaxCallFrameSize variables. 102c5ec8a78ea898087ad361e5b755f74a76150e5fdAnton Korobeynikov if (!F->hasFnAttr(Attribute::Naked)) 103c5ec8a78ea898087ad361e5b755f74a76150e5fdAnton Korobeynikov insertPrologEpilogCode(Fn); 104378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 105378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Replace all MO_FrameIndex operands with physical register references 106378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // and actual offsets. 107378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // 108378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby replaceFrameIndices(Fn); 109b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 1103d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach // If register scavenging is needed, as we've enabled doing it as a 1113d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach // post-pass, scavenge the virtual registers that frame index elimiation 1123d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach // inserted. 1133d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach if (TRI->requiresRegisterScavenging(Fn) && FrameIndexVirtualScavenging) 1143d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach scavengeFrameVirtualRegs(Fn); 1153d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach 116378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby delete RS; 117378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby clearAllSets(); 118b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby return true; 119ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby} 120ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 121378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby#if 0 122378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosbyvoid PEI::getAnalysisUsage(AnalysisUsage &AU) const { 123845012e6d31799c7fbd1193fa1af8ee2d12e9231Dan Gohman AU.setPreservesCFG(); 124378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby if (ShrinkWrapping || ShrinkWrapFunc != "") { 125378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby AU.addRequired<MachineLoopInfo>(); 126378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby AU.addRequired<MachineDominatorTree>(); 127b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 128378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby AU.addPreserved<MachineLoopInfo>(); 129378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby AU.addPreserved<MachineDominatorTree>(); 130378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby MachineFunctionPass::getAnalysisUsage(AU); 131ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby} 132378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby#endif 133ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 13433b350bf24be396a127c81af045468765731afc7Anton Korobeynikov/// calculateCallsInformation - Calculate the MaxCallFrameSize and HasCalls 13533b350bf24be396a127c81af045468765731afc7Anton Korobeynikov/// variables for the function's frame information and eliminate call frame 13633b350bf24be396a127c81af045468765731afc7Anton Korobeynikov/// pseudo instructions. 13733b350bf24be396a127c81af045468765731afc7Anton Korobeynikovvoid PEI::calculateCallsInformation(MachineFunction &Fn) { 1386f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo(); 13958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 14033b350bf24be396a127c81af045468765731afc7Anton Korobeynikov unsigned MaxCallFrameSize = 0; 14133b350bf24be396a127c81af045468765731afc7Anton Korobeynikov bool HasCalls = false; 14258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 14358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner // Get the function call frame set-up and tear-down instruction opcode 14458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner int FrameSetupOpcode = RegInfo->getCallFrameSetupOpcode(); 14558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner int FrameDestroyOpcode = RegInfo->getCallFrameDestroyOpcode(); 14658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 14733b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Early exit for targets which have no call frame setup/destroy pseudo 14833b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // instructions. 14933b350bf24be396a127c81af045468765731afc7Anton Korobeynikov if (FrameSetupOpcode == -1 && FrameDestroyOpcode == -1) 15058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner return; 15158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 1525c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng std::vector<MachineBasicBlock::iterator> FrameSDOps; 15358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) 1545c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ++I) 155c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos if (I->getOpcode() == FrameSetupOpcode || 156d555da52f4301f0a221845d5a549848f5ae84577Chris Lattner I->getOpcode() == FrameDestroyOpcode) { 1572a82ef317c39ac436f80854c7ddbb06bfddeada1Chris Lattner assert(I->getNumOperands() >= 1 && "Call Frame Setup/Destroy Pseudo" 158d555da52f4301f0a221845d5a549848f5ae84577Chris Lattner " instructions should have a single immediate argument!"); 1599e3304900ff69c4920fea7369c9c36916c4a6a6aChris Lattner unsigned Size = I->getOperand(0).getImm(); 160d555da52f4301f0a221845d5a549848f5ae84577Chris Lattner if (Size > MaxCallFrameSize) MaxCallFrameSize = Size; 161d555da52f4301f0a221845d5a549848f5ae84577Chris Lattner HasCalls = true; 1625c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng FrameSDOps.push_back(I); 163423ccfe51daa699a969cd716ce3a69cb2ada6234Dale Johannesen } else if (I->getOpcode() == TargetInstrInfo::INLINEASM) { 164423ccfe51daa699a969cd716ce3a69cb2ada6234Dale Johannesen // An InlineAsm might be a call; assume it is to get the stack frame 165423ccfe51daa699a969cd716ce3a69cb2ada6234Dale Johannesen // aligned correctly for calls. 166423ccfe51daa699a969cd716ce3a69cb2ada6234Dale Johannesen HasCalls = true; 16758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 16858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 169eb24db9727a7babe863d5afe70c7bda3a460da18Chris Lattner MachineFrameInfo *FFI = Fn.getFrameInfo(); 17058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner FFI->setHasCalls(HasCalls); 17158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner FFI->setMaxCallFrameSize(MaxCallFrameSize); 1728e3347332120956538a6d882b02719e34b57f0cdEvan Cheng 173058a024eb7265239d527680b0a448cdb48102a46Bill Wendling for (std::vector<MachineBasicBlock::iterator>::iterator 174058a024eb7265239d527680b0a448cdb48102a46Bill Wendling i = FrameSDOps.begin(), e = FrameSDOps.end(); i != e; ++i) { 175058a024eb7265239d527680b0a448cdb48102a46Bill Wendling MachineBasicBlock::iterator I = *i; 176058a024eb7265239d527680b0a448cdb48102a46Bill Wendling 177058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // If call frames are not being included as part of the stack frame, and 178058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // there is no dynamic allocation (therefore referencing frame slots off 179058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // sp), leave the pseudo ops alone. We'll eliminate them later. 1808e3347332120956538a6d882b02719e34b57f0cdEvan Cheng if (RegInfo->hasReservedCallFrame(Fn) || RegInfo->hasFP(Fn)) 1818e3347332120956538a6d882b02719e34b57f0cdEvan Cheng RegInfo->eliminateCallFramePseudoInstr(Fn, *I->getParent(), I); 1825c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng } 18333b350bf24be396a127c81af045468765731afc7Anton Korobeynikov} 18433b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 18533b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 18633b350bf24be396a127c81af045468765731afc7Anton Korobeynikov/// calculateCalleeSavedRegisters - Scan the function for modified callee saved 18733b350bf24be396a127c81af045468765731afc7Anton Korobeynikov/// registers. 18833b350bf24be396a127c81af045468765731afc7Anton Korobeynikovvoid PEI::calculateCalleeSavedRegisters(MachineFunction &Fn) { 18933b350bf24be396a127c81af045468765731afc7Anton Korobeynikov const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo(); 19033b350bf24be396a127c81af045468765731afc7Anton Korobeynikov const TargetFrameInfo *TFI = Fn.getTarget().getFrameInfo(); 19133b350bf24be396a127c81af045468765731afc7Anton Korobeynikov MachineFrameInfo *FFI = Fn.getFrameInfo(); 19233b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 19333b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Get the callee saved register list... 19433b350bf24be396a127c81af045468765731afc7Anton Korobeynikov const unsigned *CSRegs = RegInfo->getCalleeSavedRegs(&Fn); 19533b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 19633b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // These are used to keep track the callee-save area. Initialize them. 19733b350bf24be396a127c81af045468765731afc7Anton Korobeynikov MinCSFrameIndex = INT_MAX; 19833b350bf24be396a127c81af045468765731afc7Anton Korobeynikov MaxCSFrameIndex = 0; 19933b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 20033b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Early exit for targets which have no callee saved registers. 20133b350bf24be396a127c81af045468765731afc7Anton Korobeynikov if (CSRegs == 0 || CSRegs[0] == 0) 20233b350bf24be396a127c81af045468765731afc7Anton Korobeynikov return; 20358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 20433b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Figure out which *callee saved* registers are modified by the current 20558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner // function, thus needing to be saved and restored in the prolog/epilog. 206058a024eb7265239d527680b0a448cdb48102a46Bill Wendling const TargetRegisterClass * const *CSRegClasses = 2072365f51ed03afe6993bae962fdc2e5a956a64cd5Anton Korobeynikov RegInfo->getCalleeSavedRegClasses(&Fn); 208058a024eb7265239d527680b0a448cdb48102a46Bill Wendling 20908ede262a744f99429658fadb43662441bdcb42dJim Laskey std::vector<CalleeSavedInfo> CSI; 21058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner for (unsigned i = 0; CSRegs[i]; ++i) { 21158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner unsigned Reg = CSRegs[i]; 2122afb3b7251dbcfadef7a8126e9516bde78fc13bbJim Grosbach if (Fn.getRegInfo().isPhysRegUsed(Reg)) { 213058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // If the reg is modified, save it! 214f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey CSI.push_back(CalleeSavedInfo(Reg, CSRegClasses[i])); 21573ff5120eb8b8c0ccbfed8a17f1024c67a75f319Alkis Evlogimenos } else { 21673ff5120eb8b8c0ccbfed8a17f1024c67a75f319Alkis Evlogimenos for (const unsigned *AliasSet = RegInfo->getAliasSet(Reg); 2173563015b0df358cfc4ec310eb0df195015ea54a5Chris Lattner *AliasSet; ++AliasSet) { // Check alias registers too. 21884bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner if (Fn.getRegInfo().isPhysRegUsed(*AliasSet)) { 219f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey CSI.push_back(CalleeSavedInfo(Reg, CSRegClasses[i])); 220d555da52f4301f0a221845d5a549848f5ae84577Chris Lattner break; 221ecf8afdc2065dec1ca739e2b6a96f8e72dc34533Chris Lattner } 22273ff5120eb8b8c0ccbfed8a17f1024c67a75f319Alkis Evlogimenos } 22373ff5120eb8b8c0ccbfed8a17f1024c67a75f319Alkis Evlogimenos } 22458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 22558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 226f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey if (CSI.empty()) 227c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng return; // Early exit if no callee saved registers are modified! 22858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 229c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner unsigned NumFixedSpillSlots; 2308ff95de83cbe85d939535d2f4fb5f9b2b721081aTilmann Scheller const TargetFrameInfo::SpillSlot *FixedSpillSlots = 231ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng TFI->getCalleeSavedSpillSlots(NumFixedSpillSlots); 232c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 23358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner // Now that we know which registers need to be saved and restored, allocate 23458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner // stack slots for them. 235058a024eb7265239d527680b0a448cdb48102a46Bill Wendling for (std::vector<CalleeSavedInfo>::iterator 236058a024eb7265239d527680b0a448cdb48102a46Bill Wendling I = CSI.begin(), E = CSI.end(); I != E; ++I) { 237058a024eb7265239d527680b0a448cdb48102a46Bill Wendling unsigned Reg = I->getReg(); 238058a024eb7265239d527680b0a448cdb48102a46Bill Wendling const TargetRegisterClass *RC = I->getRegClass(); 239c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 240910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng int FrameIdx; 241910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng if (RegInfo->hasReservedSpillSlot(Fn, Reg, FrameIdx)) { 242910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng I->setFrameIdx(FrameIdx); 243910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng continue; 244910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng } 245910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng 246c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner // Check to see if this physreg must be spilled to a particular stack slot 247c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner // on this target. 2488ff95de83cbe85d939535d2f4fb5f9b2b721081aTilmann Scheller const TargetFrameInfo::SpillSlot *FixedSlot = FixedSpillSlots; 249c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner while (FixedSlot != FixedSpillSlots+NumFixedSpillSlots && 2508ff95de83cbe85d939535d2f4fb5f9b2b721081aTilmann Scheller FixedSlot->Reg != Reg) 251c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner ++FixedSlot; 252c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 253058a024eb7265239d527680b0a448cdb48102a46Bill Wendling if (FixedSlot == FixedSpillSlots + NumFixedSpillSlots) { 254c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner // Nope, just spill it anywhere convenient. 2555feaa9a70716e9181a9b940236bc461f2a75334aEvan Cheng unsigned Align = RC->getAlignment(); 2565feaa9a70716e9181a9b940236bc461f2a75334aEvan Cheng unsigned StackAlign = TFI->getStackAlignment(); 257058a024eb7265239d527680b0a448cdb48102a46Bill Wendling 258058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // We may not be able to satisfy the desired alignment specification of 259058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // the TargetRegisterClass if the stack alignment is smaller. Use the 260058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // min. 2615feaa9a70716e9181a9b940236bc461f2a75334aEvan Cheng Align = std::min(Align, StackAlign); 262491f54f1fd700204db0a19efde0cc2627641d711Evan Cheng FrameIdx = FFI->CreateStackObject(RC->getSize(), Align, true); 263c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng if ((unsigned)FrameIdx < MinCSFrameIndex) MinCSFrameIndex = FrameIdx; 264c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng if ((unsigned)FrameIdx > MaxCSFrameIndex) MaxCSFrameIndex = FrameIdx; 265c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner } else { 266c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner // Spill it to the stack where we must. 2678ff95de83cbe85d939535d2f4fb5f9b2b721081aTilmann Scheller FrameIdx = FFI->CreateFixedObject(RC->getSize(), FixedSlot->Offset); 268c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner } 269058a024eb7265239d527680b0a448cdb48102a46Bill Wendling 270058a024eb7265239d527680b0a448cdb48102a46Bill Wendling I->setFrameIdx(FrameIdx); 27158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 27208ede262a744f99429658fadb43662441bdcb42dJim Laskey 27308ede262a744f99429658fadb43662441bdcb42dJim Laskey FFI->setCalleeSavedInfo(CSI); 274c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner} 275c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 276ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby/// insertCSRSpillsAndRestores - Insert spill and restore code for 277ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby/// callee saved registers used in the function, handling shrink wrapping. 278c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner/// 279ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosbyvoid PEI::insertCSRSpillsAndRestores(MachineFunction &Fn) { 280f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey // Get callee saved register information. 281f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey MachineFrameInfo *FFI = Fn.getFrameInfo(); 28208ede262a744f99429658fadb43662441bdcb42dJim Laskey const std::vector<CalleeSavedInfo> &CSI = FFI->getCalleeSavedInfo(); 283ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 284d62c9a697b53f9e754926a89126fd121220ed09bJakob Stoklund Olesen FFI->setCalleeSavedInfoValid(true); 285d62c9a697b53f9e754926a89126fd121220ed09bJakob Stoklund Olesen 286c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // Early exit if no callee saved registers are modified! 287f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey if (CSI.empty()) 288edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman return; 289c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 290f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson const TargetInstrInfo &TII = *Fn.getTarget().getInstrInfo(); 291ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby MachineBasicBlock::iterator I; 29200dff8dda29b5a249cd99405ce26e84cef13ba53Evan Cheng 293b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (! ShrinkWrapThisFunction) { 294b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Spill using target interface. 295b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = EntryBlock->begin(); 296b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (!TII.spillCalleeSavedRegisters(*EntryBlock, I, CSI)) { 297b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 298ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // Add the callee-saved register as live-in. 299ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // It's killed at the spill. 300b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby EntryBlock->addLiveIn(CSI[i].getReg()); 301ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 302ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // Insert the spill to the stack frame. 303b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby TII.storeRegToStackSlot(*EntryBlock, I, CSI[i].getReg(), true, 304b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby CSI[i].getFrameIdx(), CSI[i].getRegClass()); 305ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } 306ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng } 307ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 308b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Restore using target interface. 309b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (unsigned ri = 0, re = ReturnBlocks.size(); ri != re; ++ri) { 310b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock* MBB = ReturnBlocks[ri]; 311c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos I = MBB->end(); --I; 31258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 313f7c094000f4baf094b1d60ba68a5b4e0193c502aBill Wendling // Skip over all terminator instructions, which are part of the return 3144fc997941dde5c11e91a28c9b5b8fa331d053a18Chris Lattner // sequence. 3154fc997941dde5c11e91a28c9b5b8fa331d053a18Chris Lattner MachineBasicBlock::iterator I2 = I; 316f7c094000f4baf094b1d60ba68a5b4e0193c502aBill Wendling while (I2 != MBB->begin() && (--I2)->getDesc().isTerminator()) 3174fc997941dde5c11e91a28c9b5b8fa331d053a18Chris Lattner I = I2; 3184fc997941dde5c11e91a28c9b5b8fa331d053a18Chris Lattner 319dfd58709cc78e841ef4a50ba75d940473031617eChris Lattner bool AtStart = I == MBB->begin(); 320ed461e0fafbd0b905cb716df108000bcd6ecf3d4Chris Lattner MachineBasicBlock::iterator BeforeI = I; 321ed461e0fafbd0b905cb716df108000bcd6ecf3d4Chris Lattner if (!AtStart) 322ed461e0fafbd0b905cb716df108000bcd6ecf3d4Chris Lattner --BeforeI; 323ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 324ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // Restore all registers immediately before the return and any 325ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // terminators that preceed it. 326a393cd3306b865e8e5d82dc4e6cfabcdf5d8dc44Owen Anderson if (!TII.restoreCalleeSavedRegisters(*MBB, I, CSI)) { 327ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 328f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson TII.loadRegFromStackSlot(*MBB, I, CSI[i].getReg(), 329ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby CSI[i].getFrameIdx(), 330ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby CSI[i].getRegClass()); 331ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng assert(I != MBB->begin() && 332ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng "loadRegFromStackSlot didn't insert any code!"); 333ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // Insert in reverse order. loadRegFromStackSlot can insert 334ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // multiple instructions. 335ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng if (AtStart) 336ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng I = MBB->begin(); 337ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng else { 338ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng I = BeforeI; 339ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng ++I; 340ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng } 341ed461e0fafbd0b905cb716df108000bcd6ecf3d4Chris Lattner } 34258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 343b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 344b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby return; 345b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 346ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 347b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Insert spills. 348b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby std::vector<CalleeSavedInfo> blockCSI; 349b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (CSRegBlockMap::iterator BI = CSRSave.begin(), 350b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby BE = CSRSave.end(); BI != BE; ++BI) { 351b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock* MBB = BI->first; 352b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby CSRegSet save = BI->second; 353ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 354b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (save.empty()) 355b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby continue; 356ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 357b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI.clear(); 358b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (CSRegSet::iterator RI = save.begin(), 359b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby RE = save.end(); RI != RE; ++RI) { 360b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI.push_back(CSI[*RI]); 361b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 362b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby assert(blockCSI.size() > 0 && 363b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby "Could not collect callee saved register info"); 364b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 365b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = MBB->begin(); 366b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 367b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // When shrink wrapping, use stack slot stores/loads. 368b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (unsigned i = 0, e = blockCSI.size(); i != e; ++i) { 369b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Add the callee-saved register as live-in. 370b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // It's killed at the spill. 371b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MBB->addLiveIn(blockCSI[i].getReg()); 372b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 373b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Insert the spill to the stack frame. 374b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby TII.storeRegToStackSlot(*MBB, I, blockCSI[i].getReg(), 375b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby true, 376b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI[i].getFrameIdx(), 377b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI[i].getRegClass()); 378b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 379b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 380b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 381b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (CSRegBlockMap::iterator BI = CSRRestore.begin(), 382b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby BE = CSRRestore.end(); BI != BE; ++BI) { 383b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock* MBB = BI->first; 384b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby CSRegSet restore = BI->second; 385b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 386b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (restore.empty()) 387b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby continue; 388b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 389b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI.clear(); 390b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (CSRegSet::iterator RI = restore.begin(), 391b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby RE = restore.end(); RI != RE; ++RI) { 392b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI.push_back(CSI[*RI]); 393b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 394b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby assert(blockCSI.size() > 0 && 395b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby "Could not find callee saved register info"); 396b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 397b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // If MBB is empty and needs restores, insert at the _beginning_. 398b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (MBB->empty()) { 399b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = MBB->begin(); 400b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } else { 401b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = MBB->end(); 402b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby --I; 403b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 404b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Skip over all terminator instructions, which are part of the 405b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // return sequence. 406b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (! I->getDesc().isTerminator()) { 407b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby ++I; 408ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } else { 409b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock::iterator I2 = I; 410b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby while (I2 != MBB->begin() && (--I2)->getDesc().isTerminator()) 411b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = I2; 412ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } 413b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 414ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 415b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby bool AtStart = I == MBB->begin(); 416b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock::iterator BeforeI = I; 417b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (!AtStart) 418b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby --BeforeI; 419b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 420b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Restore all registers immediately before the return and any 421b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // terminators that preceed it. 422b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (unsigned i = 0, e = blockCSI.size(); i != e; ++i) { 423b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby TII.loadRegFromStackSlot(*MBB, I, blockCSI[i].getReg(), 424b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI[i].getFrameIdx(), 425b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI[i].getRegClass()); 426b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby assert(I != MBB->begin() && 427b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby "loadRegFromStackSlot didn't insert any code!"); 428b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Insert in reverse order. loadRegFromStackSlot can insert 429b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // multiple instructions. 430b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (AtStart) 431b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = MBB->begin(); 432b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby else { 433b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = BeforeI; 434b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby ++I; 435ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } 43658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 437ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } 43858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner} 43958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 440cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling/// AdjustStackOffset - Helper function used to adjust the stack frame offset. 441cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendlingstatic inline void 442cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill WendlingAdjustStackOffset(MachineFrameInfo *FFI, int FrameIdx, 443cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling bool StackGrowsDown, int64_t &Offset, 444cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling unsigned &MaxAlign) { 44594188d4e67cf1c570ad87dbabf198931033d628eBob Wilson // If the stack grows down, add the object size to find the lowest address. 446cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling if (StackGrowsDown) 447cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling Offset += FFI->getObjectSize(FrameIdx); 448cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling 449cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling unsigned Align = FFI->getObjectAlignment(FrameIdx); 450cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling 451cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling // If the alignment of this object is greater than that of the stack, then 452cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling // increase the stack alignment to match. 453cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling MaxAlign = std::max(MaxAlign, Align); 454cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling 455cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling // Adjust to alignment boundary. 456cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling Offset = (Offset + Align - 1) / Align * Align; 457cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling 458cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling if (StackGrowsDown) { 459cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling FFI->setObjectOffset(FrameIdx, -Offset); // Set the computed offset 460cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling } else { 461cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling FFI->setObjectOffset(FrameIdx, Offset); 462cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling Offset += FFI->getObjectSize(FrameIdx); 463cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling } 464cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling} 46558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 46658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the 46792b9fcea7b3180ed18f379212d14bd5cea7a1954Chris Lattner/// abstract stack objects. 46858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// 46958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattnervoid PEI::calculateFrameObjectOffsets(MachineFunction &Fn) { 4709bcdcd17c7219dbc68de2f11ca2de86471c8c390Chris Lattner const TargetFrameInfo &TFI = *Fn.getTarget().getFrameInfo(); 471edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 47258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner bool StackGrowsDown = 47358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner TFI.getStackGrowthDirection() == TargetFrameInfo::StackGrowsDown; 474edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 47558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner // Loop over all of the stack objects, assigning sequential addresses... 476eb24db9727a7babe863d5afe70c7bda3a460da18Chris Lattner MachineFrameInfo *FFI = Fn.getFrameInfo(); 47758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 4780035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson unsigned MaxAlign = 1; 47978d6db5627bdf41ab3ffd96133821647dbc60d53Chris Lattner 48005d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattner // Start at the beginning of the local area. 481577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // The Offset is the distance from the stack top in the direction 482c0d6012b31afa2220306afa27db1b02e18427776Dan Gohman // of stack growth -- so it's always nonnegative. 483c34666ee1871d47dfa4865c7138902dd1b770101Bob Wilson int LocalAreaOffset = TFI.getOffsetOfLocalArea(); 484577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner if (StackGrowsDown) 485c34666ee1871d47dfa4865c7138902dd1b770101Bob Wilson LocalAreaOffset = -LocalAreaOffset; 486c34666ee1871d47dfa4865c7138902dd1b770101Bob Wilson assert(LocalAreaOffset >= 0 487577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner && "Local area offset should be in direction of stack growth"); 488c34666ee1871d47dfa4865c7138902dd1b770101Bob Wilson int64_t Offset = LocalAreaOffset; 489577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner 490577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // If there are fixed sized objects that are preallocated in the local area, 491577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // non-fixed objects can't be allocated right at the start of local area. 492ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // We currently don't support filling in holes in between fixed sized 493ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // objects, so we adjust 'Offset' to point to the end of last fixed sized 49405d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattner // preallocated object. 49505d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattner for (int i = FFI->getObjectIndexBegin(); i != 0; ++i) { 496a401b1e1c5eb9563617db8a2477b4c5f8b239521Chris Lattner int64_t FixedOff; 497577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner if (StackGrowsDown) { 498577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // The maximum distance from the stack pointer is at lower address of 499577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // the object -- which is given by offset. For down growing stack 500577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // the offset is negative, so we negate the offset to get the distance. 501577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner FixedOff = -FFI->getObjectOffset(i); 502577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner } else { 503edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman // The maximum distance from the start pointer is at the upper 504577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // address of the object. 505577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner FixedOff = FFI->getObjectOffset(i) + FFI->getObjectSize(i); 506edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman } 507edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman if (FixedOff > Offset) Offset = FixedOff; 50805d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattner } 50905d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattner 510c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // First assign frame offsets to stack objects that are used to spill 511ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng // callee saved registers. 512c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng if (StackGrowsDown) { 5135c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng for (unsigned i = MinCSFrameIndex; i <= MaxCSFrameIndex; ++i) { 514c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // If stack grows down, we need to add size of find the lowest 515c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // address of the object. 516c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng Offset += FFI->getObjectSize(i); 517c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 518c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng unsigned Align = FFI->getObjectAlignment(i); 519ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // If the alignment of this object is greater than that of the stack, 520ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // then increase the stack alignment to match. 521c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng MaxAlign = std::max(MaxAlign, Align); 522c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // Adjust to alignment boundary 523c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng Offset = (Offset+Align-1)/Align*Align; 524c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 525c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng FFI->setObjectOffset(i, -Offset); // Set the computed offset 526c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng } 527c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng } else { 528a8c63f0fc9feb48f17d702a907f065959c41e337Bruno Cardoso Lopes int MaxCSFI = MaxCSFrameIndex, MinCSFI = MinCSFrameIndex; 529a8c63f0fc9feb48f17d702a907f065959c41e337Bruno Cardoso Lopes for (int i = MaxCSFI; i >= MinCSFI ; --i) { 530c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng unsigned Align = FFI->getObjectAlignment(i); 531ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // If the alignment of this object is greater than that of the stack, 532ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // then increase the stack alignment to match. 533c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng MaxAlign = std::max(MaxAlign, Align); 534c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // Adjust to alignment boundary 535c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng Offset = (Offset+Align-1)/Align*Align; 536c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 537c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng FFI->setObjectOffset(i, Offset); 538c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng Offset += FFI->getObjectSize(i); 539c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng } 540c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng } 541c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 54287f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng // Make sure the special register scavenging spill slot is closest to the 54387f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng // frame pointer if a frame pointer is required. 5446f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo(); 54587f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng if (RS && RegInfo->hasFP(Fn)) { 54687f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng int SFI = RS->getScavengingFrameIndex(); 547cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling if (SFI >= 0) 548cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling AdjustStackOffset(FFI, SFI, StackGrowsDown, Offset, MaxAlign); 54987f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng } 55087f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng 551b2a4298ce41e7ef80cd75a3c1dfa6433f0759a1aBill Wendling // Make sure that the stack protector comes before the local variables on the 552b2a4298ce41e7ef80cd75a3c1dfa6433f0759a1aBill Wendling // stack. 553cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling if (FFI->getStackProtectorIndex() >= 0) 554cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling AdjustStackOffset(FFI, FFI->getStackProtectorIndex(), StackGrowsDown, 555cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling Offset, MaxAlign); 556b2a4298ce41e7ef80cd75a3c1dfa6433f0759a1aBill Wendling 557c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // Then assign frame offsets to stack objects that are not used to spill 558ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng // callee saved registers. 55958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner for (unsigned i = 0, e = FFI->getObjectIndexEnd(); i != e; ++i) { 560c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex) 561c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng continue; 56287f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng if (RS && (int)i == RS->getScavengingFrameIndex()) 56387f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng continue; 564d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng if (FFI->isDeadObjectIndex(i)) 565d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng continue; 56644cf38c01ff610139d2e8dbbdc4e6123a3debcddBill Wendling if (FFI->getStackProtectorIndex() == (int)i) 56744cf38c01ff610139d2e8dbbdc4e6123a3debcddBill Wendling continue; 568c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 569cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling AdjustStackOffset(FFI, i, StackGrowsDown, Offset, MaxAlign); 57058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 57158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 57287f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng // Make sure the special register scavenging spill slot is closest to the 57387f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng // stack pointer. 5748d410b69384ae4e178b3b522ef3357290a714de5Lauro Ramos Venancio if (RS && !RegInfo->hasFP(Fn)) { 57587f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng int SFI = RS->getScavengingFrameIndex(); 576cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling if (SFI >= 0) 577cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling AdjustStackOffset(FFI, SFI, StackGrowsDown, Offset, MaxAlign); 57887f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng } 57987f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng 5800035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson if (!RegInfo->targetHandlesStackFrameRounding()) { 5815c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng // If we have reserved argument space for call sites in the function 5825c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng // immediately on entry to the current function, count it as part of the 5835c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng // overall stack size. 5840035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson if (FFI->hasCalls() && RegInfo->hasReservedCallFrame(Fn)) 585367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng Offset += FFI->getMaxCallFrameSize(); 586367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng 5870035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson // Round up the size to a multiple of the alignment. If the function has 5880035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson // any calls or alloca's, align to the target's StackAlignment value to 5890035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson // ensure that the callee's frame or the alloca data is suitably aligned; 5900035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson // otherwise, for leaf functions, align to the TransientStackAlignment 5910035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson // value. 5920035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson unsigned StackAlign; 5930035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson if (FFI->hasCalls() || FFI->hasVarSizedObjects() || 5940035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson (RegInfo->needsStackRealignment(Fn) && FFI->getObjectIndexEnd() != 0)) 5950035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson StackAlign = TFI.getStackAlignment(); 5960035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson else 5970035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson StackAlign = TFI.getTransientStackAlignment(); 5980035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson // If the frame pointer is eliminated, all frame offsets will be relative 5990035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson // to SP not FP; align to MaxAlign so this works. 6000035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson StackAlign = std::max(StackAlign, MaxAlign); 6010035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson unsigned AlignMask = StackAlign - 1; 602ea84c5ee952c62dd0c703c9852d7a60715e4a435Chris Lattner Offset = (Offset + AlignMask) & ~uint64_t(AlignMask); 603367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng } 604367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng 605367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng // Update frame info to pretend that this is part of the stack... 606c34666ee1871d47dfa4865c7138902dd1b770101Bob Wilson FFI->setStackSize(Offset - LocalAreaOffset); 607cbef8ba5f959b3c4f932005ceef5cf2e0d899f9bChris Lattner 608cbef8ba5f959b3c4f932005ceef5cf2e0d899f9bChris Lattner // Remember the required stack alignment in case targets need it to perform 609cbef8ba5f959b3c4f932005ceef5cf2e0d899f9bChris Lattner // dynamic stack alignment. 6100035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson if (MaxAlign > FFI->getMaxAlignment()) 6110035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson FFI->setMaxAlignment(MaxAlign); 6124ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner} 6134ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner 6144ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner 615c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng/// insertPrologEpilogCode - Scan the function for modified callee saved 616c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng/// registers, insert spill code for these callee saved registers, then add 6174ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner/// prolog and epilog code to the function. 6184ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner/// 6194ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattnervoid PEI::insertPrologEpilogCode(MachineFunction &Fn) { 620874384e20f618d6ac932628db64e048757213fcdAnton Korobeynikov const TargetRegisterInfo *TRI = Fn.getTarget().getRegisterInfo(); 621874384e20f618d6ac932628db64e048757213fcdAnton Korobeynikov 6224ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner // Add prologue to the function... 623874384e20f618d6ac932628db64e048757213fcdAnton Korobeynikov TRI->emitPrologue(Fn); 6244ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner 6254ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner // Add epilogue to restore the callee-save registers in each exiting block 6264ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner for (MachineFunction::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) { 6274ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner // If last instruction is a return instruction, add an epilogue 628749c6f6b5ed301c84aac562e414486549d7b98ebChris Lattner if (!I->empty() && I->back().getDesc().isReturn()) 629874384e20f618d6ac932628db64e048757213fcdAnton Korobeynikov TRI->emitEpilogue(Fn, *I); 6304ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner } 63158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner} 63258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 63358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 63458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// replaceFrameIndices - Replace all MO_FrameIndex operands with physical 63558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// register references and actual offsets. 63658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// 63758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattnervoid PEI::replaceFrameIndices(MachineFunction &Fn) { 63858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner if (!Fn.getFrameInfo()->hasStackObjects()) return; // Nothing to do? 63958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 64058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner const TargetMachine &TM = Fn.getTarget(); 64158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner assert(TM.getRegisterInfo() && "TM::getRegisterInfo() must be implemented!"); 6426f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman const TargetRegisterInfo &TRI = *TM.getRegisterInfo(); 6438e3347332120956538a6d882b02719e34b57f0cdEvan Cheng const TargetFrameInfo *TFI = TM.getFrameInfo(); 6448e3347332120956538a6d882b02719e34b57f0cdEvan Cheng bool StackGrowsDown = 6458e3347332120956538a6d882b02719e34b57f0cdEvan Cheng TFI->getStackGrowthDirection() == TargetFrameInfo::StackGrowsDown; 6466f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman int FrameSetupOpcode = TRI.getCallFrameSetupOpcode(); 6476f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman int FrameDestroyOpcode = TRI.getCallFrameDestroyOpcode(); 64858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 649ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby for (MachineFunction::iterator BB = Fn.begin(), 650ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby E = Fn.end(); BB != E; ++BB) { 6518e3347332120956538a6d882b02719e34b57f0cdEvan Cheng int SPAdj = 0; // SP offset due to call frame setup / destroy. 6523d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach if (RS && !FrameIndexVirtualScavenging) RS->enterBasicBlock(BB); 653ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 6540ebe9c132c6b9c74b334f0c7503e702b499575d5Chris Lattner for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ) { 655405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 656405abffd5eb1ad1841491e51943b598c935f309bBill Wendling if (I->getOpcode() == FrameSetupOpcode || 657405abffd5eb1ad1841491e51943b598c935f309bBill Wendling I->getOpcode() == FrameDestroyOpcode) { 658405abffd5eb1ad1841491e51943b598c935f309bBill Wendling // Remember how much SP has been adjusted to create the call 659405abffd5eb1ad1841491e51943b598c935f309bBill Wendling // frame. 66071a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner int Size = I->getOperand(0).getImm(); 661405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 66271a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner if ((!StackGrowsDown && I->getOpcode() == FrameSetupOpcode) || 66371a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner (StackGrowsDown && I->getOpcode() == FrameDestroyOpcode)) 66471a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner Size = -Size; 665988a5782d3ce3cddc65d57d6aac7312d33ed59abBill Wendling 66671a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner SPAdj += Size; 667405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 6685e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner MachineBasicBlock::iterator PrevI = BB->end(); 6695e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner if (I != BB->begin()) PrevI = prior(I); 67071a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner TRI.eliminateCallFramePseudoInstr(Fn, *BB, I); 671405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 67271a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // Visit the instructions created by eliminateCallFramePseudoInstr(). 6735e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner if (PrevI == BB->end()) 6745e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner I = BB->begin(); // The replaced instr was the first in the block. 6755e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner else 6765e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner I = next(PrevI); 67771a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner continue; 6788e3347332120956538a6d882b02719e34b57f0cdEvan Cheng } 679988a5782d3ce3cddc65d57d6aac7312d33ed59abBill Wendling 68078a5bd5dbd4d99d916c69d89ceaabd83c0e52469Evan Cheng MachineInstr *MI = I; 681405abffd5eb1ad1841491e51943b598c935f309bBill Wendling bool DoIncr = true; 682405abffd5eb1ad1841491e51943b598c935f309bBill Wendling for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) 683d735b8019b0f297d7c14b55adcd887af24d8e602Dan Gohman if (MI->getOperand(i).isFI()) { 68471a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // Some instructions (e.g. inline asm instructions) can have 68571a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // multiple frame indices and/or cause eliminateFrameIndex 68671a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // to insert more than one instruction. We need the register 68771a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // scavenger to go through all of these instructions so that 68871a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // it can update its register information. We keep the 68971a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // iterator at the point before insertion so that we can 69071a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // revisit them in full. 69171a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner bool AtBeginning = (I == BB->begin()); 69271a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner if (!AtBeginning) --I; 69371a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner 69471a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // If this instruction has a FrameIndex operand, we need to 69571a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // use that target machine register info object to eliminate 69671a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // it. 697b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach int Value; 698b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach unsigned VReg = 699b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach TRI.eliminateFrameIndex(MI, SPAdj, &Value, 700b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach FrameIndexVirtualScavenging ? NULL : RS); 701b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach if (VReg) { 702b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach assert (FrameIndexVirtualScavenging && 703b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach "Not scavenging, but virtual returned from " 704b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach "eliminateFrameIndex()!"); 705b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach FrameConstantRegMap[VReg] = FrameConstantEntry(Value, SPAdj); 706b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 70771a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner 70871a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // Reset the iterator if we were at the beginning of the BB. 70971a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner if (AtBeginning) { 71071a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner I = BB->begin(); 71171a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner DoIncr = false; 71271a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner } 71371a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner 71471a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner MI = 0; 71571a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner break; 71671a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner } 717405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 7188fc2d0ee8dd4e077ee90a1fcc36fd0101c2947a2Chris Lattner if (DoIncr && I != BB->end()) ++I; 719405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 72049dd06461a7e027a6c938f0570297d46f2f34218Evan Cheng // Update register states. 7213d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach if (RS && !FrameIndexVirtualScavenging && MI) RS->forward(MI); 72249dd06461a7e027a6c938f0570297d46f2f34218Evan Cheng } 723988a5782d3ce3cddc65d57d6aac7312d33ed59abBill Wendling 7248e3347332120956538a6d882b02719e34b57f0cdEvan Cheng assert(SPAdj == 0 && "Unbalanced call frame setup / destroy pairs?"); 72549dd06461a7e027a6c938f0570297d46f2f34218Evan Cheng } 72658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner} 727b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 728b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach/// findLastUseReg - find the killing use of the specified register within 729b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach/// the instruciton range. Return the operand number of the kill in Operand. 730b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbachstatic MachineBasicBlock::iterator 731b58f498f7502e7e1833decbbbb4df771367c7341Jim GrosbachfindLastUseReg(MachineBasicBlock::iterator I, MachineBasicBlock::iterator ME, 732b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach unsigned Reg, unsigned *Operand) { 733b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // Scan forward to find the last use of this virtual register 734b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach for (++I; I != ME; ++I) { 735b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach MachineInstr *MI = I; 736b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) 737b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach if (MI->getOperand(i).isReg()) { 738b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach unsigned OpReg = MI->getOperand(i).getReg(); 739b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach if (OpReg == 0 || !TargetRegisterInfo::isVirtualRegister(OpReg)) 740b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach continue; 741b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach assert (OpReg == Reg 742b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach && "overlapping use of scavenged index register!"); 743b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // If this is the killing use, we're done 744b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach if (MI->getOperand(i).isKill()) { 745b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach if (Operand) 746b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach *Operand = i; 747b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach return I; 748b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 749b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 750b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 751b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // If we hit the end of the basic block, there was no kill of 752b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // the virtual register, which is wrong. 753b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach assert (0 && "scavenged index register never killed!"); 754b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach return ME; 755b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach} 756b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach 7579a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach/// scavengeFrameVirtualRegs - Replace all frame index virtual registers 7589a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach/// with physical registers. Use the register scavenger to find an 7599a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach/// appropriate register to use. 7603d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbachvoid PEI::scavengeFrameVirtualRegs(MachineFunction &Fn) { 7613d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach // Run through the instructions and find any virtual registers. 7623d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach for (MachineFunction::iterator BB = Fn.begin(), 7633d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach E = Fn.end(); BB != E; ++BB) { 7643d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach RS->enterBasicBlock(BB); 7653d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach 7669a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach unsigned CurrentVirtReg = 0; 7670a13e566abcfacc3e07f509437060eee294dbfeeJim Grosbach unsigned CurrentScratchReg = 0; 768e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach bool havePrevValue = false; 769b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach unsigned PrevScratchReg = 0; 770d0c38327547d6f864bec2e0b88042b1c97b89131Jim Grosbach int PrevValue = 0; 771391e1704c2e6934bae2ef5df07fc9690c26dbb62Jim Grosbach MachineInstr *PrevLastUseMI = NULL; 772391e1704c2e6934bae2ef5df07fc9690c26dbb62Jim Grosbach unsigned PrevLastUseOp = 0; 773e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach bool trackingCurrentValue = false; 774e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach int SPAdj = 0; 775e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach int Value = 0; 7763d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach 777b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // The instruction stream may change in the loop, so check BB->end() 778b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // directly. 7793d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ++I) { 7803d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach MachineInstr *MI = I; 78103d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach bool isDefInsn = false; 78203d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach bool isKillInsn = false; 78333524c3b26e3b709488d84094493d9a6098c0155Jim Grosbach for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) 7843d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach if (MI->getOperand(i).isReg()) { 785b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach MachineOperand &MO = MI->getOperand(i); 786b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach unsigned Reg = MO.getReg(); 78732030fe021ee614df6fdd77a2228e0e265049f3dJim Grosbach if (Reg == 0) 7889a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach continue; 78932030fe021ee614df6fdd77a2228e0e265049f3dJim Grosbach if (!TargetRegisterInfo::isVirtualRegister(Reg)) { 790b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // If we have a previous scratch reg, check and see if anything 791b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // here kills whatever value is in there. 792b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach if (Reg == PrevScratchReg) { 793b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach if (MO.isUse()) { 794b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // Two-address operands implicitly kill 79571c8dc9b20536e89afdae1b82075806761a57c89Jim Grosbach if (MO.isKill() || MI->isRegTiedToDefOperand(i)) { 79671c8dc9b20536e89afdae1b82075806761a57c89Jim Grosbach havePrevValue = false; 797b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach PrevScratchReg = 0; 79871c8dc9b20536e89afdae1b82075806761a57c89Jim Grosbach } 799b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } else { 800b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach assert (MO.isDef()); 80171c8dc9b20536e89afdae1b82075806761a57c89Jim Grosbach havePrevValue = false; 802b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach PrevScratchReg = 0; 803b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 804b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 80532030fe021ee614df6fdd77a2228e0e265049f3dJim Grosbach continue; 80632030fe021ee614df6fdd77a2228e0e265049f3dJim Grosbach } 80703d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach // If this is a def, remember that this insn defines the value. 80803d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach // This lets us properly consider insns which re-use the scratch 80903d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach // register, such as r2 = sub r2, #imm, in the middle of the 81003d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach // scratch range. 81103d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach if (MO.isDef()) 81203d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach isDefInsn = true; 8139a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach 814e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach // Have we already allocated a scratch register for this virtual? 8159a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach if (Reg != CurrentVirtReg) { 816e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach // When we first encounter a new virtual register, it 817e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach // must be a definition. 818e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach assert(MI->getOperand(i).isDef() && 819e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach "frame index virtual missing def!"); 820e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach // We can't have nested virtual register live ranges because 821e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach // there's only a guarantee of one scavenged register at a time. 822e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach assert (CurrentVirtReg == 0 && 823e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach "overlapping frame index virtual registers!"); 824e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach 825e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach // If the target gave us information about what's in the register, 826e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach // we can use that to re-use scratch regs. 827e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach DenseMap<unsigned, FrameConstantEntry>::iterator Entry = 828e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach FrameConstantRegMap.find(Reg); 829e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach trackingCurrentValue = Entry != FrameConstantRegMap.end(); 830e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach if (trackingCurrentValue) { 831e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach SPAdj = (*Entry).second.second; 832e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach Value = (*Entry).second.first; 833e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach } else 834e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach SPAdj = Value = 0; 835b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach 836b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // If the scratch register from the last allocation is still 837b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // available, see if the value matches. If it does, just re-use it. 838e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach if (trackingCurrentValue && havePrevValue && PrevValue == Value) { 839b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // FIXME: This assumes that the instructions in the live range 840b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // for the virtual register are exclusively for the purpose 841b8452b80f4b24bed1efe0bace9e925c2ec01122eJim Grosbach // of populating the value in the register. That's reasonable 842b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // for these frame index registers, but it's still a very, very 843b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // strong assumption. Perhaps this implies that the frame index 844b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // elimination should be before register allocation, with 845b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // conservative heuristics since we'll know less then, and 846b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // the reuse calculations done directly when doing the code-gen? 847b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach 848b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // Find the last use of the new virtual register. Remove all 849b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // instruction between here and there, and update the current 850b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // instruction to reference the last use insn instead. 851b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach MachineBasicBlock::iterator LastUseMI = 852b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach findLastUseReg(I, BB->end(), Reg, &i); 853b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // Remove all instructions up 'til the last use, since they're 854b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // just calculating the value we already have. 855b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach BB->erase(I, LastUseMI); 856b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach MI = I = LastUseMI; 85733524c3b26e3b709488d84094493d9a6098c0155Jim Grosbach e = MI->getNumOperands(); 858b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach 859b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach CurrentScratchReg = PrevScratchReg; 860b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // Extend the live range of the register 861b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach PrevLastUseMI->getOperand(PrevLastUseOp).setIsKill(false); 862b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach RS->setUsed(CurrentScratchReg); 863b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } else { 864b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach CurrentVirtReg = Reg; 865b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach const TargetRegisterClass *RC = Fn.getRegInfo().getRegClass(Reg); 866b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach CurrentScratchReg = RS->FindUnusedReg(RC); 867b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach if (CurrentScratchReg == 0) 868b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // No register is "free". Scavenge a register. 869b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach CurrentScratchReg = RS->scavengeRegister(RC, I, SPAdj); 870b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach 871b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach PrevValue = Value; 872b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 8733d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach } 8749a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach assert (CurrentScratchReg && "Missing scratch register!"); 8759a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach MI->getOperand(i).setReg(CurrentScratchReg); 8769a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach 877b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach if (MI->getOperand(i).isKill()) { 87803d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach isKillInsn = true; 879391e1704c2e6934bae2ef5df07fc9690c26dbb62Jim Grosbach PrevLastUseOp = i; 88003d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach PrevLastUseMI = MI; 881b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 8823d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach } 88303d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach // If this is the last use of the scratch, stop tracking it. The 88403d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach // last use will be a kill operand in an instruction that does 88503d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach // not also define the scratch register. 88603d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach if (isKillInsn && !isDefInsn) { 88703d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach PrevScratchReg = CurrentScratchReg; 88803d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach CurrentScratchReg = CurrentVirtReg = 0; 88903d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach havePrevValue = trackingCurrentValue; 89003d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach } 8913d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach RS->forward(MI); 8923d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach } 8933d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach } 8943d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach} 895