Home | History | Annotate | Download | only in X86 
      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:
     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