1 //===-- X86TargetFrameLowering.h - Define frame lowering for X86 -*- C++ -*-==// 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 class implements X86-specific bits of TargetFrameLowering class. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #ifndef LLVM_LIB_TARGET_X86_X86FRAMELOWERING_H 14 #define LLVM_LIB_TARGET_X86_X86FRAMELOWERING_H 15 16 #include "llvm/CodeGen/TargetFrameLowering.h" 17 18 namespace llvm { 19 20 class MachineInstrBuilder; 21 class MCCFIInstruction; 22 class X86InstrInfo; 23 class X86Subtarget; 24 class X86RegisterInfo; 25 26 class X86FrameLowering : public TargetFrameLowering { 27 public: 28 X86FrameLowering(const X86Subtarget &STI, MaybeAlign StackAlignOverride); 29 30 // Cached subtarget predicates. 31 32 const X86Subtarget &STI; 33 const X86InstrInfo &TII; 34 const X86RegisterInfo *TRI; 35 36 unsigned SlotSize; 37 38 /// Is64Bit implies that x86_64 instructions are available. 39 bool Is64Bit; 40 41 bool IsLP64; 42 43 /// True if the 64-bit frame or stack pointer should be used. True for most 44 /// 64-bit targets with the exception of x32. If this is false, 32-bit 45 /// instruction operands should be used to manipulate StackPtr and FramePtr. 46 bool Uses64BitFramePtr; 47 48 unsigned StackPtr; 49 50 /// Emit target stack probe code. This is required for all 51 /// large stack allocations on Windows. The caller is required to materialize 52 /// the number of bytes to probe in RAX/EAX. 53 void emitStackProbe(MachineFunction &MF, MachineBasicBlock &MBB, 54 MachineBasicBlock::iterator MBBI, const DebugLoc &DL, 55 bool InProlog) const; 56 57 /// Replace a StackProbe inline-stub with the actual probe code inline. 58 void inlineStackProbe(MachineFunction &MF, 59 MachineBasicBlock &PrologMBB) const override; 60 61 void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB, 62 MachineBasicBlock::iterator MBBI, 63 const DebugLoc &DL) const; 64 65 /// emitProlog/emitEpilog - These methods insert prolog and epilog code into 66 /// the function. 67 void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override; 68 void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override; 69 70 void adjustForSegmentedStacks(MachineFunction &MF, 71 MachineBasicBlock &PrologueMBB) const override; 72 73 void adjustForHiPEPrologue(MachineFunction &MF, 74 MachineBasicBlock &PrologueMBB) const override; 75 76 void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs, 77 RegScavenger *RS = nullptr) const override; 78 79 bool 80 assignCalleeSavedSpillSlots(MachineFunction &MF, 81 const TargetRegisterInfo *TRI, 82 std::vector<CalleeSavedInfo> &CSI) const override; 83 84 bool spillCalleeSavedRegisters(MachineBasicBlock &MBB, 85 MachineBasicBlock::iterator MI, 86 const std::vector<CalleeSavedInfo> &CSI, 87 const TargetRegisterInfo *TRI) const override; 88 89 bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB, 90 MachineBasicBlock::iterator MI, 91 std::vector<CalleeSavedInfo> &CSI, 92 const TargetRegisterInfo *TRI) const override; 93 94 bool hasFP(const MachineFunction &MF) const override; 95 bool hasReservedCallFrame(const MachineFunction &MF) const override; 96 bool canSimplifyCallFramePseudos(const MachineFunction &MF) const override; 97 bool needsFrameIndexResolution(const MachineFunction &MF) const override; 98 99 int getFrameIndexReference(const MachineFunction &MF, int FI, 100 unsigned &FrameReg) const override; 101 102 int getWin64EHFrameIndexRef(const MachineFunction &MF, 103 int FI, unsigned &SPReg) const; 104 int getFrameIndexReferenceSP(const MachineFunction &MF, 105 int FI, unsigned &SPReg, int Adjustment) const; 106 int getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI, 107 unsigned &FrameReg, 108 bool IgnoreSPUpdates) const override; 109 110 MachineBasicBlock::iterator 111 eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB, 112 MachineBasicBlock::iterator MI) const override; 113 114 unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const override; 115 116 void processFunctionBeforeFrameFinalized(MachineFunction &MF, 117 RegScavenger *RS) const override; 118 119 /// Check the instruction before/after the passed instruction. If 120 /// it is an ADD/SUB/LEA instruction it is deleted argument and the 121 /// stack adjustment is returned as a positive value for ADD/LEA and 122 /// a negative for SUB. 123 int mergeSPUpdates(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI, 124 bool doMergeWithPrevious) const; 125 126 /// Emit a series of instructions to increment / decrement the stack 127 /// pointer by a constant value. 128 void emitSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI, 129 const DebugLoc &DL, int64_t NumBytes, bool InEpilogue) const; 130 131 /// Check that LEA can be used on SP in an epilogue sequence for \p MF. 132 bool canUseLEAForSPInEpilogue(const MachineFunction &MF) const; 133 134 /// Check whether or not the given \p MBB can be used as a prologue 135 /// for the target. 136 /// The prologue will be inserted first in this basic block. 137 /// This method is used by the shrink-wrapping pass to decide if 138 /// \p MBB will be correctly handled by the target. 139 /// As soon as the target enable shrink-wrapping without overriding 140 /// this method, we assume that each basic block is a valid 141 /// prologue. 142 bool canUseAsPrologue(const MachineBasicBlock &MBB) const override; 143 144 /// Check whether or not the given \p MBB can be used as a epilogue 145 /// for the target. 146 /// The epilogue will be inserted before the first terminator of that block. 147 /// This method is used by the shrink-wrapping pass to decide if 148 /// \p MBB will be correctly handled by the target. 149 bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override; 150 151 /// Returns true if the target will correctly handle shrink wrapping. 152 bool enableShrinkWrapping(const MachineFunction &MF) const override; 153 154 /// Order the symbols in the local stack. 155 /// We want to place the local stack objects in some sort of sensible order. 156 /// The heuristic we use is to try and pack them according to static number 157 /// of uses and size in order to minimize code size. 158 void orderFrameObjects(const MachineFunction &MF, 159 SmallVectorImpl<int> &ObjectsToAllocate) const override; 160 161 /// Wraps up getting a CFI index and building a MachineInstr for it. 162 void BuildCFI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI, 163 const DebugLoc &DL, const MCCFIInstruction &CFIInst) const; 164 165 /// Sets up EBP and optionally ESI based on the incoming EBP value. Only 166 /// needed for 32-bit. Used in funclet prologues and at catchret destinations. 167 MachineBasicBlock::iterator 168 restoreWin32EHStackPointers(MachineBasicBlock &MBB, 169 MachineBasicBlock::iterator MBBI, 170 const DebugLoc &DL, bool RestoreSP = false) const; 171 172 int getInitialCFAOffset(const MachineFunction &MF) const override; 173 174 unsigned getInitialCFARegister(const MachineFunction &MF) const override; 175 176 /// Return true if the function has a redzone (accessible bytes past the 177 /// frame of the top of stack function) as part of it's ABI. 178 bool has128ByteRedZone(const MachineFunction& MF) const; 179 180 private: 181 uint64_t calculateMaxStackAlign(const MachineFunction &MF) const; 182 183 /// Emit target stack probe as a call to a helper function 184 void emitStackProbeCall(MachineFunction &MF, MachineBasicBlock &MBB, 185 MachineBasicBlock::iterator MBBI, const DebugLoc &DL, 186 bool InProlog) const; 187 188 /// Emit target stack probe as an inline sequence. 189 void emitStackProbeInline(MachineFunction &MF, MachineBasicBlock &MBB, 190 MachineBasicBlock::iterator MBBI, 191 const DebugLoc &DL, bool InProlog) const; 192 193 /// Emit a stub to later inline the target stack probe. 194 void emitStackProbeInlineStub(MachineFunction &MF, MachineBasicBlock &MBB, 195 MachineBasicBlock::iterator MBBI, 196 const DebugLoc &DL, bool InProlog) const; 197 198 /// Aligns the stack pointer by ANDing it with -MaxAlign. 199 void BuildStackAlignAND(MachineBasicBlock &MBB, 200 MachineBasicBlock::iterator MBBI, const DebugLoc &DL, 201 unsigned Reg, uint64_t MaxAlign) const; 202 203 /// Make small positive stack adjustments using POPs. 204 bool adjustStackWithPops(MachineBasicBlock &MBB, 205 MachineBasicBlock::iterator MBBI, const DebugLoc &DL, 206 int Offset) const; 207 208 /// Adjusts the stack pointer using LEA, SUB, or ADD. 209 MachineInstrBuilder BuildStackAdjustment(MachineBasicBlock &MBB, 210 MachineBasicBlock::iterator MBBI, 211 const DebugLoc &DL, int64_t Offset, 212 bool InEpilogue) const; 213 214 unsigned getPSPSlotOffsetFromSP(const MachineFunction &MF) const; 215 216 unsigned getWinEHFuncletFrameSize(const MachineFunction &MF) const; 217 218 /// Materialize the catchret target MBB in RAX. 219 void emitCatchRetReturnValue(MachineBasicBlock &MBB, 220 MachineBasicBlock::iterator MBBI, 221 MachineInstr *CatchRet) const; 222 }; 223 224 } // End llvm namespace 225 226 #endif 227