1 //===---- MipsCCState.cpp - CCState with Mips specific extensions ---------===//
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
7 //===----------------------------------------------------------------------===//
9 #include "MipsCCState.h"
10 #include "MipsSubtarget.h"
11 #include "llvm/IR/Module.h"
15 /// This function returns true if CallSym is a long double emulation routine.
16 static bool isF128SoftLibCall(const char *CallSym
) {
17 const char *const LibCalls
[] = {
18 "__addtf3", "__divtf3", "__eqtf2", "__extenddftf2",
19 "__extendsftf2", "__fixtfdi", "__fixtfsi", "__fixtfti",
20 "__fixunstfdi", "__fixunstfsi", "__fixunstfti", "__floatditf",
21 "__floatsitf", "__floattitf", "__floatunditf", "__floatunsitf",
22 "__floatuntitf", "__getf2", "__gttf2", "__letf2",
23 "__lttf2", "__multf3", "__netf2", "__powitf2",
24 "__subtf3", "__trunctfdf2", "__trunctfsf2", "__unordtf2",
25 "ceill", "copysignl", "cosl", "exp2l",
26 "expl", "floorl", "fmal", "fmaxl",
27 "fmodl", "log10l", "log2l", "logl",
28 "nearbyintl", "powl", "rintl", "roundl",
29 "sinl", "sqrtl", "truncl"};
31 // Check that LibCalls is sorted alphabetically.
32 auto Comp
= [](const char *S1
, const char *S2
) { return strcmp(S1
, S2
) < 0; };
33 assert(std::is_sorted(std::begin(LibCalls
), std::end(LibCalls
), Comp
));
34 return std::binary_search(std::begin(LibCalls
), std::end(LibCalls
),
38 /// This function returns true if Ty is fp128, {f128} or i128 which was
39 /// originally a fp128.
40 static bool originalTypeIsF128(const Type
*Ty
, const char *Func
) {
44 if (Ty
->isStructTy() && Ty
->getStructNumElements() == 1 &&
45 Ty
->getStructElementType(0)->isFP128Ty())
48 // If the Ty is i128 and the function being called is a long double emulation
49 // routine, then the original type is f128.
50 return (Func
&& Ty
->isIntegerTy(128) && isF128SoftLibCall(Func
));
53 /// Return true if the original type was vXfXX.
54 static bool originalEVTTypeIsVectorFloat(EVT Ty
) {
55 if (Ty
.isVector() && Ty
.getVectorElementType().isFloatingPoint())
61 /// Return true if the original type was vXfXX / vXfXX.
62 static bool originalTypeIsVectorFloat(const Type
* Ty
) {
63 if (Ty
->isVectorTy() && Ty
->isFPOrFPVectorTy())
69 MipsCCState::SpecialCallingConvType
70 MipsCCState::getSpecialCallingConvForCallee(const SDNode
*Callee
,
71 const MipsSubtarget
&Subtarget
) {
72 MipsCCState::SpecialCallingConvType SpecialCallingConv
= NoSpecialCallingConv
;
73 if (Subtarget
.inMips16HardFloat()) {
74 if (const GlobalAddressSDNode
*G
=
75 dyn_cast
<const GlobalAddressSDNode
>(Callee
)) {
76 llvm::StringRef Sym
= G
->getGlobal()->getName();
77 Function
*F
= G
->getGlobal()->getParent()->getFunction(Sym
);
78 if (F
&& F
->hasFnAttribute("__Mips16RetHelper")) {
79 SpecialCallingConv
= Mips16RetHelperConv
;
83 return SpecialCallingConv
;
86 void MipsCCState::PreAnalyzeCallResultForF128(
87 const SmallVectorImpl
<ISD::InputArg
> &Ins
,
88 const Type
*RetTy
, const char *Call
) {
89 for (unsigned i
= 0; i
< Ins
.size(); ++i
) {
90 OriginalArgWasF128
.push_back(
91 originalTypeIsF128(RetTy
, Call
));
92 OriginalArgWasFloat
.push_back(RetTy
->isFloatingPointTy());
96 /// Identify lowered values that originated from f128 or float arguments and
97 /// record this for use by RetCC_MipsN.
98 void MipsCCState::PreAnalyzeReturnForF128(
99 const SmallVectorImpl
<ISD::OutputArg
> &Outs
) {
100 const MachineFunction
&MF
= getMachineFunction();
101 for (unsigned i
= 0; i
< Outs
.size(); ++i
) {
102 OriginalArgWasF128
.push_back(
103 originalTypeIsF128(MF
.getFunction().getReturnType(), nullptr));
104 OriginalArgWasFloat
.push_back(
105 MF
.getFunction().getReturnType()->isFloatingPointTy());
109 /// Identify lower values that originated from vXfXX and record
111 void MipsCCState::PreAnalyzeCallResultForVectorFloat(
112 const SmallVectorImpl
<ISD::InputArg
> &Ins
, const Type
*RetTy
) {
113 for (unsigned i
= 0; i
< Ins
.size(); ++i
) {
114 OriginalRetWasFloatVector
.push_back(originalTypeIsVectorFloat(RetTy
));
118 /// Identify lowered values that originated from vXfXX arguments and record
120 void MipsCCState::PreAnalyzeReturnForVectorFloat(
121 const SmallVectorImpl
<ISD::OutputArg
> &Outs
) {
122 for (unsigned i
= 0; i
< Outs
.size(); ++i
) {
123 ISD::OutputArg Out
= Outs
[i
];
124 OriginalRetWasFloatVector
.push_back(
125 originalEVTTypeIsVectorFloat(Out
.ArgVT
));
129 /// Identify lowered values that originated from f128, float and sret to vXfXX
130 /// arguments and record this.
131 void MipsCCState::PreAnalyzeCallOperands(
132 const SmallVectorImpl
<ISD::OutputArg
> &Outs
,
133 std::vector
<TargetLowering::ArgListEntry
> &FuncArgs
,
135 for (unsigned i
= 0; i
< Outs
.size(); ++i
) {
136 TargetLowering::ArgListEntry FuncArg
= FuncArgs
[Outs
[i
].OrigArgIndex
];
138 OriginalArgWasF128
.push_back(originalTypeIsF128(FuncArg
.Ty
, Func
));
139 OriginalArgWasFloat
.push_back(FuncArg
.Ty
->isFloatingPointTy());
140 OriginalArgWasFloatVector
.push_back(FuncArg
.Ty
->isVectorTy());
141 CallOperandIsFixed
.push_back(Outs
[i
].IsFixed
);
145 /// Identify lowered values that originated from f128, float and vXfXX arguments
147 void MipsCCState::PreAnalyzeFormalArgumentsForF128(
148 const SmallVectorImpl
<ISD::InputArg
> &Ins
) {
149 const MachineFunction
&MF
= getMachineFunction();
150 for (unsigned i
= 0; i
< Ins
.size(); ++i
) {
151 Function::const_arg_iterator FuncArg
= MF
.getFunction().arg_begin();
153 // SRet arguments cannot originate from f128 or {f128} returns so we just
154 // push false. We have to handle this specially since SRet arguments
155 // aren't mapped to an original argument.
156 if (Ins
[i
].Flags
.isSRet()) {
157 OriginalArgWasF128
.push_back(false);
158 OriginalArgWasFloat
.push_back(false);
159 OriginalArgWasFloatVector
.push_back(false);
163 assert(Ins
[i
].getOrigArgIndex() < MF
.getFunction().arg_size());
164 std::advance(FuncArg
, Ins
[i
].getOrigArgIndex());
166 OriginalArgWasF128
.push_back(
167 originalTypeIsF128(FuncArg
->getType(), nullptr));
168 OriginalArgWasFloat
.push_back(FuncArg
->getType()->isFloatingPointTy());
170 // The MIPS vector ABI exhibits a corner case of sorts or quirk; if the
171 // first argument is actually an SRet pointer to a vector, then the next
172 // argument slot is $a2.
173 OriginalArgWasFloatVector
.push_back(FuncArg
->getType()->isVectorTy());