PrologEpilogInserter.cpp revision a0fc005321ac163f10ebc5216a85068a496969df
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 223d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach#define DEBUG_TYPE "pei" 23752c1df73949438ef6fa86a86363ee7091aa2532John Mosby#include "PrologEpilogInserter.h" 24ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby#include "llvm/CodeGen/MachineDominators.h" 25ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby#include "llvm/CodeGen/MachineLoopInfo.h" 2658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner#include "llvm/CodeGen/MachineInstr.h" 27eb24db9727a7babe863d5afe70c7bda3a460da18Chris Lattner#include "llvm/CodeGen/MachineFrameInfo.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" 363d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach#include "llvm/Support/Debug.h" 373d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach#include "llvm/ADT/IndexedMap.h" 38dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling#include "llvm/ADT/SmallSet.h" 398e3347332120956538a6d882b02719e34b57f0cdEvan Cheng#include "llvm/ADT/STLExtras.h" 40c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng#include <climits> 41ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 4205d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattnerusing namespace llvm; 43d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 443d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach// FIXME: For testing purposes only. Remove once the pre-allocation pass 453d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach// is done. 463d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbachextern cl::opt<bool> EnableLocalStackAlloc; 473d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach 48378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosbychar PEI::ID = 0; 49b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 50d13db2c59cc94162d6cf0a04187d408bfef6d4a7Owen AndersonINITIALIZE_PASS(PEI, "prologepilog", 51d13db2c59cc94162d6cf0a04187d408bfef6d4a7Owen Anderson "Prologue/Epilogue Insertion", false, false); 52b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 5358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// createPrologEpilogCodeInserter - This function returns a pass that inserts 5458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// prolog and epilog code, and eliminates abstract frame references. 5558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// 5605d8350c12d8d81de1d8af6f7da155bc1c1da50eChris LattnerFunctionPass *llvm::createPrologEpilogCodeInserter() { return new PEI(); } 5758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 58378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby/// runOnMachineFunction - Insert prolog/epilog code and replace abstract 59378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby/// frame indexes with appropriate references. 60b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby/// 61378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosbybool PEI::runOnMachineFunction(MachineFunction &Fn) { 62c5ec8a78ea898087ad361e5b755f74a76150e5fdAnton Korobeynikov const Function* F = Fn.getFunction(); 63b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby const TargetRegisterInfo *TRI = Fn.getTarget().getRegisterInfo(); 64378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby RS = TRI->requiresRegisterScavenging(Fn) ? new RegScavenger() : NULL; 6565c58daa8b8985d2116216043103009815a55e77Jim Grosbach FrameIndexVirtualScavenging = TRI->requiresFrameIndexScavenging(Fn); 667c617b5e53987d786451dd668b5113f2e2b983f8Jim Grosbach FrameConstantRegMap.clear(); 67378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 68b92187a4103dca24c3767c380f63593d1f6161a7Bill Wendling // Calculate the MaxCallFrameSize and AdjustsStack variables for the 69b92187a4103dca24c3767c380f63593d1f6161a7Bill Wendling // function's frame information. Also eliminates call frame pseudo 70b92187a4103dca24c3767c380f63593d1f6161a7Bill Wendling // instructions. 7133b350bf24be396a127c81af045468765731afc7Anton Korobeynikov calculateCallsInformation(Fn); 7233b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 73378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Allow the target machine to make some adjustments to the function 74378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // e.g. UsedPhysRegs before calculateCalleeSavedRegisters. 75378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby TRI->processFunctionBeforeCalleeSavedScan(Fn, RS); 76378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 7733b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Scan the function for modified callee saved registers and insert spill code 7833b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // for any callee saved registers that are modified. 79378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby calculateCalleeSavedRegisters(Fn); 80378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 81378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Determine placement of CSR spill/restore code: 825b02901e91a155feca84d7383c1e569aacd1739eJim Grosbach // - With shrink wrapping, place spills and restores to tightly 83378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // enclose regions in the Machine CFG of the function where 845b02901e91a155feca84d7383c1e569aacd1739eJim Grosbach // they are used. 855b02901e91a155feca84d7383c1e569aacd1739eJim Grosbach // - Without shink wrapping (default), place all spills in the 86378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // entry block, all restores in return blocks. 87378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby placeCSRSpillsAndRestores(Fn); 88378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 89378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Add the code to save and restore the callee saved registers 90c5ec8a78ea898087ad361e5b755f74a76150e5fdAnton Korobeynikov if (!F->hasFnAttr(Attribute::Naked)) 91c5ec8a78ea898087ad361e5b755f74a76150e5fdAnton Korobeynikov insertCSRSpillsAndRestores(Fn); 92378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 93378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Allow the target machine to make final modifications to the function 94378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // before the frame layout is finalized. 95378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby TRI->processFunctionBeforeFrameFinalized(Fn); 96378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 97378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Calculate actual frame offsets for all abstract stack objects... 98378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby calculateFrameObjectOffsets(Fn); 99378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 100378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Add prolog and epilog code to the function. This function is required 101378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // to align the stack frame as necessary for any stack variables or 102b92187a4103dca24c3767c380f63593d1f6161a7Bill Wendling // called functions. Because of this, calculateCalleeSavedRegisters() 103b92187a4103dca24c3767c380f63593d1f6161a7Bill Wendling // must be called before this function in order to set the AdjustsStack 104378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // and MaxCallFrameSize variables. 105c5ec8a78ea898087ad361e5b755f74a76150e5fdAnton Korobeynikov if (!F->hasFnAttr(Attribute::Naked)) 106c5ec8a78ea898087ad361e5b755f74a76150e5fdAnton Korobeynikov insertPrologEpilogCode(Fn); 107378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby 108378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // Replace all MO_FrameIndex operands with physical register references 109378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // and actual offsets. 110378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby // 111378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby replaceFrameIndices(Fn); 112b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 1133d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach // If register scavenging is needed, as we've enabled doing it as a 1143d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach // post-pass, scavenge the virtual registers that frame index elimiation 1153d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach // inserted. 1163d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach if (TRI->requiresRegisterScavenging(Fn) && FrameIndexVirtualScavenging) 1173d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach scavengeFrameVirtualRegs(Fn); 1183d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach 119378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby delete RS; 120378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby clearAllSets(); 121b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby return true; 122ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby} 123ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 124378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby#if 0 125378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosbyvoid PEI::getAnalysisUsage(AnalysisUsage &AU) const { 126845012e6d31799c7fbd1193fa1af8ee2d12e9231Dan Gohman AU.setPreservesCFG(); 127378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby if (ShrinkWrapping || ShrinkWrapFunc != "") { 128378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby AU.addRequired<MachineLoopInfo>(); 129378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby AU.addRequired<MachineDominatorTree>(); 130b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 131378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby AU.addPreserved<MachineLoopInfo>(); 132378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby AU.addPreserved<MachineDominatorTree>(); 133378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby MachineFunctionPass::getAnalysisUsage(AU); 134ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby} 135378553cb079aba2b8dee5d52b5166316d4132d5aJohn Mosby#endif 136ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 137b92187a4103dca24c3767c380f63593d1f6161a7Bill Wendling/// calculateCallsInformation - Calculate the MaxCallFrameSize and AdjustsStack 13833b350bf24be396a127c81af045468765731afc7Anton Korobeynikov/// variables for the function's frame information and eliminate call frame 13933b350bf24be396a127c81af045468765731afc7Anton Korobeynikov/// pseudo instructions. 14033b350bf24be396a127c81af045468765731afc7Anton Korobeynikovvoid PEI::calculateCallsInformation(MachineFunction &Fn) { 1416f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo(); 1429e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman MachineFrameInfo *MFI = Fn.getFrameInfo(); 14358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 14433b350bf24be396a127c81af045468765731afc7Anton Korobeynikov unsigned MaxCallFrameSize = 0; 145b92187a4103dca24c3767c380f63593d1f6161a7Bill Wendling bool AdjustsStack = MFI->adjustsStack(); 14658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 14758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner // Get the function call frame set-up and tear-down instruction opcode 14858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner int FrameSetupOpcode = RegInfo->getCallFrameSetupOpcode(); 14958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner int FrameDestroyOpcode = RegInfo->getCallFrameDestroyOpcode(); 15058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 15133b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Early exit for targets which have no call frame setup/destroy pseudo 15233b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // instructions. 15333b350bf24be396a127c81af045468765731afc7Anton Korobeynikov if (FrameSetupOpcode == -1 && FrameDestroyOpcode == -1) 15458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner return; 15558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 1565c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng std::vector<MachineBasicBlock::iterator> FrameSDOps; 15758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner for (MachineFunction::iterator BB = Fn.begin(), E = Fn.end(); BB != E; ++BB) 1585c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ++I) 159c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos if (I->getOpcode() == FrameSetupOpcode || 160d555da52f4301f0a221845d5a549848f5ae84577Chris Lattner I->getOpcode() == FrameDestroyOpcode) { 1612a82ef317c39ac436f80854c7ddbb06bfddeada1Chris Lattner assert(I->getNumOperands() >= 1 && "Call Frame Setup/Destroy Pseudo" 162d555da52f4301f0a221845d5a549848f5ae84577Chris Lattner " instructions should have a single immediate argument!"); 1639e3304900ff69c4920fea7369c9c36916c4a6a6aChris Lattner unsigned Size = I->getOperand(0).getImm(); 164d555da52f4301f0a221845d5a549848f5ae84577Chris Lattner if (Size > MaxCallFrameSize) MaxCallFrameSize = Size; 165b92187a4103dca24c3767c380f63593d1f6161a7Bill Wendling AdjustsStack = true; 1665c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng FrameSDOps.push_back(I); 167518bb53485df640d7b7e3f6b0544099020c42aa7Chris Lattner } else if (I->isInlineAsm()) { 168f1e309eb4862459a76445942ba4dafc433b6f317Dale Johannesen // Some inline asm's need a stack frame, as indicated by operand 1. 169f1e309eb4862459a76445942ba4dafc433b6f317Dale Johannesen if (I->getOperand(1).getImm()) 170f1e309eb4862459a76445942ba4dafc433b6f317Dale Johannesen AdjustsStack = true; 17158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 17258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 173b92187a4103dca24c3767c380f63593d1f6161a7Bill Wendling MFI->setAdjustsStack(AdjustsStack); 1749e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman MFI->setMaxCallFrameSize(MaxCallFrameSize); 1758e3347332120956538a6d882b02719e34b57f0cdEvan Cheng 176058a024eb7265239d527680b0a448cdb48102a46Bill Wendling for (std::vector<MachineBasicBlock::iterator>::iterator 177058a024eb7265239d527680b0a448cdb48102a46Bill Wendling i = FrameSDOps.begin(), e = FrameSDOps.end(); i != e; ++i) { 178058a024eb7265239d527680b0a448cdb48102a46Bill Wendling MachineBasicBlock::iterator I = *i; 179058a024eb7265239d527680b0a448cdb48102a46Bill Wendling 180058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // If call frames are not being included as part of the stack frame, and 1814642ad3af1cf508ac320b9afd25b065f08b36574Jim Grosbach // the target doesn't indicate otherwise, remove the call frame pseudos 1824642ad3af1cf508ac320b9afd25b065f08b36574Jim Grosbach // here. The sub/add sp instruction pairs are still inserted, but we don't 1834642ad3af1cf508ac320b9afd25b065f08b36574Jim Grosbach // need to track the SP adjustment for frame index elimination. 1844642ad3af1cf508ac320b9afd25b065f08b36574Jim Grosbach if (RegInfo->canSimplifyCallFramePseudos(Fn)) 1858e3347332120956538a6d882b02719e34b57f0cdEvan Cheng RegInfo->eliminateCallFramePseudoInstr(Fn, *I->getParent(), I); 1865c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng } 18733b350bf24be396a127c81af045468765731afc7Anton Korobeynikov} 18833b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 18933b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 19033b350bf24be396a127c81af045468765731afc7Anton Korobeynikov/// calculateCalleeSavedRegisters - Scan the function for modified callee saved 19133b350bf24be396a127c81af045468765731afc7Anton Korobeynikov/// registers. 19233b350bf24be396a127c81af045468765731afc7Anton Korobeynikovvoid PEI::calculateCalleeSavedRegisters(MachineFunction &Fn) { 19333b350bf24be396a127c81af045468765731afc7Anton Korobeynikov const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo(); 19433b350bf24be396a127c81af045468765731afc7Anton Korobeynikov const TargetFrameInfo *TFI = Fn.getTarget().getFrameInfo(); 1959e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman MachineFrameInfo *MFI = Fn.getFrameInfo(); 19633b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 19733b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Get the callee saved register list... 19833b350bf24be396a127c81af045468765731afc7Anton Korobeynikov const unsigned *CSRegs = RegInfo->getCalleeSavedRegs(&Fn); 19933b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 20033b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // These are used to keep track the callee-save area. Initialize them. 20133b350bf24be396a127c81af045468765731afc7Anton Korobeynikov MinCSFrameIndex = INT_MAX; 20233b350bf24be396a127c81af045468765731afc7Anton Korobeynikov MaxCSFrameIndex = 0; 20333b350bf24be396a127c81af045468765731afc7Anton Korobeynikov 20433b350bf24be396a127c81af045468765731afc7Anton Korobeynikov // Early exit for targets which have no callee saved registers. 20533b350bf24be396a127c81af045468765731afc7Anton Korobeynikov if (CSRegs == 0 || CSRegs[0] == 0) 20633b350bf24be396a127c81af045468765731afc7Anton Korobeynikov return; 20758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 2088c5358c93675b009ba2d57c3a5980f6bc58ba536Dale Johannesen // In Naked functions we aren't going to save any registers. 2098c5358c93675b009ba2d57c3a5980f6bc58ba536Dale Johannesen if (Fn.getFunction()->hasFnAttr(Attribute::Naked)) 2108c5358c93675b009ba2d57c3a5980f6bc58ba536Dale Johannesen return; 2118c5358c93675b009ba2d57c3a5980f6bc58ba536Dale Johannesen 21208ede262a744f99429658fadb43662441bdcb42dJim Laskey std::vector<CalleeSavedInfo> CSI; 21358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner for (unsigned i = 0; CSRegs[i]; ++i) { 21458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner unsigned Reg = CSRegs[i]; 2152afb3b7251dbcfadef7a8126e9516bde78fc13bbJim Grosbach if (Fn.getRegInfo().isPhysRegUsed(Reg)) { 216058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // If the reg is modified, save it! 21742d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola CSI.push_back(CalleeSavedInfo(Reg)); 21873ff5120eb8b8c0ccbfed8a17f1024c67a75f319Alkis Evlogimenos } else { 21973ff5120eb8b8c0ccbfed8a17f1024c67a75f319Alkis Evlogimenos for (const unsigned *AliasSet = RegInfo->getAliasSet(Reg); 2203563015b0df358cfc4ec310eb0df195015ea54a5Chris Lattner *AliasSet; ++AliasSet) { // Check alias registers too. 22184bc5427d6883f73cfeae3da640acd011d35c006Chris Lattner if (Fn.getRegInfo().isPhysRegUsed(*AliasSet)) { 22242d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola CSI.push_back(CalleeSavedInfo(Reg)); 223d555da52f4301f0a221845d5a549848f5ae84577Chris Lattner break; 224ecf8afdc2065dec1ca739e2b6a96f8e72dc34533Chris Lattner } 22573ff5120eb8b8c0ccbfed8a17f1024c67a75f319Alkis Evlogimenos } 22673ff5120eb8b8c0ccbfed8a17f1024c67a75f319Alkis Evlogimenos } 22758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 22858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 229f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey if (CSI.empty()) 230c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng return; // Early exit if no callee saved registers are modified! 23158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 232c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner unsigned NumFixedSpillSlots; 2338ff95de83cbe85d939535d2f4fb5f9b2b721081aTilmann Scheller const TargetFrameInfo::SpillSlot *FixedSpillSlots = 234ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng TFI->getCalleeSavedSpillSlots(NumFixedSpillSlots); 235c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 23658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner // Now that we know which registers need to be saved and restored, allocate 23758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner // stack slots for them. 238058a024eb7265239d527680b0a448cdb48102a46Bill Wendling for (std::vector<CalleeSavedInfo>::iterator 239058a024eb7265239d527680b0a448cdb48102a46Bill Wendling I = CSI.begin(), E = CSI.end(); I != E; ++I) { 240058a024eb7265239d527680b0a448cdb48102a46Bill Wendling unsigned Reg = I->getReg(); 24142d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola const TargetRegisterClass *RC = RegInfo->getMinimalPhysRegClass(Reg); 242c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 243910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng int FrameIdx; 244910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng if (RegInfo->hasReservedSpillSlot(Fn, Reg, FrameIdx)) { 245910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng I->setFrameIdx(FrameIdx); 246910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng continue; 247910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng } 248910139f9ca53fc20a680d51ae61bb1e072095141Evan Cheng 249c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner // Check to see if this physreg must be spilled to a particular stack slot 250c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner // on this target. 2518ff95de83cbe85d939535d2f4fb5f9b2b721081aTilmann Scheller const TargetFrameInfo::SpillSlot *FixedSlot = FixedSpillSlots; 252c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner while (FixedSlot != FixedSpillSlots+NumFixedSpillSlots && 2538ff95de83cbe85d939535d2f4fb5f9b2b721081aTilmann Scheller FixedSlot->Reg != Reg) 254c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner ++FixedSlot; 255c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 256058a024eb7265239d527680b0a448cdb48102a46Bill Wendling if (FixedSlot == FixedSpillSlots + NumFixedSpillSlots) { 257c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner // Nope, just spill it anywhere convenient. 2585feaa9a70716e9181a9b940236bc461f2a75334aEvan Cheng unsigned Align = RC->getAlignment(); 2595feaa9a70716e9181a9b940236bc461f2a75334aEvan Cheng unsigned StackAlign = TFI->getStackAlignment(); 260058a024eb7265239d527680b0a448cdb48102a46Bill Wendling 261058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // We may not be able to satisfy the desired alignment specification of 262058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // the TargetRegisterClass if the stack alignment is smaller. Use the 263058a024eb7265239d527680b0a448cdb48102a46Bill Wendling // min. 2645feaa9a70716e9181a9b940236bc461f2a75334aEvan Cheng Align = std::min(Align, StackAlign); 2659e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman FrameIdx = MFI->CreateStackObject(RC->getSize(), Align, true); 266c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng if ((unsigned)FrameIdx < MinCSFrameIndex) MinCSFrameIndex = FrameIdx; 267c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng if ((unsigned)FrameIdx > MaxCSFrameIndex) MaxCSFrameIndex = FrameIdx; 268c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner } else { 269c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner // Spill it to the stack where we must. 270ed2ae136d29dd36122d2476801e7d7a86e8301e3Evan Cheng FrameIdx = MFI->CreateFixedObject(RC->getSize(), FixedSlot->Offset, true); 271c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner } 272058a024eb7265239d527680b0a448cdb48102a46Bill Wendling 273058a024eb7265239d527680b0a448cdb48102a46Bill Wendling I->setFrameIdx(FrameIdx); 27458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 27508ede262a744f99429658fadb43662441bdcb42dJim Laskey 2769e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman MFI->setCalleeSavedInfo(CSI); 277c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner} 278c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 279ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby/// insertCSRSpillsAndRestores - Insert spill and restore code for 280ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby/// callee saved registers used in the function, handling shrink wrapping. 281c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner/// 282ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosbyvoid PEI::insertCSRSpillsAndRestores(MachineFunction &Fn) { 283f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey // Get callee saved register information. 2849e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman MachineFrameInfo *MFI = Fn.getFrameInfo(); 2859e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo(); 286ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 2879e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman MFI->setCalleeSavedInfoValid(true); 288d62c9a697b53f9e754926a89126fd121220ed09bJakob Stoklund Olesen 289c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // Early exit if no callee saved registers are modified! 290f3e4f0e615bb2c36c4a9d60bb908e08b76025c75Jim Laskey if (CSI.empty()) 291edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman return; 292c330b68fb7f1cb7f05a60ab4d811bba397538840Chris Lattner 293f6372aa1cc568df19da7c5023e83c75aa9404a07Owen Anderson const TargetInstrInfo &TII = *Fn.getTarget().getInstrInfo(); 294746ad69e088176819981b4b2c5ac8dcd49f5e60eEvan Cheng const TargetRegisterInfo *TRI = Fn.getTarget().getRegisterInfo(); 295ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby MachineBasicBlock::iterator I; 29600dff8dda29b5a249cd99405ce26e84cef13ba53Evan Cheng 297b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (! ShrinkWrapThisFunction) { 298b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Spill using target interface. 299b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = EntryBlock->begin(); 3002457f2c66184e978d4ed8fa9e2128effff26cb0bEvan Cheng if (!TII.spillCalleeSavedRegisters(*EntryBlock, I, CSI, TRI)) { 301b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 302ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // Add the callee-saved register as live-in. 303ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // It's killed at the spill. 304b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby EntryBlock->addLiveIn(CSI[i].getReg()); 305ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 306ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // Insert the spill to the stack frame. 30742d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola unsigned Reg = CSI[i].getReg(); 30842d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg); 30942d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola TII.storeRegToStackSlot(*EntryBlock, I, Reg, true, 31042d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola CSI[i].getFrameIdx(), RC, TRI); 311ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } 312ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng } 313ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 314b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Restore using target interface. 315b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (unsigned ri = 0, re = ReturnBlocks.size(); ri != re; ++ri) { 316b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock* MBB = ReturnBlocks[ri]; 317c0b9dc5be79f009d260edb5cd5e1d8346587aaa2Alkis Evlogimenos I = MBB->end(); --I; 31858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 319f7c094000f4baf094b1d60ba68a5b4e0193c502aBill Wendling // Skip over all terminator instructions, which are part of the return 3204fc997941dde5c11e91a28c9b5b8fa331d053a18Chris Lattner // sequence. 3214fc997941dde5c11e91a28c9b5b8fa331d053a18Chris Lattner MachineBasicBlock::iterator I2 = I; 322f7c094000f4baf094b1d60ba68a5b4e0193c502aBill Wendling while (I2 != MBB->begin() && (--I2)->getDesc().isTerminator()) 3234fc997941dde5c11e91a28c9b5b8fa331d053a18Chris Lattner I = I2; 3244fc997941dde5c11e91a28c9b5b8fa331d053a18Chris Lattner 325dfd58709cc78e841ef4a50ba75d940473031617eChris Lattner bool AtStart = I == MBB->begin(); 326ed461e0fafbd0b905cb716df108000bcd6ecf3d4Chris Lattner MachineBasicBlock::iterator BeforeI = I; 327ed461e0fafbd0b905cb716df108000bcd6ecf3d4Chris Lattner if (!AtStart) 328ed461e0fafbd0b905cb716df108000bcd6ecf3d4Chris Lattner --BeforeI; 329ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 330ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // Restore all registers immediately before the return and any 331ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // terminators that preceed it. 3322457f2c66184e978d4ed8fa9e2128effff26cb0bEvan Cheng if (!TII.restoreCalleeSavedRegisters(*MBB, I, CSI, TRI)) { 333ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 33442d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola unsigned Reg = CSI[i].getReg(); 33542d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg); 33642d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola TII.loadRegFromStackSlot(*MBB, I, Reg, 337ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby CSI[i].getFrameIdx(), 33842d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola RC, TRI); 339ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng assert(I != MBB->begin() && 340ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng "loadRegFromStackSlot didn't insert any code!"); 341ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // Insert in reverse order. loadRegFromStackSlot can insert 342ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // multiple instructions. 343ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng if (AtStart) 344ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng I = MBB->begin(); 345ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng else { 346ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng I = BeforeI; 347ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng ++I; 348ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng } 349ed461e0fafbd0b905cb716df108000bcd6ecf3d4Chris Lattner } 35058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 351b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 352b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby return; 353b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 354ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 355b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Insert spills. 356b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby std::vector<CalleeSavedInfo> blockCSI; 357b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (CSRegBlockMap::iterator BI = CSRSave.begin(), 358b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby BE = CSRSave.end(); BI != BE; ++BI) { 359b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock* MBB = BI->first; 360b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby CSRegSet save = BI->second; 361ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 362b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (save.empty()) 363b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby continue; 364ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 365b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI.clear(); 366b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (CSRegSet::iterator RI = save.begin(), 367b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby RE = save.end(); RI != RE; ++RI) { 368b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI.push_back(CSI[*RI]); 369b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 370b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby assert(blockCSI.size() > 0 && 371b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby "Could not collect callee saved register info"); 372b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 373b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = MBB->begin(); 374b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 375b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // When shrink wrapping, use stack slot stores/loads. 376b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (unsigned i = 0, e = blockCSI.size(); i != e; ++i) { 377b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Add the callee-saved register as live-in. 378b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // It's killed at the spill. 379b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MBB->addLiveIn(blockCSI[i].getReg()); 380b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 381b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Insert the spill to the stack frame. 38242d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola unsigned Reg = blockCSI[i].getReg(); 38342d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg); 38442d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola TII.storeRegToStackSlot(*MBB, I, Reg, 385b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby true, 386b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI[i].getFrameIdx(), 38742d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola RC, TRI); 388b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 389b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 390b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 391b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (CSRegBlockMap::iterator BI = CSRRestore.begin(), 392b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby BE = CSRRestore.end(); BI != BE; ++BI) { 393b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock* MBB = BI->first; 394b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby CSRegSet restore = BI->second; 395b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 396b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (restore.empty()) 397b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby continue; 398b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 399b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI.clear(); 400b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (CSRegSet::iterator RI = restore.begin(), 401b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby RE = restore.end(); RI != RE; ++RI) { 402b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI.push_back(CSI[*RI]); 403b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 404b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby assert(blockCSI.size() > 0 && 405b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby "Could not find callee saved register info"); 406b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 407b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // If MBB is empty and needs restores, insert at the _beginning_. 408b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (MBB->empty()) { 409b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = MBB->begin(); 410b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } else { 411b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = MBB->end(); 412b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby --I; 413b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 414b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Skip over all terminator instructions, which are part of the 415b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // return sequence. 416b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (! I->getDesc().isTerminator()) { 417b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby ++I; 418ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } else { 419b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock::iterator I2 = I; 420b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby while (I2 != MBB->begin() && (--I2)->getDesc().isTerminator()) 421b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = I2; 422ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } 423b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby } 424ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 425b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby bool AtStart = I == MBB->begin(); 426b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby MachineBasicBlock::iterator BeforeI = I; 427b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (!AtStart) 428b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby --BeforeI; 429b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 430b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Restore all registers immediately before the return and any 431b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // terminators that preceed it. 432b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby for (unsigned i = 0, e = blockCSI.size(); i != e; ++i) { 43342d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola unsigned Reg = blockCSI[i].getReg(); 43442d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg); 43542d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola TII.loadRegFromStackSlot(*MBB, I, Reg, 436b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby blockCSI[i].getFrameIdx(), 43742d075c4fb21995265961501cec9ff6e3fb497ceRafael Espindola RC, TRI); 438b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby assert(I != MBB->begin() && 439b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby "loadRegFromStackSlot didn't insert any code!"); 440b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // Insert in reverse order. loadRegFromStackSlot can insert 441b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby // multiple instructions. 442b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby if (AtStart) 443b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = MBB->begin(); 444b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby else { 445b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby I = BeforeI; 446b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby ++I; 447ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } 44858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 449ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby } 45058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner} 45158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 452cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling/// AdjustStackOffset - Helper function used to adjust the stack frame offset. 453cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendlingstatic inline void 4549e9aa44d1a33fb845268ba07b726a31f26195690Dan GohmanAdjustStackOffset(MachineFrameInfo *MFI, int FrameIdx, 455cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling bool StackGrowsDown, int64_t &Offset, 456cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling unsigned &MaxAlign) { 45794188d4e67cf1c570ad87dbabf198931033d628eBob Wilson // If the stack grows down, add the object size to find the lowest address. 458cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling if (StackGrowsDown) 4599e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman Offset += MFI->getObjectSize(FrameIdx); 460cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling 4619e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman unsigned Align = MFI->getObjectAlignment(FrameIdx); 462cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling 463cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling // If the alignment of this object is greater than that of the stack, then 464cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling // increase the stack alignment to match. 465cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling MaxAlign = std::max(MaxAlign, Align); 466cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling 467cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling // Adjust to alignment boundary. 468cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling Offset = (Offset + Align - 1) / Align * Align; 469cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling 470cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling if (StackGrowsDown) { 4713d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") at SP[" << -Offset << "]\n"); 4729e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman MFI->setObjectOffset(FrameIdx, -Offset); // Set the computed offset 473cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling } else { 4743d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach DEBUG(dbgs() << "alloc FI(" << FrameIdx << ") at SP[" << Offset << "]\n"); 4759e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman MFI->setObjectOffset(FrameIdx, Offset); 4769e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman Offset += MFI->getObjectSize(FrameIdx); 477cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling } 478cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling} 47958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 48058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// calculateFrameObjectOffsets - Calculate actual frame offsets for all of the 48192b9fcea7b3180ed18f379212d14bd5cea7a1954Chris Lattner/// abstract stack objects. 48258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// 48358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattnervoid PEI::calculateFrameObjectOffsets(MachineFunction &Fn) { 4849bcdcd17c7219dbc68de2f11ca2de86471c8c390Chris Lattner const TargetFrameInfo &TFI = *Fn.getTarget().getFrameInfo(); 485edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 48658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner bool StackGrowsDown = 48758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner TFI.getStackGrowthDirection() == TargetFrameInfo::StackGrowsDown; 488edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman 48958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner // Loop over all of the stack objects, assigning sequential addresses... 4909e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman MachineFrameInfo *MFI = Fn.getFrameInfo(); 49158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 49205d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattner // Start at the beginning of the local area. 493577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // The Offset is the distance from the stack top in the direction 494c0d6012b31afa2220306afa27db1b02e18427776Dan Gohman // of stack growth -- so it's always nonnegative. 495c34666ee1871d47dfa4865c7138902dd1b770101Bob Wilson int LocalAreaOffset = TFI.getOffsetOfLocalArea(); 496577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner if (StackGrowsDown) 497c34666ee1871d47dfa4865c7138902dd1b770101Bob Wilson LocalAreaOffset = -LocalAreaOffset; 498c34666ee1871d47dfa4865c7138902dd1b770101Bob Wilson assert(LocalAreaOffset >= 0 499577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner && "Local area offset should be in direction of stack growth"); 500c34666ee1871d47dfa4865c7138902dd1b770101Bob Wilson int64_t Offset = LocalAreaOffset; 501577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner 502577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // If there are fixed sized objects that are preallocated in the local area, 503577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // non-fixed objects can't be allocated right at the start of local area. 504ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // We currently don't support filling in holes in between fixed sized 505ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby // objects, so we adjust 'Offset' to point to the end of last fixed sized 50605d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattner // preallocated object. 5079e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman for (int i = MFI->getObjectIndexBegin(); i != 0; ++i) { 508a401b1e1c5eb9563617db8a2477b4c5f8b239521Chris Lattner int64_t FixedOff; 509577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner if (StackGrowsDown) { 510577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // The maximum distance from the stack pointer is at lower address of 511577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // the object -- which is given by offset. For down growing stack 512577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // the offset is negative, so we negate the offset to get the distance. 5139e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman FixedOff = -MFI->getObjectOffset(i); 514577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner } else { 515edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman // The maximum distance from the start pointer is at the upper 516577aec14288b86ab1fb07e164375ebc7d3038cb7Chris Lattner // address of the object. 5179e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman FixedOff = MFI->getObjectOffset(i) + MFI->getObjectSize(i); 518edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman } 519edf128a7fa90f2b0b7ee24741a04a7ae1ecd6f7eMisha Brukman if (FixedOff > Offset) Offset = FixedOff; 52005d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattner } 52105d8350c12d8d81de1d8af6f7da155bc1c1da50eChris Lattner 522c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // First assign frame offsets to stack objects that are used to spill 523ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng // callee saved registers. 524c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng if (StackGrowsDown) { 5255c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng for (unsigned i = MinCSFrameIndex; i <= MaxCSFrameIndex; ++i) { 526b4c14aaa50b58ac723d0ed179695e1cd7296572aEric Christopher // If the stack grows down, we need to add the size to find the lowest 527c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // address of the object. 5289e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman Offset += MFI->getObjectSize(i); 529c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 5309e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman unsigned Align = MFI->getObjectAlignment(i); 531c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // Adjust to alignment boundary 532c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng Offset = (Offset+Align-1)/Align*Align; 533c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 5349e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman MFI->setObjectOffset(i, -Offset); // Set the computed offset 535c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng } 536c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng } else { 537a8c63f0fc9feb48f17d702a907f065959c41e337Bruno Cardoso Lopes int MaxCSFI = MaxCSFrameIndex, MinCSFI = MinCSFrameIndex; 538a8c63f0fc9feb48f17d702a907f065959c41e337Bruno Cardoso Lopes for (int i = MaxCSFI; i >= MinCSFI ; --i) { 5399e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman unsigned Align = MFI->getObjectAlignment(i); 540c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // Adjust to alignment boundary 541c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng Offset = (Offset+Align-1)/Align*Align; 542c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 5439e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman MFI->setObjectOffset(i, Offset); 5449e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman Offset += MFI->getObjectSize(i); 545c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng } 546c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng } 547c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 5489e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman unsigned MaxAlign = MFI->getMaxAlignment(); 5497545f49a5edfe19612d03e683d8b955c03018056Evan Cheng 55087f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng // Make sure the special register scavenging spill slot is closest to the 55187f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng // frame pointer if a frame pointer is required. 5526f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman const TargetRegisterInfo *RegInfo = Fn.getTarget().getRegisterInfo(); 553f2ce516828ed6b04bad5132a13c8e228d9a0b117Jim Grosbach if (RS && RegInfo->hasFP(Fn) && !RegInfo->needsStackRealignment(Fn)) { 55487f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng int SFI = RS->getScavengingFrameIndex(); 555cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling if (SFI >= 0) 5569e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman AdjustStackOffset(MFI, SFI, StackGrowsDown, Offset, MaxAlign); 55787f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng } 55887f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng 5594861ed60ac68a543d1b88e631e9fe2c55583b24bJim Grosbach // FIXME: Once this is working, then enable flag will change to a target 5604861ed60ac68a543d1b88e631e9fe2c55583b24bJim Grosbach // check for whether the frame is large enough to want to use virtual 5614861ed60ac68a543d1b88e631e9fe2c55583b24bJim Grosbach // frame index registers. Functions which don't want/need this optimization 5624861ed60ac68a543d1b88e631e9fe2c55583b24bJim Grosbach // will continue to use the existing code path. 563a0fc005321ac163f10ebc5216a85068a496969dfJim Grosbach if (EnableLocalStackAlloc && MFI->getUseLocalStackAllocationBlock()) { 5644861ed60ac68a543d1b88e631e9fe2c55583b24bJim Grosbach unsigned Align = MFI->getLocalFrameMaxAlign(); 5654861ed60ac68a543d1b88e631e9fe2c55583b24bJim Grosbach 5664861ed60ac68a543d1b88e631e9fe2c55583b24bJim Grosbach // Adjust to alignment boundary. 5674861ed60ac68a543d1b88e631e9fe2c55583b24bJim Grosbach Offset = (Offset + Align - 1) / Align * Align; 5684861ed60ac68a543d1b88e631e9fe2c55583b24bJim Grosbach 5694861ed60ac68a543d1b88e631e9fe2c55583b24bJim Grosbach // Store the offset of the start of the local allocation block. This 5704861ed60ac68a543d1b88e631e9fe2c55583b24bJim Grosbach // will be used later when resolving frame base virtual register pseudos. 5714861ed60ac68a543d1b88e631e9fe2c55583b24bJim Grosbach MFI->setLocalFrameBaseOffset(Offset); 5724861ed60ac68a543d1b88e631e9fe2c55583b24bJim Grosbach 573fecdea0bf77599038eb368db3bc6a38a14900308Jim Grosbach DEBUG(dbgs() << "Local frame base offset: " << Offset << "\n"); 574fecdea0bf77599038eb368db3bc6a38a14900308Jim Grosbach 5753d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach // Allocate the local block 5763d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach Offset += MFI->getLocalFrameSize(); 5773d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach 5783d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach // Resolve offsets for objects in the local block. 5793d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach for (unsigned i = 0, e = MFI->getLocalFrameObjectCount(); i != e; ++i) { 5803d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach std::pair<int, int64_t> Entry = MFI->getLocalFrameObjectMap(i); 5813d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach int64_t FIOffset = MFI->getLocalFrameBaseOffset() + Entry.second; 5823d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach 5833d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach AdjustStackOffset(MFI, Entry.first, StackGrowsDown, FIOffset, MaxAlign); 5843d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach } 5853d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach } 5863d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach 587b2a4298ce41e7ef80cd75a3c1dfa6433f0759a1aBill Wendling // Make sure that the stack protector comes before the local variables on the 588b2a4298ce41e7ef80cd75a3c1dfa6433f0759a1aBill Wendling // stack. 589dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling SmallSet<int, 16> LargeStackObjs; 590dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling if (MFI->getStackProtectorIndex() >= 0) { 5919e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman AdjustStackOffset(MFI, MFI->getStackProtectorIndex(), StackGrowsDown, 592cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling Offset, MaxAlign); 593b2a4298ce41e7ef80cd75a3c1dfa6433f0759a1aBill Wendling 594dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling // Assign large stack objects first. 595dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling for (unsigned i = 0, e = MFI->getObjectIndexEnd(); i != e; ++i) { 596a0fc005321ac163f10ebc5216a85068a496969dfJim Grosbach if (MFI->isObjectPreAllocated(i) && 597a0fc005321ac163f10ebc5216a85068a496969dfJim Grosbach MFI->getUseLocalStackAllocationBlock()) 5983d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach continue; 599dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex) 600dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling continue; 601dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling if (RS && (int)i == RS->getScavengingFrameIndex()) 602dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling continue; 603dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling if (MFI->isDeadObjectIndex(i)) 604dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling continue; 605dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling if (MFI->getStackProtectorIndex() == (int)i) 606dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling continue; 607dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling if (!MFI->MayNeedStackProtector(i)) 608dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling continue; 609dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling 610dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling AdjustStackOffset(MFI, i, StackGrowsDown, Offset, MaxAlign); 611dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling LargeStackObjs.insert(i); 612dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling } 613dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling } 614dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling 615c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng // Then assign frame offsets to stack objects that are not used to spill 616ad93d7fda53d92d07a3b3a2087e46de7cd695752Evan Cheng // callee saved registers. 6179e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman for (unsigned i = 0, e = MFI->getObjectIndexEnd(); i != e; ++i) { 618a0fc005321ac163f10ebc5216a85068a496969dfJim Grosbach if (MFI->isObjectPreAllocated(i) && 619a0fc005321ac163f10ebc5216a85068a496969dfJim Grosbach MFI->getUseLocalStackAllocationBlock()) 6203d72367d30c9ce6f387764a028763f7a366cc443Jim Grosbach continue; 621c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng if (i >= MinCSFrameIndex && i <= MaxCSFrameIndex) 622c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng continue; 62387f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng if (RS && (int)i == RS->getScavengingFrameIndex()) 62487f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng continue; 6259e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman if (MFI->isDeadObjectIndex(i)) 626d36531249a9a9500e516148e7e72d4c0a7a4d0eeEvan Cheng continue; 6279e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman if (MFI->getStackProtectorIndex() == (int)i) 62844cf38c01ff610139d2e8dbbdc4e6123a3debcddBill Wendling continue; 629dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling if (LargeStackObjs.count(i)) 630dfc2c51d12fd53822279b6e564cdd5cef5c00b46Bill Wendling continue; 631c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng 6329e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman AdjustStackOffset(MFI, i, StackGrowsDown, Offset, MaxAlign); 63358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner } 63458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 63587f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng // Make sure the special register scavenging spill slot is closest to the 63687f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng // stack pointer. 637f2ce516828ed6b04bad5132a13c8e228d9a0b117Jim Grosbach if (RS && (!RegInfo->hasFP(Fn) || RegInfo->needsStackRealignment(Fn))) { 63887f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng int SFI = RS->getScavengingFrameIndex(); 639cab3e68136b20a10cb0fe8ad97874bacf27dda7dBill Wendling if (SFI >= 0) 6409e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman AdjustStackOffset(MFI, SFI, StackGrowsDown, Offset, MaxAlign); 64187f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng } 64287f8bf65dd869348dd4d2884a417e2e22ae4f981Evan Cheng 6430035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson if (!RegInfo->targetHandlesStackFrameRounding()) { 6445c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng // If we have reserved argument space for call sites in the function 6455c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng // immediately on entry to the current function, count it as part of the 6465c3885ce8e6a3dc69913b50fe6bdc0c89c5432d5Evan Cheng // overall stack size. 647b92187a4103dca24c3767c380f63593d1f6161a7Bill Wendling if (MFI->adjustsStack() && RegInfo->hasReservedCallFrame(Fn)) 6489e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman Offset += MFI->getMaxCallFrameSize(); 649367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng 6500035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson // Round up the size to a multiple of the alignment. If the function has 6510035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson // any calls or alloca's, align to the target's StackAlignment value to 6520035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson // ensure that the callee's frame or the alloca data is suitably aligned; 6530035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson // otherwise, for leaf functions, align to the TransientStackAlignment 6540035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson // value. 6550035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson unsigned StackAlign; 656b92187a4103dca24c3767c380f63593d1f6161a7Bill Wendling if (MFI->adjustsStack() || MFI->hasVarSizedObjects() || 6579e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman (RegInfo->needsStackRealignment(Fn) && MFI->getObjectIndexEnd() != 0)) 6580035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson StackAlign = TFI.getStackAlignment(); 6590035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson else 6600035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson StackAlign = TFI.getTransientStackAlignment(); 661b92187a4103dca24c3767c380f63593d1f6161a7Bill Wendling 662b92187a4103dca24c3767c380f63593d1f6161a7Bill Wendling // If the frame pointer is eliminated, all frame offsets will be relative to 663b92187a4103dca24c3767c380f63593d1f6161a7Bill Wendling // SP not FP. Align to MaxAlign so this works. 6640035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson StackAlign = std::max(StackAlign, MaxAlign); 6650035f9c3b9982eeef098b608fceb7572df969b3eBob Wilson unsigned AlignMask = StackAlign - 1; 666ea84c5ee952c62dd0c703c9852d7a60715e4a435Chris Lattner Offset = (Offset + AlignMask) & ~uint64_t(AlignMask); 667367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng } 668367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng 669367372a30c36776e31958f0dc38306f32b80aa7cEvan Cheng // Update frame info to pretend that this is part of the stack... 6709e9aa44d1a33fb845268ba07b726a31f26195690Dan Gohman MFI->setStackSize(Offset - LocalAreaOffset); 6714ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner} 6724ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner 673c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng/// insertPrologEpilogCode - Scan the function for modified callee saved 674c2b4ec37dea2586765a04d74120e1b6197bbd804Evan Cheng/// registers, insert spill code for these callee saved registers, then add 6754ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner/// prolog and epilog code to the function. 6764ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner/// 6774ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattnervoid PEI::insertPrologEpilogCode(MachineFunction &Fn) { 678874384e20f618d6ac932628db64e048757213fcdAnton Korobeynikov const TargetRegisterInfo *TRI = Fn.getTarget().getRegisterInfo(); 679874384e20f618d6ac932628db64e048757213fcdAnton Korobeynikov 6804ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner // Add prologue to the function... 681874384e20f618d6ac932628db64e048757213fcdAnton Korobeynikov TRI->emitPrologue(Fn); 6824ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner 6834ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner // Add epilogue to restore the callee-save registers in each exiting block 6844ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner for (MachineFunction::iterator I = Fn.begin(), E = Fn.end(); I != E; ++I) { 6854ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner // If last instruction is a return instruction, add an epilogue 686749c6f6b5ed301c84aac562e414486549d7b98ebChris Lattner if (!I->empty() && I->back().getDesc().isReturn()) 687874384e20f618d6ac932628db64e048757213fcdAnton Korobeynikov TRI->emitEpilogue(Fn, *I); 6884ac7d7302b36a5d20f71b5c290c63a7f6c345289Chris Lattner } 68958b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner} 69058b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 69158b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// replaceFrameIndices - Replace all MO_FrameIndex operands with physical 69258b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// register references and actual offsets. 69358b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner/// 69458b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattnervoid PEI::replaceFrameIndices(MachineFunction &Fn) { 69558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner if (!Fn.getFrameInfo()->hasStackObjects()) return; // Nothing to do? 69658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 69758b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner const TargetMachine &TM = Fn.getTarget(); 69858b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner assert(TM.getRegisterInfo() && "TM::getRegisterInfo() must be implemented!"); 6996f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman const TargetRegisterInfo &TRI = *TM.getRegisterInfo(); 7008e3347332120956538a6d882b02719e34b57f0cdEvan Cheng const TargetFrameInfo *TFI = TM.getFrameInfo(); 7018e3347332120956538a6d882b02719e34b57f0cdEvan Cheng bool StackGrowsDown = 7028e3347332120956538a6d882b02719e34b57f0cdEvan Cheng TFI->getStackGrowthDirection() == TargetFrameInfo::StackGrowsDown; 7036f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman int FrameSetupOpcode = TRI.getCallFrameSetupOpcode(); 7046f0d024a534af18d9e60b3ea757376cd8a3a980eDan Gohman int FrameDestroyOpcode = TRI.getCallFrameDestroyOpcode(); 70558b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner 706ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby for (MachineFunction::iterator BB = Fn.begin(), 707ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby E = Fn.end(); BB != E; ++BB) { 7086627ac040a14f3a79564fd6ec030f9361f81d20eJim Grosbach#ifndef NDEBUG 7096627ac040a14f3a79564fd6ec030f9361f81d20eJim Grosbach int SPAdjCount = 0; // frame setup / destroy count. 7106627ac040a14f3a79564fd6ec030f9361f81d20eJim Grosbach#endif 7118e3347332120956538a6d882b02719e34b57f0cdEvan Cheng int SPAdj = 0; // SP offset due to call frame setup / destroy. 7123d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach if (RS && !FrameIndexVirtualScavenging) RS->enterBasicBlock(BB); 713ea4d351fc690bd6558fe9ca61db88ee809f0572fJohn Mosby 7140ebe9c132c6b9c74b334f0c7503e702b499575d5Chris Lattner for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ) { 715405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 716405abffd5eb1ad1841491e51943b598c935f309bBill Wendling if (I->getOpcode() == FrameSetupOpcode || 717405abffd5eb1ad1841491e51943b598c935f309bBill Wendling I->getOpcode() == FrameDestroyOpcode) { 7186627ac040a14f3a79564fd6ec030f9361f81d20eJim Grosbach#ifndef NDEBUG 7196627ac040a14f3a79564fd6ec030f9361f81d20eJim Grosbach // Track whether we see even pairs of them 7206627ac040a14f3a79564fd6ec030f9361f81d20eJim Grosbach SPAdjCount += I->getOpcode() == FrameSetupOpcode ? 1 : -1; 7216627ac040a14f3a79564fd6ec030f9361f81d20eJim Grosbach#endif 722405abffd5eb1ad1841491e51943b598c935f309bBill Wendling // Remember how much SP has been adjusted to create the call 723405abffd5eb1ad1841491e51943b598c935f309bBill Wendling // frame. 72471a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner int Size = I->getOperand(0).getImm(); 725405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 72671a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner if ((!StackGrowsDown && I->getOpcode() == FrameSetupOpcode) || 72771a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner (StackGrowsDown && I->getOpcode() == FrameDestroyOpcode)) 72871a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner Size = -Size; 729988a5782d3ce3cddc65d57d6aac7312d33ed59abBill Wendling 73071a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner SPAdj += Size; 731405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 7325e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner MachineBasicBlock::iterator PrevI = BB->end(); 7335e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner if (I != BB->begin()) PrevI = prior(I); 73471a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner TRI.eliminateCallFramePseudoInstr(Fn, *BB, I); 735405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 73671a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // Visit the instructions created by eliminateCallFramePseudoInstr(). 7375e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner if (PrevI == BB->end()) 7385e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner I = BB->begin(); // The replaced instr was the first in the block. 7395e6345bde0f3a6405ec1ea852f1e5e5df8642f9cChris Lattner else 7407896c9f436a4eda5ec15e882a7505ba482a2fcd0Chris Lattner I = llvm::next(PrevI); 74171a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner continue; 7428e3347332120956538a6d882b02719e34b57f0cdEvan Cheng } 743988a5782d3ce3cddc65d57d6aac7312d33ed59abBill Wendling 74478a5bd5dbd4d99d916c69d89ceaabd83c0e52469Evan Cheng MachineInstr *MI = I; 745405abffd5eb1ad1841491e51943b598c935f309bBill Wendling bool DoIncr = true; 746405abffd5eb1ad1841491e51943b598c935f309bBill Wendling for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) 747d735b8019b0f297d7c14b55adcd887af24d8e602Dan Gohman if (MI->getOperand(i).isFI()) { 74871a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // Some instructions (e.g. inline asm instructions) can have 74971a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // multiple frame indices and/or cause eliminateFrameIndex 75071a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // to insert more than one instruction. We need the register 75171a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // scavenger to go through all of these instructions so that 75271a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // it can update its register information. We keep the 75371a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // iterator at the point before insertion so that we can 75471a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // revisit them in full. 75571a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner bool AtBeginning = (I == BB->begin()); 75671a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner if (!AtBeginning) --I; 75771a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner 75871a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // If this instruction has a FrameIndex operand, we need to 75971a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // use that target machine register info object to eliminate 76071a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // it. 761dff4b4c5a7cc894d3b4b6c6e779ea8f47fa50630Jim Grosbach TargetRegisterInfo::FrameIndexValue Value; 762b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach unsigned VReg = 763b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach TRI.eliminateFrameIndex(MI, SPAdj, &Value, 764b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach FrameIndexVirtualScavenging ? NULL : RS); 765b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach if (VReg) { 766b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach assert (FrameIndexVirtualScavenging && 767b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach "Not scavenging, but virtual returned from " 768b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach "eliminateFrameIndex()!"); 7697c617b5e53987d786451dd668b5113f2e2b983f8Jim Grosbach FrameConstantRegMap[VReg] = FrameConstantEntry(Value, SPAdj); 770b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 77171a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner 77271a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner // Reset the iterator if we were at the beginning of the BB. 77371a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner if (AtBeginning) { 77471a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner I = BB->begin(); 77571a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner DoIncr = false; 77671a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner } 77771a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner 77871a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner MI = 0; 77971a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner break; 78071a2cb25ebc818383dd0f80475bc166f834e8d99Chris Lattner } 781405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 7828fc2d0ee8dd4e077ee90a1fcc36fd0101c2947a2Chris Lattner if (DoIncr && I != BB->end()) ++I; 783405abffd5eb1ad1841491e51943b598c935f309bBill Wendling 78449dd06461a7e027a6c938f0570297d46f2f34218Evan Cheng // Update register states. 7853d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach if (RS && !FrameIndexVirtualScavenging && MI) RS->forward(MI); 78649dd06461a7e027a6c938f0570297d46f2f34218Evan Cheng } 787988a5782d3ce3cddc65d57d6aac7312d33ed59abBill Wendling 7886627ac040a14f3a79564fd6ec030f9361f81d20eJim Grosbach // If we have evenly matched pairs of frame setup / destroy instructions, 7896627ac040a14f3a79564fd6ec030f9361f81d20eJim Grosbach // make sure the adjustments come out to zero. If we don't have matched 7906627ac040a14f3a79564fd6ec030f9361f81d20eJim Grosbach // pairs, we can't be sure the missing bit isn't in another basic block 7916627ac040a14f3a79564fd6ec030f9361f81d20eJim Grosbach // due to a custom inserter playing tricks, so just asserting SPAdj==0 7926627ac040a14f3a79564fd6ec030f9361f81d20eJim Grosbach // isn't sufficient. See tMOVCC on Thumb1, for example. 7936627ac040a14f3a79564fd6ec030f9361f81d20eJim Grosbach assert((SPAdjCount || SPAdj == 0) && 7946627ac040a14f3a79564fd6ec030f9361f81d20eJim Grosbach "Unbalanced call frame setup / destroy pairs?"); 79549dd06461a7e027a6c938f0570297d46f2f34218Evan Cheng } 79658b3328ac709a5706a8bfa522012ed90f1b4d4bdChris Lattner} 797b9cfbd94abb23ec8646b9b10aa4ac3d1cbf4461eJohn Mosby 798b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach/// findLastUseReg - find the killing use of the specified register within 799b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach/// the instruciton range. Return the operand number of the kill in Operand. 800b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbachstatic MachineBasicBlock::iterator 801b58f498f7502e7e1833decbbbb4df771367c7341Jim GrosbachfindLastUseReg(MachineBasicBlock::iterator I, MachineBasicBlock::iterator ME, 802332553768242e82383df61d9161d1a665bfb3122Jim Grosbach unsigned Reg) { 803b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // Scan forward to find the last use of this virtual register 804b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach for (++I; I != ME; ++I) { 805b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach MachineInstr *MI = I; 806332553768242e82383df61d9161d1a665bfb3122Jim Grosbach bool isDefInsn = false; 807332553768242e82383df61d9161d1a665bfb3122Jim Grosbach bool isKillInsn = false; 808b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) 809b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach if (MI->getOperand(i).isReg()) { 810b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach unsigned OpReg = MI->getOperand(i).getReg(); 811b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach if (OpReg == 0 || !TargetRegisterInfo::isVirtualRegister(OpReg)) 812b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach continue; 813b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach assert (OpReg == Reg 814b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach && "overlapping use of scavenged index register!"); 815332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // If this is the killing use, we have a candidate. 816332553768242e82383df61d9161d1a665bfb3122Jim Grosbach if (MI->getOperand(i).isKill()) 817332553768242e82383df61d9161d1a665bfb3122Jim Grosbach isKillInsn = true; 818332553768242e82383df61d9161d1a665bfb3122Jim Grosbach else if (MI->getOperand(i).isDef()) 819332553768242e82383df61d9161d1a665bfb3122Jim Grosbach isDefInsn = true; 820b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 821332553768242e82383df61d9161d1a665bfb3122Jim Grosbach if (isKillInsn && !isDefInsn) 822332553768242e82383df61d9161d1a665bfb3122Jim Grosbach return I; 823b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 824b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // If we hit the end of the basic block, there was no kill of 825b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // the virtual register, which is wrong. 826b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach assert (0 && "scavenged index register never killed!"); 827b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach return ME; 828b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach} 829b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach 8309a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach/// scavengeFrameVirtualRegs - Replace all frame index virtual registers 8319a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach/// with physical registers. Use the register scavenger to find an 8329a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach/// appropriate register to use. 8333d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbachvoid PEI::scavengeFrameVirtualRegs(MachineFunction &Fn) { 8343d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach // Run through the instructions and find any virtual registers. 8353d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach for (MachineFunction::iterator BB = Fn.begin(), 8363d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach E = Fn.end(); BB != E; ++BB) { 8373d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach RS->enterBasicBlock(BB); 8383d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach 839332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // FIXME: The logic flow in this function is still too convoluted. 840332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // It needs a cleanup refactoring. Do that in preparation for tracking 841332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // more than one scratch register value and using ranges to find 842332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // available scratch registers. 8439a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach unsigned CurrentVirtReg = 0; 8440a13e566abcfacc3e07f509437060eee294dbfeeJim Grosbach unsigned CurrentScratchReg = 0; 845e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach bool havePrevValue = false; 8467c617b5e53987d786451dd668b5113f2e2b983f8Jim Grosbach TargetRegisterInfo::FrameIndexValue PrevValue(0,0); 8477c617b5e53987d786451dd668b5113f2e2b983f8Jim Grosbach TargetRegisterInfo::FrameIndexValue Value(0,0); 848391e1704c2e6934bae2ef5df07fc9690c26dbb62Jim Grosbach MachineInstr *PrevLastUseMI = NULL; 849391e1704c2e6934bae2ef5df07fc9690c26dbb62Jim Grosbach unsigned PrevLastUseOp = 0; 850e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach bool trackingCurrentValue = false; 851e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach int SPAdj = 0; 8523d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach 853b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // The instruction stream may change in the loop, so check BB->end() 854b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // directly. 855332553768242e82383df61d9161d1a665bfb3122Jim Grosbach for (MachineBasicBlock::iterator I = BB->begin(); I != BB->end(); ) { 8563d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach MachineInstr *MI = I; 85703d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach bool isDefInsn = false; 85803d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach bool isKillInsn = false; 859332553768242e82383df61d9161d1a665bfb3122Jim Grosbach bool clobbersScratchReg = false; 860332553768242e82383df61d9161d1a665bfb3122Jim Grosbach bool DoIncr = true; 861332553768242e82383df61d9161d1a665bfb3122Jim Grosbach for (unsigned i = 0, e = MI->getNumOperands(); i != e; ++i) { 8623d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach if (MI->getOperand(i).isReg()) { 863b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach MachineOperand &MO = MI->getOperand(i); 864b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach unsigned Reg = MO.getReg(); 86532030fe021ee614df6fdd77a2228e0e265049f3dJim Grosbach if (Reg == 0) 8669a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach continue; 86732030fe021ee614df6fdd77a2228e0e265049f3dJim Grosbach if (!TargetRegisterInfo::isVirtualRegister(Reg)) { 868b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // If we have a previous scratch reg, check and see if anything 869b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // here kills whatever value is in there. 870332553768242e82383df61d9161d1a665bfb3122Jim Grosbach if (Reg == CurrentScratchReg) { 871b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach if (MO.isUse()) { 872b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // Two-address operands implicitly kill 873332553768242e82383df61d9161d1a665bfb3122Jim Grosbach if (MO.isKill() || MI->isRegTiedToDefOperand(i)) 874332553768242e82383df61d9161d1a665bfb3122Jim Grosbach clobbersScratchReg = true; 875b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } else { 876b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach assert (MO.isDef()); 877332553768242e82383df61d9161d1a665bfb3122Jim Grosbach clobbersScratchReg = true; 878b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 879b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 88032030fe021ee614df6fdd77a2228e0e265049f3dJim Grosbach continue; 88132030fe021ee614df6fdd77a2228e0e265049f3dJim Grosbach } 88203d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach // If this is a def, remember that this insn defines the value. 88303d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach // This lets us properly consider insns which re-use the scratch 88403d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach // register, such as r2 = sub r2, #imm, in the middle of the 88503d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach // scratch range. 88603d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach if (MO.isDef()) 88703d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach isDefInsn = true; 8889a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach 889e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach // Have we already allocated a scratch register for this virtual? 8909a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach if (Reg != CurrentVirtReg) { 891e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach // When we first encounter a new virtual register, it 892e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach // must be a definition. 893e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach assert(MI->getOperand(i).isDef() && 894e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach "frame index virtual missing def!"); 895e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach // We can't have nested virtual register live ranges because 896e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach // there's only a guarantee of one scavenged register at a time. 897e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach assert (CurrentVirtReg == 0 && 898e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach "overlapping frame index virtual registers!"); 899e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach 900e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach // If the target gave us information about what's in the register, 901e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach // we can use that to re-use scratch regs. 902e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach DenseMap<unsigned, FrameConstantEntry>::iterator Entry = 903e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach FrameConstantRegMap.find(Reg); 904e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach trackingCurrentValue = Entry != FrameConstantRegMap.end(); 905e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach if (trackingCurrentValue) { 906e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach SPAdj = (*Entry).second.second; 907e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach Value = (*Entry).second.first; 9087c617b5e53987d786451dd668b5113f2e2b983f8Jim Grosbach } else { 9097c617b5e53987d786451dd668b5113f2e2b983f8Jim Grosbach SPAdj = 0; 9107c617b5e53987d786451dd668b5113f2e2b983f8Jim Grosbach Value.first = 0; 9117c617b5e53987d786451dd668b5113f2e2b983f8Jim Grosbach Value.second = 0; 9127c617b5e53987d786451dd668b5113f2e2b983f8Jim Grosbach } 913b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach 914b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // If the scratch register from the last allocation is still 915b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // available, see if the value matches. If it does, just re-use it. 916e40bf5f9f40a4672cd55bfa51c64a4bb6f4b2f8fJim Grosbach if (trackingCurrentValue && havePrevValue && PrevValue == Value) { 917b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // FIXME: This assumes that the instructions in the live range 918b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // for the virtual register are exclusively for the purpose 919b8452b80f4b24bed1efe0bace9e925c2ec01122eJim Grosbach // of populating the value in the register. That's reasonable 920b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // for these frame index registers, but it's still a very, very 921332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // strong assumption. rdar://7322732. Better would be to 922332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // explicitly check each instruction in the range for references 923332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // to the virtual register. Only delete those insns that 924332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // touch the virtual register. 925b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach 926b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // Find the last use of the new virtual register. Remove all 927b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // instruction between here and there, and update the current 928b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // instruction to reference the last use insn instead. 929b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach MachineBasicBlock::iterator LastUseMI = 930332553768242e82383df61d9161d1a665bfb3122Jim Grosbach findLastUseReg(I, BB->end(), Reg); 931332553768242e82383df61d9161d1a665bfb3122Jim Grosbach 932b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // Remove all instructions up 'til the last use, since they're 933b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach // just calculating the value we already have. 934b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach BB->erase(I, LastUseMI); 935a98add69bd53fcaf896e5632e5b4557d09c748dfBill Wendling I = LastUseMI; 936b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach 937332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // Extend the live range of the scratch register 938b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach PrevLastUseMI->getOperand(PrevLastUseOp).setIsKill(false); 939b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach RS->setUsed(CurrentScratchReg); 940b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach CurrentVirtReg = Reg; 941b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach 942332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // We deleted the instruction we were scanning the operands of. 943332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // Jump back to the instruction iterator loop. Don't increment 944332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // past this instruction since we updated the iterator already. 945332553768242e82383df61d9161d1a665bfb3122Jim Grosbach DoIncr = false; 946332553768242e82383df61d9161d1a665bfb3122Jim Grosbach break; 947b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 948332553768242e82383df61d9161d1a665bfb3122Jim Grosbach 949332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // Scavenge a new scratch register 950332553768242e82383df61d9161d1a665bfb3122Jim Grosbach CurrentVirtReg = Reg; 951332553768242e82383df61d9161d1a665bfb3122Jim Grosbach const TargetRegisterClass *RC = Fn.getRegInfo().getRegClass(Reg); 952ed903d746d96d071305b8182680595ba281b3f12Jim Grosbach CurrentScratchReg = RS->scavengeRegister(RC, I, SPAdj); 953332553768242e82383df61d9161d1a665bfb3122Jim Grosbach PrevValue = Value; 9543d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach } 955332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // replace this reference to the virtual register with the 956332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // scratch register. 9579a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach assert (CurrentScratchReg && "Missing scratch register!"); 9589a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach MI->getOperand(i).setReg(CurrentScratchReg); 9599a0b6e6ded68db772631c2938c7a07905e28144fJim Grosbach 960b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach if (MI->getOperand(i).isKill()) { 96103d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach isKillInsn = true; 962391e1704c2e6934bae2ef5df07fc9690c26dbb62Jim Grosbach PrevLastUseOp = i; 96303d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach PrevLastUseMI = MI; 964b58f498f7502e7e1833decbbbb4df771367c7341Jim Grosbach } 9653d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach } 966332553768242e82383df61d9161d1a665bfb3122Jim Grosbach } 96703d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach // If this is the last use of the scratch, stop tracking it. The 96803d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach // last use will be a kill operand in an instruction that does 96903d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach // not also define the scratch register. 97003d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach if (isKillInsn && !isDefInsn) { 971332553768242e82383df61d9161d1a665bfb3122Jim Grosbach CurrentVirtReg = 0; 97203d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach havePrevValue = trackingCurrentValue; 97303d02d4faa6cf8ae1337f64bc83dcbd9de570372Jim Grosbach } 974332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // Similarly, notice if instruction clobbered the value in the 975332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // register we're tracking for possible later reuse. This is noted 976332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // above, but enforced here since the value is still live while we 977332553768242e82383df61d9161d1a665bfb3122Jim Grosbach // process the rest of the operands of the instruction. 978332553768242e82383df61d9161d1a665bfb3122Jim Grosbach if (clobbersScratchReg) { 979332553768242e82383df61d9161d1a665bfb3122Jim Grosbach havePrevValue = false; 980332553768242e82383df61d9161d1a665bfb3122Jim Grosbach CurrentScratchReg = 0; 981332553768242e82383df61d9161d1a665bfb3122Jim Grosbach } 982332553768242e82383df61d9161d1a665bfb3122Jim Grosbach if (DoIncr) { 983332553768242e82383df61d9161d1a665bfb3122Jim Grosbach RS->forward(I); 984332553768242e82383df61d9161d1a665bfb3122Jim Grosbach ++I; 985332553768242e82383df61d9161d1a665bfb3122Jim Grosbach } 9863d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach } 9873d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach } 9883d6cb88a64fe67064de206405951eb326d86fc0cJim Grosbach} 989