lib/Target/X86/X86FrameLowering.h

   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