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 // Check that LibCalls is sorted alphabetically. 33 auto Comp = [](const char *S1, const char *S2) { return strcmp(S1, S2) < 0; }; 34 assert(std::is_sorted(std::begin(LibCalls), std::end(LibCalls), Comp)); 35 return std::binary_search(std::begin(LibCalls), std::end(LibCalls), 36 CallSym, Comp); 37 } 38 39 /// This function returns true if Ty is fp128, {f128} or i128 which was 40 /// originally a fp128. 41 static bool originalTypeIsF128(Type *Ty, const SDNode *CallNode) { 42 if (Ty->isFP128Ty()) 43 return true; 44 45 if (Ty->isStructTy() && Ty->getStructNumElements() == 1 && 46 Ty->getStructElementType(0)->isFP128Ty()) 47 return true; 48 49 const ExternalSymbolSDNode *ES = 50 dyn_cast_or_null<const ExternalSymbolSDNode>(CallNode); 51 52 // If the Ty is i128 and the function being called is a long double emulation 53 // routine, then the original type is f128. 54 return (ES && Ty->isIntegerTy(128) && isF128SoftLibCall(ES->getSymbol())); 55 } 56 57 MipsCCState::SpecialCallingConvType 58 MipsCCState::getSpecialCallingConvForCallee(const SDNode *Callee, 59 const MipsSubtarget &Subtarget) { 60 MipsCCState::SpecialCallingConvType SpecialCallingConv = NoSpecialCallingConv; 61 if (Subtarget.inMips16HardFloat()) { 62 if (const GlobalAddressSDNode *G = 63 dyn_cast<const GlobalAddressSDNode>(Callee)) { 64 llvm::StringRef Sym = G->getGlobal()->getName(); 65 Function *F = G->getGlobal()->getParent()->getFunction(Sym); 66 if (F && F->hasFnAttribute("__Mips16RetHelper")) { 67 SpecialCallingConv = Mips16RetHelperConv; 68 } 69 } 70 } 71 return SpecialCallingConv; 72 } 73 74 void MipsCCState::PreAnalyzeCallResultForF128( 75 const SmallVectorImpl<ISD::InputArg> &Ins, 76 const TargetLowering::CallLoweringInfo &CLI) { 77 for (unsigned i = 0; i < Ins.size(); ++i) { 78 OriginalArgWasF128.push_back( 79 originalTypeIsF128(CLI.RetTy, CLI.Callee.getNode())); 80 OriginalArgWasFloat.push_back(CLI.RetTy->isFloatingPointTy()); 81 } 82 } 83 84 /// Identify lowered values that originated from f128 arguments and record 85 /// this for use by RetCC_MipsN. 86 void MipsCCState::PreAnalyzeReturnForF128( 87 const SmallVectorImpl<ISD::OutputArg> &Outs) { 88 const MachineFunction &MF = getMachineFunction(); 89 for (unsigned i = 0; i < Outs.size(); ++i) { 90 OriginalArgWasF128.push_back( 91 originalTypeIsF128(MF.getFunction()->getReturnType(), nullptr)); 92 OriginalArgWasFloat.push_back( 93 MF.getFunction()->getReturnType()->isFloatingPointTy()); 94 } 95 } 96 97 /// Identify lowered values that originated from f128 arguments and record 98 /// this. 99 void MipsCCState::PreAnalyzeCallOperands( 100 const SmallVectorImpl<ISD::OutputArg> &Outs, 101 std::vector<TargetLowering::ArgListEntry> &FuncArgs, 102 const SDNode *CallNode) { 103 for (unsigned i = 0; i < Outs.size(); ++i) { 104 OriginalArgWasF128.push_back( 105 originalTypeIsF128(FuncArgs[Outs[i].OrigArgIndex].Ty, CallNode)); 106 OriginalArgWasFloat.push_back( 107 FuncArgs[Outs[i].OrigArgIndex].Ty->isFloatingPointTy()); 108 CallOperandIsFixed.push_back(Outs[i].IsFixed); 109 } 110 } 111 112 /// Identify lowered values that originated from f128 arguments and record 113 /// this. 114 void MipsCCState::PreAnalyzeFormalArgumentsForF128( 115 const SmallVectorImpl<ISD::InputArg> &Ins) { 116 const MachineFunction &MF = getMachineFunction(); 117 for (unsigned i = 0; i < Ins.size(); ++i) { 118 Function::const_arg_iterator FuncArg = MF.getFunction()->arg_begin(); 119 120 // SRet arguments cannot originate from f128 or {f128} returns so we just 121 // push false. We have to handle this specially since SRet arguments 122 // aren't mapped to an original argument. 123 if (Ins[i].Flags.isSRet()) { 124 OriginalArgWasF128.push_back(false); 125 OriginalArgWasFloat.push_back(false); 126 continue; 127 } 128 129 assert(Ins[i].getOrigArgIndex() < MF.getFunction()->arg_size()); 130 std::advance(FuncArg, Ins[i].getOrigArgIndex()); 131 132 OriginalArgWasF128.push_back( 133 originalTypeIsF128(FuncArg->getType(), nullptr)); 134 OriginalArgWasFloat.push_back(FuncArg->getType()->isFloatingPointTy()); 135 } 136 } 137