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 19 namespace llvm { 20 21 /// X86MachineFunctionInfo - This class is derived from MachineFunction and 22 /// contains private X86 target-specific information for each MachineFunction. 23 class 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 /// ReserveFP - whether the function should reserve the frame pointer 57 /// when allocating, even if there may not actually be a frame pointer used. 58 bool ReserveFP; 59 60 /// VarArgsFrameIndex - FrameIndex for start of varargs area. 61 int VarArgsFrameIndex; 62 /// RegSaveFrameIndex - X86-64 vararg func register save area. 63 int RegSaveFrameIndex; 64 /// VarArgsGPOffset - X86-64 vararg func int reg offset. 65 unsigned VarArgsGPOffset; 66 /// VarArgsFPOffset - X86-64 vararg func fp reg offset. 67 unsigned VarArgsFPOffset; 68 69 public: X86MachineFunctionInfo()70 X86MachineFunctionInfo() : ForceFramePointer(false), 71 CalleeSavedFrameSize(0), 72 BytesToPopOnReturn(0), 73 ReturnAddrIndex(0), 74 TailCallReturnAddrDelta(0), 75 SRetReturnReg(0), 76 GlobalBaseReg(0), 77 VarArgsFrameIndex(0), 78 RegSaveFrameIndex(0), 79 VarArgsGPOffset(0), 80 VarArgsFPOffset(0) {} 81 X86MachineFunctionInfo(MachineFunction & MF)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 ReserveFP(false), 91 VarArgsFrameIndex(0), 92 RegSaveFrameIndex(0), 93 VarArgsGPOffset(0), 94 VarArgsFPOffset(0) {} 95 getForceFramePointer()96 bool getForceFramePointer() const { return ForceFramePointer;} setForceFramePointer(bool forceFP)97 void setForceFramePointer(bool forceFP) { ForceFramePointer = forceFP; } 98 getCalleeSavedFrameSize()99 unsigned getCalleeSavedFrameSize() const { return CalleeSavedFrameSize; } setCalleeSavedFrameSize(unsigned bytes)100 void setCalleeSavedFrameSize(unsigned bytes) { CalleeSavedFrameSize = bytes; } 101 getBytesToPopOnReturn()102 unsigned getBytesToPopOnReturn() const { return BytesToPopOnReturn; } setBytesToPopOnReturn(unsigned bytes)103 void setBytesToPopOnReturn (unsigned bytes) { BytesToPopOnReturn = bytes;} 104 getRAIndex()105 int getRAIndex() const { return ReturnAddrIndex; } setRAIndex(int Index)106 void setRAIndex(int Index) { ReturnAddrIndex = Index; } 107 getTCReturnAddrDelta()108 int getTCReturnAddrDelta() const { return TailCallReturnAddrDelta; } setTCReturnAddrDelta(int delta)109 void setTCReturnAddrDelta(int delta) {TailCallReturnAddrDelta = delta;} 110 getSRetReturnReg()111 unsigned getSRetReturnReg() const { return SRetReturnReg; } setSRetReturnReg(unsigned Reg)112 void setSRetReturnReg(unsigned Reg) { SRetReturnReg = Reg; } 113 getGlobalBaseReg()114 unsigned getGlobalBaseReg() const { return GlobalBaseReg; } setGlobalBaseReg(unsigned Reg)115 void setGlobalBaseReg(unsigned Reg) { GlobalBaseReg = Reg; } 116 getReserveFP()117 bool getReserveFP() const { return ReserveFP; } setReserveFP(bool reserveFP)118 void setReserveFP(bool reserveFP) { ReserveFP = reserveFP; } 119 getVarArgsFrameIndex()120 int getVarArgsFrameIndex() const { return VarArgsFrameIndex; } setVarArgsFrameIndex(int Idx)121 void setVarArgsFrameIndex(int Idx) { VarArgsFrameIndex = Idx; } 122 getRegSaveFrameIndex()123 int getRegSaveFrameIndex() const { return RegSaveFrameIndex; } setRegSaveFrameIndex(int Idx)124 void setRegSaveFrameIndex(int Idx) { RegSaveFrameIndex = Idx; } 125 getVarArgsGPOffset()126 unsigned getVarArgsGPOffset() const { return VarArgsGPOffset; } setVarArgsGPOffset(unsigned Offset)127 void setVarArgsGPOffset(unsigned Offset) { VarArgsGPOffset = Offset; } 128 getVarArgsFPOffset()129 unsigned getVarArgsFPOffset() const { return VarArgsFPOffset; } setVarArgsFPOffset(unsigned Offset)130 void setVarArgsFPOffset(unsigned Offset) { VarArgsFPOffset = Offset; } 131 }; 132 133 } // End llvm namespace 134 135 #endif 136