PPCFrameLowering.cpp revision 6948897e478cbd66626159776a8017b3c18579b9
131d157ae1ac2cd9c787dc3c1d28e64c682803844Jia Liu//===-- PPCFrameLowering.cpp - PPC Frame Information ----------------------===// 233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov// 333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov// The LLVM Compiler Infrastructure 433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov// 533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov// This file is distributed under the University of Illinois Open Source 633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov// License. See LICENSE.TXT for details. 733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov// 833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov//===----------------------------------------------------------------------===// 933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov// 1016c29b5f285f375be53dabaa73e3e91107485fe4Anton Korobeynikov// This file contains the PPC implementation of TargetFrameLowering class. 1133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov// 1233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov//===----------------------------------------------------------------------===// 1333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 1416c29b5f285f375be53dabaa73e3e91107485fe4Anton Korobeynikov#include "PPCFrameLowering.h" 159d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky#include "PPCInstrBuilder.h" 16d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "PPCInstrInfo.h" 1733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov#include "PPCMachineFunctionInfo.h" 18c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines#include "PPCSubtarget.h" 19ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines#include "PPCTargetMachine.h" 2033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov#include "llvm/CodeGen/MachineFrameInfo.h" 2133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov#include "llvm/CodeGen/MachineFunction.h" 2233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov#include "llvm/CodeGen/MachineInstrBuilder.h" 2333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov#include "llvm/CodeGen/MachineModuleInfo.h" 2433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov#include "llvm/CodeGen/MachineRegisterInfo.h" 2594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov#include "llvm/CodeGen/RegisterScavenging.h" 260b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Function.h" 2733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov#include "llvm/Target/TargetOptions.h" 2833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 2933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikovusing namespace llvm; 3033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 3133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov/// VRRegNo - Map from a numbered VR register to its enum value. 3233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov/// 33b78ca423844f19f4a838abb49b4b4fa7ae499707Craig Topperstatic const uint16_t VRRegNo[] = { 3433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov PPC::V0 , PPC::V1 , PPC::V2 , PPC::V3 , PPC::V4 , PPC::V5 , PPC::V6 , PPC::V7 , 3533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov PPC::V8 , PPC::V9 , PPC::V10, PPC::V11, PPC::V12, PPC::V13, PPC::V14, PPC::V15, 3633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov PPC::V16, PPC::V17, PPC::V18, PPC::V19, PPC::V20, PPC::V21, PPC::V22, PPC::V23, 3733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov PPC::V24, PPC::V25, PPC::V26, PPC::V27, PPC::V28, PPC::V29, PPC::V30, PPC::V31 3833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov}; 3933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 40ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic unsigned computeReturnSaveOffset(const PPCSubtarget &STI) { 41ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (STI.isDarwinABI()) 42ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return STI.isPPC64() ? 16 : 8; 43ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // SVR4 ABI: 44ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return STI.isPPC64() ? 16 : 4; 45ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 46ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 47ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic unsigned computeTOCSaveOffset(const PPCSubtarget &STI) { 48ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return STI.isELFv2ABI() ? 24 : 40; 49ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 50ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 51ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic unsigned computeFramePointerSaveOffset(const PPCSubtarget &STI) { 52ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // For the Darwin ABI: 53ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // We cannot use the TOC save slot (offset +20) in the PowerPC linkage area 54ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // for saving the frame pointer (if needed.) While the published ABI has 55ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // not used this slot since at least MacOSX 10.2, there is older code 56ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // around that does use it, and that needs to continue to work. 57ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (STI.isDarwinABI()) 58ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return STI.isPPC64() ? -8U : -4U; 59ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 60ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // SVR4 ABI: First slot in the general register save area. 61ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return STI.isPPC64() ? -8U : -4U; 62ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 63ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 64ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic unsigned computeLinkageSize(const PPCSubtarget &STI) { 65ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (STI.isDarwinABI() || STI.isPPC64()) 66ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return (STI.isELFv2ABI() ? 4 : 6) * (STI.isPPC64() ? 8 : 4); 67ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 68ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // SVR4 ABI: 69ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return 8; 70ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 71ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 72ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic unsigned computeBasePointerSaveOffset(const PPCSubtarget &STI) { 73ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (STI.isDarwinABI()) 74ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return STI.isPPC64() ? -16U : -8U; 75ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 76ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // SVR4 ABI: First slot in the general register save area. 77ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return STI.isPPC64() 78ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ? -16U 79ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines : (STI.getTargetMachine().getRelocationModel() == Reloc::PIC_) 80ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ? -12U 81ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines : -8U; 82ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 83ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 84c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen HinesPPCFrameLowering::PPCFrameLowering(const PPCSubtarget &STI) 85c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines : TargetFrameLowering(TargetFrameLowering::StackGrowsDown, 86ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines STI.getPlatformStackAlignment(), 0), 87ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Subtarget(STI), ReturnSaveOffset(computeReturnSaveOffset(Subtarget)), 88ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TOCSaveOffset(computeTOCSaveOffset(Subtarget)), 89ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines FramePointerSaveOffset(computeFramePointerSaveOffset(Subtarget)), 90ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines LinkageSize(computeLinkageSize(Subtarget)), 91ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines BasePointerSaveOffset(computeBasePointerSaveOffset(STI)) {} 92c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 93c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines// With the SVR4 ABI, callee-saved registers have fixed offsets on the stack. 94c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hinesconst PPCFrameLowering::SpillSlot *PPCFrameLowering::getCalleeSavedSpillSlots( 95c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines unsigned &NumEntries) const { 96c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines if (Subtarget.isDarwinABI()) { 97c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines NumEntries = 1; 98c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines if (Subtarget.isPPC64()) { 99c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines static const SpillSlot darwin64Offsets = {PPC::X31, -8}; 100c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines return &darwin64Offsets; 101c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } else { 102c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines static const SpillSlot darwinOffsets = {PPC::R31, -4}; 103c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines return &darwinOffsets; 104c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } 105c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } 106c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 107c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // Early exit if not using the SVR4 ABI. 108c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines if (!Subtarget.isSVR4ABI()) { 109c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines NumEntries = 0; 110c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines return nullptr; 111c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } 112c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 113c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // Note that the offsets here overlap, but this is fixed up in 114c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // processFunctionBeforeFrameFinalized. 115c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 116c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines static const SpillSlot Offsets[] = { 117c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // Floating-point register save area offsets. 118c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F31, -8}, 119c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F30, -16}, 120c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F29, -24}, 121c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F28, -32}, 122c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F27, -40}, 123c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F26, -48}, 124c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F25, -56}, 125c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F24, -64}, 126c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F23, -72}, 127c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F22, -80}, 128c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F21, -88}, 129c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F20, -96}, 130c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F19, -104}, 131c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F18, -112}, 132c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F17, -120}, 133c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F16, -128}, 134c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F15, -136}, 135c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F14, -144}, 136c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 137c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // General register save area offsets. 138c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R31, -4}, 139c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R30, -8}, 140c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R29, -12}, 141c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R28, -16}, 142c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R27, -20}, 143c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R26, -24}, 144c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R25, -28}, 145c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R24, -32}, 146c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R23, -36}, 147c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R22, -40}, 148c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R21, -44}, 149c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R20, -48}, 150c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R19, -52}, 151c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R18, -56}, 152c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R17, -60}, 153c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R16, -64}, 154c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R15, -68}, 155c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::R14, -72}, 156c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 157c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // CR save area offset. We map each of the nonvolatile CR fields 158c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // to the slot for CR2, which is the first of the nonvolatile CR 159c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // fields to be assigned, so that we only allocate one save slot. 160c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // See PPCRegisterInfo::hasReservedSpillSlot() for more information. 161c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::CR2, -4}, 162c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 163c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // VRSAVE save area offset. 164c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::VRSAVE, -4}, 165c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 166c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // Vector register save area 167c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V31, -16}, 168c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V30, -32}, 169c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V29, -48}, 170c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V28, -64}, 171c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V27, -80}, 172c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V26, -96}, 173c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V25, -112}, 174c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V24, -128}, 175c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V23, -144}, 176c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V22, -160}, 177c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V21, -176}, 178c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V20, -192}}; 179c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 180c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines static const SpillSlot Offsets64[] = { 181c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // Floating-point register save area offsets. 182c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F31, -8}, 183c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F30, -16}, 184c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F29, -24}, 185c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F28, -32}, 186c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F27, -40}, 187c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F26, -48}, 188c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F25, -56}, 189c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F24, -64}, 190c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F23, -72}, 191c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F22, -80}, 192c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F21, -88}, 193c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F20, -96}, 194c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F19, -104}, 195c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F18, -112}, 196c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F17, -120}, 197c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F16, -128}, 198c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F15, -136}, 199c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::F14, -144}, 200c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 201c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // General register save area offsets. 202c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X31, -8}, 203c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X30, -16}, 204c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X29, -24}, 205c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X28, -32}, 206c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X27, -40}, 207c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X26, -48}, 208c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X25, -56}, 209c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X24, -64}, 210c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X23, -72}, 211c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X22, -80}, 212c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X21, -88}, 213c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X20, -96}, 214c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X19, -104}, 215c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X18, -112}, 216c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X17, -120}, 217c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X16, -128}, 218c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X15, -136}, 219c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::X14, -144}, 220c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 221c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // VRSAVE save area offset. 222c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::VRSAVE, -4}, 223c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 224c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // Vector register save area 225c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V31, -16}, 226c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V30, -32}, 227c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V29, -48}, 228c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V28, -64}, 229c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V27, -80}, 230c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V26, -96}, 231c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V25, -112}, 232c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V24, -128}, 233c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V23, -144}, 234c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V22, -160}, 235c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V21, -176}, 236c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines {PPC::V20, -192}}; 237c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 238c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines if (Subtarget.isPPC64()) { 239c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines NumEntries = array_lengthof(Offsets64); 240c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 241c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines return Offsets64; 242c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } else { 243c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines NumEntries = array_lengthof(Offsets); 244c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 245c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines return Offsets; 246c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } 247c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines} 248c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 24933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov/// RemoveVRSaveCode - We have found that this function does not need any code 25033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov/// to manipulate the VRSAVE register, even though it uses vector registers. 25133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov/// This can happen when the only registers used are known to be live in or out 25233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov/// of the function. Remove all of the VRSAVE related code from the function. 253a5d0ab555384baa293b06686bec5a01fb9638ca3Bill Schmidt/// FIXME: The removal of the code results in a compile failure at -O0 when the 254a5d0ab555384baa293b06686bec5a01fb9638ca3Bill Schmidt/// function contains a function call, as the GPR containing original VRSAVE 255a5d0ab555384baa293b06686bec5a01fb9638ca3Bill Schmidt/// contents is spilled and reloaded around the call. Without the prolog code, 256a5d0ab555384baa293b06686bec5a01fb9638ca3Bill Schmidt/// the spill instruction refers to an undefined register. This code needs 257a5d0ab555384baa293b06686bec5a01fb9638ca3Bill Schmidt/// to account for all uses of that GPR. 25833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikovstatic void RemoveVRSaveCode(MachineInstr *MI) { 25933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineBasicBlock *Entry = MI->getParent(); 26033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineFunction *MF = Entry->getParent(); 26133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 26233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // We know that the MTVRSAVE instruction immediately follows MI. Remove it. 26333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineBasicBlock::iterator MBBI = MI; 26433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov ++MBBI; 26533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov assert(MBBI != Entry->end() && MBBI->getOpcode() == PPC::MTVRSAVE); 26633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MBBI->eraseFromParent(); 26733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 26833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov bool RemovedAllMTVRSAVEs = true; 26933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // See if we can find and remove the MTVRSAVE instruction from all of the 27033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // epilog blocks. 27133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov for (MachineFunction::iterator I = MF->begin(), E = MF->end(); I != E; ++I) { 27233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // If last instruction is a return instruction, add an epilogue 2735a96b3dad2f634c9081c8b2b6c2575441dc5a2bdEvan Cheng if (!I->empty() && I->back().isReturn()) { 27433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov bool FoundIt = false; 27533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov for (MBBI = I->end(); MBBI != I->begin(); ) { 27633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov --MBBI; 27733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (MBBI->getOpcode() == PPC::MTVRSAVE) { 27833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MBBI->eraseFromParent(); // remove it. 27933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov FoundIt = true; 28033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov break; 28133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 28233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 28333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov RemovedAllMTVRSAVEs &= FoundIt; 28433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 28533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 28633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 28733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // If we found and removed all MTVRSAVE instructions, remove the read of 28833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // VRSAVE as well. 28933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (RemovedAllMTVRSAVEs) { 29033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MBBI = MI; 29133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov assert(MBBI != Entry->begin() && "UPDATE_VRSAVE is first instr in block?"); 29233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov --MBBI; 29333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov assert(MBBI->getOpcode() == PPC::MFVRSAVE && "VRSAVE instrs wandered?"); 29433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MBBI->eraseFromParent(); 29533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 29633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 29733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Finally, nuke the UPDATE_VRSAVE. 29833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MI->eraseFromParent(); 29933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov} 30033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 30133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov// HandleVRSaveUpdate - MI is the UPDATE_VRSAVE instruction introduced by the 30233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov// instruction selector. Based on the vector registers that have been used, 30333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov// transform this into the appropriate ORI instruction. 30433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikovstatic void HandleVRSaveUpdate(MachineInstr *MI, const TargetInstrInfo &TII) { 30533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineFunction *MF = MI->getParent()->getParent(); 30637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo(); 30733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov DebugLoc dl = MI->getDebugLoc(); 30833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 30933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov unsigned UsedRegMask = 0; 31033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov for (unsigned i = 0; i != 32; ++i) 31133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (MF->getRegInfo().isPhysRegUsed(VRRegNo[i])) 31233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov UsedRegMask |= 1 << (31-i); 31333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 31433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Live in and live out values already must be in the mask, so don't bother 31533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // marking them. 31633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov for (MachineRegisterInfo::livein_iterator 31733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov I = MF->getRegInfo().livein_begin(), 31833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov E = MF->getRegInfo().livein_end(); I != E; ++I) { 319aa6047d23d8ed55abd8545f5cbe82cd13cbd756aHal Finkel unsigned RegNo = TRI->getEncodingValue(I->first); 32033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (VRRegNo[RegNo] == I->first) // If this really is a vector reg. 32133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov UsedRegMask &= ~(1 << (31-RegNo)); // Doesn't need to be marked. 32233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 3230a9d1d31e9b3239b1dc38a67d31810c4bb405d0aJakob Stoklund Olesen 3240a9d1d31e9b3239b1dc38a67d31810c4bb405d0aJakob Stoklund Olesen // Live out registers appear as use operands on return instructions. 3250a9d1d31e9b3239b1dc38a67d31810c4bb405d0aJakob Stoklund Olesen for (MachineFunction::const_iterator BI = MF->begin(), BE = MF->end(); 3260a9d1d31e9b3239b1dc38a67d31810c4bb405d0aJakob Stoklund Olesen UsedRegMask != 0 && BI != BE; ++BI) { 3270a9d1d31e9b3239b1dc38a67d31810c4bb405d0aJakob Stoklund Olesen const MachineBasicBlock &MBB = *BI; 3280a9d1d31e9b3239b1dc38a67d31810c4bb405d0aJakob Stoklund Olesen if (MBB.empty() || !MBB.back().isReturn()) 3290a9d1d31e9b3239b1dc38a67d31810c4bb405d0aJakob Stoklund Olesen continue; 3300a9d1d31e9b3239b1dc38a67d31810c4bb405d0aJakob Stoklund Olesen const MachineInstr &Ret = MBB.back(); 3310a9d1d31e9b3239b1dc38a67d31810c4bb405d0aJakob Stoklund Olesen for (unsigned I = 0, E = Ret.getNumOperands(); I != E; ++I) { 3320a9d1d31e9b3239b1dc38a67d31810c4bb405d0aJakob Stoklund Olesen const MachineOperand &MO = Ret.getOperand(I); 3330a9d1d31e9b3239b1dc38a67d31810c4bb405d0aJakob Stoklund Olesen if (!MO.isReg() || !PPC::VRRCRegClass.contains(MO.getReg())) 3340a9d1d31e9b3239b1dc38a67d31810c4bb405d0aJakob Stoklund Olesen continue; 335aa6047d23d8ed55abd8545f5cbe82cd13cbd756aHal Finkel unsigned RegNo = TRI->getEncodingValue(MO.getReg()); 3360a9d1d31e9b3239b1dc38a67d31810c4bb405d0aJakob Stoklund Olesen UsedRegMask &= ~(1 << (31-RegNo)); 3370a9d1d31e9b3239b1dc38a67d31810c4bb405d0aJakob Stoklund Olesen } 33833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 33933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 34033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // If no registers are used, turn this into a copy. 34133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (UsedRegMask == 0) { 34233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Remove all VRSAVE code. 34333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov RemoveVRSaveCode(MI); 34433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov return; 34533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 34633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 34733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov unsigned SrcReg = MI->getOperand(1).getReg(); 34833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov unsigned DstReg = MI->getOperand(0).getReg(); 34933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 35033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if ((UsedRegMask & 0xFFFF) == UsedRegMask) { 35133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (DstReg != SrcReg) 35233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORI), DstReg) 35333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addReg(SrcReg) 35433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addImm(UsedRegMask); 35533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov else 35633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORI), DstReg) 35733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addReg(SrcReg, RegState::Kill) 35833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addImm(UsedRegMask); 35933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } else if ((UsedRegMask & 0xFFFF0000) == UsedRegMask) { 36033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (DstReg != SrcReg) 36133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORIS), DstReg) 36233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addReg(SrcReg) 36333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addImm(UsedRegMask >> 16); 36433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov else 36533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORIS), DstReg) 36633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addReg(SrcReg, RegState::Kill) 36733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addImm(UsedRegMask >> 16); 36833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } else { 36933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (DstReg != SrcReg) 37033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORIS), DstReg) 37133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addReg(SrcReg) 37233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addImm(UsedRegMask >> 16); 37333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov else 37433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORIS), DstReg) 37533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addReg(SrcReg, RegState::Kill) 37633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addImm(UsedRegMask >> 16); 37733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 37833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov BuildMI(*MI->getParent(), MI, dl, TII.get(PPC::ORI), DstReg) 37933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addReg(DstReg, RegState::Kill) 38033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addImm(UsedRegMask & 0xFFFF); 38133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 38233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 38333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Remove the old UPDATE_VRSAVE instruction. 38433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MI->eraseFromParent(); 38533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov} 38633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 3879d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divackystatic bool spillsCR(const MachineFunction &MF) { 3889d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky const PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>(); 3899d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky return FuncInfo->isCRSpilled(); 3909d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky} 3919d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 3923f2c047f32c9b488d9c49bb2dc87b979530dab3fHal Finkelstatic bool spillsVRSAVE(const MachineFunction &MF) { 3933f2c047f32c9b488d9c49bb2dc87b979530dab3fHal Finkel const PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>(); 3943f2c047f32c9b488d9c49bb2dc87b979530dab3fHal Finkel return FuncInfo->isVRSAVESpilled(); 3953f2c047f32c9b488d9c49bb2dc87b979530dab3fHal Finkel} 3963f2c047f32c9b488d9c49bb2dc87b979530dab3fHal Finkel 3970cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkelstatic bool hasSpills(const MachineFunction &MF) { 3980cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel const PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>(); 3990cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel return FuncInfo->hasSpills(); 4000cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel} 4010cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel 402324972904353594ad4a0cdfc79370f85e9fb9c8fHal Finkelstatic bool hasNonRISpills(const MachineFunction &MF) { 403324972904353594ad4a0cdfc79370f85e9fb9c8fHal Finkel const PPCFunctionInfo *FuncInfo = MF.getInfo<PPCFunctionInfo>(); 404324972904353594ad4a0cdfc79370f85e9fb9c8fHal Finkel return FuncInfo->hasNonRISpills(); 405324972904353594ad4a0cdfc79370f85e9fb9c8fHal Finkel} 406324972904353594ad4a0cdfc79370f85e9fb9c8fHal Finkel 407ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// MustSaveLR - Return true if this function requires that we save the LR 408ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// register onto the stack in the prolog and restore it in the epilog of the 409ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// function. 410ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic bool MustSaveLR(const MachineFunction &MF, unsigned LR) { 411ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const PPCFunctionInfo *MFI = MF.getInfo<PPCFunctionInfo>(); 412ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 413ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // We need a save/restore of LR if there is any def of LR (which is 414ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // defined by calls, including the PIC setup sequence), or if there is 415ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // some use of the LR stack slot (e.g. for builtin_return_address). 416ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // (LR comes in 32 and 64 bit versions.) 417ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MachineRegisterInfo::def_iterator RI = MF.getRegInfo().def_begin(LR); 418ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return RI !=MF.getRegInfo().def_end() || MFI->isLRStoreRequired(); 419ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 420ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 42133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov/// determineFrameLayout - Determine the size of the frame and maximum call 42233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov/// frame size. 4230cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkelunsigned PPCFrameLowering::determineFrameLayout(MachineFunction &MF, 4240cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel bool UpdateMF, 4250cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel bool UseEstimate) const { 42633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineFrameInfo *MFI = MF.getFrameInfo(); 42733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 42833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Get the number of bytes to allocate from the FrameInfo 4290cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel unsigned FrameSize = 4300cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel UseEstimate ? MFI->estimateStackSize(MF) : MFI->getStackSize(); 43133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 4329bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // Get stack alignments. The frame must be aligned to the greatest of these: 4339bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt unsigned TargetAlign = getStackAlignment(); // alignment required per the ABI 4349bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt unsigned MaxAlign = MFI->getMaxAlignment(); // algmt required by data in frame 435fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel unsigned AlignMask = std::max(MaxAlign, TargetAlign) - 1; 436fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel 437fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel const PPCRegisterInfo *RegInfo = 438ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines static_cast<const PPCRegisterInfo *>(Subtarget.getRegisterInfo()); 43933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 44033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // If we are a leaf function, and use up to 224 bytes of stack space, 44133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // don't have a frame pointer, calls, or dynamic alloca then we do not need 442fb6fe0aea2d1adde6d5e86f43797b5795ff2dc36Hal Finkel // to adjust the stack pointer (we fit in the Red Zone). 44365396823305326bcb379e88a95ded318e1da875cBill Schmidt // The 32-bit SVR4 ABI has no Red Zone. However, it can still generate 44465396823305326bcb379e88a95ded318e1da875cBill Schmidt // stackless code if all local vars are reg-allocated. 445ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines bool DisableRedZone = MF.getFunction()->hasFnAttribute(Attribute::NoRedZone); 446ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines unsigned LR = RegInfo->getRARegister(); 44733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (!DisableRedZone && 44865396823305326bcb379e88a95ded318e1da875cBill Schmidt (Subtarget.isPPC64() || // 32-bit SVR4, no stack- 44965396823305326bcb379e88a95ded318e1da875cBill Schmidt !Subtarget.isSVR4ABI() || // allocated locals. 450dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines FrameSize == 0) && 45133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov FrameSize <= 224 && // Fits in red zone. 45233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov !MFI->hasVarSizedObjects() && // No dynamic alloca. 45333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov !MFI->adjustsStack() && // No calls. 454ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines !MustSaveLR(MF, LR) && 455fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel !RegInfo->hasBasePointer(MF)) { // No special alignment. 45633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // No need for frame 4570cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel if (UpdateMF) 4580cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel MFI->setStackSize(0); 4590cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel return 0; 46033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 46133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 46233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Get the maximum call frame size of all the calls. 46333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov unsigned maxCallFrameSize = MFI->getMaxCallFrameSize(); 46433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 465c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // Maximum call frame needs to be at least big enough for linkage area. 466ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines unsigned minCallFrameSize = getLinkageSize(); 46733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov maxCallFrameSize = std::max(maxCallFrameSize, minCallFrameSize); 46833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 46933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // If we have dynamic alloca then maxCallFrameSize needs to be aligned so 47033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // that allocations will be aligned. 47133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (MFI->hasVarSizedObjects()) 47233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov maxCallFrameSize = (maxCallFrameSize + AlignMask) & ~AlignMask; 47333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 47433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Update maximum call frame size. 4750cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel if (UpdateMF) 4760cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel MFI->setMaxCallFrameSize(maxCallFrameSize); 47733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 47833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Include call frame size in total. 47933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov FrameSize += maxCallFrameSize; 48033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 48133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Make sure the frame is aligned. 48233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov FrameSize = (FrameSize + AlignMask) & ~AlignMask; 48333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 48433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Update frame info. 4850cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel if (UpdateMF) 4860cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel MFI->setStackSize(FrameSize); 4870cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel 4880cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel return FrameSize; 48933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov} 49033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 491d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov// hasFP - Return true if the specified function actually has a dedicated frame 492d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov// pointer register. 49316c29b5f285f375be53dabaa73e3e91107485fe4Anton Korobeynikovbool PPCFrameLowering::hasFP(const MachineFunction &MF) const { 494d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov const MachineFrameInfo *MFI = MF.getFrameInfo(); 495c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov // FIXME: This is pretty much broken by design: hasFP() might be called really 496c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov // early, before the stack layout was calculated and thus hasFP() might return 497c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov // true or false here depending on the time of call. 498c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov return (MFI->getStackSize()) && needsFP(MF); 499c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov} 500c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov 501c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov// needsFP - Return true if the specified function should have a dedicated frame 502c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov// pointer register. This is true if the function has variable sized allocas or 503c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov// if frame pointer elimination is disabled. 50416c29b5f285f375be53dabaa73e3e91107485fe4Anton Korobeynikovbool PPCFrameLowering::needsFP(const MachineFunction &MF) const { 505c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov const MachineFrameInfo *MFI = MF.getFrameInfo(); 506d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov 507d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov // Naked functions have no stack frame pushed, so we don't have a frame 508d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov // pointer. 509ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (MF.getFunction()->hasFnAttribute(Attribute::Naked)) 510d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov return false; 511d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov 5128a8d479214745c82ef00f08d4e4f1c173b5f9ce2Nick Lewycky return MF.getTarget().Options.DisableFramePointerElim(MF) || 5138a8d479214745c82ef00f08d4e4f1c173b5f9ce2Nick Lewycky MFI->hasVarSizedObjects() || 514ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MFI->hasStackMap() || MFI->hasPatchPoint() || 5158a8d479214745c82ef00f08d4e4f1c173b5f9ce2Nick Lewycky (MF.getTarget().Options.GuaranteedTailCallOpt && 5168a8d479214745c82ef00f08d4e4f1c173b5f9ce2Nick Lewycky MF.getInfo<PPCFunctionInfo>()->hasFastCall()); 517d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov} 518d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov 519e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkelvoid PPCFrameLowering::replaceFPWithRealFP(MachineFunction &MF) const { 520e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel bool is31 = needsFP(MF); 521e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel unsigned FPReg = is31 ? PPC::R31 : PPC::R1; 522e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel unsigned FP8Reg = is31 ? PPC::X31 : PPC::X1; 523e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel 5240541722de4beb2e53058dbf4ed1ebf0d96ddd6cbHal Finkel const PPCRegisterInfo *RegInfo = 525ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines static_cast<const PPCRegisterInfo *>(Subtarget.getRegisterInfo()); 5260541722de4beb2e53058dbf4ed1ebf0d96ddd6cbHal Finkel bool HasBP = RegInfo->hasBasePointer(MF); 52737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines unsigned BPReg = HasBP ? (unsigned) RegInfo->getBaseRegister(MF) : FPReg; 5280541722de4beb2e53058dbf4ed1ebf0d96ddd6cbHal Finkel unsigned BP8Reg = HasBP ? (unsigned) PPC::X30 : FPReg; 5290541722de4beb2e53058dbf4ed1ebf0d96ddd6cbHal Finkel 530e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel for (MachineFunction::iterator BI = MF.begin(), BE = MF.end(); 531e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel BI != BE; ++BI) 532e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel for (MachineBasicBlock::iterator MBBI = BI->end(); MBBI != BI->begin(); ) { 533e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel --MBBI; 534e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel for (unsigned I = 0, E = MBBI->getNumOperands(); I != E; ++I) { 535e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel MachineOperand &MO = MBBI->getOperand(I); 536e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel if (!MO.isReg()) 537e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel continue; 538e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel 539e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel switch (MO.getReg()) { 540e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel case PPC::FP: 541e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel MO.setReg(FPReg); 542e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel break; 543e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel case PPC::FP8: 544e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel MO.setReg(FP8Reg); 545e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel break; 5460541722de4beb2e53058dbf4ed1ebf0d96ddd6cbHal Finkel case PPC::BP: 5470541722de4beb2e53058dbf4ed1ebf0d96ddd6cbHal Finkel MO.setReg(BPReg); 5480541722de4beb2e53058dbf4ed1ebf0d96ddd6cbHal Finkel break; 5490541722de4beb2e53058dbf4ed1ebf0d96ddd6cbHal Finkel case PPC::BP8: 5500541722de4beb2e53058dbf4ed1ebf0d96ddd6cbHal Finkel MO.setReg(BP8Reg); 5510541722de4beb2e53058dbf4ed1ebf0d96ddd6cbHal Finkel break; 5520541722de4beb2e53058dbf4ed1ebf0d96ddd6cbHal Finkel 553e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel } 554e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel } 555e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel } 556e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel} 557d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov 5586948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainarvoid PPCFrameLowering::emitPrologue(MachineFunction &MF, 5596948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar MachineBasicBlock &MBB) const { 5606948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported"); 56133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineBasicBlock::iterator MBBI = MBB.begin(); 56233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineFrameInfo *MFI = MF.getFrameInfo(); 56333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov const PPCInstrInfo &TII = 564ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines *static_cast<const PPCInstrInfo *>(Subtarget.getInstrInfo()); 565fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel const PPCRegisterInfo *RegInfo = 566ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines static_cast<const PPCRegisterInfo *>(Subtarget.getRegisterInfo()); 56733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 56833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineModuleInfo &MMI = MF.getMMI(); 56999cb622041a0839c7dfcf0263c5102a305a0fdb5Bill Wendling const MCRegisterInfo *MRI = MMI.getContext().getRegisterInfo(); 57033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov DebugLoc dl; 571ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines bool needsCFI = MMI.hasDebugInfo() || 572fc2bb8c4448fa884d79e437cc2d2627a7d7740a8Rafael Espindola MF.getFunction()->needsUnwindTableEntry(); 57333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 5749bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // Get processor type. 5759bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt bool isPPC64 = Subtarget.isPPC64(); 5769bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // Get the ABI. 5779bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt bool isSVR4ABI = Subtarget.isSVR4ABI(); 57837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines bool isELFv2ABI = Subtarget.isELFv2ABI(); 579ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert((Subtarget.isDarwinABI() || isSVR4ABI) && 5809bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt "Currently only Darwin and SVR4 ABIs are supported for PowerPC."); 5819bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt 58233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Scan the prolog, looking for an UPDATE_VRSAVE instruction. If we find it, 58333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // process it. 5849bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt if (!isSVR4ABI) 585a5d0ab555384baa293b06686bec5a01fb9638ca3Bill Schmidt for (unsigned i = 0; MBBI != MBB.end(); ++i, ++MBBI) { 586a5d0ab555384baa293b06686bec5a01fb9638ca3Bill Schmidt if (MBBI->getOpcode() == PPC::UPDATE_VRSAVE) { 587a5d0ab555384baa293b06686bec5a01fb9638ca3Bill Schmidt HandleVRSaveUpdate(MBBI, TII); 588a5d0ab555384baa293b06686bec5a01fb9638ca3Bill Schmidt break; 589a5d0ab555384baa293b06686bec5a01fb9638ca3Bill Schmidt } 59033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 59133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 59233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Move MBBI back to the beginning of the function. 59333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MBBI = MBB.begin(); 59433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 59533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Work out frame sizes. 5960cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel unsigned FrameSize = determineFrameLayout(MF); 59733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov int NegFrameSize = -FrameSize; 598fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel if (!isInt<32>(NegFrameSize)) 599fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel llvm_unreachable("Unhandled stack size!"); 60033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 601e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel if (MFI->isFrameAddressTaken()) 602e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel replaceFPWithRealFP(MF); 603e9cc0a09ae38c87b1b26a44f5e32222ede4f84e6Hal Finkel 60433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Check if the link register (LR) must be saved. 60533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>(); 60633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov bool MustSaveLR = FI->mustSaveLR(); 607a0ec3f9b7b826b9b40b80199923b664bad808cceCraig Topper const SmallVectorImpl<unsigned> &MustSaveCRs = FI->getMustSaveCRs(); 6086af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt // Do we have a frame pointer and/or base pointer for this function? 609c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov bool HasFP = hasFP(MF); 610fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel bool HasBP = RegInfo->hasBasePointer(MF); 61133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 6126af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt unsigned SPReg = isPPC64 ? PPC::X1 : PPC::R1; 61337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines unsigned BPReg = RegInfo->getBaseRegister(MF); 6146af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt unsigned FPReg = isPPC64 ? PPC::X31 : PPC::R31; 6156af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt unsigned LRReg = isPPC64 ? PPC::LR8 : PPC::LR; 6166af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt unsigned ScratchReg = isPPC64 ? PPC::X0 : PPC::R0; 6176af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt unsigned TempReg = isPPC64 ? PPC::X12 : PPC::R12; // another scratch reg 6186af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt // ...(R12/X12 is volatile in both Darwin & SVR4, & can't be a function arg.) 6196af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& MFLRInst = TII.get(isPPC64 ? PPC::MFLR8 6206af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::MFLR ); 6216af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& StoreInst = TII.get(isPPC64 ? PPC::STD 6226af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::STW ); 6236af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& StoreUpdtInst = TII.get(isPPC64 ? PPC::STDU 6246af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::STWU ); 6256af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& StoreUpdtIdxInst = TII.get(isPPC64 ? PPC::STDUX 6266af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::STWUX); 6276af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& LoadImmShiftedInst = TII.get(isPPC64 ? PPC::LIS8 6286af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::LIS ); 6296af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& OrImmInst = TII.get(isPPC64 ? PPC::ORI8 6306af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::ORI ); 6316af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& OrInst = TII.get(isPPC64 ? PPC::OR8 6326af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::OR ); 6336af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& SubtractCarryingInst = TII.get(isPPC64 ? PPC::SUBFC8 6346af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::SUBFC); 6356af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& SubtractImmCarryingInst = TII.get(isPPC64 ? PPC::SUBFIC8 6366af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::SUBFIC); 6376af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt 6389bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // Regarding this assert: Even though LR is saved in the caller's frame (i.e., 6399bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // LROffset is positive), that slot is callee-owned. Because PPC32 SVR4 has no 6409bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // Red Zone, an asynchronous event (a form of "callee") could claim a frame & 6419bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // overwrite it, so PPC32 SVR4 must claim at least a minimal frame to save LR. 6429bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt assert((isPPC64 || !isSVR4ABI || !(!FrameSize && (MustSaveLR || HasFP))) && 6439bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt "FrameSize must be >0 to save/restore the FP or LR for 32-bit SVR4."); 6449bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt 645ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines int LROffset = getReturnSaveOffset(); 64633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 64733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov int FPOffset = 0; 64833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (HasFP) { 6499bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt if (isSVR4ABI) { 65033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineFrameInfo *FFI = MF.getFrameInfo(); 65133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov int FPIndex = FI->getFramePointerSaveIndex(); 65233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov assert(FPIndex && "No Frame Pointer Save Slot!"); 65333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov FPOffset = FFI->getObjectOffset(FPIndex); 65433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } else { 655ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines FPOffset = getFramePointerSaveOffset(); 65633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 65733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 65833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 659fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel int BPOffset = 0; 660fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel if (HasBP) { 6619bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt if (isSVR4ABI) { 662fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel MachineFrameInfo *FFI = MF.getFrameInfo(); 663fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel int BPIndex = FI->getBasePointerSaveIndex(); 664fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel assert(BPIndex && "No Base Pointer Save Slot!"); 665fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel BPOffset = FFI->getObjectOffset(BPIndex); 666fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel } else { 667ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines BPOffset = getBasePointerSaveOffset(); 668fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel } 669fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel } 670fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel 671ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines int PBPOffset = 0; 672ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (FI->usesPICBase()) { 673ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MachineFrameInfo *FFI = MF.getFrameInfo(); 674ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines int PBPIndex = FI->getPICBasePointerSaveIndex(); 675ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(PBPIndex && "No PIC Base Pointer Save Slot!"); 676ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines PBPOffset = FFI->getObjectOffset(PBPIndex); 677ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 678ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 6799bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // Get stack alignments. 6809bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt unsigned MaxAlign = MFI->getMaxAlignment(); 6819bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt if (HasBP && MaxAlign > 1) 6829bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt assert(isPowerOf2_32(MaxAlign) && isInt<16>(MaxAlign) && 6839bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt "Invalid alignment!"); 6849bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt 6859bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // Frames of 32KB & larger require special handling because they cannot be 6869bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // indexed into with a simple STDU/STWU/STD/STW immediate offset operand. 6879bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt bool isLargeFrame = !isInt<16>(NegFrameSize); 6889bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt 6896af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (MustSaveLR) 6906af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, MFLRInst, ScratchReg); 69133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 6926af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt assert((isPPC64 || MustSaveCRs.empty()) && 6936af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt "Prologue CR saving supported only in 64-bit mode"); 694fb6fe0aea2d1adde6d5e86f43797b5795ff2dc36Hal Finkel 6956af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (!MustSaveCRs.empty()) { // will only occur for PPC64 69637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // FIXME: In the ELFv2 ABI, we are not required to save all CR fields. 69737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // If only one or two CR fields are clobbered, it could be more 69837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // efficient to use mfocrf to selectively save just those fields. 6996af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt MachineInstrBuilder MIB = 7006af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, TII.get(PPC::MFCR8), TempReg); 7016af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt for (unsigned i = 0, e = MustSaveCRs.size(); i != e; ++i) 7026af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt MIB.addReg(MustSaveCRs[i], RegState::ImplicitKill); 70333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 70433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 7056af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (HasFP) 7066af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt // FIXME: On PPC32 SVR4, we must not spill before claiming the stackframe. 7076af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, StoreInst) 7086af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(FPReg) 7096af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(FPOffset) 7106af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg); 7116af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt 712ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (FI->usesPICBase()) 713ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // FIXME: On PPC32 SVR4, we must not spill before claiming the stackframe. 714ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines BuildMI(MBB, MBBI, dl, StoreInst) 715ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines .addReg(PPC::R30) 716ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines .addImm(PBPOffset) 717ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines .addReg(SPReg); 718ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 7196af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (HasBP) 7206af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt // FIXME: On PPC32 SVR4, we must not spill before claiming the stackframe. 7216af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, StoreInst) 7226af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(BPReg) 7236af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(BPOffset) 7246af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg); 7256af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt 7266af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (MustSaveLR) 7276af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt // FIXME: On PPC32 SVR4, we must not spill before claiming the stackframe. 7286af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, StoreInst) 7296af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(ScratchReg) 7306af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(LROffset) 7316af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg); 7326af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt 7336af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (!MustSaveCRs.empty()) // will only occur for PPC64 7346af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, TII.get(PPC::STW8)) 7356af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(TempReg, getKillRegState(true)) 7366af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(8) 7376af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg); 7386af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt 7399bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // Skip the rest if this is a leaf function & all spills fit in the Red Zone. 74033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (!FrameSize) return; 74133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 74233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Adjust stack pointer: r1 += NegFrameSize. 74333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // If there is a preferred stack alignment, align R1 now 744fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel 7456af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (HasBP) { 7466af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt // Save a copy of r1 as the base pointer. 7476af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, OrInst, BPReg) 7486af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg) 7496af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg); 7506af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt } 7516af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt 7526af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (HasBP && MaxAlign > 1) { 7536af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (isPPC64) 7546af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, TII.get(PPC::RLDICL), ScratchReg) 7556af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg) 7566af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(0) 7576af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(64 - Log2_32(MaxAlign)); 7586af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt else // PPC32... 7596af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, TII.get(PPC::RLWINM), ScratchReg) 7606af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg) 76133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addImm(0) 76233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addImm(32 - Log2_32(MaxAlign)) 76333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addImm(31); 7646af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (!isLargeFrame) { 7656af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, SubtractImmCarryingInst, ScratchReg) 7666af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(ScratchReg, RegState::Kill) 7676af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(NegFrameSize); 76833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } else { 7696af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, LoadImmShiftedInst, TempReg) 77033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addImm(NegFrameSize >> 16); 7716af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, OrImmInst, TempReg) 7726af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(TempReg, RegState::Kill) 77333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addImm(NegFrameSize & 0xFFFF); 7746af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, SubtractCarryingInst, ScratchReg) 7756af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(ScratchReg, RegState::Kill) 7766af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(TempReg, RegState::Kill); 777fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel } 7786af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, StoreUpdtIdxInst, SPReg) 7796af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg, RegState::Kill) 7806af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg) 7816af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(ScratchReg); 782fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel 7836af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt } else if (!isLargeFrame) { 7846af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, StoreUpdtInst, SPReg) 7856af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg) 7866af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(NegFrameSize) 7876af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg); 7889bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt 7896af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt } else { 7906af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, LoadImmShiftedInst, ScratchReg) 7916af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(NegFrameSize >> 16); 7926af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, OrImmInst, ScratchReg) 7936af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(ScratchReg, RegState::Kill) 7946af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(NegFrameSize & 0xFFFF); 7956af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, StoreUpdtIdxInst, SPReg) 7966af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg, RegState::Kill) 7976af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg) 7986af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(ScratchReg); 79933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 80033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 801ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Add Call Frame Information for the instructions we generated above. 802ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (needsCFI) { 803ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines unsigned CFIIndex; 804ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 805ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (HasBP) { 806ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Define CFA in terms of BP. Do this in preference to using FP/SP, 807ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // because if the stack needed aligning then CFA won't be at a fixed 808ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // offset from FP/SP. 809ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines unsigned Reg = MRI->getDwarfRegNum(BPReg, true); 810ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines CFIIndex = MMI.addFrameInst( 811ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MCCFIInstruction::createDefCfaRegister(nullptr, Reg)); 812ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } else { 813ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Adjust the definition of CFA to account for the change in SP. 814ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(NegFrameSize); 815ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines CFIIndex = MMI.addFrameInst( 816ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MCCFIInstruction::createDefCfaOffset(nullptr, NegFrameSize)); 817ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 818dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION)) 819dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines .addCFIIndex(CFIIndex); 82033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 82133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (HasFP) { 822ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Describe where FP was saved, at a fixed offset from CFA. 8236af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt unsigned Reg = MRI->getDwarfRegNum(FPReg, true); 82436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines CFIIndex = MMI.addFrameInst( 82536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MCCFIInstruction::createOffset(nullptr, Reg, FPOffset)); 826dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION)) 82736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines .addCFIIndex(CFIIndex); 82833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 82933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 830ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (FI->usesPICBase()) { 831ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Describe where FP was saved, at a fixed offset from CFA. 832ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines unsigned Reg = MRI->getDwarfRegNum(PPC::R30, true); 833ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines CFIIndex = MMI.addFrameInst( 834ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MCCFIInstruction::createOffset(nullptr, Reg, PBPOffset)); 835ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION)) 836ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines .addCFIIndex(CFIIndex); 837ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 838ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 839fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel if (HasBP) { 840ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Describe where BP was saved, at a fixed offset from CFA. 8416af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt unsigned Reg = MRI->getDwarfRegNum(BPReg, true); 84236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines CFIIndex = MMI.addFrameInst( 84336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MCCFIInstruction::createOffset(nullptr, Reg, BPOffset)); 844dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION)) 84536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines .addCFIIndex(CFIIndex); 846fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel } 847fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel 84833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (MustSaveLR) { 849ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Describe where LR was saved, at a fixed offset from CFA. 8506af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt unsigned Reg = MRI->getDwarfRegNum(LRReg, true); 85136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines CFIIndex = MMI.addFrameInst( 85236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MCCFIInstruction::createOffset(nullptr, Reg, LROffset)); 853dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION)) 85436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines .addCFIIndex(CFIIndex); 85533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 85633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 85733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 85833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // If there is a frame pointer, copy R1 into R31 85933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (HasFP) { 8606af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, OrInst, FPReg) 8616af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg) 8626af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg); 86333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 864ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!HasBP && needsCFI) { 865ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Change the definition of CFA from SP+offset to FP+offset, because SP 866ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // will change at every alloca. 8676af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt unsigned Reg = MRI->getDwarfRegNum(FPReg, true); 86836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned CFIIndex = MMI.addFrameInst( 86936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines MCCFIInstruction::createDefCfaRegister(nullptr, Reg)); 87036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 871dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION)) 87236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines .addCFIIndex(CFIIndex); 87333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 87433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 87533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 876ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (needsCFI) { 877ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Describe where callee saved registers were saved, at fixed offsets from 878ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // CFA. 87933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov const std::vector<CalleeSavedInfo> &CSI = MFI->getCalleeSavedInfo(); 88033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov for (unsigned I = 0, E = CSI.size(); I != E; ++I) { 88133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov unsigned Reg = CSI[I].getReg(); 88233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (Reg == PPC::LR || Reg == PPC::LR8 || Reg == PPC::RM) continue; 8836e032942cf58d1c41f88609a1cec74eb74940ecdRafael Espindola 8846e032942cf58d1c41f88609a1cec74eb74940ecdRafael Espindola // This is a bit of a hack: CR2LT, CR2GT, CR2EQ and CR2UN are just 8856e032942cf58d1c41f88609a1cec74eb74940ecdRafael Espindola // subregisters of CR2. We just need to emit a move of CR2. 886c909950c384e8234a7b3c5a76b7f79e3f7012cebCraig Topper if (PPC::CRBITRCRegClass.contains(Reg)) 8876e032942cf58d1c41f88609a1cec74eb74940ecdRafael Espindola continue; 8886e032942cf58d1c41f88609a1cec74eb74940ecdRafael Espindola 8899d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // For SVR4, don't emit a move for the CR spill slot if we haven't 8909d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // spilled CRs. 8919bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt if (isSVR4ABI && (PPC::CR2 <= Reg && Reg <= PPC::CR4) 8929bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt && MustSaveCRs.empty()) 8939bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt continue; 8949d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 8959d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // For 64-bit SVR4 when we have spilled CRs, the spill location 8969d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // is SP+8, not a frame-relative slot. 8979bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt if (isSVR4ABI && isPPC64 && (PPC::CR2 <= Reg && Reg <= PPC::CR4)) { 89837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // In the ELFv1 ABI, only CR2 is noted in CFI and stands in for 89937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // the whole CR word. In the ELFv2 ABI, every CR that was 90037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // actually saved gets its own CFI record. 90137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines unsigned CRReg = isELFv2ABI? Reg : (unsigned) PPC::CR2; 90236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned CFIIndex = MMI.addFrameInst(MCCFIInstruction::createOffset( 90337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines nullptr, MRI->getDwarfRegNum(CRReg, true), 8)); 904dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION)) 90536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines .addCFIIndex(CFIIndex); 9069bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt continue; 9079d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky } 9089d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 9099d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky int Offset = MFI->getObjectOffset(CSI[I].getFrameIdx()); 91036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines unsigned CFIIndex = MMI.addFrameInst(MCCFIInstruction::createOffset( 91136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines nullptr, MRI->getDwarfRegNum(Reg, true), Offset)); 912dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines BuildMI(MBB, MBBI, dl, TII.get(TargetOpcode::CFI_INSTRUCTION)) 91336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines .addCFIIndex(CFIIndex); 91433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 91533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 91633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov} 91733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 91816c29b5f285f375be53dabaa73e3e91107485fe4Anton Korobeynikovvoid PPCFrameLowering::emitEpilogue(MachineFunction &MF, 91933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineBasicBlock &MBB) const { 9204f28c1c71450c711e96aa283de53739d8b4504cdJakob Stoklund Olesen MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr(); 9214f28c1c71450c711e96aa283de53739d8b4504cdJakob Stoklund Olesen assert(MBBI != MBB.end() && "Returning block has no terminator"); 92233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov const PPCInstrInfo &TII = 923ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines *static_cast<const PPCInstrInfo *>(Subtarget.getInstrInfo()); 924fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel const PPCRegisterInfo *RegInfo = 925ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines static_cast<const PPCRegisterInfo *>(Subtarget.getRegisterInfo()); 92633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 92733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov unsigned RetOpcode = MBBI->getOpcode(); 92833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov DebugLoc dl; 92933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 930d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov assert((RetOpcode == PPC::BLR || 931ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines RetOpcode == PPC::BLR8 || 932d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov RetOpcode == PPC::TCRETURNri || 933d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov RetOpcode == PPC::TCRETURNdi || 934d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov RetOpcode == PPC::TCRETURNai || 935d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov RetOpcode == PPC::TCRETURNri8 || 936d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov RetOpcode == PPC::TCRETURNdi8 || 937d0c38176690e9602a93a20a43f1bd084564a8116Anton Korobeynikov RetOpcode == PPC::TCRETURNai8) && 93833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov "Can only insert epilog into returning blocks"); 93933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 9409bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // Get alignment info so we know how to restore the SP. 94133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov const MachineFrameInfo *MFI = MF.getFrameInfo(); 94233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 94333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Get the number of bytes allocated from the FrameInfo. 94433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov int FrameSize = MFI->getStackSize(); 94533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 94633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Get processor type. 94733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov bool isPPC64 = Subtarget.isPPC64(); 9489bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // Get the ABI. 9499bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt bool isSVR4ABI = Subtarget.isSVR4ABI(); 9509bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt 95133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Check if the link register (LR) has been saved. 95233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>(); 95333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov bool MustSaveLR = FI->mustSaveLR(); 954a0ec3f9b7b826b9b40b80199923b664bad808cceCraig Topper const SmallVectorImpl<unsigned> &MustSaveCRs = FI->getMustSaveCRs(); 9556af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt // Do we have a frame pointer and/or base pointer for this function? 956c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov bool HasFP = hasFP(MF); 957fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel bool HasBP = RegInfo->hasBasePointer(MF); 95833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 9596af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt unsigned SPReg = isPPC64 ? PPC::X1 : PPC::R1; 96037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines unsigned BPReg = RegInfo->getBaseRegister(MF); 9616af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt unsigned FPReg = isPPC64 ? PPC::X31 : PPC::R31; 9626af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt unsigned ScratchReg = isPPC64 ? PPC::X0 : PPC::R0; 9636af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt unsigned TempReg = isPPC64 ? PPC::X12 : PPC::R12; // another scratch reg 9646af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& MTLRInst = TII.get( isPPC64 ? PPC::MTLR8 9656af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::MTLR ); 9666af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& LoadInst = TII.get( isPPC64 ? PPC::LD 9676af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::LWZ ); 9686af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& LoadImmShiftedInst = TII.get( isPPC64 ? PPC::LIS8 9696af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::LIS ); 9706af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& OrImmInst = TII.get( isPPC64 ? PPC::ORI8 9716af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::ORI ); 9726af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& AddImmInst = TII.get( isPPC64 ? PPC::ADDI8 9736af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::ADDI ); 9746af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt const MCInstrDesc& AddInst = TII.get( isPPC64 ? PPC::ADD8 9756af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt : PPC::ADD4 ); 9766af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt 977ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines int LROffset = getReturnSaveOffset(); 97833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 97933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov int FPOffset = 0; 98033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (HasFP) { 9819bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt if (isSVR4ABI) { 98233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineFrameInfo *FFI = MF.getFrameInfo(); 98333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov int FPIndex = FI->getFramePointerSaveIndex(); 98433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov assert(FPIndex && "No Frame Pointer Save Slot!"); 98533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov FPOffset = FFI->getObjectOffset(FPIndex); 98633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } else { 987ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines FPOffset = getFramePointerSaveOffset(); 98833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 98933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 99033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 991fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel int BPOffset = 0; 992fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel if (HasBP) { 9939bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt if (isSVR4ABI) { 994fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel MachineFrameInfo *FFI = MF.getFrameInfo(); 995fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel int BPIndex = FI->getBasePointerSaveIndex(); 996fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel assert(BPIndex && "No Base Pointer Save Slot!"); 997fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel BPOffset = FFI->getObjectOffset(BPIndex); 998fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel } else { 999ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines BPOffset = getBasePointerSaveOffset(); 1000fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel } 1001fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel } 1002fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel 1003ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines int PBPOffset = 0; 1004ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (FI->usesPICBase()) { 1005ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MachineFrameInfo *FFI = MF.getFrameInfo(); 1006ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines int PBPIndex = FI->getPICBasePointerSaveIndex(); 1007ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(PBPIndex && "No PIC Base Pointer Save Slot!"); 1008ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines PBPOffset = FFI->getObjectOffset(PBPIndex); 1009ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 1010ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 101133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov bool UsesTCRet = RetOpcode == PPC::TCRETURNri || 101233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov RetOpcode == PPC::TCRETURNdi || 101333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov RetOpcode == PPC::TCRETURNai || 101433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov RetOpcode == PPC::TCRETURNri8 || 101533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov RetOpcode == PPC::TCRETURNdi8 || 101633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov RetOpcode == PPC::TCRETURNai8; 101733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 101833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (UsesTCRet) { 101933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov int MaxTCRetDelta = FI->getTailCallSPDelta(); 102033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineOperand &StackAdjust = MBBI->getOperand(1); 102133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov assert(StackAdjust.isImm() && "Expecting immediate value."); 102233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Adjust stack pointer. 102333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov int StackAdj = StackAdjust.getImm(); 102433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov int Delta = StackAdj - MaxTCRetDelta; 102533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov assert((Delta >= 0) && "Delta must be positive"); 102633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (MaxTCRetDelta>0) 102733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov FrameSize += (StackAdj +Delta); 102833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov else 102933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov FrameSize += StackAdj; 103033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 103133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 10329bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // Frames of 32KB & larger require special handling because they cannot be 10339bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // indexed into with a simple LD/LWZ immediate offset operand. 10349bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt bool isLargeFrame = !isInt<16>(FrameSize); 10359bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt 103633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (FrameSize) { 10379bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // In the prologue, the loaded (or persistent) stack pointer value is offset 10389bb6c81683393363ed1ff8c66397f2d944c0966bBill Schmidt // by the STDU/STDUX/STWU/STWUX instruction. Add this offset back now. 10396af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt 10406af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt // If this function contained a fastcc call and GuaranteedTailCallOpt is 10416af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt // enabled (=> hasFastCall()==true) the fastcc call might contain a tail 10426af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt // call which invalidates the stack pointer value in SP(0). So we use the 10436af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt // value of R31 in this case. 10446af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (FI->hasFastCall()) { 10456af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt assert(HasFP && "Expecting a valid frame pointer."); 10466af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (!isLargeFrame) { 10476af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, AddImmInst, SPReg) 10486af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(FPReg).addImm(FrameSize); 104933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } else { 10506af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, LoadImmShiftedInst, ScratchReg) 10516af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(FrameSize >> 16); 10526af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, OrImmInst, ScratchReg) 10536af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(ScratchReg, RegState::Kill) 10546af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(FrameSize & 0xFFFF); 10556af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, AddInst) 10566af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg) 10576af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(FPReg) 10586af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(ScratchReg); 105933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 10606af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt } else if (!isLargeFrame && !HasBP && !MFI->hasVarSizedObjects()) { 10616af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, AddImmInst, SPReg) 10626af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg) 10636af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(FrameSize); 10646af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt } else { 10656af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, LoadInst, SPReg) 10666af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(0) 10676af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg); 106833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 1069fb6fe0aea2d1adde6d5e86f43797b5795ff2dc36Hal Finkel 10706af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt } 107133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 10726af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (MustSaveLR) 10736af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, LoadInst, ScratchReg) 10746af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(LROffset) 10756af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg); 1076fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel 10776af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt assert((isPPC64 || MustSaveCRs.empty()) && 10786af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt "Epilogue CR restoring supported only in 64-bit mode"); 1079fb6fe0aea2d1adde6d5e86f43797b5795ff2dc36Hal Finkel 10806af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (!MustSaveCRs.empty()) // will only occur for PPC64 10816af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, TII.get(PPC::LWZ8), TempReg) 10826af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(8) 10836af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg); 108433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 10856af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (HasFP) 10866af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, LoadInst, FPReg) 10876af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(FPOffset) 10886af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg); 1089fb6fe0aea2d1adde6d5e86f43797b5795ff2dc36Hal Finkel 1090ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (FI->usesPICBase()) 1091ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // FIXME: On PPC32 SVR4, we must not spill before claiming the stackframe. 1092ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines BuildMI(MBB, MBBI, dl, LoadInst) 1093ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines .addReg(PPC::R30) 1094ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines .addImm(PBPOffset) 1095ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines .addReg(SPReg); 1096ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 10976af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (HasBP) 10986af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, LoadInst, BPReg) 10996af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addImm(BPOffset) 11006af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg); 110133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 11026af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (!MustSaveCRs.empty()) // will only occur for PPC64 11036af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt for (unsigned i = 0, e = MustSaveCRs.size(); i != e; ++i) 11046af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, TII.get(PPC::MTOCRF8), MustSaveCRs[i]) 11056af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(TempReg, getKillRegState(i == e-1)); 1106fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel 11076af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt if (MustSaveLR) 11086af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, MTLRInst).addReg(ScratchReg); 110933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 111033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // Callee pop calling convention. Pop parameter/linkage area. Used for tail 111133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov // call optimization 1112ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (MF.getTarget().Options.GuaranteedTailCallOpt && 1113ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines (RetOpcode == PPC::BLR || RetOpcode == PPC::BLR8) && 111433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MF.getFunction()->getCallingConv() == CallingConv::Fast) { 111533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>(); 111633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov unsigned CallerAllocatedAmt = FI->getMinReservedArea(); 111733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov 111833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov if (CallerAllocatedAmt && isInt<16>(CallerAllocatedAmt)) { 11196af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, AddImmInst, SPReg) 11206af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg).addImm(CallerAllocatedAmt); 112133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } else { 11226af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, LoadImmShiftedInst, ScratchReg) 112333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addImm(CallerAllocatedAmt >> 16); 11246af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, OrImmInst, ScratchReg) 11256af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(ScratchReg, RegState::Kill) 112633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addImm(CallerAllocatedAmt & 0xFFFF); 11276af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt BuildMI(MBB, MBBI, dl, AddInst) 11286af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(SPReg) 112933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov .addReg(FPReg) 11306af35e95765e2d577919714dfbdac3ebf84cac78Bill Schmidt .addReg(ScratchReg); 113133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 113233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } else if (RetOpcode == PPC::TCRETURNdi) { 11334f28c1c71450c711e96aa283de53739d8b4504cdJakob Stoklund Olesen MBBI = MBB.getLastNonDebugInstr(); 113433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineOperand &JumpTarget = MBBI->getOperand(0); 113533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILB)). 113633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset()); 113733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } else if (RetOpcode == PPC::TCRETURNri) { 11384f28c1c71450c711e96aa283de53739d8b4504cdJakob Stoklund Olesen MBBI = MBB.getLastNonDebugInstr(); 113933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov assert(MBBI->getOperand(0).isReg() && "Expecting register operand."); 114033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILBCTR)); 114133464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } else if (RetOpcode == PPC::TCRETURNai) { 11424f28c1c71450c711e96aa283de53739d8b4504cdJakob Stoklund Olesen MBBI = MBB.getLastNonDebugInstr(); 114333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineOperand &JumpTarget = MBBI->getOperand(0); 114433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILBA)).addImm(JumpTarget.getImm()); 114533464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } else if (RetOpcode == PPC::TCRETURNdi8) { 11464f28c1c71450c711e96aa283de53739d8b4504cdJakob Stoklund Olesen MBBI = MBB.getLastNonDebugInstr(); 114733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineOperand &JumpTarget = MBBI->getOperand(0); 114833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILB8)). 114933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov addGlobalAddress(JumpTarget.getGlobal(), JumpTarget.getOffset()); 115033464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } else if (RetOpcode == PPC::TCRETURNri8) { 11514f28c1c71450c711e96aa283de53739d8b4504cdJakob Stoklund Olesen MBBI = MBB.getLastNonDebugInstr(); 115233464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov assert(MBBI->getOperand(0).isReg() && "Expecting register operand."); 115333464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILBCTR8)); 115433464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } else if (RetOpcode == PPC::TCRETURNai8) { 11554f28c1c71450c711e96aa283de53739d8b4504cdJakob Stoklund Olesen MBBI = MBB.getLastNonDebugInstr(); 115633464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov MachineOperand &JumpTarget = MBBI->getOperand(0); 115733464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov BuildMI(MBB, MBBI, dl, TII.get(PPC::TAILBA8)).addImm(JumpTarget.getImm()); 115833464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov } 115933464912237efaa0ed7060829e66b59055bdd48bAnton Korobeynikov} 1160d9e3385ced2dc887e2fe8e1c071bd2611e4d3edeAnton Korobeynikov 116194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikovvoid 116216c29b5f285f375be53dabaa73e3e91107485fe4Anton KorobeynikovPPCFrameLowering::processFunctionBeforeCalleeSavedScan(MachineFunction &MF, 11630cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel RegScavenger *) const { 1164fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel const PPCRegisterInfo *RegInfo = 1165ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines static_cast<const PPCRegisterInfo *>(Subtarget.getRegisterInfo()); 116694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 116794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Save and clear the LR state. 116894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov PPCFunctionInfo *FI = MF.getInfo<PPCFunctionInfo>(); 116994c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov unsigned LR = RegInfo->getRARegister(); 117094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov FI->setMustSaveLR(MustSaveLR(MF, LR)); 11714edd84da1b3f7fd73e96a13b6b7e183ad04ac7c4Bill Schmidt MachineRegisterInfo &MRI = MF.getRegInfo(); 11724edd84da1b3f7fd73e96a13b6b7e183ad04ac7c4Bill Schmidt MRI.setPhysRegUnused(LR); 117394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 117494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Save R31 if necessary 117594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov int FPSI = FI->getFramePointerSaveIndex(); 117694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov bool isPPC64 = Subtarget.isPPC64(); 117794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov bool isDarwinABI = Subtarget.isDarwinABI(); 117894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov MachineFrameInfo *MFI = MF.getFrameInfo(); 117994c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 118094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // If the frame pointer save index hasn't been defined yet. 1181c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov if (!FPSI && needsFP(MF)) { 118294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Find out what the fix offset of the frame pointer save area. 1183ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines int FPOffset = getFramePointerSaveOffset(); 118494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Allocate the frame index for frame pointer save area. 118516c29b5f285f375be53dabaa73e3e91107485fe4Anton Korobeynikov FPSI = MFI->CreateFixedObject(isPPC64? 8 : 4, FPOffset, true); 118694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Save the result. 118794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov FI->setFramePointerSaveIndex(FPSI); 118894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 118994c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 1190fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel int BPSI = FI->getBasePointerSaveIndex(); 1191fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel if (!BPSI && RegInfo->hasBasePointer(MF)) { 1192ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines int BPOffset = getBasePointerSaveOffset(); 1193fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel // Allocate the frame index for the base pointer save area. 1194fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel BPSI = MFI->CreateFixedObject(isPPC64? 8 : 4, BPOffset, true); 1195fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel // Save the result. 1196fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel FI->setBasePointerSaveIndex(BPSI); 1197fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel } 1198fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel 1199ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Reserve stack space for the PIC Base register (R30). 1200ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Only used in SVR4 32-bit. 1201ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (FI->usesPICBase()) { 1202ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines int PBPSI = FI->getPICBasePointerSaveIndex(); 1203ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines PBPSI = MFI->CreateFixedObject(4, -8, true); 1204ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines FI->setPICBasePointerSaveIndex(PBPSI); 1205ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 1206ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 120794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Reserve stack space to move the linkage area to in case of a tail call. 120894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov int TCSPDelta = 0; 12098a8d479214745c82ef00f08d4e4f1c173b5f9ce2Nick Lewycky if (MF.getTarget().Options.GuaranteedTailCallOpt && 12108a8d479214745c82ef00f08d4e4f1c173b5f9ce2Nick Lewycky (TCSPDelta = FI->getTailCallSPDelta()) < 0) { 121116c29b5f285f375be53dabaa73e3e91107485fe4Anton Korobeynikov MFI->CreateFixedObject(-1 * TCSPDelta, TCSPDelta, true); 121294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 121394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 1214dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // For 32-bit SVR4, allocate the nonvolatile CR spill slot iff the 12154edd84da1b3f7fd73e96a13b6b7e183ad04ac7c4Bill Schmidt // function uses CR 2, 3, or 4. 1216dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!isPPC64 && !isDarwinABI && 12174edd84da1b3f7fd73e96a13b6b7e183ad04ac7c4Bill Schmidt (MRI.isPhysRegUsed(PPC::CR2) || 12184edd84da1b3f7fd73e96a13b6b7e183ad04ac7c4Bill Schmidt MRI.isPhysRegUsed(PPC::CR3) || 12194edd84da1b3f7fd73e96a13b6b7e183ad04ac7c4Bill Schmidt MRI.isPhysRegUsed(PPC::CR4))) { 12204edd84da1b3f7fd73e96a13b6b7e183ad04ac7c4Bill Schmidt int FrameIdx = MFI->CreateFixedObject((uint64_t)4, (int64_t)-4, true); 12214edd84da1b3f7fd73e96a13b6b7e183ad04ac7c4Bill Schmidt FI->setCRSpillFrameIndex(FrameIdx); 12224edd84da1b3f7fd73e96a13b6b7e183ad04ac7c4Bill Schmidt } 122394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov} 122494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 12253080d23fde4981835d8a7faf46c152441fadb11fHal Finkelvoid PPCFrameLowering::processFunctionBeforeFrameFinalized(MachineFunction &MF, 12260cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel RegScavenger *RS) const { 122794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Early exit if not using the SVR4 ABI. 12280cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel if (!Subtarget.isSVR4ABI()) { 12290cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel addScavengingSpillSlot(MF, RS); 123094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov return; 12310cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel } 123294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 123394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Get callee saved register information. 123494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov MachineFrameInfo *FFI = MF.getFrameInfo(); 123594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov const std::vector<CalleeSavedInfo> &CSI = FFI->getCalleeSavedInfo(); 123694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 123794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Early exit if no callee saved registers are modified! 1238c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov if (CSI.empty() && !needsFP(MF)) { 12390cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel addScavengingSpillSlot(MF, RS); 124094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov return; 124194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 124294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 124394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov unsigned MinGPR = PPC::R31; 124494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov unsigned MinG8R = PPC::X31; 124594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov unsigned MinFPR = PPC::F31; 124694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov unsigned MinVR = PPC::V31; 124794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 124894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov bool HasGPSaveArea = false; 124994c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov bool HasG8SaveArea = false; 125094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov bool HasFPSaveArea = false; 125194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov bool HasVRSAVESaveArea = false; 125294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov bool HasVRSaveArea = false; 125394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 125494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov SmallVector<CalleeSavedInfo, 18> GPRegs; 125594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov SmallVector<CalleeSavedInfo, 18> G8Regs; 125694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov SmallVector<CalleeSavedInfo, 18> FPRegs; 125794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov SmallVector<CalleeSavedInfo, 18> VRegs; 125894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 125994c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 126094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov unsigned Reg = CSI[i].getReg(); 1261c909950c384e8234a7b3c5a76b7f79e3f7012cebCraig Topper if (PPC::GPRCRegClass.contains(Reg)) { 126294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov HasGPSaveArea = true; 126394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 126494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov GPRegs.push_back(CSI[i]); 126594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 126694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov if (Reg < MinGPR) { 126794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov MinGPR = Reg; 126894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 1269c909950c384e8234a7b3c5a76b7f79e3f7012cebCraig Topper } else if (PPC::G8RCRegClass.contains(Reg)) { 127094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov HasG8SaveArea = true; 127194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 127294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov G8Regs.push_back(CSI[i]); 127394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 127494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov if (Reg < MinG8R) { 127594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov MinG8R = Reg; 127694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 1277c909950c384e8234a7b3c5a76b7f79e3f7012cebCraig Topper } else if (PPC::F8RCRegClass.contains(Reg)) { 127894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov HasFPSaveArea = true; 127994c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 128094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov FPRegs.push_back(CSI[i]); 128194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 128294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov if (Reg < MinFPR) { 128394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov MinFPR = Reg; 128494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 1285c909950c384e8234a7b3c5a76b7f79e3f7012cebCraig Topper } else if (PPC::CRBITRCRegClass.contains(Reg) || 1286c909950c384e8234a7b3c5a76b7f79e3f7012cebCraig Topper PPC::CRRCRegClass.contains(Reg)) { 12879d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky ; // do nothing, as we already know whether CRs are spilled 1288c909950c384e8234a7b3c5a76b7f79e3f7012cebCraig Topper } else if (PPC::VRSAVERCRegClass.contains(Reg)) { 128994c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov HasVRSAVESaveArea = true; 1290c909950c384e8234a7b3c5a76b7f79e3f7012cebCraig Topper } else if (PPC::VRRCRegClass.contains(Reg)) { 129194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov HasVRSaveArea = true; 129294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 129394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov VRegs.push_back(CSI[i]); 129494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 129594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov if (Reg < MinVR) { 129694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov MinVR = Reg; 129794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 129894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } else { 129994c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov llvm_unreachable("Unknown RegisterClass!"); 130094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 130194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 130294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 130394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov PPCFunctionInfo *PFI = MF.getInfo<PPCFunctionInfo>(); 1304ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const TargetRegisterInfo *TRI = Subtarget.getRegisterInfo(); 130594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 130694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov int64_t LowerBound = 0; 130794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 130894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Take into account stack space reserved for tail calls. 130994c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov int TCSPDelta = 0; 13108a8d479214745c82ef00f08d4e4f1c173b5f9ce2Nick Lewycky if (MF.getTarget().Options.GuaranteedTailCallOpt && 13118a8d479214745c82ef00f08d4e4f1c173b5f9ce2Nick Lewycky (TCSPDelta = PFI->getTailCallSPDelta()) < 0) { 131294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov LowerBound = TCSPDelta; 131394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 131494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 131594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // The Floating-point register save area is right below the back chain word 131694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // of the previous stack frame. 131794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov if (HasFPSaveArea) { 131894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov for (unsigned i = 0, e = FPRegs.size(); i != e; ++i) { 131994c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov int FI = FPRegs[i].getFrameIdx(); 132094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 132194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI)); 132294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 132394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 1324aa6047d23d8ed55abd8545f5cbe82cd13cbd756aHal Finkel LowerBound -= (31 - TRI->getEncodingValue(MinFPR) + 1) * 8; 132594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 132694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 132794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Check whether the frame pointer register is allocated. If so, make sure it 132894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // is spilled to the correct offset. 1329c8bd78c16ba0489835f2eb6101d9bdb96301cfe7Anton Korobeynikov if (needsFP(MF)) { 133094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov HasGPSaveArea = true; 133194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 133294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov int FI = PFI->getFramePointerSaveIndex(); 133394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov assert(FI && "No Frame Pointer Save Slot!"); 133494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 133594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI)); 133694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 133794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 1338ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (PFI->usesPICBase()) { 1339ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines HasGPSaveArea = true; 1340ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 1341ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines int FI = PFI->getPICBasePointerSaveIndex(); 1342ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(FI && "No PIC Base Pointer Save Slot!"); 1343ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 1344ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI)); 1345ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 1346ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 1347fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel const PPCRegisterInfo *RegInfo = 1348ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines static_cast<const PPCRegisterInfo *>(Subtarget.getRegisterInfo()); 1349fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel if (RegInfo->hasBasePointer(MF)) { 1350fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel HasGPSaveArea = true; 1351fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel 1352fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel int FI = PFI->getBasePointerSaveIndex(); 1353fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel assert(FI && "No Base Pointer Save Slot!"); 1354fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel 1355fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI)); 1356fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel } 1357fe47bf8fa07e12b70ff8b234fa1f6b97c8d2753dHal Finkel 135894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // General register save area starts right below the Floating-point 135994c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // register save area. 136094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov if (HasGPSaveArea || HasG8SaveArea) { 136194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Move general register save area spill slots down, taking into account 136294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // the size of the Floating-point register save area. 136394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov for (unsigned i = 0, e = GPRegs.size(); i != e; ++i) { 136494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov int FI = GPRegs[i].getFrameIdx(); 136594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 136694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI)); 136794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 136894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 136994c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Move general register save area spill slots down, taking into account 137094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // the size of the Floating-point register save area. 137194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov for (unsigned i = 0, e = G8Regs.size(); i != e; ++i) { 137294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov int FI = G8Regs[i].getFrameIdx(); 137394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 137494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI)); 137594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 137694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 137794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov unsigned MinReg = 1378aa6047d23d8ed55abd8545f5cbe82cd13cbd756aHal Finkel std::min<unsigned>(TRI->getEncodingValue(MinGPR), 1379aa6047d23d8ed55abd8545f5cbe82cd13cbd756aHal Finkel TRI->getEncodingValue(MinG8R)); 138094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 138194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov if (Subtarget.isPPC64()) { 138294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov LowerBound -= (31 - MinReg + 1) * 8; 138394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } else { 138494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov LowerBound -= (31 - MinReg + 1) * 4; 138594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 138694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 138794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 13889d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // For 32-bit only, the CR save area is below the general register 13899d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // save area. For 64-bit SVR4, the CR save area is addressed relative 13909d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // to the stack pointer and hence does not need an adjustment here. 13919d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // Only CR2 (the first nonvolatile spilled) has an associated frame 13929d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // index so that we have a single uniform save area. 13939d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky if (spillsCR(MF) && !(Subtarget.isPPC64() && Subtarget.isSVR4ABI())) { 139494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Adjust the frame index of the CR spill slot. 139594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 139694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov unsigned Reg = CSI[i].getReg(); 139794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 13989d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky if ((Subtarget.isSVR4ABI() && Reg == PPC::CR2) 1399dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // Leave Darwin logic as-is. 1400dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines || (!Subtarget.isSVR4ABI() && 1401dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines (PPC::CRBITRCRegClass.contains(Reg) || 1402dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines PPC::CRRCRegClass.contains(Reg)))) { 140394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov int FI = CSI[i].getFrameIdx(); 140494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 140594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI)); 140694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 140794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 140894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 140994c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov LowerBound -= 4; // The CR save area is always 4 bytes long. 141094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 141194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 141294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov if (HasVRSAVESaveArea) { 141394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // FIXME SVR4: Is it actually possible to have multiple elements in CSI 141494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // which have the VRSAVE register class? 141594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Adjust the frame index of the VRSAVE spill slot. 141694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 141794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov unsigned Reg = CSI[i].getReg(); 141894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 1419c909950c384e8234a7b3c5a76b7f79e3f7012cebCraig Topper if (PPC::VRSAVERCRegClass.contains(Reg)) { 142094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov int FI = CSI[i].getFrameIdx(); 142194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 142294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI)); 142394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 142494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 142594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 142694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov LowerBound -= 4; // The VRSAVE save area is always 4 bytes long. 142794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 142894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 142994c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov if (HasVRSaveArea) { 143094c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov // Insert alignment padding, we need 16-byte alignment. 143194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov LowerBound = (LowerBound - 15) & ~(15); 143294c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 143394c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov for (unsigned i = 0, e = VRegs.size(); i != e; ++i) { 143494c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov int FI = VRegs[i].getFrameIdx(); 143594c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov 143694c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov FFI->setObjectOffset(FI, LowerBound + FFI->getObjectOffset(FI)); 143794c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 143894c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov } 14390cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel 14400cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel addScavengingSpillSlot(MF, RS); 14410cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel} 14420cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel 14430cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkelvoid 14440cfb42adb5072fb19a01dba3ea58a33fd5927947Hal FinkelPPCFrameLowering::addScavengingSpillSlot(MachineFunction &MF, 14450cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel RegScavenger *RS) const { 14460cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel // Reserve a slot closest to SP or frame pointer if we have a dynalloc or 14470cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel // a large stack, which will require scavenging a register to materialize a 14480cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel // large offset. 14490cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel 14500cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel // We need to have a scavenger spill slot for spills if the frame size is 14510cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel // large. In case there is no free register for large-offset addressing, 14520cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel // this slot is used for the necessary emergency spill. Also, we need the 14530cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel // slot for dynamic stack allocations. 14540cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel 14550cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel // The scavenger might be invoked if the frame offset does not fit into 14560cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel // the 16-bit immediate. We don't know the complete frame size here 14570cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel // because we've not yet computed callee-saved register spills or the 14580cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel // needed alignment padding. 14590cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel unsigned StackSize = determineFrameLayout(MF, false, true); 14600cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel MachineFrameInfo *MFI = MF.getFrameInfo(); 14613f2c047f32c9b488d9c49bb2dc87b979530dab3fHal Finkel if (MFI->hasVarSizedObjects() || spillsCR(MF) || spillsVRSAVE(MF) || 14623f2c047f32c9b488d9c49bb2dc87b979530dab3fHal Finkel hasNonRISpills(MF) || (hasSpills(MF) && !isInt<16>(StackSize))) { 14630cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel const TargetRegisterClass *GPRC = &PPC::GPRCRegClass; 14640cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel const TargetRegisterClass *G8RC = &PPC::G8RCRegClass; 14650cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel const TargetRegisterClass *RC = Subtarget.isPPC64() ? G8RC : GPRC; 1466dc3beb90178fc316f63790812b22201884eaa017Hal Finkel RS->addScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(), 14670cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel RC->getAlignment(), 14680cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel false)); 146901f99d29c3010f2891e5edb78182216214017063Hal Finkel 1470aad2a72c285a48e34d89ba69d24eb624f2b09b0eHal Finkel // Might we have over-aligned allocas? 1471aad2a72c285a48e34d89ba69d24eb624f2b09b0eHal Finkel bool HasAlVars = MFI->hasVarSizedObjects() && 1472aad2a72c285a48e34d89ba69d24eb624f2b09b0eHal Finkel MFI->getMaxAlignment() > getStackAlignment(); 1473aad2a72c285a48e34d89ba69d24eb624f2b09b0eHal Finkel 147401f99d29c3010f2891e5edb78182216214017063Hal Finkel // These kinds of spills might need two registers. 1475aad2a72c285a48e34d89ba69d24eb624f2b09b0eHal Finkel if (spillsCR(MF) || spillsVRSAVE(MF) || HasAlVars) 147601f99d29c3010f2891e5edb78182216214017063Hal Finkel RS->addScavengingFrameIndex(MFI->CreateStackObject(RC->getSize(), 147701f99d29c3010f2891e5edb78182216214017063Hal Finkel RC->getAlignment(), 147801f99d29c3010f2891e5edb78182216214017063Hal Finkel false)); 147901f99d29c3010f2891e5edb78182216214017063Hal Finkel 14800cfb42adb5072fb19a01dba3ea58a33fd5927947Hal Finkel } 148194c5ae08750f314bc3cf1bf882b686244a3927d9Anton Korobeynikov} 14829d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 1483dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hinesbool 14849d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman DivackyPPCFrameLowering::spillCalleeSavedRegisters(MachineBasicBlock &MBB, 1485dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MachineBasicBlock::iterator MI, 1486dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const std::vector<CalleeSavedInfo> &CSI, 1487dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const TargetRegisterInfo *TRI) const { 14889d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 14899d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // Currently, this function only handles SVR4 32- and 64-bit ABIs. 14909d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // Return false otherwise to maintain pre-existing behavior. 14919d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky if (!Subtarget.isSVR4ABI()) 14929d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky return false; 14939d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 14949d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky MachineFunction *MF = MBB.getParent(); 14959d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky const PPCInstrInfo &TII = 1496ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines *static_cast<const PPCInstrInfo *>(Subtarget.getInstrInfo()); 14979d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky DebugLoc DL; 14989d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky bool CRSpilled = false; 149963496f66c5b528a48f8da7714ee3f635f8aadd18Hal Finkel MachineInstrBuilder CRMIB; 1500dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 15019d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 15029d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky unsigned Reg = CSI[i].getReg(); 15036a636a813f33b46b3271ec8517ee1936a0c92c9fHal Finkel // Only Darwin actually uses the VRSAVE register, but it can still appear 15046a636a813f33b46b3271ec8517ee1936a0c92c9fHal Finkel // here if, for example, @llvm.eh.unwind.init() is used. If we're not on 15056a636a813f33b46b3271ec8517ee1936a0c92c9fHal Finkel // Darwin, ignore it. 15066a636a813f33b46b3271ec8517ee1936a0c92c9fHal Finkel if (Reg == PPC::VRSAVE && !Subtarget.isDarwinABI()) 15076a636a813f33b46b3271ec8517ee1936a0c92c9fHal Finkel continue; 15086a636a813f33b46b3271ec8517ee1936a0c92c9fHal Finkel 15099d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // CR2 through CR4 are the nonvolatile CR fields. 15109d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky bool IsCRField = PPC::CR2 <= Reg && Reg <= PPC::CR4; 15119d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 15129d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // Add the callee-saved register as live-in; it's killed at the spill. 15139d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky MBB.addLiveIn(Reg); 15149d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 151563496f66c5b528a48f8da7714ee3f635f8aadd18Hal Finkel if (CRSpilled && IsCRField) { 151663496f66c5b528a48f8da7714ee3f635f8aadd18Hal Finkel CRMIB.addReg(Reg, RegState::ImplicitKill); 151763496f66c5b528a48f8da7714ee3f635f8aadd18Hal Finkel continue; 151863496f66c5b528a48f8da7714ee3f635f8aadd18Hal Finkel } 151963496f66c5b528a48f8da7714ee3f635f8aadd18Hal Finkel 15209d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // Insert the spill to the stack frame. 15219d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky if (IsCRField) { 1522fb6fe0aea2d1adde6d5e86f43797b5795ff2dc36Hal Finkel PPCFunctionInfo *FuncInfo = MF->getInfo<PPCFunctionInfo>(); 15239d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky if (Subtarget.isPPC64()) { 1524fb6fe0aea2d1adde6d5e86f43797b5795ff2dc36Hal Finkel // The actual spill will happen at the start of the prologue. 1525fb6fe0aea2d1adde6d5e86f43797b5795ff2dc36Hal Finkel FuncInfo->addMustSaveCR(Reg); 15269d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky } else { 1527fb6fe0aea2d1adde6d5e86f43797b5795ff2dc36Hal Finkel CRSpilled = true; 1528ded53bf4dd499f213334400fa870d0c7896d1d0dBill Schmidt FuncInfo->setSpillsCR(); 1529fb6fe0aea2d1adde6d5e86f43797b5795ff2dc36Hal Finkel 1530dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 32-bit: FP-relative. Note that we made sure CR2-CR4 all have 1531dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // the same frame index in PPCRegisterInfo::hasReservedSpillSlot. 1532dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CRMIB = BuildMI(*MF, DL, TII.get(PPC::MFCR), PPC::R12) 153363496f66c5b528a48f8da7714ee3f635f8aadd18Hal Finkel .addReg(Reg, RegState::ImplicitKill); 153463496f66c5b528a48f8da7714ee3f635f8aadd18Hal Finkel 1535dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MBB.insert(MI, CRMIB); 1536dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MBB.insert(MI, addFrameReference(BuildMI(*MF, DL, TII.get(PPC::STW)) 1537dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines .addReg(PPC::R12, 1538dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines getKillRegState(true)), 1539dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CSI[i].getFrameIdx())); 15409d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky } 15419d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky } else { 15429d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg); 15439d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky TII.storeRegToStackSlot(MBB, MI, Reg, true, 1544dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CSI[i].getFrameIdx(), RC, TRI); 15459d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky } 15469d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky } 15479d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky return true; 15489d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky} 15499d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 15509d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divackystatic void 1551b99c995825a49f0da5af40ee1b61269deb8994b5Hal FinkelrestoreCRs(bool isPPC64, bool is31, 1552b99c995825a49f0da5af40ee1b61269deb8994b5Hal Finkel bool CR2Spilled, bool CR3Spilled, bool CR4Spilled, 1553dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MachineBasicBlock &MBB, MachineBasicBlock::iterator MI, 1554dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const std::vector<CalleeSavedInfo> &CSI, unsigned CSIIndex) { 15559d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 15569d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky MachineFunction *MF = MBB.getParent(); 1557ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const PPCInstrInfo &TII = *MF->getSubtarget<PPCSubtarget>().getInstrInfo(); 15589d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky DebugLoc DL; 15599d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky unsigned RestoreOp, MoveReg; 15609d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 1561fb6fe0aea2d1adde6d5e86f43797b5795ff2dc36Hal Finkel if (isPPC64) 1562fb6fe0aea2d1adde6d5e86f43797b5795ff2dc36Hal Finkel // This is handled during epilogue generation. 1563fb6fe0aea2d1adde6d5e86f43797b5795ff2dc36Hal Finkel return; 1564fb6fe0aea2d1adde6d5e86f43797b5795ff2dc36Hal Finkel else { 15659d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // 32-bit: FP-relative 15669d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky MBB.insert(MI, addFrameReference(BuildMI(*MF, DL, TII.get(PPC::LWZ), 1567dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines PPC::R12), 1568dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CSI[CSIIndex].getFrameIdx())); 156933efedc0481c4b0d9866ff526eb1161372b5919fUlrich Weigand RestoreOp = PPC::MTOCRF; 15709d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky MoveReg = PPC::R12; 15719d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky } 1572dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 15739d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky if (CR2Spilled) 15749d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky MBB.insert(MI, BuildMI(*MF, DL, TII.get(RestoreOp), PPC::CR2) 1575d957f957eee12cf26a7160e6015f0a7c2629904fHal Finkel .addReg(MoveReg, getKillRegState(!CR3Spilled && !CR4Spilled))); 15769d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 15779d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky if (CR3Spilled) 15789d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky MBB.insert(MI, BuildMI(*MF, DL, TII.get(RestoreOp), PPC::CR3) 1579d957f957eee12cf26a7160e6015f0a7c2629904fHal Finkel .addReg(MoveReg, getKillRegState(!CR4Spilled))); 15809d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 15819d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky if (CR4Spilled) 15829d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky MBB.insert(MI, BuildMI(*MF, DL, TII.get(RestoreOp), PPC::CR4) 1583d957f957eee12cf26a7160e6015f0a7c2629904fHal Finkel .addReg(MoveReg, getKillRegState(true))); 15849d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky} 15859d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 1586700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Benderskyvoid PPCFrameLowering:: 1587700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli BenderskyeliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, 1588700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky MachineBasicBlock::iterator I) const { 1589ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const TargetInstrInfo &TII = *Subtarget.getInstrInfo(); 1590700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky if (MF.getTarget().Options.GuaranteedTailCallOpt && 1591700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky I->getOpcode() == PPC::ADJCALLSTACKUP) { 1592700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky // Add (actually subtract) back the amount the callee popped on return. 1593700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky if (int CalleeAmt = I->getOperand(1).getImm()) { 1594700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky bool is64Bit = Subtarget.isPPC64(); 1595700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky CalleeAmt *= -1; 1596700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky unsigned StackReg = is64Bit ? PPC::X1 : PPC::R1; 1597700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky unsigned TmpReg = is64Bit ? PPC::X0 : PPC::R0; 1598700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky unsigned ADDIInstr = is64Bit ? PPC::ADDI8 : PPC::ADDI; 1599700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky unsigned ADDInstr = is64Bit ? PPC::ADD8 : PPC::ADD4; 1600700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky unsigned LISInstr = is64Bit ? PPC::LIS8 : PPC::LIS; 1601700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky unsigned ORIInstr = is64Bit ? PPC::ORI8 : PPC::ORI; 1602700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky MachineInstr *MI = I; 1603700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky DebugLoc dl = MI->getDebugLoc(); 1604700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky 1605700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky if (isInt<16>(CalleeAmt)) { 1606700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky BuildMI(MBB, I, dl, TII.get(ADDIInstr), StackReg) 1607700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky .addReg(StackReg, RegState::Kill) 1608700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky .addImm(CalleeAmt); 1609700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky } else { 1610700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky MachineBasicBlock::iterator MBBI = I; 1611700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky BuildMI(MBB, MBBI, dl, TII.get(LISInstr), TmpReg) 1612700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky .addImm(CalleeAmt >> 16); 1613700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky BuildMI(MBB, MBBI, dl, TII.get(ORIInstr), TmpReg) 1614700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky .addReg(TmpReg, RegState::Kill) 1615700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky .addImm(CalleeAmt & 0xFFFF); 1616700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky BuildMI(MBB, MBBI, dl, TII.get(ADDInstr), StackReg) 1617700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky .addReg(StackReg, RegState::Kill) 1618700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky .addReg(TmpReg); 1619700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky } 1620700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky } 1621700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky } 1622700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky // Simply discard ADJCALLSTACKDOWN, ADJCALLSTACKUP instructions. 1623700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky MBB.erase(I); 1624700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky} 1625700ed80d3da5e98e05ceb90e9bfb66058581a6dbEli Bendersky 1626dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hinesbool 16279d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman DivackyPPCFrameLowering::restoreCalleeSavedRegisters(MachineBasicBlock &MBB, 1628dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MachineBasicBlock::iterator MI, 1629dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const std::vector<CalleeSavedInfo> &CSI, 1630dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines const TargetRegisterInfo *TRI) const { 16319d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 16329d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // Currently, this function only handles SVR4 32- and 64-bit ABIs. 16339d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // Return false otherwise to maintain pre-existing behavior. 16349d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky if (!Subtarget.isSVR4ABI()) 16359d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky return false; 16369d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 16379d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky MachineFunction *MF = MBB.getParent(); 16389d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky const PPCInstrInfo &TII = 1639ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines *static_cast<const PPCInstrInfo *>(Subtarget.getInstrInfo()); 16409d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky bool CR2Spilled = false; 16419d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky bool CR3Spilled = false; 16429d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky bool CR4Spilled = false; 16439d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky unsigned CSIIndex = 0; 16449d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 16459d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // Initialize insertion-point logic; we will be restoring in reverse 16469d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // order of spill. 16479d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky MachineBasicBlock::iterator I = MI, BeforeI = I; 16489d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky bool AtStart = I == MBB.begin(); 16499d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 16509d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky if (!AtStart) 16519d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky --BeforeI; 16529d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 16539d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky for (unsigned i = 0, e = CSI.size(); i != e; ++i) { 16549d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky unsigned Reg = CSI[i].getReg(); 16559d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 16566a636a813f33b46b3271ec8517ee1936a0c92c9fHal Finkel // Only Darwin actually uses the VRSAVE register, but it can still appear 16576a636a813f33b46b3271ec8517ee1936a0c92c9fHal Finkel // here if, for example, @llvm.eh.unwind.init() is used. If we're not on 16586a636a813f33b46b3271ec8517ee1936a0c92c9fHal Finkel // Darwin, ignore it. 16596a636a813f33b46b3271ec8517ee1936a0c92c9fHal Finkel if (Reg == PPC::VRSAVE && !Subtarget.isDarwinABI()) 16606a636a813f33b46b3271ec8517ee1936a0c92c9fHal Finkel continue; 16616a636a813f33b46b3271ec8517ee1936a0c92c9fHal Finkel 16629d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky if (Reg == PPC::CR2) { 16639d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky CR2Spilled = true; 16649d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // The spill slot is associated only with CR2, which is the 16659d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // first nonvolatile spilled. Save it here. 16669d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky CSIIndex = i; 16679d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky continue; 16689d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky } else if (Reg == PPC::CR3) { 16699d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky CR3Spilled = true; 16709d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky continue; 16719d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky } else if (Reg == PPC::CR4) { 16729d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky CR4Spilled = true; 16739d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky continue; 16749d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky } else { 16759d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // When we first encounter a non-CR register after seeing at 16769d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // least one CR register, restore all spilled CRs together. 16779d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky if ((CR2Spilled || CR3Spilled || CR4Spilled) 1678dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines && !(PPC::CR2 <= Reg && Reg <= PPC::CR4)) { 1679b99c995825a49f0da5af40ee1b61269deb8994b5Hal Finkel bool is31 = needsFP(*MF); 1680b99c995825a49f0da5af40ee1b61269deb8994b5Hal Finkel restoreCRs(Subtarget.isPPC64(), is31, 1681b99c995825a49f0da5af40ee1b61269deb8994b5Hal Finkel CR2Spilled, CR3Spilled, CR4Spilled, 1682dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MBB, I, CSI, CSIIndex); 1683dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines CR2Spilled = CR3Spilled = CR4Spilled = false; 16849d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky } 16859d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 16869d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // Default behavior for non-CR saves. 16879d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky const TargetRegisterClass *RC = TRI->getMinimalPhysRegClass(Reg); 16889d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky TII.loadRegFromStackSlot(MBB, I, Reg, CSI[i].getFrameIdx(), 1689dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines RC, TRI); 16909d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky assert(I != MBB.begin() && 1691dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines "loadRegFromStackSlot didn't insert any code!"); 16929d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky } 16939d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 16949d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // Insert in reverse order. 16959d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky if (AtStart) 16969d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky I = MBB.begin(); 16979d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky else { 16989d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky I = BeforeI; 16999d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky ++I; 1700dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 17019d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky } 17029d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 17039d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky // If we haven't yet spilled the CRs, do so now. 1704b99c995825a49f0da5af40ee1b61269deb8994b5Hal Finkel if (CR2Spilled || CR3Spilled || CR4Spilled) { 1705dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines bool is31 = needsFP(*MF); 1706b99c995825a49f0da5af40ee1b61269deb8994b5Hal Finkel restoreCRs(Subtarget.isPPC64(), is31, CR2Spilled, CR3Spilled, CR4Spilled, 1707dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines MBB, I, CSI, CSIIndex); 1708b99c995825a49f0da5af40ee1b61269deb8994b5Hal Finkel } 17099d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky 17109d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky return true; 17119d760ae5c6bc1d1482e2824efcf9cb11db1cc16fRoman Divacky} 1712