1 //===-- MipsMachineFunctionInfo.h - Private data used for Mips ----*- 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 Mips specific subclass of MachineFunctionInfo. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #ifndef LLVM_LIB_TARGET_MIPS_MIPSMACHINEFUNCTION_H 15 #define LLVM_LIB_TARGET_MIPS_MIPSMACHINEFUNCTION_H 16 17 #include "Mips16HardFloatInfo.h" 18 #include "llvm/CodeGen/MachineFrameInfo.h" 19 #include "llvm/CodeGen/MachineFunction.h" 20 #include "llvm/CodeGen/MachineMemOperand.h" 21 #include "llvm/CodeGen/PseudoSourceValue.h" 22 #include "llvm/IR/ValueMap.h" 23 #include "llvm/Target/TargetFrameLowering.h" 24 #include "llvm/Target/TargetMachine.h" 25 #include <map> 26 #include <string> 27 #include <utility> 28 29 namespace llvm { 30 31 /// MipsFunctionInfo - This class is derived from MachineFunction private 32 /// Mips target-specific information for each MachineFunction. 33 class MipsFunctionInfo : public MachineFunctionInfo { 34 public: MipsFunctionInfo(MachineFunction & MF)35 MipsFunctionInfo(MachineFunction &MF) 36 : MF(MF), SRetReturnReg(0), GlobalBaseReg(0), Mips16SPAliasReg(0), 37 VarArgsFrameIndex(0), CallsEhReturn(false), IsISR(false), SaveS2(false), 38 MoveF64ViaSpillFI(-1) {} 39 40 ~MipsFunctionInfo(); 41 getSRetReturnReg()42 unsigned getSRetReturnReg() const { return SRetReturnReg; } setSRetReturnReg(unsigned Reg)43 void setSRetReturnReg(unsigned Reg) { SRetReturnReg = Reg; } 44 45 bool globalBaseRegSet() const; 46 unsigned getGlobalBaseReg(); 47 48 bool mips16SPAliasRegSet() const; 49 unsigned getMips16SPAliasReg(); 50 getVarArgsFrameIndex()51 int getVarArgsFrameIndex() const { return VarArgsFrameIndex; } setVarArgsFrameIndex(int Index)52 void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; } 53 hasByvalArg()54 bool hasByvalArg() const { return HasByvalArg; } setFormalArgInfo(unsigned Size,bool HasByval)55 void setFormalArgInfo(unsigned Size, bool HasByval) { 56 IncomingArgSize = Size; 57 HasByvalArg = HasByval; 58 } 59 getIncomingArgSize()60 unsigned getIncomingArgSize() const { return IncomingArgSize; } 61 callsEhReturn()62 bool callsEhReturn() const { return CallsEhReturn; } setCallsEhReturn()63 void setCallsEhReturn() { CallsEhReturn = true; } 64 65 void createEhDataRegsFI(); getEhDataRegFI(unsigned Reg)66 int getEhDataRegFI(unsigned Reg) const { return EhDataRegFI[Reg]; } 67 bool isEhDataRegFI(int FI) const; 68 69 /// Create a MachinePointerInfo that has an ExternalSymbolPseudoSourceValue 70 /// object representing a GOT entry for an external function. 71 MachinePointerInfo callPtrInfo(const char *ES); 72 73 // Functions with the "interrupt" attribute require special prologues, 74 // epilogues and additional spill slots. isISR()75 bool isISR() const { return IsISR; } setISR()76 void setISR() { IsISR = true; } 77 void createISRRegFI(); getISRRegFI(unsigned Reg)78 int getISRRegFI(unsigned Reg) const { return ISRDataRegFI[Reg]; } 79 bool isISRRegFI(int FI) const; 80 81 /// Create a MachinePointerInfo that has a GlobalValuePseudoSourceValue object 82 /// representing a GOT entry for a global function. 83 MachinePointerInfo callPtrInfo(const GlobalValue *GV); 84 setSaveS2()85 void setSaveS2() { SaveS2 = true; } hasSaveS2()86 bool hasSaveS2() const { return SaveS2; } 87 88 int getMoveF64ViaSpillFI(const TargetRegisterClass *RC); 89 90 std::map<const char *, const llvm::Mips16HardFloatInfo::FuncSignature *> 91 StubsNeeded; 92 93 private: 94 virtual void anchor(); 95 96 MachineFunction& MF; 97 /// SRetReturnReg - Some subtargets require that sret lowering includes 98 /// returning the value of the returned struct in a register. This field 99 /// holds the virtual register into which the sret argument is passed. 100 unsigned SRetReturnReg; 101 102 /// GlobalBaseReg - keeps track of the virtual register initialized for 103 /// use as the global base register. This is used for PIC in some PIC 104 /// relocation models. 105 unsigned GlobalBaseReg; 106 107 /// Mips16SPAliasReg - keeps track of the virtual register initialized for 108 /// use as an alias for SP for use in load/store of halfword/byte from/to 109 /// the stack 110 unsigned Mips16SPAliasReg; 111 112 /// VarArgsFrameIndex - FrameIndex for start of varargs area. 113 int VarArgsFrameIndex; 114 115 /// True if function has a byval argument. 116 bool HasByvalArg; 117 118 /// Size of incoming argument area. 119 unsigned IncomingArgSize; 120 121 /// CallsEhReturn - Whether the function calls llvm.eh.return. 122 bool CallsEhReturn; 123 124 /// Frame objects for spilling eh data registers. 125 int EhDataRegFI[4]; 126 127 /// ISR - Whether the function is an Interrupt Service Routine. 128 bool IsISR; 129 130 /// Frame objects for spilling C0_STATUS, C0_EPC 131 int ISRDataRegFI[2]; 132 133 // saveS2 134 bool SaveS2; 135 136 /// FrameIndex for expanding BuildPairF64 nodes to spill and reload when the 137 /// O32 FPXX ABI is enabled. -1 is used to denote invalid index. 138 int MoveF64ViaSpillFI; 139 }; 140 141 } // end of namespace llvm 142 143 #endif 144