contrib/llvm/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 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. Returns instruction just
  53   /// after the expansion.
  54   MachineInstr *emitStackProbe(MachineFunction &MF, MachineBasicBlock &MBB,
  55                                MachineBasicBlock::iterator MBBI,
  56                                const DebugLoc &DL, bool InProlog) const;
  57
  58   /// Replace a StackProbe inline-stub with the actual probe code inline.
  59   void inlineStackProbe(MachineFunction &MF,
  60                         MachineBasicBlock &PrologMBB) const override;
  61
  62   void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
  63                                  MachineBasicBlock::iterator MBBI,
  64                                  const DebugLoc &DL) const;
  65
  66   /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
  67   /// the function.
  68   void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  69   void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
  70
  71   void adjustForSegmentedStacks(MachineFunction &MF,
  72                                 MachineBasicBlock &PrologueMBB) const override;
  73
  74   void adjustForHiPEPrologue(MachineFunction &MF,
  75                              MachineBasicBlock &PrologueMBB) const override;
  76
  77   void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
  78                             RegScavenger *RS = nullptr) const override;
  79
  80   bool
  81   assignCalleeSavedSpillSlots(MachineFunction &MF,
  82                               const TargetRegisterInfo *TRI,
  83                               std::vector<CalleeSavedInfo> &CSI) const override;
  84
  85   bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
  86                                  MachineBasicBlock::iterator MI,
  87                                  const std::vector<CalleeSavedInfo> &CSI,
  88                                  const TargetRegisterInfo *TRI) const override;
  89
  90   bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
  91                                   MachineBasicBlock::iterator MI,
  92                                   const std::vector<CalleeSavedInfo> &CSI,
  93                                   const TargetRegisterInfo *TRI) const override;
  94
  95   bool hasFP(const MachineFunction &MF) const override;
  96   bool hasReservedCallFrame(const MachineFunction &MF) const override;
  97   bool canSimplifyCallFramePseudos(const MachineFunction &MF) const override;
  98   bool needsFrameIndexResolution(const MachineFunction &MF) const override;
  99
 100   int getFrameIndexReference(const MachineFunction &MF, int FI,
 101                              unsigned &FrameReg) const override;
 102
 103   int getFrameIndexReferencePreferSP(const MachineFunction &MF, int FI,
 104                                      unsigned &FrameReg,
 105                                      bool IgnoreSPUpdates) const override;
 106
 107   MachineBasicBlock::iterator
 108   eliminateCallFramePseudoInstr(MachineFunction &MF, MachineBasicBlock &MBB,
 109                                 MachineBasicBlock::iterator MI) const override;
 110
 111   unsigned getWinEHParentFrameOffset(const MachineFunction &MF) const override;
 112
 113   void processFunctionBeforeFrameFinalized(MachineFunction &MF,
 114                                            RegScavenger *RS) const override;
 115
 116   /// Check the instruction before/after the passed instruction. If
 117   /// it is an ADD/SUB/LEA instruction it is deleted argument and the
 118   /// stack adjustment is returned as a positive value for ADD/LEA and
 119   /// a negative for SUB.
 120   int mergeSPUpdates(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
 121                      bool doMergeWithPrevious) const;
 122
 123   /// Emit a series of instructions to increment / decrement the stack
 124   /// pointer by a constant value.
 125   void emitSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
 126                     int64_t NumBytes, bool InEpilogue) const;
 127
 128   /// Check that LEA can be used on SP in an epilogue sequence for \p MF.
 129   bool canUseLEAForSPInEpilogue(const MachineFunction &MF) const;
 130
 131   /// Check whether or not the given \p MBB can be used as a prologue
 132   /// for the target.
 133   /// The prologue will be inserted first in this basic block.
 134   /// This method is used by the shrink-wrapping pass to decide if
 135   /// \p MBB will be correctly handled by the target.
 136   /// As soon as the target enable shrink-wrapping without overriding
 137   /// this method, we assume that each basic block is a valid
 138   /// prologue.
 139   bool canUseAsPrologue(const MachineBasicBlock &MBB) const override;
 140
 141   /// Check whether or not the given \p MBB can be used as a epilogue
 142   /// for the target.
 143   /// The epilogue will be inserted before the first terminator of that block.
 144   /// This method is used by the shrink-wrapping pass to decide if
 145   /// \p MBB will be correctly handled by the target.
 146   bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override;
 147
 148   /// Returns true if the target will correctly handle shrink wrapping.
 149   bool enableShrinkWrapping(const MachineFunction &MF) const override;
 150
 151   /// Order the symbols in the local stack.
 152   /// We want to place the local stack objects in some sort of sensible order.
 153   /// The heuristic we use is to try and pack them according to static number
 154   /// of uses and size in order to minimize code size.
 155   void orderFrameObjects(const MachineFunction &MF,
 156                          SmallVectorImpl<int> &ObjectsToAllocate) const override;
 157
 158   /// convertArgMovsToPushes - This method tries to convert a call sequence
 159   /// that uses sub and mov instructions to put the argument onto the stack
 160   /// into a series of pushes.
 161   /// Returns true if the transformation succeeded, false if not.
 162   bool convertArgMovsToPushes(MachineFunction &MF,
 163                               MachineBasicBlock &MBB,
 164                               MachineBasicBlock::iterator I,
 165                               uint64_t Amount) const;
 166
 167   /// Wraps up getting a CFI index and building a MachineInstr for it.
 168   void BuildCFI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
 169                 const DebugLoc &DL, const MCCFIInstruction &CFIInst) const;
 170
 171   /// Sets up EBP and optionally ESI based on the incoming EBP value.  Only
 172   /// needed for 32-bit. Used in funclet prologues and at catchret destinations.
 173   MachineBasicBlock::iterator
 174   restoreWin32EHStackPointers(MachineBasicBlock &MBB,
 175                               MachineBasicBlock::iterator MBBI,
 176                               const DebugLoc &DL, bool RestoreSP = false) const;
 177
 178 private:
 179   uint64_t calculateMaxStackAlign(const MachineFunction &MF) const;
 180
 181   /// Emit target stack probe as a call to a helper function
 182   MachineInstr *emitStackProbeCall(MachineFunction &MF, MachineBasicBlock &MBB,
 183                                    MachineBasicBlock::iterator MBBI,
 184                                    const DebugLoc &DL, bool InProlog) const;
 185
 186   /// Emit target stack probe as an inline sequence.
 187   MachineInstr *emitStackProbeInline(MachineFunction &MF,
 188                                      MachineBasicBlock &MBB,
 189                                      MachineBasicBlock::iterator MBBI,
 190                                      const DebugLoc &DL, bool InProlog) const;
 191
 192   /// Emit a stub to later inline the target stack probe.
 193   MachineInstr *emitStackProbeInlineStub(MachineFunction &MF,
 194                                          MachineBasicBlock &MBB,
 195                                          MachineBasicBlock::iterator MBBI,
 196                                          const DebugLoc &DL,
 197                                          bool InProlog) const;
 198
 199   /// Aligns the stack pointer by ANDing it with -MaxAlign.
 200   void BuildStackAlignAND(MachineBasicBlock &MBB,
 201                           MachineBasicBlock::iterator MBBI, const DebugLoc &DL,
 202                           unsigned Reg, uint64_t MaxAlign) const;
 203
 204   /// Make small positive stack adjustments using POPs.
 205   bool adjustStackWithPops(MachineBasicBlock &MBB,
 206                            MachineBasicBlock::iterator MBBI, const DebugLoc &DL,
 207                            int Offset) const;
 208
 209   /// Adjusts the stack pointer using LEA, SUB, or ADD.
 210   MachineInstrBuilder BuildStackAdjustment(MachineBasicBlock &MBB,
 211                                            MachineBasicBlock::iterator MBBI,
 212                                            const DebugLoc &DL, int64_t Offset,
 213                                            bool InEpilogue) const;
 214
 215   unsigned getPSPSlotOffsetFromSP(const MachineFunction &MF) const;
 216
 217   unsigned getWinEHFuncletFrameSize(const MachineFunction &MF) const;
 218 };
 219
 220 } // End llvm namespace
 221
 222 #endif