LLVM  3.7.0
MipsMachineFunction.h
Go to the documentation of this file.
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/ADT/StringMap.h"
23 #include "llvm/IR/GlobalValue.h"
24 #include "llvm/IR/ValueMap.h"
27 #include <map>
28 #include <string>
29 #include <utility>
30 
31 namespace llvm {
32 
33 /// \brief A class derived from PseudoSourceValue that represents a GOT entry
34 /// resolved by lazy-binding.
36 public:
37  explicit MipsCallEntry(StringRef N);
38  explicit MipsCallEntry(const GlobalValue *V);
39  bool isConstant(const MachineFrameInfo *) const override;
40  bool isAliased(const MachineFrameInfo *) const override;
41  bool mayAlias(const MachineFrameInfo *) const override;
42 
43 private:
44  void printCustom(raw_ostream &O) const override;
45 #ifndef NDEBUG
46  std::string Name;
47  const GlobalValue *Val;
48 #endif
49 };
50 
51 /// MipsFunctionInfo - This class is derived from MachineFunction private
52 /// Mips target-specific information for each MachineFunction.
54 public:
56  : MF(MF), SRetReturnReg(0), GlobalBaseReg(0), Mips16SPAliasReg(0),
57  VarArgsFrameIndex(0), CallsEhReturn(false), SaveS2(false),
58  MoveF64ViaSpillFI(-1) {}
59 
61 
62  unsigned getSRetReturnReg() const { return SRetReturnReg; }
63  void setSRetReturnReg(unsigned Reg) { SRetReturnReg = Reg; }
64 
65  bool globalBaseRegSet() const;
66  unsigned getGlobalBaseReg();
67 
68  bool mips16SPAliasRegSet() const;
69  unsigned getMips16SPAliasReg();
70 
71  int getVarArgsFrameIndex() const { return VarArgsFrameIndex; }
72  void setVarArgsFrameIndex(int Index) { VarArgsFrameIndex = Index; }
73 
74  bool hasByvalArg() const { return HasByvalArg; }
75  void setFormalArgInfo(unsigned Size, bool HasByval) {
76  IncomingArgSize = Size;
77  HasByvalArg = HasByval;
78  }
79 
80  unsigned getIncomingArgSize() const { return IncomingArgSize; }
81 
82  bool callsEhReturn() const { return CallsEhReturn; }
83  void setCallsEhReturn() { CallsEhReturn = true; }
84 
85  void createEhDataRegsFI();
86  int getEhDataRegFI(unsigned Reg) const { return EhDataRegFI[Reg]; }
87  bool isEhDataRegFI(int FI) const;
88 
89  /// \brief Create a MachinePointerInfo that has a MipsCallEntr object
90  /// representing a GOT entry for an external function.
92 
93  /// \brief Create a MachinePointerInfo that has a MipsCallEntr object
94  /// representing a GOT entry for a global function.
96 
97  void setSaveS2() { SaveS2 = true; }
98  bool hasSaveS2() const { return SaveS2; }
99 
101 
102  std::map<const char *, const llvm::Mips16HardFloatInfo::FuncSignature *>
104 
105 private:
106  virtual void anchor();
107 
108  MachineFunction& MF;
109  /// SRetReturnReg - Some subtargets require that sret lowering includes
110  /// returning the value of the returned struct in a register. This field
111  /// holds the virtual register into which the sret argument is passed.
112  unsigned SRetReturnReg;
113 
114  /// GlobalBaseReg - keeps track of the virtual register initialized for
115  /// use as the global base register. This is used for PIC in some PIC
116  /// relocation models.
117  unsigned GlobalBaseReg;
118 
119  /// Mips16SPAliasReg - keeps track of the virtual register initialized for
120  /// use as an alias for SP for use in load/store of halfword/byte from/to
121  /// the stack
122  unsigned Mips16SPAliasReg;
123 
124  /// VarArgsFrameIndex - FrameIndex for start of varargs area.
125  int VarArgsFrameIndex;
126 
127  /// True if function has a byval argument.
128  bool HasByvalArg;
129 
130  /// Size of incoming argument area.
131  unsigned IncomingArgSize;
132 
133  /// CallsEhReturn - Whether the function calls llvm.eh.return.
134  bool CallsEhReturn;
135 
136  /// Frame objects for spilling eh data registers.
137  int EhDataRegFI[4];
138 
139  // saveS2
140  bool SaveS2;
141 
142  /// FrameIndex for expanding BuildPairF64 nodes to spill and reload when the
143  /// O32 FPXX ABI is enabled. -1 is used to denote invalid index.
144  int MoveF64ViaSpillFI;
145 
146  /// MipsCallEntry maps.
149  GlobalCallEntries;
150 };
151 
152 } // end of namespace llvm
153 
154 #endif
unsigned getIncomingArgSize() const
bool mayAlias(const MachineFrameInfo *) const override
mayAlias - Return true if the memory pointed to by this PseudoSourceValue can ever alias an LLVM IR V...
void setVarArgsFrameIndex(int Index)
MachineFunctionInfo - This class can be derived from and used by targets to hold private target-speci...
unsigned getSRetReturnReg() const
Reg
All possible values of the reg field in the ModR/M byte.
The MachineFrameInfo class represents an abstract stack frame until prolog/epilog code is inserted...
#define false
Definition: ConvertUTF.c:65
A class derived from PseudoSourceValue that represents a GOT entry resolved by lazy-binding.
int getEhDataRegFI(unsigned Reg) const
MachinePointerInfo - This class contains a discriminated union of information about pointers in memor...
bool isEhDataRegFI(int FI) const
See the file comment.
Definition: ValueMap.h:80
StringMap - This is an unconventional map that is specialized for handling keys that are "strings"...
Definition: StringMap.h:214
PseudoSourceValue - Special value supplied for machine level alias analysis.
bool isAliased(const MachineFrameInfo *) const override
isAliased - Test whether the memory pointed to by this PseudoSourceValue may also be pointed to by an...
void setFormalArgInfo(unsigned Size, bool HasByval)
MachinePointerInfo callPtrInfo(StringRef Name)
Create a MachinePointerInfo that has a MipsCallEntr object representing a GOT entry for an external f...
std::map< const char *, const llvm::Mips16HardFloatInfo::FuncSignature * > StubsNeeded
MipsFunctionInfo(MachineFunction &MF)
#define N
bool isConstant(const MachineFrameInfo *) const override
isConstant - Test whether the memory pointed to by this PseudoSourceValue has a constant value...
int getMoveF64ViaSpillFI(const TargetRegisterClass *RC)
MipsFunctionInfo - This class is derived from MachineFunction private Mips target-specific informatio...
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:38
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:40
void setSRetReturnReg(unsigned Reg)