1 //===---- MipsCCState.cpp - 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 #include "MipsCCState.h"
10 #include "MipsSubtarget.h"
11 #include "llvm/IR/Module.h"
12
13 using namespace llvm;
14
15 /// This function returns true if CallSym is a long double emulation routine.
isF128SoftLibCall(const char * CallSym)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"};
30
31 // Check that LibCalls is sorted alphabetically.
32 auto Comp = [](const char *S1, const char *S2) { return strcmp(S1, S2) < 0; };
33 assert(llvm::is_sorted(LibCalls, Comp));
34 return std::binary_search(std::begin(LibCalls), std::end(LibCalls), CallSym,
35 Comp);
36 }
37
38 /// This function returns true if Ty is fp128, {f128} or i128 which was
39 /// originally a fp128.
originalTypeIsF128(const Type * Ty,const char * Func)40 static bool originalTypeIsF128(const Type *Ty, const char *Func) {
41 if (Ty->isFP128Ty())
42 return true;
43
44 if (Ty->isStructTy() && Ty->getStructNumElements() == 1 &&
45 Ty->getStructElementType(0)->isFP128Ty())
46 return true;
47
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));
51 }
52
53 /// Return true if the original type was vXfXX.
originalEVTTypeIsVectorFloat(EVT Ty)54 static bool originalEVTTypeIsVectorFloat(EVT Ty) {
55 if (Ty.isVector() && Ty.getVectorElementType().isFloatingPoint())
56 return true;
57
58 return false;
59 }
60
61 /// Return true if the original type was vXfXX / vXfXX.
originalTypeIsVectorFloat(const Type * Ty)62 static bool originalTypeIsVectorFloat(const Type * Ty) {
63 if (Ty->isVectorTy() && Ty->isFPOrFPVectorTy())
64 return true;
65
66 return false;
67 }
68
69 MipsCCState::SpecialCallingConvType
getSpecialCallingConvForCallee(const SDNode * Callee,const MipsSubtarget & Subtarget)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;
80 }
81 }
82 }
83 return SpecialCallingConv;
84 }
85
PreAnalyzeCallResultForF128(const SmallVectorImpl<ISD::InputArg> & Ins,const Type * RetTy,const char * Call)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());
93 }
94 }
95
96 /// Identify lowered values that originated from f128 or float arguments and
97 /// record this for use by RetCC_MipsN.
PreAnalyzeReturnForF128(const SmallVectorImpl<ISD::OutputArg> & Outs)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());
106 }
107 }
108
109 /// Identify lower values that originated from vXfXX and record
110 /// this.
PreAnalyzeCallResultForVectorFloat(const SmallVectorImpl<ISD::InputArg> & Ins,const Type * RetTy)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));
115 }
116 }
117
118 /// Identify lowered values that originated from vXfXX arguments and record
119 /// this.
PreAnalyzeReturnForVectorFloat(const SmallVectorImpl<ISD::OutputArg> & Outs)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));
126 }
127 }
128
129 /// Identify lowered values that originated from f128, float and sret to vXfXX
130 /// arguments and record this.
PreAnalyzeCallOperands(const SmallVectorImpl<ISD::OutputArg> & Outs,std::vector<TargetLowering::ArgListEntry> & FuncArgs,const char * Func)131 void MipsCCState::PreAnalyzeCallOperands(
132 const SmallVectorImpl<ISD::OutputArg> &Outs,
133 std::vector<TargetLowering::ArgListEntry> &FuncArgs,
134 const char *Func) {
135 for (unsigned i = 0; i < Outs.size(); ++i) {
136 TargetLowering::ArgListEntry FuncArg = FuncArgs[Outs[i].OrigArgIndex];
137
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);
142 }
143 }
144
145 /// Identify lowered values that originated from f128, float and vXfXX arguments
146 /// and record this.
PreAnalyzeFormalArgumentsForF128(const SmallVectorImpl<ISD::InputArg> & Ins)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();
152
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);
160 continue;
161 }
162
163 assert(Ins[i].getOrigArgIndex() < MF.getFunction().arg_size());
164 std::advance(FuncArg, Ins[i].getOrigArgIndex());
165
166 OriginalArgWasF128.push_back(
167 originalTypeIsF128(FuncArg->getType(), nullptr));
168 OriginalArgWasFloat.push_back(FuncArg->getType()->isFloatingPointTy());
169
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());
174 }
175 }
176