-//===-- X86TargetFrameLowering.h - Define frame lowering for X86 -*- C++ -*-==//\r
-//\r
-// The LLVM Compiler Infrastructure\r
-//\r
-// This file is distributed under the University of Illinois Open Source\r
-// License. See LICENSE.TXT for details.\r
-//\r
-//===----------------------------------------------------------------------===//\r
-//\r
-// This class implements X86-specific bits of TargetFrameLowering class.\r
-//\r
-//===----------------------------------------------------------------------===//\r
-\r
-#ifndef LLVM_LIB_TARGET_X86_X86FRAMELOWERING_H\r
-#define LLVM_LIB_TARGET_X86_X86FRAMELOWERING_H\r
-\r
-#include "llvm/Target/TargetFrameLowering.h"\r
-\r
-namespace llvm {\r
-\r
-class MCSymbol;\r
-class X86TargetMachine;\r
-class X86Subtarget;\r
-\r
-class X86FrameLowering : public TargetFrameLowering {\r
-public:\r
- explicit X86FrameLowering(StackDirection D, unsigned StackAl, int LAO)\r
- : TargetFrameLowering(StackGrowsDown, StackAl, LAO) {}\r
-\r
- /// Emit a call to the target's stack probe function. This is required for all\r
- /// large stack allocations on Windows. The caller is required to materialize\r
- /// the number of bytes to probe in RAX/EAX.\r
- static void emitStackProbeCall(MachineFunction &MF, MachineBasicBlock &MBB,\r
- MachineBasicBlock::iterator MBBI, DebugLoc DL);\r
-\r
- void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,\r
- MachineBasicBlock::iterator MBBI,\r
- DebugLoc DL) const;\r
-\r
- /// emitProlog/emitEpilog - These methods insert prolog and epilog code into\r
- /// the function.\r
- void emitPrologue(MachineFunction &MF) const override;\r
- void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;\r
-\r
- void adjustForSegmentedStacks(MachineFunction &MF) const override;\r
-\r
- void adjustForHiPEPrologue(MachineFunction &MF) const override;\r
-\r
- void processFunctionBeforeCalleeSavedScan(MachineFunction &MF,\r
- RegScavenger *RS = nullptr) const override;\r
-\r
- bool\r
- assignCalleeSavedSpillSlots(MachineFunction &MF,\r
- const TargetRegisterInfo *TRI,\r
- std::vector<CalleeSavedInfo> &CSI) const override;\r
-\r
- bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,\r
- MachineBasicBlock::iterator MI,\r
- const std::vector<CalleeSavedInfo> &CSI,\r
- const TargetRegisterInfo *TRI) const override;\r
-\r
- bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,\r
- MachineBasicBlock::iterator MI,\r
- const std::vector<CalleeSavedInfo> &CSI,\r
- const TargetRegisterInfo *TRI) const override;\r
-\r
- bool hasFP(const MachineFunction &MF) const override;\r
- bool hasReservedCallFrame(const MachineFunction &MF) const override;\r
- bool canSimplifyCallFramePseudos(const MachineFunction &MF) const override;\r
- bool needsFrameIndexResolution(const MachineFunction &MF) const override;\r
-\r
- int getFrameIndexOffset(const MachineFunction &MF, int FI) const override;\r
- int getFrameIndexReference(const MachineFunction &MF, int FI,\r
- unsigned &FrameReg) const override;\r
-\r
- int getFrameIndexOffsetFromSP(const MachineFunction &MF, int FI) const;\r
- int getFrameIndexReferenceFromSP(const MachineFunction &MF, int FI,\r
- unsigned &FrameReg) const override;\r
-\r
- void eliminateCallFramePseudoInstr(MachineFunction &MF,\r
- MachineBasicBlock &MBB,\r
- MachineBasicBlock::iterator MI) const override;\r
-\r
-private:\r
- /// convertArgMovsToPushes - This method tries to convert a call sequence\r
- /// that uses sub and mov instructions to put the argument onto the stack\r
- /// into a series of pushes.\r
- /// Returns true if the transformation succeeded, false if not.\r
- bool convertArgMovsToPushes(MachineFunction &MF, \r
- MachineBasicBlock &MBB,\r
- MachineBasicBlock::iterator I, \r
- uint64_t Amount) const;\r
-};\r
-\r
-} // End llvm namespace\r
-\r
-#endif\r
+//===-- X86TargetFrameLowering.h - Define frame lowering for X86 -*- C++ -*-==//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This class implements X86-specific bits of TargetFrameLowering class.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_X86_X86FRAMELOWERING_H
+#define LLVM_LIB_TARGET_X86_X86FRAMELOWERING_H
+
+#include "llvm/Target/TargetFrameLowering.h"
+
+namespace llvm {
+
+class MachineInstrBuilder;
+class MCCFIInstruction;
+class X86Subtarget;
+class X86RegisterInfo;
+
+class X86FrameLowering : public TargetFrameLowering {
+public:
+ X86FrameLowering(const X86Subtarget &STI, unsigned StackAlignOverride);
+
+ // Cached subtarget predicates.
+
+ const X86Subtarget &STI;
+ const TargetInstrInfo &TII;
+ const X86RegisterInfo *TRI;
+
+ unsigned SlotSize;
+
+ /// Is64Bit implies that x86_64 instructions are available.
+ bool Is64Bit;
+
+ bool IsLP64;
+
+ /// True if the 64-bit frame or stack pointer should be used. True for most
+ /// 64-bit targets with the exception of x32. If this is false, 32-bit
+ /// instruction operands should be used to manipulate StackPtr and FramePtr.
+ bool Uses64BitFramePtr;
+
+ unsigned StackPtr;
+
+ /// Emit a call to the target's stack probe function. This is required for all
+ /// large stack allocations on Windows. The caller is required to materialize
+ /// the number of bytes to probe in RAX/EAX.
+ void emitStackProbeCall(MachineFunction &MF, MachineBasicBlock &MBB,
+ MachineBasicBlock::iterator MBBI, DebugLoc DL) const;
+
+ void emitCalleeSavedFrameMoves(MachineBasicBlock &MBB,
+ MachineBasicBlock::iterator MBBI,
+ DebugLoc DL) const;
+
+ /// emitProlog/emitEpilog - These methods insert prolog and epilog code into
+ /// the function.
+ void emitPrologue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+ void emitEpilogue(MachineFunction &MF, MachineBasicBlock &MBB) const override;
+
+ void adjustForSegmentedStacks(MachineFunction &MF,
+ MachineBasicBlock &PrologueMBB) const override;
+
+ void adjustForHiPEPrologue(MachineFunction &MF,
+ MachineBasicBlock &PrologueMBB) const override;
+
+ void determineCalleeSaves(MachineFunction &MF, BitVector &SavedRegs,
+ RegScavenger *RS = nullptr) const override;
+
+ bool
+ assignCalleeSavedSpillSlots(MachineFunction &MF,
+ const TargetRegisterInfo *TRI,
+ std::vector<CalleeSavedInfo> &CSI) const override;
+
+ bool spillCalleeSavedRegisters(MachineBasicBlock &MBB,
+ MachineBasicBlock::iterator MI,
+ const std::vector<CalleeSavedInfo> &CSI,
+ const TargetRegisterInfo *TRI) const override;
+
+ bool restoreCalleeSavedRegisters(MachineBasicBlock &MBB,
+ MachineBasicBlock::iterator MI,
+ const std::vector<CalleeSavedInfo> &CSI,
+ const TargetRegisterInfo *TRI) const override;
+
+ bool hasFP(const MachineFunction &MF) const override;
+ bool hasReservedCallFrame(const MachineFunction &MF) const override;
+ bool canSimplifyCallFramePseudos(const MachineFunction &MF) const override;
+ bool needsFrameIndexResolution(const MachineFunction &MF) const override;
+
+ int getFrameIndexOffset(const MachineFunction &MF, int FI) const override;
+ int getFrameIndexReference(const MachineFunction &MF, int FI,
+ unsigned &FrameReg) const override;
+
+ int getFrameIndexOffsetFromSP(const MachineFunction &MF, int FI) const;
+ int getFrameIndexReferenceFromSP(const MachineFunction &MF, int FI,
+ unsigned &FrameReg) const override;
+
+ void eliminateCallFramePseudoInstr(MachineFunction &MF,
+ MachineBasicBlock &MBB,
+ MachineBasicBlock::iterator MI) const override;
+
+ /// Check the instruction before/after the passed instruction. If
+ /// it is an ADD/SUB/LEA instruction it is deleted argument and the
+ /// stack adjustment is returned as a positive value for ADD/LEA and
+ /// a negative for SUB.
+ int mergeSPUpdates(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
+ bool doMergeWithPrevious) const;
+
+ /// Emit a series of instructions to increment / decrement the stack
+ /// pointer by a constant value.
+ void emitSPUpdate(MachineBasicBlock &MBB, MachineBasicBlock::iterator &MBBI,
+ int64_t NumBytes, bool InEpilogue) const;
+
+ /// Check that LEA can be used on SP in an epilogue sequence for \p MF.
+ bool canUseLEAForSPInEpilogue(const MachineFunction &MF) const;
+
+ /// Check whether or not the given \p MBB can be used as a epilogue
+ /// for the target.
+ /// The epilogue will be inserted before the first terminator of that block.
+ /// This method is used by the shrink-wrapping pass to decide if
+ /// \p MBB will be correctly handled by the target.
+ bool canUseAsEpilogue(const MachineBasicBlock &MBB) const override;
+
+private:
+ /// convertArgMovsToPushes - This method tries to convert a call sequence
+ /// that uses sub and mov instructions to put the argument onto the stack
+ /// into a series of pushes.
+ /// Returns true if the transformation succeeded, false if not.
+ bool convertArgMovsToPushes(MachineFunction &MF,
+ MachineBasicBlock &MBB,
+ MachineBasicBlock::iterator I,
+ uint64_t Amount) const;
+
+ uint64_t calculateMaxStackAlign(const MachineFunction &MF) const;
+
+ /// Wraps up getting a CFI index and building a MachineInstr for it.
+ void BuildCFI(MachineBasicBlock &MBB, MachineBasicBlock::iterator MBBI,
+ DebugLoc DL, MCCFIInstruction CFIInst) const;
+
+ /// Aligns the stack pointer by ANDing it with -MaxAlign.
+ void BuildStackAlignAND(MachineBasicBlock &MBB,
+ MachineBasicBlock::iterator MBBI, DebugLoc DL,
+ uint64_t MaxAlign) const;
+
+ /// Adjusts the stack pointer using LEA, SUB, or ADD.
+ MachineInstrBuilder BuildStackAdjustment(MachineBasicBlock &MBB,
+ MachineBasicBlock::iterator MBBI,
+ DebugLoc DL, int64_t Offset,
+ bool InEpilogue) const;
+};
+
+} // End llvm namespace
+
+#endif
projects / oota-llvm.git / blobdiff