lib/Target/Mips/MipsCCState.cpp

   1 //===---- MipsCCState.cpp - CCState with Mips specific extensions ---------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9
  10 #include "MipsCCState.h"
  11 #include "MipsSubtarget.h"
  12 #include "llvm/IR/Module.h"
  13
  14 using namespace llvm;
  15
  16 /// This function returns true if CallSym is a long double emulation routine.
  17 static bool isF128SoftLibCall(const char *CallSym) {
  18   const char *const LibCalls[] = {
  19       "__addtf3",      "__divtf3",     "__eqtf2",       "__extenddftf2",
  20       "__extendsftf2", "__fixtfdi",    "__fixtfsi",     "__fixtfti",
  21       "__fixunstfdi",  "__fixunstfsi", "__fixunstfti",  "__floatditf",
  22       "__floatsitf",   "__floattitf",  "__floatunditf", "__floatunsitf",
  23       "__floatuntitf", "__getf2",      "__gttf2",       "__letf2",
  24       "__lttf2",       "__multf3",     "__netf2",       "__powitf2",
  25       "__subtf3",      "__trunctfdf2", "__trunctfsf2",  "__unordtf2",
  26       "ceill",         "copysignl",    "cosl",          "exp2l",
  27       "expl",          "floorl",       "fmal",          "fmodl",
  28       "log10l",        "log2l",        "logl",          "nearbyintl",
  29       "powl",          "rintl",        "sinl",          "sqrtl",
  30       "truncl"};
  31
  32   const char *const *End = LibCalls + array_lengthof(LibCalls);
  33
  34   // Check that LibCalls is sorted alphabetically.
  35   MipsTargetLowering::LTStr Comp;
  36
  37 #ifndef NDEBUG
  38   for (const char *const *I = LibCalls; I < End - 1; ++I)
  39     assert(Comp(*I, *(I + 1)));
  40 #endif
  41
  42   return std::binary_search(LibCalls, End, CallSym, Comp);
  43 }
  44
  45 /// This function returns true if Ty is fp128, {f128} or i128 which was
  46 /// originally a fp128.
  47 static bool originalTypeIsF128(const Type *Ty, const SDNode *CallNode) {
  48   if (Ty->isFP128Ty())
  49     return true;
  50
  51   if (Ty->isStructTy() && Ty->getStructNumElements() == 1 &&
  52       Ty->getStructElementType(0)->isFP128Ty())
  53     return true;
  54
  55   const ExternalSymbolSDNode *ES =
  56       dyn_cast_or_null<const ExternalSymbolSDNode>(CallNode);
  57
  58   // If the Ty is i128 and the function being called is a long double emulation
  59   // routine, then the original type is f128.
  60   return (ES && Ty->isIntegerTy(128) && isF128SoftLibCall(ES->getSymbol()));
  61 }
  62
  63 MipsCCState::SpecialCallingConvType
  64 MipsCCState::getSpecialCallingConvForCallee(const SDNode *Callee,
  65                                             const MipsSubtarget &Subtarget) {
  66   MipsCCState::SpecialCallingConvType SpecialCallingConv = NoSpecialCallingConv;
  67   if (Subtarget.inMips16HardFloat()) {
  68     if (const GlobalAddressSDNode *G =
  69             dyn_cast<const GlobalAddressSDNode>(Callee)) {
  70       llvm::StringRef Sym = G->getGlobal()->getName();
  71       Function *F = G->getGlobal()->getParent()->getFunction(Sym);
  72       if (F && F->hasFnAttribute("__Mips16RetHelper")) {
  73         SpecialCallingConv = Mips16RetHelperConv;
  74       }
  75     }
  76   }
  77   return SpecialCallingConv;
  78 }
  79
  80 void MipsCCState::PreAnalyzeCallResultForF128(
  81     const SmallVectorImpl<ISD::InputArg> &Ins,
  82     const TargetLowering::CallLoweringInfo &CLI) {
  83   for (unsigned i = 0; i < Ins.size(); ++i) {
  84     OriginalArgWasF128.push_back(
  85         originalTypeIsF128(CLI.RetTy, CLI.Callee.getNode()));
  86     OriginalArgWasFloat.push_back(CLI.RetTy->isFloatingPointTy());
  87   }
  88 }
  89
  90 /// Identify lowered values that originated from f128 arguments and record
  91 /// this for use by RetCC_MipsN.
  92 void MipsCCState::PreAnalyzeReturnForF128(
  93     const SmallVectorImpl<ISD::OutputArg> &Outs) {
  94   const MachineFunction &MF = getMachineFunction();
  95   for (unsigned i = 0; i < Outs.size(); ++i) {
  96     OriginalArgWasF128.push_back(
  97         originalTypeIsF128(MF.getFunction()->getReturnType(), nullptr));
  98     OriginalArgWasFloat.push_back(
  99         MF.getFunction()->getReturnType()->isFloatingPointTy());
 100   }
 101 }
 102
 103 /// Identify lowered values that originated from f128 arguments and record
 104 /// this.
 105 void MipsCCState::PreAnalyzeCallOperands(
 106     const SmallVectorImpl<ISD::OutputArg> &Outs,
 107     std::vector<TargetLowering::ArgListEntry> &FuncArgs,
 108     const SDNode *CallNode) {
 109   for (unsigned i = 0; i < Outs.size(); ++i) {
 110     OriginalArgWasF128.push_back(
 111         originalTypeIsF128(FuncArgs[Outs[i].OrigArgIndex].Ty, CallNode));
 112     OriginalArgWasFloat.push_back(
 113         FuncArgs[Outs[i].OrigArgIndex].Ty->isFloatingPointTy());
 114     CallOperandIsFixed.push_back(Outs[i].IsFixed);
 115   }
 116 }
 117
 118 /// Identify lowered values that originated from f128 arguments and record
 119 /// this.
 120 void MipsCCState::PreAnalyzeFormalArgumentsForF128(
 121     const SmallVectorImpl<ISD::InputArg> &Ins) {
 122   const MachineFunction &MF = getMachineFunction();
 123   for (unsigned i = 0; i < Ins.size(); ++i) {
 124     Function::const_arg_iterator FuncArg = MF.getFunction()->arg_begin();
 125
 126     // SRet arguments cannot originate from f128 or {f128} returns so we just
 127     // push false. We have to handle this specially since SRet arguments
 128     // aren't mapped to an original argument.
 129     if (Ins[i].Flags.isSRet()) {
 130       OriginalArgWasF128.push_back(false);
 131       continue;
 132     }
 133
 134     assert(Ins[i].OrigArgIndex < MF.getFunction()->arg_size());
 135     std::advance(FuncArg, Ins[i].OrigArgIndex);
 136
 137     OriginalArgWasF128.push_back(
 138         originalTypeIsF128(FuncArg->getType(), nullptr));
 139     OriginalArgWasFloat.push_back(FuncArg->getType()->isFloatingPointTy());
 140   }
 141 }