MipsCCState.cpp revision 303975 
1271294Sngie//===---- MipsCCState.cpp - CCState with Mips specific extensions ---------===//
2271294Sngie//
3271294Sngie//                     The LLVM Compiler Infrastructure
4271294Sngie//
5271294Sngie// This file is distributed under the University of Illinois Open Source
6271294Sngie// License. See LICENSE.TXT for details.
7271294Sngie//
8271294Sngie//===----------------------------------------------------------------------===//
9271294Sngie
10271294Sngie#include "MipsCCState.h"
11271294Sngie#include "MipsSubtarget.h"
12271294Sngie#include "llvm/IR/Module.h"
13271294Sngie
14271294Sngieusing namespace llvm;
15271294Sngie
16271294Sngie/// This function returns true if CallSym is a long double emulation routine.
17271294Sngiestatic bool isF128SoftLibCall(const char *CallSym) {
18271294Sngie  const char *const LibCalls[] = {
19271294Sngie      "__addtf3",      "__divtf3",     "__eqtf2",       "__extenddftf2",
20271294Sngie      "__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.
41static 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
57MipsCCState::SpecialCallingConvType
58MipsCCState::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
74void 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.
86void 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.
99void 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.
114void 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