MBlazeMachineFunction.h revision 0a67d92938d77b6a8cde6e1676750264b274cebc
1//===-- MBlazeMachineFunctionInfo.h - Private data ----------------*- 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 the MBlaze specific subclass of MachineFunctionInfo. 11// 12//===----------------------------------------------------------------------===// 13 14#ifndef MBLAZE_MACHINE_FUNCTION_INFO_H 15#define MBLAZE_MACHINE_FUNCTION_INFO_H 16 17#include "llvm/ADT/SmallVector.h" 18#include "llvm/ADT/VectorExtras.h" 19#include "llvm/CodeGen/MachineFunction.h" 20#include "llvm/CodeGen/MachineFrameInfo.h" 21 22namespace llvm { 23 24/// MBlazeFunctionInfo - This class is derived from MachineFunction private 25/// MBlaze target-specific information for each MachineFunction. 26class MBlazeFunctionInfo : public MachineFunctionInfo { 27 28private: 29 /// Holds for each function where on the stack the Frame Pointer must be 30 /// saved. This is used on Prologue and Epilogue to emit FP save/restore 31 int FPStackOffset; 32 33 /// Holds for each function where on the stack the Return Address must be 34 /// saved. This is used on Prologue and Epilogue to emit RA save/restore 35 int RAStackOffset; 36 37 /// At each function entry a special bitmask directive must be emitted 38 /// to help in debugging CPU callee saved registers. It needs a negative 39 /// offset from the final stack size and its higher register location on 40 /// the stack. 41 int CPUTopSavedRegOff; 42 43 /// MBlazeFIHolder - Holds a FrameIndex and it's Stack Pointer Offset 44 struct MBlazeFIHolder { 45 46 int FI; 47 int SPOffset; 48 49 MBlazeFIHolder(int FrameIndex, int StackPointerOffset) 50 : FI(FrameIndex), SPOffset(StackPointerOffset) {} 51 }; 52 53 /// When PIC is used the GP must be saved on the stack on the function 54 /// prologue and must be reloaded from this stack location after every 55 /// call. A reference to its stack location and frame index must be kept 56 /// to be used on emitPrologue and processFunctionBeforeFrameFinalized. 57 MBlazeFIHolder GPHolder; 58 59 /// On LowerFormalArguments the stack size is unknown, so the Stack 60 /// Pointer Offset calculation of "not in register arguments" must be 61 /// postponed to emitPrologue. 62 SmallVector<MBlazeFIHolder, 16> FnLoadArgs; 63 bool HasLoadArgs; 64 65 // When VarArgs, we must write registers back to caller stack, preserving 66 // on register arguments. Since the stack size is unknown on 67 // LowerFormalArguments, the Stack Pointer Offset calculation must be 68 // postponed to emitPrologue. 69 SmallVector<MBlazeFIHolder, 4> FnStoreVarArgs; 70 bool HasStoreVarArgs; 71 72 /// SRetReturnReg - Some subtargets require that sret lowering includes 73 /// returning the value of the returned struct in a register. This field 74 /// holds the virtual register into which the sret argument is passed. 75 unsigned SRetReturnReg; 76 77 /// GlobalBaseReg - keeps track of the virtual register initialized for 78 /// use as the global base register. This is used for PIC in some PIC 79 /// relocation models. 80 unsigned GlobalBaseReg; 81 82 // VarArgsFrameIndex - FrameIndex for start of varargs area. 83 int VarArgsFrameIndex; 84 85public: 86 MBlazeFunctionInfo(MachineFunction& MF) 87 : FPStackOffset(0), RAStackOffset(0), CPUTopSavedRegOff(0), 88 GPHolder(-1,-1), HasLoadArgs(false), HasStoreVarArgs(false), 89 SRetReturnReg(0), GlobalBaseReg(0), VarArgsFrameIndex(0) 90 {} 91 92 int getFPStackOffset() const { return FPStackOffset; } 93 void setFPStackOffset(int Off) { FPStackOffset = Off; } 94 95 int getRAStackOffset() const { return RAStackOffset; } 96 void setRAStackOffset(int Off) { RAStackOffset = Off; } 97 98 int getCPUTopSavedRegOff() const { return CPUTopSavedRegOff; } 99 void setCPUTopSavedRegOff(int Off) { CPUTopSavedRegOff = Off; } 100 101 int getGPStackOffset() const { return GPHolder.SPOffset; } 102 int getGPFI() const { return GPHolder.FI; } 103 void setGPStackOffset(int Off) { GPHolder.SPOffset = Off; } 104 void setGPFI(int FI) { GPHolder.FI = FI; } 105 bool needGPSaveRestore() const { return GPHolder.SPOffset != -1; } 106 107 bool hasLoadArgs() const { return HasLoadArgs; } 108 bool hasStoreVarArgs() const { return HasStoreVarArgs; } 109 110 void recordLoadArgsFI(int FI, int SPOffset) { 111 if (!HasLoadArgs) HasLoadArgs=true; 112 FnLoadArgs.push_back(MBlazeFIHolder(FI, SPOffset)); 113 } 114 void recordStoreVarArgsFI(int FI, int SPOffset) { 115 if (!HasStoreVarArgs) HasStoreVarArgs=true; 116 FnStoreVarArgs.push_back(MBlazeFIHolder(FI, SPOffset)); 117 } 118 119 void adjustLoadArgsFI(MachineFrameInfo *MFI) const { 120 if (!hasLoadArgs()) return; 121 for (unsigned i = 0, e = FnLoadArgs.size(); i != e; ++i) 122 MFI->setObjectOffset(FnLoadArgs[i].FI, FnLoadArgs[i].SPOffset); 123 } 124 void adjustStoreVarArgsFI(MachineFrameInfo *MFI) const { 125 if (!hasStoreVarArgs()) return; 126 for (unsigned i = 0, e = FnStoreVarArgs.size(); i != e; ++i) 127 MFI->setObjectOffset(FnStoreVarArgs[i].FI, FnStoreVarArgs[i].SPOffset); 128 } 129 130 unsigned getSRetReturnReg() const { return SRetReturnReg; } 131 void setSRetReturnReg(unsigned Reg) { SRetReturnReg = Reg; } 132 133 unsigned getGlobalBaseReg() const { return GlobalBaseReg; } 134 void setGlobalBaseReg(unsigned Reg) { GlobalBaseReg = Reg; } 135 136 int getVarArgsFrameIndex() const { return VarArgsFrameIndex; } 137 void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; } 138}; 139 140} // end of namespace llvm 141 142#endif // MBLAZE_MACHINE_FUNCTION_INFO_H 143