#ifndef LLVM_CODEGEN_MACHINEFRAMEINFO_H
#define LLVM_CODEGEN_MACHINEFRAMEINFO_H
+#include "llvm/Support/DataTypes.h"
+#include <cassert>
+#include <iosfwd>
#include <vector>
namespace llvm {
///
/// To support this, the class assigns unique integer identifiers to stack
/// objects requested clients. These identifiers are negative integers for
-/// fixed stack objects (such as arguments passed on the stack) or positive
+/// fixed stack objects (such as arguments passed on the stack) or nonnegative
/// for objects that may be reordered. Instructions which refer to stack
/// objects use a special MO_FrameIndex operand to represent these frame
/// indexes.
// the function. This field has no meaning for a variable sized element.
int64_t SPOffset;
- StackObject(uint64_t Sz, unsigned Al, int64_t SP, bool IM = false)
+ StackObject(uint64_t Sz, unsigned Al, int64_t SP = 0, bool IM = false)
: Size(Sz), Alignment(Al), isImmutable(IM), SPOffset(SP) {}
};
///
bool HasVarSizedObjects;
+ /// FrameAddressTaken - This boolean keeps track of whether there is a call
+ /// to builtin \@llvm.frameaddress.
+ bool FrameAddressTaken;
+
/// StackSize - The prolog/epilog code inserter calculates the final stack
/// offsets for all of the fixed size objects, updating the Objects list
/// above. It then updates StackSize to contain the number of bytes that need
/// only valid during and after prolog/epilog code insertion.
bool HasCalls;
+ /// StackProtectorIdx - The frame index for the stack protector.
+ int StackProtectorIdx;
+
/// MaxCallFrameSize - This contains the size of the largest call frame if the
/// target uses frame setup/destroy pseudo instructions (as defined in the
/// TargetFrameInfo class). This information is important for frame pointer
///
const TargetFrameInfo &TFI;
public:
- MachineFrameInfo(const TargetFrameInfo &tfi) : TFI(tfi) {
+ explicit MachineFrameInfo(const TargetFrameInfo &tfi) : TFI(tfi) {
StackSize = NumFixedObjects = OffsetAdjustment = MaxAlignment = 0;
HasVarSizedObjects = false;
+ FrameAddressTaken = false;
HasCalls = false;
+ StackProtectorIdx = -1;
MaxCallFrameSize = 0;
MMI = 0;
}
///
bool hasVarSizedObjects() const { return HasVarSizedObjects; }
- /// getObjectIndexBegin - Return the minimum frame object index...
+ /// getStackProtectorIndex/setStackProtectorIndex - Return the index for the
+ /// stack protector object.
+ ///
+ int getStackProtectorIndex() const { return StackProtectorIdx; }
+ void setStackProtectorIndex(int I) { StackProtectorIdx = I; }
+
+ /// isFrameAddressTaken - This method may be called any time after instruction
+ /// selection is complete to determine if there is a call to
+ /// \@llvm.frameaddress in this function.
+ bool isFrameAddressTaken() const { return FrameAddressTaken; }
+ void setFrameAddressIsTaken(bool T) { FrameAddressTaken = T; }
+
+ /// getObjectIndexBegin - Return the minimum frame object index.
///
int getObjectIndexBegin() const { return -NumFixedObjects; }
- /// getObjectIndexEnd - Return one past the maximum frame object index...
+ /// getObjectIndexEnd - Return one past the maximum frame object index.
///
- int getObjectIndexEnd() const { return Objects.size()-NumFixedObjects; }
+ int getObjectIndexEnd() const { return (int)Objects.size()-NumFixedObjects; }
- /// getObjectSize - Return the size of the specified object
+ /// getNumFixedObjects() - Return the number of fixed objects.
+ unsigned getNumFixedObjects() const { return NumFixedObjects; }
+
+ /// getNumObjects() - Return the number of objects.
+ ///
+ unsigned getNumObjects() const { return Objects.size(); }
+
+ /// getObjectSize - Return the size of the specified object.
///
int64_t getObjectSize(int ObjectIdx) const {
assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
return Objects[ObjectIdx+NumFixedObjects].Size;
}
- /// getObjectAlignment - Return the alignment of the specified stack object...
- int getObjectAlignment(int ObjectIdx) const {
+ /// setObjectSize - Change the size of the specified stack object.
+ void setObjectSize(int ObjectIdx, int64_t Size) {
+ assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
+ "Invalid Object Idx!");
+ Objects[ObjectIdx+NumFixedObjects].Size = Size;
+ }
+
+ /// getObjectAlignment - Return the alignment of the specified stack object.
+ unsigned getObjectAlignment(int ObjectIdx) const {
assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
"Invalid Object Idx!");
return Objects[ObjectIdx+NumFixedObjects].Alignment;
}
+ /// setObjectAlignment - Change the alignment of the specified stack object.
+ void setObjectAlignment(int ObjectIdx, unsigned Align) {
+ assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
+ "Invalid Object Idx!");
+ Objects[ObjectIdx+NumFixedObjects].Alignment = Align;
+ }
+
/// getObjectOffset - Return the assigned stack offset of the specified object
/// from the incoming stack pointer.
///
int64_t getObjectOffset(int ObjectIdx) const {
assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
"Invalid Object Idx!");
+ assert(!isDeadObjectIndex(ObjectIdx) &&
+ "Getting frame offset for a dead object?");
return Objects[ObjectIdx+NumFixedObjects].SPOffset;
}
void setObjectOffset(int ObjectIdx, int64_t SPOffset) {
assert(unsigned(ObjectIdx+NumFixedObjects) < Objects.size() &&
"Invalid Object Idx!");
+ assert(!isDeadObjectIndex(ObjectIdx) &&
+ "Setting frame offset for a dead object?");
Objects[ObjectIdx+NumFixedObjects].SPOffset = SPOffset;
}
}
/// CreateStackObject - Create a new statically sized stack object, returning
- /// a postive identifier to represent it.
+ /// a nonnegative identifier to represent it.
///
int CreateStackObject(uint64_t Size, unsigned Alignment) {
- // Keep track of the maximum alignment.
- if (MaxAlignment < Alignment) MaxAlignment = Alignment;
-
assert(Size != 0 && "Cannot allocate zero size stack objects!");
- Objects.push_back(StackObject(Size, Alignment, -1));
- return Objects.size()-NumFixedObjects-1;
+ Objects.push_back(StackObject(Size, Alignment));
+ return (int)Objects.size()-NumFixedObjects-1;
}
/// RemoveStackObject - Remove or mark dead a statically sized stack object.
///
void RemoveStackObject(int ObjectIdx) {
- if (ObjectIdx == (int)(Objects.size()-NumFixedObjects-1))
- // Last object, simply pop it off the list.
- Objects.pop_back();
- else
- // Mark it dead.
- Objects[ObjectIdx+NumFixedObjects].Size = ~0ULL;
+ // Mark it dead.
+ Objects[ObjectIdx+NumFixedObjects].Size = ~0ULL;
}
/// CreateVariableSizedObject - Notify the MachineFrameInfo object that a
///
int CreateVariableSizedObject() {
HasVarSizedObjects = true;
- if (MaxAlignment < 1) MaxAlignment = 1;
- Objects.push_back(StackObject(0, 1, -1));
- return Objects.size()-NumFixedObjects-1;
+ Objects.push_back(StackObject(0, 1));
+ return (int)Objects.size()-NumFixedObjects-1;
}
/// getCalleeSavedInfo - Returns a reference to call saved info vector for the
projects / oota-llvm.git / blobdiff