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 LLVM_LIB_TARGET_X86_X86MACHINEFUNCTIONINFO_H
15#define LLVM_LIB_TARGET_X86_X86MACHINEFUNCTIONINFO_H
16
17#include "llvm/CodeGen/CallingConvLower.h"
18#include "llvm/CodeGen/MachineFunction.h"
19#include "llvm/CodeGen/MachineValueType.h"
20#include <vector>
21
22namespace llvm {
23
24/// X86MachineFunctionInfo - This class is derived from MachineFunction and
25/// contains private X86 target-specific information for each MachineFunction.
26class X86MachineFunctionInfo : public MachineFunctionInfo {
27  virtual void anchor();
28
29  /// ForceFramePointer - True if the function is required to use of frame
30  /// pointer for reasons other than it containing dynamic allocation or
31  /// that FP eliminatation is turned off. For example, Cygwin main function
32  /// contains stack pointer re-alignment code which requires FP.
33  bool ForceFramePointer;
34
35  /// RestoreBasePointerOffset - Non-zero if the function has base pointer
36  /// and makes call to llvm.eh.sjlj.setjmp. When non-zero, the value is a
37  /// displacement from the frame pointer to a slot where the base pointer
38  /// is stashed.
39  signed char RestoreBasePointerOffset;
40
41  /// CalleeSavedFrameSize - Size of the callee-saved register portion of the
42  /// stack frame in bytes.
43  unsigned CalleeSavedFrameSize;
44
45  /// BytesToPopOnReturn - Number of bytes function pops on return (in addition
46  /// to the space used by the return address).
47  /// Used on windows platform for stdcall & fastcall name decoration
48  unsigned BytesToPopOnReturn;
49
50  /// ReturnAddrIndex - FrameIndex for return slot.
51  int ReturnAddrIndex;
52
53  /// \brief FrameIndex for return slot.
54  int FrameAddrIndex;
55
56  /// TailCallReturnAddrDelta - The number of bytes by which return address
57  /// stack slot is moved as the result of tail call optimization.
58  int TailCallReturnAddrDelta;
59
60  /// SRetReturnReg - Some subtargets require that sret lowering includes
61  /// returning the value of the returned struct in a register. This field
62  /// holds the virtual register into which the sret argument is passed.
63  unsigned SRetReturnReg;
64
65  /// GlobalBaseReg - keeps track of the virtual register initialized for
66  /// use as the global base register. This is used for PIC in some PIC
67  /// relocation models.
68  unsigned GlobalBaseReg;
69
70  /// VarArgsFrameIndex - FrameIndex for start of varargs area.
71  int VarArgsFrameIndex;
72  /// RegSaveFrameIndex - X86-64 vararg func register save area.
73  int RegSaveFrameIndex;
74  /// VarArgsGPOffset - X86-64 vararg func int reg offset.
75  unsigned VarArgsGPOffset;
76  /// VarArgsFPOffset - X86-64 vararg func fp reg offset.
77  unsigned VarArgsFPOffset;
78  /// ArgumentStackSize - The number of bytes on stack consumed by the arguments
79  /// being passed on the stack.
80  unsigned ArgumentStackSize;
81  /// NumLocalDynamics - Number of local-dynamic TLS accesses.
82  unsigned NumLocalDynamics;
83  /// HasPushSequences - Keeps track of whether this function uses sequences
84  /// of pushes to pass function parameters.
85  bool HasPushSequences;
86
87private:
88  /// ForwardedMustTailRegParms - A list of virtual and physical registers
89  /// that must be forwarded to every musttail call.
90  SmallVector<ForwardedRegister, 1> ForwardedMustTailRegParms;
91
92public:
93  X86MachineFunctionInfo() : ForceFramePointer(false),
94                             RestoreBasePointerOffset(0),
95                             CalleeSavedFrameSize(0),
96                             BytesToPopOnReturn(0),
97                             ReturnAddrIndex(0),
98                             FrameAddrIndex(0),
99                             TailCallReturnAddrDelta(0),
100                             SRetReturnReg(0),
101                             GlobalBaseReg(0),
102                             VarArgsFrameIndex(0),
103                             RegSaveFrameIndex(0),
104                             VarArgsGPOffset(0),
105                             VarArgsFPOffset(0),
106                             ArgumentStackSize(0),
107                             NumLocalDynamics(0),
108                             HasPushSequences(false) {}
109
110  explicit X86MachineFunctionInfo(MachineFunction &MF)
111    : ForceFramePointer(false),
112      RestoreBasePointerOffset(0),
113      CalleeSavedFrameSize(0),
114      BytesToPopOnReturn(0),
115      ReturnAddrIndex(0),
116      FrameAddrIndex(0),
117      TailCallReturnAddrDelta(0),
118      SRetReturnReg(0),
119      GlobalBaseReg(0),
120      VarArgsFrameIndex(0),
121      RegSaveFrameIndex(0),
122      VarArgsGPOffset(0),
123      VarArgsFPOffset(0),
124      ArgumentStackSize(0),
125      NumLocalDynamics(0),
126      HasPushSequences(false) {}
127
128  bool getForceFramePointer() const { return ForceFramePointer;}
129  void setForceFramePointer(bool forceFP) { ForceFramePointer = forceFP; }
130
131  bool getHasPushSequences() const { return HasPushSequences; }
132  void setHasPushSequences(bool HasPush) { HasPushSequences = HasPush; }
133
134  bool getRestoreBasePointer() const { return RestoreBasePointerOffset!=0; }
135  void setRestoreBasePointer(const MachineFunction *MF);
136  int getRestoreBasePointerOffset() const {return RestoreBasePointerOffset; }
137
138  unsigned getCalleeSavedFrameSize() const { return CalleeSavedFrameSize; }
139  void setCalleeSavedFrameSize(unsigned bytes) { CalleeSavedFrameSize = bytes; }
140
141  unsigned getBytesToPopOnReturn() const { return BytesToPopOnReturn; }
142  void setBytesToPopOnReturn (unsigned bytes) { BytesToPopOnReturn = bytes;}
143
144  int getRAIndex() const { return ReturnAddrIndex; }
145  void setRAIndex(int Index) { ReturnAddrIndex = Index; }
146
147  int getFAIndex() const { return FrameAddrIndex; }
148  void setFAIndex(int Index) { FrameAddrIndex = Index; }
149
150  int getTCReturnAddrDelta() const { return TailCallReturnAddrDelta; }
151  void setTCReturnAddrDelta(int delta) {TailCallReturnAddrDelta = delta;}
152
153  unsigned getSRetReturnReg() const { return SRetReturnReg; }
154  void setSRetReturnReg(unsigned Reg) { SRetReturnReg = Reg; }
155
156  unsigned getGlobalBaseReg() const { return GlobalBaseReg; }
157  void setGlobalBaseReg(unsigned Reg) { GlobalBaseReg = Reg; }
158
159  int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
160  void setVarArgsFrameIndex(int Idx) { VarArgsFrameIndex = Idx; }
161
162  int getRegSaveFrameIndex() const { return RegSaveFrameIndex; }
163  void setRegSaveFrameIndex(int Idx) { RegSaveFrameIndex = Idx; }
164
165  unsigned getVarArgsGPOffset() const { return VarArgsGPOffset; }
166  void setVarArgsGPOffset(unsigned Offset) { VarArgsGPOffset = Offset; }
167
168  unsigned getVarArgsFPOffset() const { return VarArgsFPOffset; }
169  void setVarArgsFPOffset(unsigned Offset) { VarArgsFPOffset = Offset; }
170
171  unsigned getArgumentStackSize() const { return ArgumentStackSize; }
172  void setArgumentStackSize(unsigned size) { ArgumentStackSize = size; }
173
174  unsigned getNumLocalDynamicTLSAccesses() const { return NumLocalDynamics; }
175  void incNumLocalDynamicTLSAccesses() { ++NumLocalDynamics; }
176
177  SmallVectorImpl<ForwardedRegister> &getForwardedMustTailRegParms() {
178    return ForwardedMustTailRegParms;
179  }
180};
181
182} // End llvm namespace
183
184#endif
185