X86MachineFunctionInfo.h revision 226633 
1//====- X86MachineFuctionInfo.h - X86 machine function info -----*- 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 file declares X86-specific per-machine-function information.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef X86MACHINEFUNCTIONINFO_H
15#define X86MACHINEFUNCTIONINFO_H
16
17#include "llvm/CodeGen/MachineFunction.h"
18
19namespace llvm {
20
21/// X86MachineFunctionInfo - This class is derived from MachineFunction and
22/// contains private X86 target-specific information for each MachineFunction.
23class X86MachineFunctionInfo : public MachineFunctionInfo {
24  /// ForceFramePointer - True if the function is required to use of frame
25  /// pointer for reasons other than it containing dynamic allocation or
26  /// that FP eliminatation is turned off. For example, Cygwin main function
27  /// contains stack pointer re-alignment code which requires FP.
28  bool ForceFramePointer;
29
30  /// CalleeSavedFrameSize - Size of the callee-saved register portion of the
31  /// stack frame in bytes.
32  unsigned CalleeSavedFrameSize;
33
34  /// BytesToPopOnReturn - Number of bytes function pops on return (in addition
35  /// to the space used by the return address).
36  /// Used on windows platform for stdcall & fastcall name decoration
37  unsigned BytesToPopOnReturn;
38
39  /// ReturnAddrIndex - FrameIndex for return slot.
40  int ReturnAddrIndex;
41
42  /// TailCallReturnAddrDelta - The number of bytes by which return address
43  /// stack slot is moved as the result of tail call optimization.
44  int TailCallReturnAddrDelta;
45
46  /// SRetReturnReg - Some subtargets require that sret lowering includes
47  /// returning the value of the returned struct in a register. This field
48  /// holds the virtual register into which the sret argument is passed.
49  unsigned SRetReturnReg;
50
51  /// GlobalBaseReg - keeps track of the virtual register initialized for
52  /// use as the global base register. This is used for PIC in some PIC
53  /// relocation models.
54  unsigned GlobalBaseReg;
55
56  /// VarArgsFrameIndex - FrameIndex for start of varargs area.
57  int VarArgsFrameIndex;
58  /// RegSaveFrameIndex - X86-64 vararg func register save area.
59  int RegSaveFrameIndex;
60  /// VarArgsGPOffset - X86-64 vararg func int reg offset.
61  unsigned VarArgsGPOffset;
62  /// VarArgsFPOffset - X86-64 vararg func fp reg offset.
63  unsigned VarArgsFPOffset;
64  /// ArgumentStackSize - The number of bytes on stack consumed by the arguments
65  /// being passed on the stack.
66  unsigned ArgumentStackSize;
67
68public:
69  X86MachineFunctionInfo() : ForceFramePointer(false),
70                             CalleeSavedFrameSize(0),
71                             BytesToPopOnReturn(0),
72                             ReturnAddrIndex(0),
73                             TailCallReturnAddrDelta(0),
74                             SRetReturnReg(0),
75                             GlobalBaseReg(0),
76                             VarArgsFrameIndex(0),
77                             RegSaveFrameIndex(0),
78                             VarArgsGPOffset(0),
79                             VarArgsFPOffset(0),
80                             ArgumentStackSize(0) {}
81
82  explicit X86MachineFunctionInfo(MachineFunction &MF)
83    : ForceFramePointer(false),
84      CalleeSavedFrameSize(0),
85      BytesToPopOnReturn(0),
86      ReturnAddrIndex(0),
87      TailCallReturnAddrDelta(0),
88      SRetReturnReg(0),
89      GlobalBaseReg(0),
90      VarArgsFrameIndex(0),
91      RegSaveFrameIndex(0),
92      VarArgsGPOffset(0),
93      VarArgsFPOffset(0),
94      ArgumentStackSize(0) {}
95
96  bool getForceFramePointer() const { return ForceFramePointer;}
97  void setForceFramePointer(bool forceFP) { ForceFramePointer = forceFP; }
98
99  unsigned getCalleeSavedFrameSize() const { return CalleeSavedFrameSize; }
100  void setCalleeSavedFrameSize(unsigned bytes) { CalleeSavedFrameSize = bytes; }
101
102  unsigned getBytesToPopOnReturn() const { return BytesToPopOnReturn; }
103  void setBytesToPopOnReturn (unsigned bytes) { BytesToPopOnReturn = bytes;}
104
105  int getRAIndex() const { return ReturnAddrIndex; }
106  void setRAIndex(int Index) { ReturnAddrIndex = Index; }
107
108  int getTCReturnAddrDelta() const { return TailCallReturnAddrDelta; }
109  void setTCReturnAddrDelta(int delta) {TailCallReturnAddrDelta = delta;}
110
111  unsigned getSRetReturnReg() const { return SRetReturnReg; }
112  void setSRetReturnReg(unsigned Reg) { SRetReturnReg = Reg; }
113
114  unsigned getGlobalBaseReg() const { return GlobalBaseReg; }
115  void setGlobalBaseReg(unsigned Reg) { GlobalBaseReg = Reg; }
116
117  int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
118  void setVarArgsFrameIndex(int Idx) { VarArgsFrameIndex = Idx; }
119
120  int getRegSaveFrameIndex() const { return RegSaveFrameIndex; }
121  void setRegSaveFrameIndex(int Idx) { RegSaveFrameIndex = Idx; }
122
123  unsigned getVarArgsGPOffset() const { return VarArgsGPOffset; }
124  void setVarArgsGPOffset(unsigned Offset) { VarArgsGPOffset = Offset; }
125
126  unsigned getVarArgsFPOffset() const { return VarArgsFPOffset; }
127  void setVarArgsFPOffset(unsigned Offset) { VarArgsFPOffset = Offset; }
128
129  unsigned getArgumentStackSize() const { return ArgumentStackSize; }
130  void setArgumentStackSize(unsigned size) { ArgumentStackSize = size; }
131};
132
133} // End llvm namespace
134
135#endif
136