LLVM 20.0.0git
MipsCCState.h
Go to the documentation of this file.
1//===---- MipsCCState.h - CCState with Mips specific extensions -----------===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef MIPSCCSTATE_H
10#define MIPSCCSTATE_H
11
12#include "MipsISelLowering.h"
15
16namespace llvm {
17class SDNode;
18class MipsSubtarget;
19
20class MipsCCState : public CCState {
21public:
23
24 /// Determine the SpecialCallingConvType for the given callee
27 const MipsSubtarget &Subtarget);
28
29 /// This function returns true if CallSym is a long double emulation routine.
30 ///
31 /// FIXME: Changing the ABI based on the callee name is unsound. The lib func
32 /// address could be captured.
33 static bool isF128SoftLibCall(const char *CallSym);
34
35 static bool originalTypeIsF128(const Type *Ty, const char *Func);
36 static bool originalEVTTypeIsVectorFloat(EVT Ty);
37 static bool originalTypeIsVectorFloat(const Type *Ty);
38
39 void PreAnalyzeCallOperand(const Type *ArgTy, bool IsFixed, const char *Func);
40
41 void PreAnalyzeFormalArgument(const Type *ArgTy, ISD::ArgFlagsTy Flags);
42 void PreAnalyzeReturnValue(EVT ArgVT);
43
44private:
45 /// Identify lowered values that originated from f128 arguments and record
46 /// this for use by RetCC_MipsN.
47 void PreAnalyzeCallResultForF128(const SmallVectorImpl<ISD::InputArg> &Ins,
48 const Type *RetTy, const char * Func);
49
50 /// Identify lowered values that originated from f128 arguments and record
51 /// this for use by RetCC_MipsN.
52 void PreAnalyzeReturnForF128(const SmallVectorImpl<ISD::OutputArg> &Outs);
53
54 /// Identify lowered values that originated from f128 arguments and record
55 /// this.
56 void
57 PreAnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
58 std::vector<TargetLowering::ArgListEntry> &FuncArgs,
59 const char *Func);
60
61 /// Identify lowered values that originated from f128 arguments and record
62 /// this for use by RetCC_MipsN.
63 void
64 PreAnalyzeFormalArgumentsForF128(const SmallVectorImpl<ISD::InputArg> &Ins);
65
66 void
67 PreAnalyzeCallResultForVectorFloat(const SmallVectorImpl<ISD::InputArg> &Ins,
68 const Type *RetTy);
69
70 void PreAnalyzeFormalArgumentsForVectorFloat(
72
73 void
74 PreAnalyzeReturnForVectorFloat(const SmallVectorImpl<ISD::OutputArg> &Outs);
75
76 /// Records whether the value has been lowered from an f128.
77 SmallVector<bool, 4> OriginalArgWasF128;
78
79 /// Records whether the value has been lowered from float.
80 SmallVector<bool, 4> OriginalArgWasFloat;
81
82 /// Records whether the value has been lowered from a floating point vector.
83 SmallVector<bool, 4> OriginalArgWasFloatVector;
84
85 /// Records whether the return value has been lowered from a floating point
86 /// vector.
87 SmallVector<bool, 4> OriginalRetWasFloatVector;
88
89 /// Records whether the value was a fixed argument.
90 /// See ISD::OutputArg::IsFixed,
91 SmallVector<bool, 4> CallOperandIsFixed;
92
93 // Used to handle MIPS16-specific calling convention tweaks.
94 // FIXME: This should probably be a fully fledged calling convention.
95 SpecialCallingConvType SpecialCallingConv;
96
97public:
101 : CCState(CC, isVarArg, MF, locs, C), SpecialCallingConv(SpecialCC) {}
102
105 std::vector<TargetLowering::ArgListEntry> &FuncArgs, const char *Func) {
106 OriginalArgWasF128.clear();
107 OriginalArgWasFloat.clear();
108 OriginalArgWasFloatVector.clear();
109 CallOperandIsFixed.clear();
110 PreAnalyzeCallOperands(Outs, FuncArgs, Func);
111 }
112
113 void
115 CCAssignFn Fn,
116 std::vector<TargetLowering::ArgListEntry> &FuncArgs,
117 const char *Func) {
118 PreAnalyzeCallOperands(Outs, Fn, FuncArgs, Func);
120 }
121
122 // The AnalyzeCallOperands in the base class is not usable since we must
123 // provide a means of accessing ArgListEntry::IsFixed. Delete them from this
124 // class. This doesn't stop them being used via the base class though.
126 CCAssignFn Fn) = delete;
129 CCAssignFn Fn) = delete;
130
132 CCAssignFn Fn) {
133 OriginalArgWasFloat.clear();
134 OriginalArgWasF128.clear();
135 OriginalArgWasFloatVector.clear();
136 PreAnalyzeFormalArgumentsForF128(Ins);
137 }
138
140 CCAssignFn Fn) {
143 }
144
145 void PreAnalyzeCallResult(const Type *RetTy, const char *Func) {
146 OriginalArgWasF128.push_back(originalTypeIsF128(RetTy, Func));
147 OriginalArgWasFloat.push_back(RetTy->isFloatingPointTy());
148 OriginalRetWasFloatVector.push_back(originalTypeIsVectorFloat(RetTy));
149 }
150
152 CCAssignFn Fn, const Type *RetTy,
153 const char *Func) {
154 OriginalArgWasFloat.clear();
155 OriginalArgWasF128.clear();
156 OriginalArgWasFloatVector.clear();
157 PreAnalyzeCallResultForF128(Ins, RetTy, Func);
158 PreAnalyzeCallResultForVectorFloat(Ins, RetTy);
159 }
160
162 CCAssignFn Fn, const Type *RetTy,
163 const char *Func) {
164 PreAnalyzeCallResult(Ins, Fn, RetTy, Func);
166 }
167
169 CCAssignFn Fn) {
170 OriginalArgWasFloat.clear();
171 OriginalArgWasF128.clear();
172 OriginalArgWasFloatVector.clear();
173 PreAnalyzeReturnForF128(Outs);
174 PreAnalyzeReturnForVectorFloat(Outs);
175 }
176
178 CCAssignFn Fn) {
179 PreAnalyzeReturn(Outs, Fn);
180 CCState::AnalyzeReturn(Outs, Fn);
181 }
182
184 CCAssignFn Fn) {
185 PreAnalyzeReturnForF128(ArgsFlags);
186 PreAnalyzeReturnForVectorFloat(ArgsFlags);
187 bool Return = CCState::CheckReturn(ArgsFlags, Fn);
188 OriginalArgWasFloat.clear();
189 OriginalArgWasF128.clear();
190 OriginalArgWasFloatVector.clear();
191 return Return;
192 }
193
194 bool WasOriginalArgF128(unsigned ValNo) { return OriginalArgWasF128[ValNo]; }
195 bool WasOriginalArgFloat(unsigned ValNo) {
196 return OriginalArgWasFloat[ValNo];
197 }
198 bool WasOriginalArgVectorFloat(unsigned ValNo) const {
199 return OriginalArgWasFloatVector[ValNo];
200 }
201 bool WasOriginalRetVectorFloat(unsigned ValNo) const {
202 return OriginalRetWasFloatVector[ValNo];
203 }
204 bool IsCallOperandFixed(unsigned ValNo) { return CallOperandIsFixed[ValNo]; }
205 SpecialCallingConvType getSpecialCallingConv() { return SpecialCallingConv; }
206};
207}
208
209#endif
return RetTy
This file defines the SmallVector class.
CCState - This class holds information needed while lowering arguments and return values.
void AnalyzeCallResult(const SmallVectorImpl< ISD::InputArg > &Ins, CCAssignFn Fn)
AnalyzeCallResult - Analyze the return values of a call, incorporating info about the passed values i...
bool CheckReturn(const SmallVectorImpl< ISD::OutputArg > &Outs, CCAssignFn Fn)
CheckReturn - Analyze the return values of a function, returning true if the return can be performed ...
void AnalyzeReturn(const SmallVectorImpl< ISD::OutputArg > &Outs, CCAssignFn Fn)
AnalyzeReturn - Analyze the returned values of a return, incorporating info about the result values i...
void AnalyzeCallOperands(const SmallVectorImpl< ISD::OutputArg > &Outs, CCAssignFn Fn)
AnalyzeCallOperands - Analyze the outgoing arguments to a call, incorporating info about the passed v...
bool isVarArg() const
void AnalyzeFormalArguments(const SmallVectorImpl< ISD::InputArg > &Ins, CCAssignFn Fn)
AnalyzeFormalArguments - Analyze an array of argument values, incorporating info about the formals in...
This is an important class for using LLVM in a threaded context.
Definition: LLVMContext.h:67
static bool originalTypeIsVectorFloat(const Type *Ty)
Return true if the original type was vXfXX / vXfXX.
Definition: MipsCCState.cpp:62
void AnalyzeCallResult(const SmallVectorImpl< ISD::InputArg > &Ins, CCAssignFn Fn, const Type *RetTy, const char *Func)
Definition: MipsCCState.h:161
void AnalyzeCallOperands(const SmallVectorImpl< ISD::OutputArg > &Outs, CCAssignFn Fn, std::vector< TargetLowering::ArgListEntry > &FuncArgs, const char *Func)
Definition: MipsCCState.h:114
void PreAnalyzeReturn(const SmallVectorImpl< ISD::OutputArg > &Outs, CCAssignFn Fn)
Definition: MipsCCState.h:168
bool CheckReturn(const SmallVectorImpl< ISD::OutputArg > &ArgsFlags, CCAssignFn Fn)
Definition: MipsCCState.h:183
static bool isF128SoftLibCall(const char *CallSym)
This function returns true if CallSym is a long double emulation routine.
Definition: MipsCCState.cpp:15
void PreAnalyzeReturnValue(EVT ArgVT)
static bool originalTypeIsF128(const Type *Ty, const char *Func)
This function returns true if Ty is fp128, {f128} or i128 which was originally a fp128.
Definition: MipsCCState.cpp:39
void AnalyzeCallOperands(const SmallVectorImpl< ISD::OutputArg > &Outs, CCAssignFn Fn)=delete
bool WasOriginalRetVectorFloat(unsigned ValNo) const
Definition: MipsCCState.h:201
void AnalyzeReturn(const SmallVectorImpl< ISD::OutputArg > &Outs, CCAssignFn Fn)
Definition: MipsCCState.h:177
void PreAnalyzeCallOperands(const SmallVectorImpl< ISD::OutputArg > &Outs, CCAssignFn Fn, std::vector< TargetLowering::ArgListEntry > &FuncArgs, const char *Func)
Definition: MipsCCState.h:103
void AnalyzeFormalArguments(const SmallVectorImpl< ISD::InputArg > &Ins, CCAssignFn Fn)
Definition: MipsCCState.h:139
bool WasOriginalArgFloat(unsigned ValNo)
Definition: MipsCCState.h:195
void PreAnalyzeFormalArguments(const SmallVectorImpl< ISD::InputArg > &Ins, CCAssignFn Fn)
Definition: MipsCCState.h:131
static bool originalEVTTypeIsVectorFloat(EVT Ty)
Return true if the original type was vXfXX.
Definition: MipsCCState.cpp:54
void AnalyzeCallOperands(const SmallVectorImpl< MVT > &Outs, SmallVectorImpl< ISD::ArgFlagsTy > &Flags, CCAssignFn Fn)=delete
bool WasOriginalArgVectorFloat(unsigned ValNo) const
Definition: MipsCCState.h:198
void PreAnalyzeCallOperand(const Type *ArgTy, bool IsFixed, const char *Func)
void PreAnalyzeFormalArgument(const Type *ArgTy, ISD::ArgFlagsTy Flags)
bool IsCallOperandFixed(unsigned ValNo)
Definition: MipsCCState.h:204
SpecialCallingConvType getSpecialCallingConv()
Definition: MipsCCState.h:205
bool WasOriginalArgF128(unsigned ValNo)
Definition: MipsCCState.h:194
static SpecialCallingConvType getSpecialCallingConvForCallee(const SDNode *Callee, const MipsSubtarget &Subtarget)
Determine the SpecialCallingConvType for the given callee.
Definition: MipsCCState.cpp:70
MipsCCState(CallingConv::ID CC, bool isVarArg, MachineFunction &MF, SmallVectorImpl< CCValAssign > &locs, LLVMContext &C, SpecialCallingConvType SpecialCC=NoSpecialCallingConv)
Definition: MipsCCState.h:98
void PreAnalyzeCallResult(const Type *RetTy, const char *Func)
Definition: MipsCCState.h:145
void PreAnalyzeCallResult(const SmallVectorImpl< ISD::InputArg > &Ins, CCAssignFn Fn, const Type *RetTy, const char *Func)
Definition: MipsCCState.h:151
Represents one node in the SelectionDAG.
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: SmallVector.h:586
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:45
@ C
The default llvm calling convention, compatible with C.
Definition: CallingConv.h:34
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
bool CCAssignFn(unsigned ValNo, MVT ValVT, MVT LocVT, CCValAssign::LocInfo LocInfo, ISD::ArgFlagsTy ArgFlags, CCState &State)
CCAssignFn - This function assigns a location for Val, updating State to reflect the change.
Extended Value Type.
Definition: ValueTypes.h:35