lib/Target/X86/X86FrameLowering.h

   1 //===-- X86TargetFrameLowering.h - Define frame lowering for X86 -*- C++ -*-==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This class implements X86-specific bits of TargetFrameLowering class.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #ifndef LLVM_LIB_TARGET_X86_X86FRAMELOWERING_H
  15 #define LLVM_LIB_TARGET_X86_X86FRAMELOWERING_H
  16
  17 #include "llvm/Target/TargetFrameLowering.h"
  18
  19 namespace llvm {
  20
  21 class MachineInstrBuilder;
  22 class MCCFIInstruction;
  23 class X86Subtarget;
  24 class X86RegisterInfo;
  25
  26 class X86FrameLowering : public TargetFrameLowering {
  27 public:
  28   X86FrameLowering(const X86Subtarget &STI, unsigned StackAlignOverride);
  29
  30   // Cached subtarget predicates.
  31
  32   const X86Subtarget &STI;
  33   const TargetInstrInfo &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 a call to the target's stack probe function. 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 emitStackProbeCall(MachineFunction &MF, MachineBasicBlock &MBB,
  54                           MachineBasicBlock::iterator MBBI, DebugLoc DL) const;
  55
  56   void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
  57                                  MachineBasicBlock::iterator MBBI,
  58                                  DebugLoc DL) const;
  59
  60   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
  61   /// the function.
  62   void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  63   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  64
  65   void adjustForSegmentedStacks(MachineFunction &MF,
  66                                 MachineBasicBlock &PrologueMBB) const override;
  67
  68   void adjustForHiPEPrologue(MachineFunction &MF,
  69                              MachineBasicBlock &PrologueMBB) const override;
  70
  71   void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
  72                             RegScavenger *RS = nullptr) const override;
  73
  74   bool
  75   assignCalleeSavedSpillSlots(MachineFunction &MF,
  76                               const TargetRegisterInfo *TRI,
  77                               std::vector<CalleeSavedInfo> &CSI) const override;
  78
  79   bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
  80                                  MachineBasicBlock::iterator MI,
  81                                  const std::vector<CalleeSavedInfo> &CSI,
  82                                  const TargetRegisterInfo *TRI) const override;
  83
  84   bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
  85                                   MachineBasicBlock::iterator MI,
  86                                   const std::vector<CalleeSavedInfo> &CSI,
  87                                   const TargetRegisterInfo *TRI) const override;
  88
  89   bool hasFP(const MachineFunction &MF) const override;
  90   bool hasReservedCallFrame(const MachineFunction &MF) const override;
  91   bool canSimplifyCallFramePseudos(const MachineFunction &MF) const override;
  92   bool needsFrameIndexResolution(const MachineFunction &MF) const override;
  93
  94   int getFrameIndexReference(const MachineFunction &MF, int FI,
  95                              unsigned &FrameReg) const override;
  96
  97   int getFrameIndexReferenceFromSP(const MachineFunction &MF, int FI,
  98                                    unsigned &FrameReg) const override;
  99
 100   void eliminateCallFramePseudoInstr(MachineFunction &MF,
 101                                  MachineBasicBlock &MBB,
 102                                  MachineBasicBlock::iterator MI) const override;
 103
 104   unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const override;
 105
 106   /// Check the instruction before/after the passed instruction. If
 107   /// it is an ADD/SUB/LEA instruction it is deleted argument and the
 108   /// stack adjustment is returned as a positive value for ADD/LEA and
 109   /// a negative for SUB.
 110   int mergeSPUpdates(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
 111                      bool doMergeWithPrevious) const;
 112
 113   /// Emit a series of instructions to increment / decrement the stack
 114   /// pointer by a constant value.
 115   void emitSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
 116                     int64_t NumBytes, bool InEpilogue) const;
 117
 118   /// Check that LEA can be used on SP in an epilogue sequence for \p MF.
 119   bool canUseLEAForSPInEpilogue(const MachineFunction &MF) const;
 120
 121   /// Check whether or not the given \p MBB can be used as a epilogue
 122   /// for the target.
 123   /// The epilogue will be inserted before the first terminator of that block.
 124   /// This method is used by the shrink-wrapping pass to decide if
 125   /// \p MBB will be correctly handled by the target.
 126   bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override;
 127
 128 private:
 129   uint64_t calculateMaxStackAlign(const MachineFunction &MF) const;
 130
 131   /// Wraps up getting a CFI index and building a MachineInstr for it.
 132   void BuildCFI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
 133                 DebugLoc DL, MCCFIInstruction CFIInst) const;
 134
 135   /// Aligns the stack pointer by ANDing it with -MaxAlign.
 136   void BuildStackAlignAND(MachineBasicBlock &MBB,
 137                           MachineBasicBlock::iterator MBBI, DebugLoc DL,
 138                           uint64_t MaxAlign) const;
 139
 140   /// Make small positive stack adjustments using POPs.
 141   bool adjustStackWithPops(MachineBasicBlock &MBB,
 142                            MachineBasicBlock::iterator MBBI, DebugLoc DL,
 143                            int Offset) const;
 144
 145   /// Adjusts the stack pointer using LEA, SUB, or ADD.
 146   MachineInstrBuilder BuildStackAdjustment(MachineBasicBlock &MBB,
 147                                            MachineBasicBlock::iterator MBBI,
 148                                            DebugLoc DL, int64_t Offset,
 149                                            bool InEpilogue) const;
 150
 151   /// Sets up EBP and optionally ESI based on the incoming EBP value.  Only
 152   /// needed for 32-bit. Used in funclet prologues and at catchret destinations.
 153   MachineBasicBlock::iterator
 154   restoreWin32EHStackPointers(MachineBasicBlock &MBB,
 155                               MachineBasicBlock::iterator MBBI, DebugLoc DL,
 156                               bool RestoreSP = false) const;
 157
 158   unsigned getWinEHFuncletFrameSize(const MachineFunction &MF) const;
 159 };
 160
 161 } // End llvm namespace
 162
 163 #endif