llvm/lib/Target/Mips/MipsCCState.cpp

   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 bool MipsCCState::isF128SoftLibCall(const char *CallSym) {
  16   const char *const LibCalls[] = {
  17       "__addtf3",      "__divtf3",     "__eqtf2",       "__extenddftf2",
  18       "__extendsftf2", "__fixtfdi",    "__fixtfsi",     "__fixtfti",
  19       "__fixunstfdi",  "__fixunstfsi", "__fixunstfti",  "__floatditf",
  20       "__floatsitf",   "__floattitf",  "__floatunditf", "__floatunsitf",
  21       "__floatuntitf", "__getf2",      "__gttf2",       "__letf2",
  22       "__lttf2",       "__multf3",     "__netf2",       "__powitf2",
  23       "__subtf3",      "__trunctfdf2", "__trunctfsf2",  "__unordtf2",
  24       "ceill",         "copysignl",    "cosl",          "exp2l",
  25       "expl",          "floorl",       "fmal",          "fmaxl",
  26       "fmodl",         "log10l",       "log2l",         "logl",
  27       "nearbyintl",    "powl",         "rintl",         "roundl",
  28       "sinl",          "sqrtl",        "truncl"};
  29
  30   // Check that LibCalls is sorted alphabetically.
  31   auto Comp = [](const char *S1, const char *S2) { return strcmp(S1, S2) < 0; };
  32   assert(llvm::is_sorted(LibCalls, Comp));
  33   return std::binary_search(std::begin(LibCalls), std::end(LibCalls), CallSym,
  34                             Comp);
  35 }
  36
  37 /// This function returns true if Ty is fp128, {f128} or i128 which was
  38 /// originally a fp128.
  39 bool MipsCCState::originalTypeIsF128(const Type *Ty, const char *Func) {
  40   if (Ty->isFP128Ty())
  41     return true;
  42
  43   if (Ty->isStructTy() && Ty->getStructNumElements() == 1 &&
  44       Ty->getStructElementType(0)->isFP128Ty())
  45     return true;
  46
  47   // If the Ty is i128 and the function being called is a long double emulation
  48   // routine, then the original type is f128.
  49   // FIXME: This is unsound because these functions could be indirectly called
  50   return (Func && Ty->isIntegerTy(128) && isF128SoftLibCall(Func));
  51 }
  52
  53 /// Return true if the original type was vXfXX.
  54 bool MipsCCState::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.
  62 bool MipsCCState::originalTypeIsVectorFloat(const Type *Ty) {
  63   if (Ty->isVectorTy() && Ty->isFPOrFPVectorTy())
  64     return true;
  65
  66   return false;
  67 }
  68
  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;
  80       }
  81     }
  82   }
  83   return SpecialCallingConv;
  84 }
  85
  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.
  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.
 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.
 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 void MipsCCState::PreAnalyzeReturnValue(EVT ArgVT) {
 130   OriginalRetWasFloatVector.push_back(originalEVTTypeIsVectorFloat(ArgVT));
 131 }
 132
 133 void MipsCCState::PreAnalyzeCallOperand(const Type *ArgTy, bool IsFixed,
 134                                         const char *Func) {
 135   OriginalArgWasF128.push_back(originalTypeIsF128(ArgTy, Func));
 136   OriginalArgWasFloat.push_back(ArgTy->isFloatingPointTy());
 137   OriginalArgWasFloatVector.push_back(ArgTy->isVectorTy());
 138   CallOperandIsFixed.push_back(IsFixed);
 139 }
 140
 141 /// Identify lowered values that originated from f128, float and sret to vXfXX
 142 /// arguments and record this.
 143 void MipsCCState::PreAnalyzeCallOperands(
 144     const SmallVectorImpl<ISD::OutputArg> &Outs,
 145     std::vector<TargetLowering::ArgListEntry> &FuncArgs,
 146     const char *Func) {
 147   for (unsigned i = 0; i < Outs.size(); ++i) {
 148     TargetLowering::ArgListEntry FuncArg = FuncArgs[Outs[i].OrigArgIndex];
 149
 150     OriginalArgWasF128.push_back(originalTypeIsF128(FuncArg.Ty, Func));
 151     OriginalArgWasFloat.push_back(FuncArg.Ty->isFloatingPointTy());
 152     OriginalArgWasFloatVector.push_back(FuncArg.Ty->isVectorTy());
 153     CallOperandIsFixed.push_back(Outs[i].IsFixed);
 154   }
 155 }
 156
 157 void MipsCCState::PreAnalyzeFormalArgument(const Type *ArgTy,
 158                                            ISD::ArgFlagsTy Flags) {
 159   // SRet arguments cannot originate from f128 or {f128} returns so we just
 160   // push false. We have to handle this specially since SRet arguments
 161   // aren't mapped to an original argument.
 162   if (Flags.isSRet()) {
 163     OriginalArgWasF128.push_back(false);
 164     OriginalArgWasFloat.push_back(false);
 165     OriginalArgWasFloatVector.push_back(false);
 166     return;
 167   }
 168
 169   OriginalArgWasF128.push_back(originalTypeIsF128(ArgTy, nullptr));
 170   OriginalArgWasFloat.push_back(ArgTy->isFloatingPointTy());
 171
 172   // The MIPS vector ABI exhibits a corner case of sorts or quirk; if the
 173   // first argument is actually an SRet pointer to a vector, then the next
 174   // argument slot is $a2.
 175   OriginalArgWasFloatVector.push_back(ArgTy->isVectorTy());
 176 }
 177
 178 /// Identify lowered values that originated from f128, float and vXfXX arguments
 179 /// and record this.
 180 void MipsCCState::PreAnalyzeFormalArgumentsForF128(
 181     const SmallVectorImpl<ISD::InputArg> &Ins) {
 182   const MachineFunction &MF = getMachineFunction();
 183   for (unsigned i = 0; i < Ins.size(); ++i) {
 184     Function::const_arg_iterator FuncArg = MF.getFunction().arg_begin();
 185
 186     // SRet arguments cannot originate from f128 or {f128} returns so we just
 187     // push false. We have to handle this specially since SRet arguments
 188     // aren't mapped to an original argument.
 189     if (Ins[i].Flags.isSRet()) {
 190       OriginalArgWasF128.push_back(false);
 191       OriginalArgWasFloat.push_back(false);
 192       OriginalArgWasFloatVector.push_back(false);
 193       continue;
 194     }
 195
 196     assert(Ins[i].getOrigArgIndex() < MF.getFunction().arg_size());
 197     std::advance(FuncArg, Ins[i].getOrigArgIndex());
 198
 199     OriginalArgWasF128.push_back(
 200         originalTypeIsF128(FuncArg->getType(), nullptr));
 201     OriginalArgWasFloat.push_back(FuncArg->getType()->isFloatingPointTy());
 202
 203     // The MIPS vector ABI exhibits a corner case of sorts or quirk; if the
 204     // first argument is actually an SRet pointer to a vector, then the next
 205     // argument slot is $a2.
 206     OriginalArgWasFloatVector.push_back(FuncArg->getType()->isVectorTy());
 207   }
 208 }