2014-11-07 22:24:31 +08:00
|
|
|
//===---- MipsCCState.cpp - CCState with Mips specific extensions ---------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "MipsCCState.h"
|
|
|
|
#include "MipsSubtarget.h"
|
|
|
|
#include "llvm/IR/Module.h"
|
|
|
|
|
|
|
|
using namespace llvm;
|
|
|
|
|
|
|
|
/// This function returns true if CallSym is a long double emulation routine.
|
|
|
|
static bool isF128SoftLibCall(const char *CallSym) {
|
|
|
|
const char *const LibCalls[] = {
|
|
|
|
"__addtf3", "__divtf3", "__eqtf2", "__extenddftf2",
|
|
|
|
"__extendsftf2", "__fixtfdi", "__fixtfsi", "__fixtfti",
|
|
|
|
"__fixunstfdi", "__fixunstfsi", "__fixunstfti", "__floatditf",
|
|
|
|
"__floatsitf", "__floattitf", "__floatunditf", "__floatunsitf",
|
|
|
|
"__floatuntitf", "__getf2", "__gttf2", "__letf2",
|
|
|
|
"__lttf2", "__multf3", "__netf2", "__powitf2",
|
|
|
|
"__subtf3", "__trunctfdf2", "__trunctfsf2", "__unordtf2",
|
|
|
|
"ceill", "copysignl", "cosl", "exp2l",
|
|
|
|
"expl", "floorl", "fmal", "fmodl",
|
|
|
|
"log10l", "log2l", "logl", "nearbyintl",
|
2016-03-14 20:50:23 +08:00
|
|
|
"powl", "rintl", "roundl", "sinl",
|
|
|
|
"sqrtl", "truncl"};
|
2014-11-07 22:24:31 +08:00
|
|
|
|
|
|
|
// Check that LibCalls is sorted alphabetically.
|
2015-10-18 05:32:26 +08:00
|
|
|
auto Comp = [](const char *S1, const char *S2) { return strcmp(S1, S2) < 0; };
|
|
|
|
assert(std::is_sorted(std::begin(LibCalls), std::end(LibCalls), Comp));
|
|
|
|
return std::binary_search(std::begin(LibCalls), std::end(LibCalls),
|
|
|
|
CallSym, Comp);
|
2014-11-07 22:24:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/// This function returns true if Ty is fp128, {f128} or i128 which was
|
|
|
|
/// originally a fp128.
|
2017-04-26 19:10:38 +08:00
|
|
|
static bool originalTypeIsF128(const Type *Ty, const char *Func) {
|
2014-11-07 22:24:31 +08:00
|
|
|
if (Ty->isFP128Ty())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
if (Ty->isStructTy() && Ty->getStructNumElements() == 1 &&
|
|
|
|
Ty->getStructElementType(0)->isFP128Ty())
|
|
|
|
return true;
|
|
|
|
|
|
|
|
// If the Ty is i128 and the function being called is a long double emulation
|
|
|
|
// routine, then the original type is f128.
|
2017-04-26 19:10:38 +08:00
|
|
|
return (Func && Ty->isIntegerTy(128) && isF128SoftLibCall(Func));
|
2014-11-07 22:24:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
MipsCCState::SpecialCallingConvType
|
|
|
|
MipsCCState::getSpecialCallingConvForCallee(const SDNode *Callee,
|
|
|
|
const MipsSubtarget &Subtarget) {
|
|
|
|
MipsCCState::SpecialCallingConvType SpecialCallingConv = NoSpecialCallingConv;
|
|
|
|
if (Subtarget.inMips16HardFloat()) {
|
|
|
|
if (const GlobalAddressSDNode *G =
|
|
|
|
dyn_cast<const GlobalAddressSDNode>(Callee)) {
|
|
|
|
llvm::StringRef Sym = G->getGlobal()->getName();
|
|
|
|
Function *F = G->getGlobal()->getParent()->getFunction(Sym);
|
|
|
|
if (F && F->hasFnAttribute("__Mips16RetHelper")) {
|
|
|
|
SpecialCallingConv = Mips16RetHelperConv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return SpecialCallingConv;
|
|
|
|
}
|
|
|
|
|
|
|
|
void MipsCCState::PreAnalyzeCallResultForF128(
|
|
|
|
const SmallVectorImpl<ISD::InputArg> &Ins,
|
2017-04-26 19:10:38 +08:00
|
|
|
const Type *RetTy, const char *Call) {
|
2014-11-08 00:54:21 +08:00
|
|
|
for (unsigned i = 0; i < Ins.size(); ++i) {
|
2014-11-07 22:24:31 +08:00
|
|
|
OriginalArgWasF128.push_back(
|
2017-04-26 19:10:38 +08:00
|
|
|
originalTypeIsF128(RetTy, Call));
|
|
|
|
OriginalArgWasFloat.push_back(RetTy->isFloatingPointTy());
|
2014-11-08 00:54:21 +08:00
|
|
|
}
|
2014-11-07 22:24:31 +08:00
|
|
|
}
|
|
|
|
|
2017-04-08 01:25:05 +08:00
|
|
|
/// Identify lowered values that originated from f128 arguments and record
|
|
|
|
/// this for use by RetCC_MipsN.
|
2014-11-07 22:24:31 +08:00
|
|
|
void MipsCCState::PreAnalyzeReturnForF128(
|
|
|
|
const SmallVectorImpl<ISD::OutputArg> &Outs) {
|
|
|
|
const MachineFunction &MF = getMachineFunction();
|
2014-11-08 00:54:21 +08:00
|
|
|
for (unsigned i = 0; i < Outs.size(); ++i) {
|
2014-11-07 22:24:31 +08:00
|
|
|
OriginalArgWasF128.push_back(
|
|
|
|
originalTypeIsF128(MF.getFunction()->getReturnType(), nullptr));
|
2014-11-08 00:54:21 +08:00
|
|
|
OriginalArgWasFloat.push_back(
|
|
|
|
MF.getFunction()->getReturnType()->isFloatingPointTy());
|
|
|
|
}
|
2014-11-07 22:24:31 +08:00
|
|
|
}
|
|
|
|
|
2017-04-08 01:25:05 +08:00
|
|
|
/// Identify lowered values that originated from f128 arguments and record
|
2014-11-07 22:24:31 +08:00
|
|
|
/// this.
|
|
|
|
void MipsCCState::PreAnalyzeCallOperands(
|
|
|
|
const SmallVectorImpl<ISD::OutputArg> &Outs,
|
|
|
|
std::vector<TargetLowering::ArgListEntry> &FuncArgs,
|
2017-04-26 19:10:38 +08:00
|
|
|
const char *Func) {
|
2014-11-07 22:24:31 +08:00
|
|
|
for (unsigned i = 0; i < Outs.size(); ++i) {
|
2017-04-08 01:25:05 +08:00
|
|
|
OriginalArgWasF128.push_back(
|
2017-04-26 19:10:38 +08:00
|
|
|
originalTypeIsF128(FuncArgs[Outs[i].OrigArgIndex].Ty, Func));
|
2017-04-08 01:25:05 +08:00
|
|
|
OriginalArgWasFloat.push_back(
|
|
|
|
FuncArgs[Outs[i].OrigArgIndex].Ty->isFloatingPointTy());
|
2014-11-07 22:24:31 +08:00
|
|
|
CallOperandIsFixed.push_back(Outs[i].IsFixed);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2017-04-08 01:25:05 +08:00
|
|
|
/// Identify lowered values that originated from f128 arguments and record
|
|
|
|
/// this.
|
2014-11-07 22:24:31 +08:00
|
|
|
void MipsCCState::PreAnalyzeFormalArgumentsForF128(
|
|
|
|
const SmallVectorImpl<ISD::InputArg> &Ins) {
|
|
|
|
const MachineFunction &MF = getMachineFunction();
|
|
|
|
for (unsigned i = 0; i < Ins.size(); ++i) {
|
|
|
|
Function::const_arg_iterator FuncArg = MF.getFunction()->arg_begin();
|
|
|
|
|
|
|
|
// SRet arguments cannot originate from f128 or {f128} returns so we just
|
|
|
|
// push false. We have to handle this specially since SRet arguments
|
|
|
|
// aren't mapped to an original argument.
|
|
|
|
if (Ins[i].Flags.isSRet()) {
|
|
|
|
OriginalArgWasF128.push_back(false);
|
2014-11-10 23:57:53 +08:00
|
|
|
OriginalArgWasFloat.push_back(false);
|
2014-11-07 22:24:31 +08:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
2015-02-17 02:10:47 +08:00
|
|
|
assert(Ins[i].getOrigArgIndex() < MF.getFunction()->arg_size());
|
|
|
|
std::advance(FuncArg, Ins[i].getOrigArgIndex());
|
2014-11-07 22:24:31 +08:00
|
|
|
|
|
|
|
OriginalArgWasF128.push_back(
|
|
|
|
originalTypeIsF128(FuncArg->getType(), nullptr));
|
2014-11-08 00:54:21 +08:00
|
|
|
OriginalArgWasFloat.push_back(FuncArg->getType()->isFloatingPointTy());
|
2014-11-07 22:24:31 +08:00
|
|
|
}
|
|
|
|
}
|