2002-12-28 20:12:10 +00:00
|
|
|
//===-- llvm/Target/TargetFrameInfo.h ---------------------------*- C++ -*-===//
|
2005-04-21 20:59:05 +00:00
|
|
|
//
|
2003-10-20 20:19:47 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 19:59:42 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 20:59:05 +00:00
|
|
|
//
|
2003-10-20 20:19:47 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2002-08-09 20:08:06 +00:00
|
|
|
//
|
2002-12-28 20:12:10 +00:00
|
|
|
// Interface to describe the layout of a stack frame on the target machine.
|
2002-08-09 20:08:06 +00:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
2001-11-08 04:52:27 +00:00
|
|
|
|
2002-12-28 20:12:10 +00:00
|
|
|
#ifndef LLVM_TARGET_TARGETFRAMEINFO_H
|
|
|
|
#define LLVM_TARGET_TARGETFRAMEINFO_H
|
2001-11-08 04:52:27 +00:00
|
|
|
|
2004-08-12 19:01:55 +00:00
|
|
|
#include <utility>
|
2010-11-18 23:25:52 +00:00
|
|
|
#include <vector>
|
2004-08-12 19:01:55 +00:00
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
namespace llvm {
|
2010-11-15 00:06:54 +00:00
|
|
|
class MachineFunction;
|
|
|
|
class MachineBasicBlock;
|
2010-11-18 23:25:52 +00:00
|
|
|
class MachineMove;
|
2003-11-11 22:41:34 +00:00
|
|
|
|
2004-06-08 06:23:17 +00:00
|
|
|
/// Information about stack frame layout on the target. It holds the direction
|
|
|
|
/// of stack growth, the known stack alignment on entry to each function, and
|
|
|
|
/// the offset to the locals area.
|
|
|
|
///
|
|
|
|
/// The offset to the local area is the offset from the stack pointer on
|
|
|
|
/// function entry to the first location where function data (local variables,
|
|
|
|
/// spill locations) can be stored.
|
2004-10-27 16:14:51 +00:00
|
|
|
class TargetFrameInfo {
|
|
|
|
public:
|
2002-12-28 20:12:10 +00:00
|
|
|
enum StackDirection {
|
|
|
|
StackGrowsUp, // Adding to the stack increases the stack address
|
|
|
|
StackGrowsDown // Adding to the stack decreases the stack address
|
|
|
|
};
|
2009-09-27 17:58:47 +00:00
|
|
|
|
|
|
|
// Maps a callee saved register to a stack slot with a fixed offset.
|
|
|
|
struct SpillSlot {
|
|
|
|
unsigned Reg;
|
|
|
|
int Offset; // Offset relative to stack pointer on function entry.
|
|
|
|
};
|
2002-12-28 20:12:10 +00:00
|
|
|
private:
|
|
|
|
StackDirection StackDir;
|
|
|
|
unsigned StackAlignment;
|
pr4926: ARM requires the stack pointer to be aligned, even for leaf functions.
For the AAPCS ABI, SP must always be 4-byte aligned, and at any "public
interface" it must be 8-byte aligned. For the older ARM APCS ABI, the stack
alignment is just always 4 bytes. For X86, we currently align SP at
entry to a function (e.g., to 16 bytes for Darwin), but no stack alignment
is needed at other times, such as for a leaf function.
After discussing this with Dan, I decided to go with the approach of adding
a new "TransientStackAlignment" field to TargetFrameInfo. This value
specifies the stack alignment that must be maintained even in between calls.
It defaults to 1 except for ARM, where it is 4. (Some other targets may
also want to set this if they have similar stack requirements. It's not
currently required for PPC because it sets targetHandlesStackFrameRounding
and handles the alignment in target-specific code.) The existing StackAlignment
value specifies the alignment upon entry to a function, which is how we've
been using it anyway.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@82767 91177308-0d34-0410-b5e6-96231b3b80d8
2009-09-25 14:41:49 +00:00
|
|
|
unsigned TransientStackAlignment;
|
2002-12-28 20:12:10 +00:00
|
|
|
int LocalAreaOffset;
|
2001-11-08 04:52:27 +00:00
|
|
|
public:
|
pr4926: ARM requires the stack pointer to be aligned, even for leaf functions.
For the AAPCS ABI, SP must always be 4-byte aligned, and at any "public
interface" it must be 8-byte aligned. For the older ARM APCS ABI, the stack
alignment is just always 4 bytes. For X86, we currently align SP at
entry to a function (e.g., to 16 bytes for Darwin), but no stack alignment
is needed at other times, such as for a leaf function.
After discussing this with Dan, I decided to go with the approach of adding
a new "TransientStackAlignment" field to TargetFrameInfo. This value
specifies the stack alignment that must be maintained even in between calls.
It defaults to 1 except for ARM, where it is 4. (Some other targets may
also want to set this if they have similar stack requirements. It's not
currently required for PPC because it sets targetHandlesStackFrameRounding
and handles the alignment in target-specific code.) The existing StackAlignment
value specifies the alignment upon entry to a function, which is how we've
been using it anyway.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@82767 91177308-0d34-0410-b5e6-96231b3b80d8
2009-09-25 14:41:49 +00:00
|
|
|
TargetFrameInfo(StackDirection D, unsigned StackAl, int LAO,
|
|
|
|
unsigned TransAl = 1)
|
|
|
|
: StackDir(D), StackAlignment(StackAl), TransientStackAlignment(TransAl),
|
|
|
|
LocalAreaOffset(LAO) {}
|
2002-12-28 20:12:10 +00:00
|
|
|
|
2005-04-25 02:55:55 +00:00
|
|
|
virtual ~TargetFrameInfo();
|
|
|
|
|
2002-12-28 20:12:10 +00:00
|
|
|
// These methods return information that describes the abstract stack layout
|
|
|
|
// of the target machine.
|
|
|
|
|
|
|
|
/// getStackGrowthDirection - Return the direction the stack grows
|
|
|
|
///
|
|
|
|
StackDirection getStackGrowthDirection() const { return StackDir; }
|
|
|
|
|
pr4926: ARM requires the stack pointer to be aligned, even for leaf functions.
For the AAPCS ABI, SP must always be 4-byte aligned, and at any "public
interface" it must be 8-byte aligned. For the older ARM APCS ABI, the stack
alignment is just always 4 bytes. For X86, we currently align SP at
entry to a function (e.g., to 16 bytes for Darwin), but no stack alignment
is needed at other times, such as for a leaf function.
After discussing this with Dan, I decided to go with the approach of adding
a new "TransientStackAlignment" field to TargetFrameInfo. This value
specifies the stack alignment that must be maintained even in between calls.
It defaults to 1 except for ARM, where it is 4. (Some other targets may
also want to set this if they have similar stack requirements. It's not
currently required for PPC because it sets targetHandlesStackFrameRounding
and handles the alignment in target-specific code.) The existing StackAlignment
value specifies the alignment upon entry to a function, which is how we've
been using it anyway.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@82767 91177308-0d34-0410-b5e6-96231b3b80d8
2009-09-25 14:41:49 +00:00
|
|
|
/// getStackAlignment - This method returns the number of bytes to which the
|
|
|
|
/// stack pointer must be aligned on entry to a function. Typically, this
|
|
|
|
/// is the largest alignment for any data object in the target.
|
2002-12-28 20:12:10 +00:00
|
|
|
///
|
|
|
|
unsigned getStackAlignment() const { return StackAlignment; }
|
|
|
|
|
pr4926: ARM requires the stack pointer to be aligned, even for leaf functions.
For the AAPCS ABI, SP must always be 4-byte aligned, and at any "public
interface" it must be 8-byte aligned. For the older ARM APCS ABI, the stack
alignment is just always 4 bytes. For X86, we currently align SP at
entry to a function (e.g., to 16 bytes for Darwin), but no stack alignment
is needed at other times, such as for a leaf function.
After discussing this with Dan, I decided to go with the approach of adding
a new "TransientStackAlignment" field to TargetFrameInfo. This value
specifies the stack alignment that must be maintained even in between calls.
It defaults to 1 except for ARM, where it is 4. (Some other targets may
also want to set this if they have similar stack requirements. It's not
currently required for PPC because it sets targetHandlesStackFrameRounding
and handles the alignment in target-specific code.) The existing StackAlignment
value specifies the alignment upon entry to a function, which is how we've
been using it anyway.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@82767 91177308-0d34-0410-b5e6-96231b3b80d8
2009-09-25 14:41:49 +00:00
|
|
|
/// getTransientStackAlignment - This method returns the number of bytes to
|
|
|
|
/// which the stack pointer must be aligned at all times, even between
|
|
|
|
/// calls.
|
|
|
|
///
|
|
|
|
unsigned getTransientStackAlignment() const {
|
|
|
|
return TransientStackAlignment;
|
|
|
|
}
|
|
|
|
|
2002-12-28 20:12:10 +00:00
|
|
|
/// getOffsetOfLocalArea - This method returns the offset of the local area
|
|
|
|
/// from the stack pointer on entrance to a function.
|
|
|
|
///
|
|
|
|
int getOffsetOfLocalArea() const { return LocalAreaOffset; }
|
|
|
|
|
2007-01-02 21:30:17 +00:00
|
|
|
/// getCalleeSavedSpillSlots - This method returns a pointer to an array of
|
|
|
|
/// pairs, that contains an entry for each callee saved register that must be
|
2004-08-12 19:01:55 +00:00
|
|
|
/// spilled to a particular stack location if it is spilled.
|
|
|
|
///
|
|
|
|
/// Each entry in this array contains a <register,offset> pair, indicating the
|
|
|
|
/// fixed offset from the incoming stack pointer that each register should be
|
2009-09-27 17:58:47 +00:00
|
|
|
/// spilled at. If a register is not listed here, the code generator is
|
2004-08-12 19:01:55 +00:00
|
|
|
/// allowed to spill it anywhere it chooses.
|
2005-04-21 20:59:05 +00:00
|
|
|
///
|
2009-09-27 17:58:47 +00:00
|
|
|
virtual const SpillSlot *
|
2007-01-02 21:30:17 +00:00
|
|
|
getCalleeSavedSpillSlots(unsigned &NumEntries) const {
|
2004-08-12 19:01:55 +00:00
|
|
|
NumEntries = 0;
|
|
|
|
return 0;
|
|
|
|
}
|
2010-11-15 00:06:54 +00:00
|
|
|
|
|
|
|
/// targetHandlesStackFrameRounding - Returns true if the target is
|
|
|
|
/// responsible for rounding up the stack frame (probably at emitPrologue
|
|
|
|
/// time).
|
|
|
|
virtual bool targetHandlesStackFrameRounding() const {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// emitProlog/emitEpilog - These methods insert prolog and epilog code into
|
|
|
|
/// the function.
|
|
|
|
virtual void emitPrologue(MachineFunction &MF) const = 0;
|
|
|
|
virtual void emitEpilogue(MachineFunction &MF,
|
|
|
|
MachineBasicBlock &MBB) const = 0;
|
2010-11-18 21:19:35 +00:00
|
|
|
|
|
|
|
/// hasFP - Return true if the specified function should have a dedicated
|
|
|
|
/// frame pointer register. For most targets this is true only if the function
|
|
|
|
/// has variable sized allocas or if frame pointer elimination is disabled.
|
|
|
|
virtual bool hasFP(const MachineFunction &MF) const = 0;
|
|
|
|
|
|
|
|
/// hasReservedCallFrame - Under normal circumstances, when a frame pointer is
|
|
|
|
/// not required, we reserve argument space for call sites in the function
|
|
|
|
/// immediately on entry to the current function. This eliminates the need for
|
|
|
|
/// add/sub sp brackets around call sites. Returns true if the call frame is
|
|
|
|
/// included as part of the stack frame.
|
|
|
|
virtual bool hasReservedCallFrame(const MachineFunction &MF) const {
|
|
|
|
return !hasFP(MF);
|
|
|
|
}
|
|
|
|
|
|
|
|
/// canSimplifyCallFramePseudos - When possible, it's best to simplify the
|
|
|
|
/// call frame pseudo ops before doing frame index elimination. This is
|
|
|
|
/// possible only when frame index references between the pseudos won't
|
|
|
|
/// need adjusting for the call frame adjustments. Normally, that's true
|
|
|
|
/// if the function has a reserved call frame or a frame pointer. Some
|
|
|
|
/// targets (Thumb2, for example) may have more complicated criteria,
|
|
|
|
/// however, and can override this behavior.
|
|
|
|
virtual bool canSimplifyCallFramePseudos(const MachineFunction &MF) const {
|
|
|
|
return hasReservedCallFrame(MF) || hasFP(MF);
|
|
|
|
}
|
|
|
|
|
2010-11-18 23:25:52 +00:00
|
|
|
/// getInitialFrameState - Returns a list of machine moves that are assumed
|
|
|
|
/// on entry to all functions. Note that LabelID is ignored (assumed to be
|
|
|
|
/// the beginning of the function.)
|
|
|
|
virtual void getInitialFrameState(std::vector<MachineMove> &Moves) const;
|
2001-11-08 04:52:27 +00:00
|
|
|
};
|
|
|
|
|
2003-11-11 22:41:34 +00:00
|
|
|
} // End llvm namespace
|
|
|
|
|
2001-11-08 04:52:27 +00:00
|
|
|
#endif
|