mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-06-26 10:29:57 +00:00
Update makeLibCall to return both the call and the chain associated with the libcall instead of just the call. This allows us to specify libcalls that return void.
LowerCallTo returns a pair with the return value of the call as the first element and the chain associated with the return value as the second element. If we lower a call that has a void return value, LowerCallTo returns an SDValue with a NULL SDNode and the chain for the call. Thus makeLibCall by just returning the first value makes it impossible for you to set up the chain so that the call is not eliminated as dead code. I also updated all references to makeLibCall to reflect the new return type. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@188300 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Michael Gottesman
parent
46f0b6f10a
commit
3add0679d2
|
|
@ -1702,9 +1702,12 @@ public:
|
|||
SDValue &NewLHS, SDValue &NewRHS,
|
||||
ISD::CondCode &CCCode, SDLoc DL) const;
|
||||
|
||||
SDValue makeLibCall(SelectionDAG &DAG, RTLIB::Libcall LC, EVT RetVT,
|
||||
const SDValue *Ops, unsigned NumOps,
|
||||
bool isSigned, SDLoc dl) const;
|
||||
/// Returns a pair of (return value, chain).
|
||||
std::pair<SDValue, SDValue> makeLibCall(SelectionDAG &DAG, RTLIB::Libcall LC,
|
||||
EVT RetVT, const SDValue *Ops,
|
||||
unsigned NumOps, bool isSigned,
|
||||
SDLoc dl, bool doesNotReturn = false,
|
||||
bool isReturnValueUsed = true) const;
|
||||
|
||||
//===--------------------------------------------------------------------===//
|
||||
// TargetLowering Optimization Methods
|
||||
|
|
|
|||
|
|
@ -161,7 +161,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FADD(SDNode *N) {
|
|||
RTLIB::ADD_F80,
|
||||
RTLIB::ADD_F128,
|
||||
RTLIB::ADD_PPCF128),
|
||||
NVT, Ops, 2, false, SDLoc(N));
|
||||
NVT, Ops, 2, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FCEIL(SDNode *N) {
|
||||
|
|
@ -173,7 +173,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FCEIL(SDNode *N) {
|
|||
RTLIB::CEIL_F80,
|
||||
RTLIB::CEIL_F128,
|
||||
RTLIB::CEIL_PPCF128),
|
||||
NVT, &Op, 1, false, SDLoc(N));
|
||||
NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FCOPYSIGN(SDNode *N) {
|
||||
|
|
@ -227,7 +227,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FCOS(SDNode *N) {
|
|||
RTLIB::COS_F80,
|
||||
RTLIB::COS_F128,
|
||||
RTLIB::COS_PPCF128),
|
||||
NVT, &Op, 1, false, SDLoc(N));
|
||||
NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FDIV(SDNode *N) {
|
||||
|
|
@ -240,7 +240,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FDIV(SDNode *N) {
|
|||
RTLIB::DIV_F80,
|
||||
RTLIB::DIV_F128,
|
||||
RTLIB::DIV_PPCF128),
|
||||
NVT, Ops, 2, false, SDLoc(N));
|
||||
NVT, Ops, 2, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP(SDNode *N) {
|
||||
|
|
@ -252,7 +252,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP(SDNode *N) {
|
|||
RTLIB::EXP_F80,
|
||||
RTLIB::EXP_F128,
|
||||
RTLIB::EXP_PPCF128),
|
||||
NVT, &Op, 1, false, SDLoc(N));
|
||||
NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP2(SDNode *N) {
|
||||
|
|
@ -264,7 +264,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP2(SDNode *N) {
|
|||
RTLIB::EXP2_F80,
|
||||
RTLIB::EXP2_F128,
|
||||
RTLIB::EXP2_PPCF128),
|
||||
NVT, &Op, 1, false, SDLoc(N));
|
||||
NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FFLOOR(SDNode *N) {
|
||||
|
|
@ -276,7 +276,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FFLOOR(SDNode *N) {
|
|||
RTLIB::FLOOR_F80,
|
||||
RTLIB::FLOOR_F128,
|
||||
RTLIB::FLOOR_PPCF128),
|
||||
NVT, &Op, 1, false, SDLoc(N));
|
||||
NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG(SDNode *N) {
|
||||
|
|
@ -288,7 +288,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG(SDNode *N) {
|
|||
RTLIB::LOG_F80,
|
||||
RTLIB::LOG_F128,
|
||||
RTLIB::LOG_PPCF128),
|
||||
NVT, &Op, 1, false, SDLoc(N));
|
||||
NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG2(SDNode *N) {
|
||||
|
|
@ -300,7 +300,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG2(SDNode *N) {
|
|||
RTLIB::LOG2_F80,
|
||||
RTLIB::LOG2_F128,
|
||||
RTLIB::LOG2_PPCF128),
|
||||
NVT, &Op, 1, false, SDLoc(N));
|
||||
NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG10(SDNode *N) {
|
||||
|
|
@ -312,7 +312,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG10(SDNode *N) {
|
|||
RTLIB::LOG10_F80,
|
||||
RTLIB::LOG10_F128,
|
||||
RTLIB::LOG10_PPCF128),
|
||||
NVT, &Op, 1, false, SDLoc(N));
|
||||
NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FMA(SDNode *N) {
|
||||
|
|
@ -326,7 +326,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FMA(SDNode *N) {
|
|||
RTLIB::FMA_F80,
|
||||
RTLIB::FMA_F128,
|
||||
RTLIB::FMA_PPCF128),
|
||||
NVT, Ops, 3, false, SDLoc(N));
|
||||
NVT, Ops, 3, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FMUL(SDNode *N) {
|
||||
|
|
@ -339,7 +339,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FMUL(SDNode *N) {
|
|||
RTLIB::MUL_F80,
|
||||
RTLIB::MUL_F128,
|
||||
RTLIB::MUL_PPCF128),
|
||||
NVT, Ops, 2, false, SDLoc(N));
|
||||
NVT, Ops, 2, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FNEARBYINT(SDNode *N) {
|
||||
|
|
@ -351,7 +351,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FNEARBYINT(SDNode *N) {
|
|||
RTLIB::NEARBYINT_F80,
|
||||
RTLIB::NEARBYINT_F128,
|
||||
RTLIB::NEARBYINT_PPCF128),
|
||||
NVT, &Op, 1, false, SDLoc(N));
|
||||
NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FNEG(SDNode *N) {
|
||||
|
|
@ -365,7 +365,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FNEG(SDNode *N) {
|
|||
RTLIB::SUB_F80,
|
||||
RTLIB::SUB_F128,
|
||||
RTLIB::SUB_PPCF128),
|
||||
NVT, Ops, 2, false, SDLoc(N));
|
||||
NVT, Ops, 2, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FP_EXTEND(SDNode *N) {
|
||||
|
|
@ -373,7 +373,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FP_EXTEND(SDNode *N) {
|
|||
SDValue Op = N->getOperand(0);
|
||||
RTLIB::Libcall LC = RTLIB::getFPEXT(Op.getValueType(), N->getValueType(0));
|
||||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_EXTEND!");
|
||||
return TLI.makeLibCall(DAG, LC, NVT, &Op, 1, false, SDLoc(N));
|
||||
return TLI.makeLibCall(DAG, LC, NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
// FIXME: Should we just use 'normal' FP_EXTEND / FP_TRUNC instead of special
|
||||
|
|
@ -382,7 +382,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FP16_TO_FP32(SDNode *N) {
|
|||
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
|
||||
SDValue Op = N->getOperand(0);
|
||||
return TLI.makeLibCall(DAG, RTLIB::FPEXT_F16_F32, NVT, &Op, 1, false,
|
||||
SDLoc(N));
|
||||
SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FP_ROUND(SDNode *N) {
|
||||
|
|
@ -390,7 +390,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FP_ROUND(SDNode *N) {
|
|||
SDValue Op = N->getOperand(0);
|
||||
RTLIB::Libcall LC = RTLIB::getFPROUND(Op.getValueType(), N->getValueType(0));
|
||||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND!");
|
||||
return TLI.makeLibCall(DAG, LC, NVT, &Op, 1, false, SDLoc(N));
|
||||
return TLI.makeLibCall(DAG, LC, NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FPOW(SDNode *N) {
|
||||
|
|
@ -403,7 +403,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FPOW(SDNode *N) {
|
|||
RTLIB::POW_F80,
|
||||
RTLIB::POW_F128,
|
||||
RTLIB::POW_PPCF128),
|
||||
NVT, Ops, 2, false, SDLoc(N));
|
||||
NVT, Ops, 2, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FPOWI(SDNode *N) {
|
||||
|
|
@ -417,7 +417,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FPOWI(SDNode *N) {
|
|||
RTLIB::POWI_F80,
|
||||
RTLIB::POWI_F128,
|
||||
RTLIB::POWI_PPCF128),
|
||||
NVT, Ops, 2, false, SDLoc(N));
|
||||
NVT, Ops, 2, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FREM(SDNode *N) {
|
||||
|
|
@ -430,7 +430,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FREM(SDNode *N) {
|
|||
RTLIB::REM_F80,
|
||||
RTLIB::REM_F128,
|
||||
RTLIB::REM_PPCF128),
|
||||
NVT, Ops, 2, false, SDLoc(N));
|
||||
NVT, Ops, 2, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FRINT(SDNode *N) {
|
||||
|
|
@ -442,7 +442,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FRINT(SDNode *N) {
|
|||
RTLIB::RINT_F80,
|
||||
RTLIB::RINT_F128,
|
||||
RTLIB::RINT_PPCF128),
|
||||
NVT, &Op, 1, false, SDLoc(N));
|
||||
NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FROUND(SDNode *N) {
|
||||
|
|
@ -454,7 +454,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FROUND(SDNode *N) {
|
|||
RTLIB::ROUND_F80,
|
||||
RTLIB::ROUND_F128,
|
||||
RTLIB::ROUND_PPCF128),
|
||||
NVT, &Op, 1, false, SDLoc(N));
|
||||
NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FSIN(SDNode *N) {
|
||||
|
|
@ -466,7 +466,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FSIN(SDNode *N) {
|
|||
RTLIB::SIN_F80,
|
||||
RTLIB::SIN_F128,
|
||||
RTLIB::SIN_PPCF128),
|
||||
NVT, &Op, 1, false, SDLoc(N));
|
||||
NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FSQRT(SDNode *N) {
|
||||
|
|
@ -478,7 +478,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FSQRT(SDNode *N) {
|
|||
RTLIB::SQRT_F80,
|
||||
RTLIB::SQRT_F128,
|
||||
RTLIB::SQRT_PPCF128),
|
||||
NVT, &Op, 1, false, SDLoc(N));
|
||||
NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FSUB(SDNode *N) {
|
||||
|
|
@ -491,7 +491,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FSUB(SDNode *N) {
|
|||
RTLIB::SUB_F80,
|
||||
RTLIB::SUB_F128,
|
||||
RTLIB::SUB_PPCF128),
|
||||
NVT, Ops, 2, false, SDLoc(N));
|
||||
NVT, Ops, 2, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_FTRUNC(SDNode *N) {
|
||||
|
|
@ -503,7 +503,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_FTRUNC(SDNode *N) {
|
|||
RTLIB::TRUNC_F80,
|
||||
RTLIB::TRUNC_F128,
|
||||
RTLIB::TRUNC_PPCF128),
|
||||
NVT, &Op, 1, false, SDLoc(N));
|
||||
NVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatRes_LOAD(SDNode *N) {
|
||||
|
|
@ -598,7 +598,7 @@ SDValue DAGTypeLegalizer::SoftenFloatRes_XINT_TO_FP(SDNode *N) {
|
|||
NVT, N->getOperand(0));
|
||||
return TLI.makeLibCall(DAG, LC,
|
||||
TLI.getTypeToTransformTo(*DAG.getContext(), RVT),
|
||||
&Op, 1, false, dl);
|
||||
&Op, 1, false, dl).first;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -658,7 +658,7 @@ SDValue DAGTypeLegalizer::SoftenFloatOp_FP_ROUND(SDNode *N) {
|
|||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND libcall");
|
||||
|
||||
SDValue Op = GetSoftenedFloat(N->getOperand(0));
|
||||
return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N));
|
||||
return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatOp_BR_CC(SDNode *N) {
|
||||
|
|
@ -689,7 +689,7 @@ SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_SINT(SDNode *N) {
|
|||
RTLIB::Libcall LC = RTLIB::getFPTOSINT(N->getOperand(0).getValueType(), RVT);
|
||||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_SINT!");
|
||||
SDValue Op = GetSoftenedFloat(N->getOperand(0));
|
||||
return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N));
|
||||
return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_UINT(SDNode *N) {
|
||||
|
|
@ -697,14 +697,14 @@ SDValue DAGTypeLegalizer::SoftenFloatOp_FP_TO_UINT(SDNode *N) {
|
|||
RTLIB::Libcall LC = RTLIB::getFPTOUINT(N->getOperand(0).getValueType(), RVT);
|
||||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_UINT!");
|
||||
SDValue Op = GetSoftenedFloat(N->getOperand(0));
|
||||
return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N));
|
||||
return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatOp_FP32_TO_FP16(SDNode *N) {
|
||||
EVT RVT = N->getValueType(0);
|
||||
RTLIB::Libcall LC = RTLIB::FPROUND_F32_F16;
|
||||
SDValue Op = GetSoftenedFloat(N->getOperand(0));
|
||||
return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N));
|
||||
return TLI.makeLibCall(DAG, LC, RVT, &Op, 1, false, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::SoftenFloatOp_SELECT_CC(SDNode *N) {
|
||||
|
|
@ -926,7 +926,7 @@ void DAGTypeLegalizer::ExpandFloatRes_FDIV(SDNode *N, SDValue &Lo,
|
|||
RTLIB::DIV_F128,
|
||||
RTLIB::DIV_PPCF128),
|
||||
N->getValueType(0), Ops, 2, false,
|
||||
SDLoc(N));
|
||||
SDLoc(N)).first;
|
||||
GetPairElements(Call, Lo, Hi);
|
||||
}
|
||||
|
||||
|
|
@ -1000,7 +1000,7 @@ void DAGTypeLegalizer::ExpandFloatRes_FMA(SDNode *N, SDValue &Lo,
|
|||
RTLIB::FMA_F128,
|
||||
RTLIB::FMA_PPCF128),
|
||||
N->getValueType(0), Ops, 3, false,
|
||||
SDLoc(N));
|
||||
SDLoc(N)).first;
|
||||
GetPairElements(Call, Lo, Hi);
|
||||
}
|
||||
|
||||
|
|
@ -1014,7 +1014,7 @@ void DAGTypeLegalizer::ExpandFloatRes_FMUL(SDNode *N, SDValue &Lo,
|
|||
RTLIB::MUL_F128,
|
||||
RTLIB::MUL_PPCF128),
|
||||
N->getValueType(0), Ops, 2, false,
|
||||
SDLoc(N));
|
||||
SDLoc(N)).first;
|
||||
GetPairElements(Call, Lo, Hi);
|
||||
}
|
||||
|
||||
|
|
@ -1128,7 +1128,7 @@ void DAGTypeLegalizer::ExpandFloatRes_FSUB(SDNode *N, SDValue &Lo,
|
|||
RTLIB::SUB_F128,
|
||||
RTLIB::SUB_PPCF128),
|
||||
N->getValueType(0), Ops, 2, false,
|
||||
SDLoc(N));
|
||||
SDLoc(N)).first;
|
||||
GetPairElements(Call, Lo, Hi);
|
||||
}
|
||||
|
||||
|
|
@ -1207,7 +1207,7 @@ void DAGTypeLegalizer::ExpandFloatRes_XINT_TO_FP(SDNode *N, SDValue &Lo,
|
|||
}
|
||||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported XINT_TO_FP!");
|
||||
|
||||
Hi = TLI.makeLibCall(DAG, LC, VT, &Src, 1, true, dl);
|
||||
Hi = TLI.makeLibCall(DAG, LC, VT, &Src, 1, true, dl).first;
|
||||
GetPairElements(Hi, Lo, Hi);
|
||||
}
|
||||
|
||||
|
|
@ -1379,7 +1379,7 @@ SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_SINT(SDNode *N) {
|
|||
|
||||
RTLIB::Libcall LC = RTLIB::getFPTOSINT(N->getOperand(0).getValueType(), RVT);
|
||||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_SINT!");
|
||||
return TLI.makeLibCall(DAG, LC, RVT, &N->getOperand(0), 1, false, dl);
|
||||
return TLI.makeLibCall(DAG, LC, RVT, &N->getOperand(0), 1, false, dl).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_UINT(SDNode *N) {
|
||||
|
|
@ -1412,7 +1412,7 @@ SDValue DAGTypeLegalizer::ExpandFloatOp_FP_TO_UINT(SDNode *N) {
|
|||
RTLIB::Libcall LC = RTLIB::getFPTOUINT(N->getOperand(0).getValueType(), RVT);
|
||||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_TO_UINT!");
|
||||
return TLI.makeLibCall(DAG, LC, N->getValueType(0), &N->getOperand(0), 1,
|
||||
false, dl);
|
||||
false, dl).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::ExpandFloatOp_SELECT_CC(SDNode *N) {
|
||||
|
|
|
|||
|
|
@ -1770,7 +1770,8 @@ void DAGTypeLegalizer::ExpandIntRes_FP_TO_SINT(SDNode *N, SDValue &Lo,
|
|||
SDValue Op = N->getOperand(0);
|
||||
RTLIB::Libcall LC = RTLIB::getFPTOSINT(Op.getValueType(), VT);
|
||||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unexpected fp-to-sint conversion!");
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, &Op, 1, true/*irrelevant*/, dl),
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, &Op, 1, true/*irrelevant*/,
|
||||
dl).first,
|
||||
Lo, Hi);
|
||||
}
|
||||
|
||||
|
|
@ -1781,7 +1782,8 @@ void DAGTypeLegalizer::ExpandIntRes_FP_TO_UINT(SDNode *N, SDValue &Lo,
|
|||
SDValue Op = N->getOperand(0);
|
||||
RTLIB::Libcall LC = RTLIB::getFPTOUINT(Op.getValueType(), VT);
|
||||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unexpected fp-to-uint conversion!");
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, &Op, 1, false/*irrelevant*/, dl),
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, &Op, 1, false/*irrelevant*/,
|
||||
dl).first,
|
||||
Lo, Hi);
|
||||
}
|
||||
|
||||
|
|
@ -1997,7 +1999,8 @@ void DAGTypeLegalizer::ExpandIntRes_MUL(SDNode *N,
|
|||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported MUL!");
|
||||
|
||||
SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, true/*irrelevant*/, dl),
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, true/*irrelevant*/,
|
||||
dl).first,
|
||||
Lo, Hi);
|
||||
}
|
||||
|
||||
|
|
@ -2060,7 +2063,7 @@ void DAGTypeLegalizer::ExpandIntRes_SDIV(SDNode *N,
|
|||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported SDIV!");
|
||||
|
||||
SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, true, dl), Lo, Hi);
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, true, dl).first, Lo, Hi);
|
||||
}
|
||||
|
||||
void DAGTypeLegalizer::ExpandIntRes_Shift(SDNode *N,
|
||||
|
|
@ -2155,7 +2158,8 @@ void DAGTypeLegalizer::ExpandIntRes_Shift(SDNode *N,
|
|||
|
||||
if (LC != RTLIB::UNKNOWN_LIBCALL && TLI.getLibcallName(LC)) {
|
||||
SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, isSigned, dl), Lo, Hi);
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, isSigned, dl).first, Lo,
|
||||
Hi);
|
||||
return;
|
||||
}
|
||||
|
||||
|
|
@ -2238,7 +2242,7 @@ void DAGTypeLegalizer::ExpandIntRes_SREM(SDNode *N,
|
|||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported SREM!");
|
||||
|
||||
SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, true, dl), Lo, Hi);
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, true, dl).first, Lo, Hi);
|
||||
}
|
||||
|
||||
void DAGTypeLegalizer::ExpandIntRes_TRUNCATE(SDNode *N,
|
||||
|
|
@ -2378,7 +2382,7 @@ void DAGTypeLegalizer::ExpandIntRes_UDIV(SDNode *N,
|
|||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported UDIV!");
|
||||
|
||||
SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, false, dl), Lo, Hi);
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, false, dl).first, Lo, Hi);
|
||||
}
|
||||
|
||||
void DAGTypeLegalizer::ExpandIntRes_UREM(SDNode *N,
|
||||
|
|
@ -2398,7 +2402,7 @@ void DAGTypeLegalizer::ExpandIntRes_UREM(SDNode *N,
|
|||
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported UREM!");
|
||||
|
||||
SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, false, dl), Lo, Hi);
|
||||
SplitInteger(TLI.makeLibCall(DAG, LC, VT, Ops, 2, false, dl).first, Lo, Hi);
|
||||
}
|
||||
|
||||
void DAGTypeLegalizer::ExpandIntRes_ZERO_EXTEND(SDNode *N,
|
||||
|
|
@ -2685,7 +2689,7 @@ SDValue DAGTypeLegalizer::ExpandIntOp_SINT_TO_FP(SDNode *N) {
|
|||
RTLIB::Libcall LC = RTLIB::getSINTTOFP(Op.getValueType(), DstVT);
|
||||
assert(LC != RTLIB::UNKNOWN_LIBCALL &&
|
||||
"Don't know how to expand this SINT_TO_FP!");
|
||||
return TLI.makeLibCall(DAG, LC, DstVT, &Op, 1, true, SDLoc(N));
|
||||
return TLI.makeLibCall(DAG, LC, DstVT, &Op, 1, true, SDLoc(N)).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::ExpandIntOp_STORE(StoreSDNode *N, unsigned OpNo) {
|
||||
|
|
@ -2852,7 +2856,7 @@ SDValue DAGTypeLegalizer::ExpandIntOp_UINT_TO_FP(SDNode *N) {
|
|||
RTLIB::Libcall LC = RTLIB::getUINTTOFP(SrcVT, DstVT);
|
||||
assert(LC != RTLIB::UNKNOWN_LIBCALL &&
|
||||
"Don't know how to expand this UINT_TO_FP!");
|
||||
return TLI.makeLibCall(DAG, LC, DstVT, &Op, 1, true, dl);
|
||||
return TLI.makeLibCall(DAG, LC, DstVT, &Op, 1, true, dl).first;
|
||||
}
|
||||
|
||||
SDValue DAGTypeLegalizer::ExpandIntOp_ATOMIC_STORE(SDNode *N) {
|
||||
|
|
|
|||
|
|
@ -1024,20 +1024,23 @@ SDValue DAGTypeLegalizer::LibCallify(RTLIB::Libcall LC, SDNode *N,
|
|||
unsigned NumOps = N->getNumOperands();
|
||||
SDLoc dl(N);
|
||||
if (NumOps == 0) {
|
||||
return TLI.makeLibCall(DAG, LC, N->getValueType(0), 0, 0, isSigned, dl);
|
||||
return TLI.makeLibCall(DAG, LC, N->getValueType(0), 0, 0, isSigned,
|
||||
dl).first;
|
||||
} else if (NumOps == 1) {
|
||||
SDValue Op = N->getOperand(0);
|
||||
return TLI.makeLibCall(DAG, LC, N->getValueType(0), &Op, 1, isSigned, dl);
|
||||
return TLI.makeLibCall(DAG, LC, N->getValueType(0), &Op, 1, isSigned,
|
||||
dl).first;
|
||||
} else if (NumOps == 2) {
|
||||
SDValue Ops[2] = { N->getOperand(0), N->getOperand(1) };
|
||||
return TLI.makeLibCall(DAG, LC, N->getValueType(0), Ops, 2, isSigned, dl);
|
||||
return TLI.makeLibCall(DAG, LC, N->getValueType(0), Ops, 2, isSigned,
|
||||
dl).first;
|
||||
}
|
||||
SmallVector<SDValue, 8> Ops(NumOps);
|
||||
for (unsigned i = 0; i < NumOps; ++i)
|
||||
Ops[i] = N->getOperand(i);
|
||||
|
||||
return TLI.makeLibCall(DAG, LC, N->getValueType(0),
|
||||
&Ops[0], NumOps, isSigned, dl);
|
||||
&Ops[0], NumOps, isSigned, dl).first;
|
||||
}
|
||||
|
||||
// ExpandChainLibCall - Expand a node into a call to a libcall. Similar to
|
||||
|
|
|
|||
|
|
@ -67,10 +67,13 @@ bool TargetLowering::isInTailCallPosition(SelectionDAG &DAG, SDNode *Node,
|
|||
|
||||
/// Generate a libcall taking the given operands as arguments and returning a
|
||||
/// result of type RetVT.
|
||||
SDValue TargetLowering::makeLibCall(SelectionDAG &DAG,
|
||||
RTLIB::Libcall LC, EVT RetVT,
|
||||
const SDValue *Ops, unsigned NumOps,
|
||||
bool isSigned, SDLoc dl) const {
|
||||
std::pair<SDValue, SDValue>
|
||||
TargetLowering::makeLibCall(SelectionDAG &DAG,
|
||||
RTLIB::Libcall LC, EVT RetVT,
|
||||
const SDValue *Ops, unsigned NumOps,
|
||||
bool isSigned, SDLoc dl,
|
||||
bool doesNotReturn,
|
||||
bool isReturnValueUsed) const {
|
||||
TargetLowering::ArgListTy Args;
|
||||
Args.reserve(NumOps);
|
||||
|
||||
|
|
@ -89,11 +92,9 @@ SDValue TargetLowering::makeLibCall(SelectionDAG &DAG,
|
|||
CallLoweringInfo CLI(DAG.getEntryNode(), RetTy, isSigned, !isSigned, false,
|
||||
false, 0, getLibcallCallingConv(LC),
|
||||
/*isTailCall=*/false,
|
||||
/*doesNotReturn=*/false, /*isReturnValueUsed=*/true,
|
||||
Callee, Args, DAG, dl);
|
||||
std::pair<SDValue,SDValue> CallInfo = LowerCallTo(CLI);
|
||||
|
||||
return CallInfo.first;
|
||||
doesNotReturn, isReturnValueUsed, Callee, Args,
|
||||
DAG, dl);
|
||||
return LowerCallTo(CLI);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -183,14 +184,16 @@ void TargetLowering::softenSetCCOperands(SelectionDAG &DAG, EVT VT,
|
|||
// Use the target specific return value for comparions lib calls.
|
||||
EVT RetVT = getCmpLibcallReturnType();
|
||||
SDValue Ops[2] = { NewLHS, NewRHS };
|
||||
NewLHS = makeLibCall(DAG, LC1, RetVT, Ops, 2, false/*sign irrelevant*/, dl);
|
||||
NewLHS = makeLibCall(DAG, LC1, RetVT, Ops, 2, false/*sign irrelevant*/,
|
||||
dl).first;
|
||||
NewRHS = DAG.getConstant(0, RetVT);
|
||||
CCCode = getCmpLibcallCC(LC1);
|
||||
if (LC2 != RTLIB::UNKNOWN_LIBCALL) {
|
||||
SDValue Tmp = DAG.getNode(ISD::SETCC, dl,
|
||||
getSetCCResultType(*DAG.getContext(), RetVT),
|
||||
NewLHS, NewRHS, DAG.getCondCode(CCCode));
|
||||
NewLHS = makeLibCall(DAG, LC2, RetVT, Ops, 2, false/*sign irrelevant*/, dl);
|
||||
NewLHS = makeLibCall(DAG, LC2, RetVT, Ops, 2, false/*sign irrelevant*/,
|
||||
dl).first;
|
||||
NewLHS = DAG.getNode(ISD::SETCC, dl,
|
||||
getSetCCResultType(*DAG.getContext(), RetVT), NewLHS,
|
||||
NewRHS, DAG.getCondCode(getCmpLibcallCC(LC2)));
|
||||
|
|
|
|||
|
|
@ -1875,7 +1875,7 @@ AArch64TargetLowering::LowerFP_ROUND(SDValue Op, SelectionDAG &DAG) const {
|
|||
|
||||
SDValue SrcVal = Op.getOperand(0);
|
||||
return makeLibCall(DAG, LC, Op.getValueType(), &SrcVal, 1,
|
||||
/*isSigned*/ false, SDLoc(Op));
|
||||
/*isSigned*/ false, SDLoc(Op)).first;
|
||||
}
|
||||
|
||||
SDValue
|
||||
|
|
|
|||
Loading…
Reference in New Issue
Block a user