1 //===-- LanaiFrameLowering.cpp - Lanai Frame Information ------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file contains the Lanai implementation of TargetFrameLowering class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "LanaiFrameLowering.h" 14 15 #include "LanaiAluCode.h" 16 #include "LanaiInstrInfo.h" 17 #include "LanaiSubtarget.h" 18 #include "llvm/CodeGen/MachineFrameInfo.h" 19 #include "llvm/CodeGen/MachineFunction.h" 20 #include "llvm/CodeGen/MachineInstrBuilder.h" 21 #include "llvm/CodeGen/MachineRegisterInfo.h" 22 #include "llvm/IR/Function.h" 23 24 using namespace llvm; 25 26 // Determines the size of the frame and maximum call frame size. 27 void LanaiFrameLowering::determineFrameLayout(MachineFunction &MF) const { 28 MachineFrameInfo &MFI = MF.getFrameInfo(); 29 const LanaiRegisterInfo *LRI = STI.getRegisterInfo(); 30 31 // Get the number of bytes to allocate from the FrameInfo. 32 unsigned FrameSize = MFI.getStackSize(); 33 34 // Get the alignment. 35 Align StackAlign = 36 LRI->hasStackRealignment(MF) ? MFI.getMaxAlign() : getStackAlign(); 37 38 // Get the maximum call frame size of all the calls. 39 unsigned MaxCallFrameSize = MFI.getMaxCallFrameSize(); 40 41 // If we have dynamic alloca then MaxCallFrameSize needs to be aligned so 42 // that allocations will be aligned. 43 if (MFI.hasVarSizedObjects()) 44 MaxCallFrameSize = alignTo(MaxCallFrameSize, StackAlign); 45 46 // Update maximum call frame size. 47 MFI.setMaxCallFrameSize(MaxCallFrameSize); 48 49 // Include call frame size in total. 50 if (!(hasReservedCallFrame(MF) && MFI.adjustsStack())) 51 FrameSize += MaxCallFrameSize; 52 53 // Make sure the frame is aligned. 54 FrameSize = alignTo(FrameSize, StackAlign); 55 56 // Update frame info. 57 MFI.setStackSize(FrameSize); 58 } 59 60 // Iterates through each basic block in a machine function and replaces 61 // ADJDYNALLOC pseudo instructions with a Lanai:ADDI with the 62 // maximum call frame size as the immediate. 63 void LanaiFrameLowering::replaceAdjDynAllocPseudo(MachineFunction &MF) const { 64 const LanaiInstrInfo &LII = 65 *static_cast<const LanaiInstrInfo *>(STI.getInstrInfo()); 66 unsigned MaxCallFrameSize = MF.getFrameInfo().getMaxCallFrameSize(); 67 68 for (MachineBasicBlock &MBB : MF) { 69 for (MachineInstr &MI : llvm::make_early_inc_range(MBB)) { 70 if (MI.getOpcode() == Lanai::ADJDYNALLOC) { 71 DebugLoc DL = MI.getDebugLoc(); 72 Register Dst = MI.getOperand(0).getReg(); 73 Register Src = MI.getOperand(1).getReg(); 74 75 BuildMI(MBB, MI, DL, LII.get(Lanai::ADD_I_LO), Dst) 76 .addReg(Src) 77 .addImm(MaxCallFrameSize); 78 MI.eraseFromParent(); 79 } 80 } 81 } 82 } 83 84 // Generates the following sequence for function entry: 85 // st %fp,-4[*%sp] !push old FP 86 // add %sp,8,%fp !generate new FP 87 // sub %sp,0x4,%sp !allocate stack space (as needed) 88 void LanaiFrameLowering::emitPrologue(MachineFunction &MF, 89 MachineBasicBlock &MBB) const { 90 assert(&MF.front() == &MBB && "Shrink-wrapping not yet supported"); 91 92 MachineFrameInfo &MFI = MF.getFrameInfo(); 93 const LanaiInstrInfo &LII = 94 *static_cast<const LanaiInstrInfo *>(STI.getInstrInfo()); 95 MachineBasicBlock::iterator MBBI = MBB.begin(); 96 97 // Debug location must be unknown since the first debug location is used 98 // to determine the end of the prologue. 99 DebugLoc DL; 100 101 // Determine the correct frame layout 102 determineFrameLayout(MF); 103 104 // FIXME: This appears to be overallocating. Needs investigation. 105 // Get the number of bytes to allocate from the FrameInfo. 106 unsigned StackSize = MFI.getStackSize(); 107 108 // Push old FP 109 // st %fp,-4[*%sp] 110 BuildMI(MBB, MBBI, DL, LII.get(Lanai::SW_RI)) 111 .addReg(Lanai::FP) 112 .addReg(Lanai::SP) 113 .addImm(-4) 114 .addImm(LPAC::makePreOp(LPAC::ADD)) 115 .setMIFlag(MachineInstr::FrameSetup); 116 117 // Generate new FP 118 // add %sp,8,%fp 119 BuildMI(MBB, MBBI, DL, LII.get(Lanai::ADD_I_LO), Lanai::FP) 120 .addReg(Lanai::SP) 121 .addImm(8) 122 .setMIFlag(MachineInstr::FrameSetup); 123 124 // Allocate space on the stack if needed 125 // sub %sp,StackSize,%sp 126 if (StackSize != 0) { 127 BuildMI(MBB, MBBI, DL, LII.get(Lanai::SUB_I_LO), Lanai::SP) 128 .addReg(Lanai::SP) 129 .addImm(StackSize) 130 .setMIFlag(MachineInstr::FrameSetup); 131 } 132 133 // Replace ADJDYNANALLOC 134 if (MFI.hasVarSizedObjects()) 135 replaceAdjDynAllocPseudo(MF); 136 } 137 138 MachineBasicBlock::iterator LanaiFrameLowering::eliminateCallFramePseudoInstr( 139 MachineFunction & /*MF*/, MachineBasicBlock &MBB, 140 MachineBasicBlock::iterator I) const { 141 // Discard ADJCALLSTACKDOWN, ADJCALLSTACKUP instructions. 142 return MBB.erase(I); 143 } 144 145 // The function epilogue should not depend on the current stack pointer! 146 // It should use the frame pointer only. This is mandatory because 147 // of alloca; we also take advantage of it to omit stack adjustments 148 // before returning. 149 // 150 // Note that when we go to restore the preserved register values we must 151 // not try to address their slots by using offsets from the stack pointer. 152 // That's because the stack pointer may have been moved during the function 153 // execution due to a call to alloca(). Rather, we must restore all 154 // preserved registers via offsets from the frame pointer value. 155 // 156 // Note also that when the current frame is being "popped" (by adjusting 157 // the value of the stack pointer) on function exit, we must (for the 158 // sake of alloca) set the new value of the stack pointer based upon 159 // the current value of the frame pointer. We can't just add what we 160 // believe to be the (static) frame size to the stack pointer because 161 // if we did that, and alloca() had been called during this function, 162 // we would end up returning *without* having fully deallocated all of 163 // the space grabbed by alloca. If that happened, and a function 164 // containing one or more alloca() calls was called over and over again, 165 // then the stack would grow without limit! 166 // 167 // RET is lowered to 168 // ld -4[%fp],%pc # modify %pc (two delay slots) 169 // as the return address is in the stack frame and mov to pc is allowed. 170 // emitEpilogue emits 171 // mov %fp,%sp # restore the stack pointer 172 // ld -8[%fp],%fp # restore the caller's frame pointer 173 // before RET and the delay slot filler will move RET such that these 174 // instructions execute in the delay slots of the load to PC. 175 void LanaiFrameLowering::emitEpilogue(MachineFunction & /*MF*/, 176 MachineBasicBlock &MBB) const { 177 MachineBasicBlock::iterator MBBI = MBB.getLastNonDebugInstr(); 178 const LanaiInstrInfo &LII = 179 *static_cast<const LanaiInstrInfo *>(STI.getInstrInfo()); 180 DebugLoc DL = MBBI->getDebugLoc(); 181 182 // Restore the stack pointer using the callee's frame pointer value. 183 BuildMI(MBB, MBBI, DL, LII.get(Lanai::ADD_I_LO), Lanai::SP) 184 .addReg(Lanai::FP) 185 .addImm(0); 186 187 // Restore the frame pointer from the stack. 188 BuildMI(MBB, MBBI, DL, LII.get(Lanai::LDW_RI), Lanai::FP) 189 .addReg(Lanai::FP) 190 .addImm(-8) 191 .addImm(LPAC::ADD); 192 } 193 194 void LanaiFrameLowering::determineCalleeSaves(MachineFunction &MF, 195 BitVector &SavedRegs, 196 RegScavenger *RS) const { 197 TargetFrameLowering::determineCalleeSaves(MF, SavedRegs, RS); 198 199 MachineFrameInfo &MFI = MF.getFrameInfo(); 200 const LanaiRegisterInfo *LRI = 201 static_cast<const LanaiRegisterInfo *>(STI.getRegisterInfo()); 202 int Offset = -4; 203 204 // Reserve 4 bytes for the saved RCA 205 MFI.CreateFixedObject(4, Offset, true); 206 Offset -= 4; 207 208 // Reserve 4 bytes for the saved FP 209 MFI.CreateFixedObject(4, Offset, true); 210 Offset -= 4; 211 212 if (LRI->hasBasePointer(MF)) { 213 MFI.CreateFixedObject(4, Offset, true); 214 SavedRegs.reset(LRI->getBaseRegister()); 215 } 216 } 217