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"
13#include "llvm/ADT/SmallVector.h"
14#include "llvm/CodeGen/CallingConvLower.h"
15
16namespace llvm {
17class SDNode;
18class MipsSubtarget;
19
20class MipsCCState : public CCState {
21public:
22  enum SpecialCallingConvType { Mips16RetHelperConv, NoSpecialCallingConv };
23
24  /// Determine the SpecialCallingConvType for the given callee
25  static SpecialCallingConvType
26  getSpecialCallingConvForCallee(const SDNode *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(
71      const SmallVectorImpl<ISD::InputArg> &Ins);
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:
98  MipsCCState(CallingConv::ID CC, bool isVarArg, MachineFunction &MF,
99              SmallVectorImpl<CCValAssign> &locs, LLVMContext &C,
100              SpecialCallingConvType SpecialCC = NoSpecialCallingConv)
101      : CCState(CC, isVarArg, MF, locs, C), SpecialCallingConv(SpecialCC) {}
102
103  void PreAnalyzeCallOperands(
104      const SmallVectorImpl<ISD::OutputArg> &Outs, CCAssignFn Fn,
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
114  AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
115                      CCAssignFn Fn,
116                      std::vector<TargetLowering::ArgListEntry> &FuncArgs,
117                      const char *Func) {
118    PreAnalyzeCallOperands(Outs, Fn, FuncArgs, Func);
119    CCState::AnalyzeCallOperands(Outs, Fn);
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.
125  void AnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> &Outs,
126                           CCAssignFn Fn) = delete;
127  void AnalyzeCallOperands(const SmallVectorImpl<MVT> &Outs,
128                           SmallVectorImpl<ISD::ArgFlagsTy> &Flags,
129                           CCAssignFn Fn) = delete;
130
131  void PreAnalyzeFormalArguments(const SmallVectorImpl<ISD::InputArg> &Ins,
132                                 CCAssignFn Fn) {
133    OriginalArgWasFloat.clear();
134    OriginalArgWasF128.clear();
135    OriginalArgWasFloatVector.clear();
136    PreAnalyzeFormalArgumentsForF128(Ins);
137  }
138
139  void AnalyzeFormalArguments(const SmallVectorImpl<ISD::InputArg> &Ins,
140                              CCAssignFn Fn) {
141    PreAnalyzeFormalArguments(Ins, Fn);
142    CCState::AnalyzeFormalArguments(Ins, 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
151  void PreAnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins,
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
161  void AnalyzeCallResult(const SmallVectorImpl<ISD::InputArg> &Ins,
162                         CCAssignFn Fn, const Type *RetTy,
163                         const char *Func) {
164    PreAnalyzeCallResult(Ins, Fn, RetTy, Func);
165    CCState::AnalyzeCallResult(Ins, Fn);
166  }
167
168  void PreAnalyzeReturn(const SmallVectorImpl<ISD::OutputArg> &Outs,
169                        CCAssignFn Fn) {
170    OriginalArgWasFloat.clear();
171    OriginalArgWasF128.clear();
172    OriginalArgWasFloatVector.clear();
173    PreAnalyzeReturnForF128(Outs);
174    PreAnalyzeReturnForVectorFloat(Outs);
175  }
176
177  void AnalyzeReturn(const SmallVectorImpl<ISD::OutputArg> &Outs,
178                     CCAssignFn Fn) {
179    PreAnalyzeReturn(Outs, Fn);
180    CCState::AnalyzeReturn(Outs, Fn);
181  }
182
183  bool CheckReturn(const SmallVectorImpl<ISD::OutputArg> &ArgsFlags,
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
210