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 /// 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 68 public: X86MachineFunctionInfo()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 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 VarArgsFrameIndex(0), 91 RegSaveFrameIndex(0), 92 VarArgsGPOffset(0), 93 VarArgsFPOffset(0), 94 ArgumentStackSize(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 getVarArgsFrameIndex()117 int getVarArgsFrameIndex() const { return VarArgsFrameIndex; } setVarArgsFrameIndex(int Idx)118 void setVarArgsFrameIndex(int Idx) { VarArgsFrameIndex = Idx; } 119 getRegSaveFrameIndex()120 int getRegSaveFrameIndex() const { return RegSaveFrameIndex; } setRegSaveFrameIndex(int Idx)121 void setRegSaveFrameIndex(int Idx) { RegSaveFrameIndex = Idx; } 122 getVarArgsGPOffset()123 unsigned getVarArgsGPOffset() const { return VarArgsGPOffset; } setVarArgsGPOffset(unsigned Offset)124 void setVarArgsGPOffset(unsigned Offset) { VarArgsGPOffset = Offset; } 125 getVarArgsFPOffset()126 unsigned getVarArgsFPOffset() const { return VarArgsFPOffset; } setVarArgsFPOffset(unsigned Offset)127 void setVarArgsFPOffset(unsigned Offset) { VarArgsFPOffset = Offset; } 128 getArgumentStackSize()129 unsigned getArgumentStackSize() const { return ArgumentStackSize; } setArgumentStackSize(unsigned size)130 void setArgumentStackSize(unsigned size) { ArgumentStackSize = size; } 131 }; 132 133 } // End llvm namespace 134 135 #endif 136