This is an archive of the discontinued LLVM Phabricator instance.

Differential D70736

[LegalizeTypes] Add SoftenFloatRes_Unary and SoftenFloatRes_Binary functions to factor repeated patterns out of many of the SoftenFloatRes_* functions
ClosedPublic

Authored by craig.topper on Nov 26 2019, 11:47 AM.

Details

Reviewers
efriedma
Commits
rG9b08366f5746: [LegalizeTypes] Add SoftenFloatRes_Unary and SoftenFloatRes_Binary functions to…
Summary

This has been factored out of D70654 which will add strict FP support to these functions. By making the helpers we avoid repeating even more code.

Diff Detail

Event Timeline

craig.topper created this revision.Nov 26 2019, 11:47 AM
Herald added a project: Restricted Project. · View Herald TranscriptNov 26 2019, 11:47 AM
Herald added a subscriber: hiraditya. · View Herald Transcript
craig.topper marked an inline comment as done.Nov 26 2019, 11:47 AM
craig.topper added inline comments.
llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp
200–205

Are these functions simple enough now that we should just inline this into the switch?

efriedma accepted this revision.Nov 26 2019, 12:33 PM

LGTM

llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp
200–205

Inlining wouldn't make it easier to read, I think.

We could turn the opcode->rtlib call mapping into a table, then merge all the switch cases, if you wanted to. But I don't think that's necessary.

This revision is now accepted and ready to land.Nov 26 2019, 12:33 PM
Closed by commit rG9b08366f5746: [LegalizeTypes] Add SoftenFloatRes_Unary and SoftenFloatRes_Binary functions to… (authored by craig.topper). · Explain WhyNov 26 2019, 1:08 PM
This revision was automatically updated to reflect the committed changes.

Revision Contents

PathSize
llvm/
lib/
CodeGen/
SelectionDAG/
436 lines
2 lines

Diff 231129

llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp

Show First 20 Lines • Show All 106 Lines • ▼ Show 20 Lines#endif
// If R is null, the sub-method took care of registering the result. // If R is null, the sub-method took care of registering the result.
if (R.getNode()) { if (R.getNode()) {
assert(R.getNode() != N); assert(R.getNode() != N);
SetSoftenedFloat(SDValue(N, ResNo), R); SetSoftenedFloat(SDValue(N, ResNo), R);
} }
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_Unary(SDNode *N, RTLIB::Libcall LC) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
assert(N->getNumOperands() == 1 && "Unexpected number of operands!");
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpVT = N->getOperand(0).getValueType();
CallOptions.setTypeListBeforeSoften(OpVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, LC, NVT, Op, CallOptions, SDLoc(N)).first;
}
SDValue DAGTypeLegalizer::SoftenFloatRes_Binary(SDNode *N, RTLIB::Libcall LC) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
assert(N->getNumOperands() == 2 && "Unexpected number of operands!");
SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
GetSoftenedFloat(N->getOperand(1)) };
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[2] = { N->getOperand(0).getValueType(),
N->getOperand(1).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, LC, NVT, Ops, CallOptions, SDLoc(N)).first;
}
SDValue DAGTypeLegalizer::SoftenFloatRes_BITCAST(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_BITCAST(SDNode *N) {
return BitConvertToInteger(N->getOperand(0)); return BitConvertToInteger(N->getOperand(0));
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_MERGE_VALUES(SDNode *N, SDValue DAGTypeLegalizer::SoftenFloatRes_MERGE_VALUES(SDNode *N,
unsigned ResNo) { unsigned ResNo) {
SDValue Op = DisintegrateMERGE_VALUES(N, ResNo); SDValue Op = DisintegrateMERGE_VALUES(N, ResNo);
return BitConvertToInteger(Op); return BitConvertToInteger(Op);
▲ Show 20 Lines • Show All 47 Lines • ▼ Show 20 LinesSDValue DAGTypeLegalizer::SoftenFloatRes_FABS(SDNode *N) {
APInt API = APInt::getAllOnesValue(Size); APInt API = APInt::getAllOnesValue(Size);
API.clearBit(Size - 1); API.clearBit(Size - 1);
SDValue Mask = DAG.getConstant(API, SDLoc(N), NVT); SDValue Mask = DAG.getConstant(API, SDLoc(N), NVT);
SDValue Op = GetSoftenedFloat(N->getOperand(0)); SDValue Op = GetSoftenedFloat(N->getOperand(0));
return DAG.getNode(ISD::AND, SDLoc(N), NVT, Op, Mask); return DAG.getNode(ISD::AND, SDLoc(N), NVT, Op, Mask);
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FMINNUM(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FMINNUM(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Binary(N, GetFPLibCall(N->getValueType(0),
SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
GetSoftenedFloat(N->getOperand(1)) };
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[2] = { N->getOperand(0).getValueType(),
N->getOperand(1).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::FMIN_F32, RTLIB::FMIN_F32,
RTLIB::FMIN_F64, RTLIB::FMIN_F64,
RTLIB::FMIN_F80, RTLIB::FMIN_F80,
RTLIB::FMIN_F128, RTLIB::FMIN_F128,
RTLIB::FMIN_PPCF128), RTLIB::FMIN_PPCF128));
craig.topperAuthorUnsubmitted
Done
ReplyInline Actions

Are these functions simple enough now that we should just inline this into the switch?

craig.topper: Are these functions simple enough now that we should just inline this into the switch?
efriedmaUnsubmitted
Not Done
ReplyInline Actions

Inlining wouldn't make it easier to read, I think.

We could turn the opcode->rtlib call mapping into a table, then merge all the switch cases, if you wanted to. But I don't think that's necessary.

efriedma: Inlining wouldn't make it easier to read, I think. We could turn the opcode->rtlib call…
NVT, Ops, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FMAXNUM(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FMAXNUM(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Binary(N, GetFPLibCall(N->getValueType(0),
SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
GetSoftenedFloat(N->getOperand(1)) };
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[2] = { N->getOperand(0).getValueType(),
N->getOperand(1).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::FMAX_F32, RTLIB::FMAX_F32,
RTLIB::FMAX_F64, RTLIB::FMAX_F64,
RTLIB::FMAX_F80, RTLIB::FMAX_F80,
RTLIB::FMAX_F128, RTLIB::FMAX_F128,
RTLIB::FMAX_PPCF128), RTLIB::FMAX_PPCF128));
NVT, Ops, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FADD(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FADD(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Binary(N, GetFPLibCall(N->getValueType(0),
SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
GetSoftenedFloat(N->getOperand(1)) };
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[2] = { N->getOperand(0).getValueType(),
N->getOperand(1).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::ADD_F32, RTLIB::ADD_F32,
RTLIB::ADD_F64, RTLIB::ADD_F64,
RTLIB::ADD_F80, RTLIB::ADD_F80,
RTLIB::ADD_F128, RTLIB::ADD_F128,
RTLIB::ADD_PPCF128), RTLIB::ADD_PPCF128));
NVT, Ops, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FCBRT(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FCBRT(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDValue Op = GetSoftenedFloat(N->getOperand(0)); SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions; TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() }; EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true); CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0), return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::CBRT_F32, RTLIB::CBRT_F32,
RTLIB::CBRT_F64, RTLIB::CBRT_F64,
RTLIB::CBRT_F80, RTLIB::CBRT_F80,
RTLIB::CBRT_F128, RTLIB::CBRT_F128,
RTLIB::CBRT_PPCF128), RTLIB::CBRT_PPCF128),
NVT, Op, CallOptions, SDLoc(N)).first; NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FCEIL(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FCEIL(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::CEIL_F32, RTLIB::CEIL_F32,
RTLIB::CEIL_F64, RTLIB::CEIL_F64,
RTLIB::CEIL_F80, RTLIB::CEIL_F80,
RTLIB::CEIL_F128, RTLIB::CEIL_F128,
RTLIB::CEIL_PPCF128), RTLIB::CEIL_PPCF128));
NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FCOPYSIGN(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FCOPYSIGN(SDNode *N) {
SDValue LHS = GetSoftenedFloat(N->getOperand(0)); SDValue LHS = GetSoftenedFloat(N->getOperand(0));
SDValue RHS = BitConvertToInteger(N->getOperand(1)); SDValue RHS = BitConvertToInteger(N->getOperand(1));
SDLoc dl(N); SDLoc dl(N);
EVT LVT = LHS.getValueType(); EVT LVT = LHS.getValueType();
Show All 35 LinesSDValue DAGTypeLegalizer::SoftenFloatRes_FCOPYSIGN(SDNode *N) {
Mask = DAG.getNode(ISD::SUB, dl, LVT, Mask, DAG.getConstant(1, dl, LVT)); Mask = DAG.getNode(ISD::SUB, dl, LVT, Mask, DAG.getConstant(1, dl, LVT));
LHS = DAG.getNode(ISD::AND, dl, LVT, LHS, Mask); LHS = DAG.getNode(ISD::AND, dl, LVT, LHS, Mask);
// Or the value with the sign bit. // Or the value with the sign bit.
return DAG.getNode(ISD::OR, dl, LVT, LHS, SignBit); return DAG.getNode(ISD::OR, dl, LVT, LHS, SignBit);
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FCOS(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FCOS(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::COS_F32, RTLIB::COS_F32,
RTLIB::COS_F64, RTLIB::COS_F64,
RTLIB::COS_F80, RTLIB::COS_F80,
RTLIB::COS_F128, RTLIB::COS_F128,
RTLIB::COS_PPCF128), RTLIB::COS_PPCF128));
NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FDIV(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FDIV(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Binary(N, GetFPLibCall(N->getValueType(0),
SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
GetSoftenedFloat(N->getOperand(1)) };
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[2] = { N->getOperand(0).getValueType(),
N->getOperand(1).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::DIV_F32, RTLIB::DIV_F32,
RTLIB::DIV_F64, RTLIB::DIV_F64,
RTLIB::DIV_F80, RTLIB::DIV_F80,
RTLIB::DIV_F128, RTLIB::DIV_F128,
RTLIB::DIV_PPCF128), RTLIB::DIV_PPCF128));
NVT, Ops, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::EXP_F32, RTLIB::EXP_F32,
RTLIB::EXP_F64, RTLIB::EXP_F64,
RTLIB::EXP_F80, RTLIB::EXP_F80,
RTLIB::EXP_F128, RTLIB::EXP_F128,
RTLIB::EXP_PPCF128), RTLIB::EXP_PPCF128));
NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP2(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FEXP2(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::EXP2_F32, RTLIB::EXP2_F32,
RTLIB::EXP2_F64, RTLIB::EXP2_F64,
RTLIB::EXP2_F80, RTLIB::EXP2_F80,
RTLIB::EXP2_F128, RTLIB::EXP2_F128,
RTLIB::EXP2_PPCF128), RTLIB::EXP2_PPCF128));
NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FFLOOR(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FFLOOR(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::FLOOR_F32, RTLIB::FLOOR_F32,
RTLIB::FLOOR_F64, RTLIB::FLOOR_F64,
RTLIB::FLOOR_F80, RTLIB::FLOOR_F80,
RTLIB::FLOOR_F128, RTLIB::FLOOR_F128,
RTLIB::FLOOR_PPCF128), RTLIB::FLOOR_PPCF128));
NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::LOG_F32, RTLIB::LOG_F32,
RTLIB::LOG_F64, RTLIB::LOG_F64,
RTLIB::LOG_F80, RTLIB::LOG_F80,
RTLIB::LOG_F128, RTLIB::LOG_F128,
RTLIB::LOG_PPCF128), RTLIB::LOG_PPCF128));
NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG2(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG2(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::LOG2_F32, RTLIB::LOG2_F32,
RTLIB::LOG2_F64, RTLIB::LOG2_F64,
RTLIB::LOG2_F80, RTLIB::LOG2_F80,
RTLIB::LOG2_F128, RTLIB::LOG2_F128,
RTLIB::LOG2_PPCF128), RTLIB::LOG2_PPCF128));
NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG10(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FLOG10(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::LOG10_F32, RTLIB::LOG10_F32,
RTLIB::LOG10_F64, RTLIB::LOG10_F64,
RTLIB::LOG10_F80, RTLIB::LOG10_F80,
RTLIB::LOG10_F128, RTLIB::LOG10_F128,
RTLIB::LOG10_PPCF128), RTLIB::LOG10_PPCF128));
NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FMA(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FMA(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDValue Ops[3] = { GetSoftenedFloat(N->getOperand(0)), SDValue Ops[3] = { GetSoftenedFloat(N->getOperand(0)),
GetSoftenedFloat(N->getOperand(1)), GetSoftenedFloat(N->getOperand(1)),
GetSoftenedFloat(N->getOperand(2)) }; GetSoftenedFloat(N->getOperand(2)) };
TargetLowering::MakeLibCallOptions CallOptions; TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[3] = { N->getOperand(0).getValueType(), EVT OpsVT[3] = { N->getOperand(0).getValueType(),
N->getOperand(1).getValueType(), N->getOperand(1).getValueType(),
N->getOperand(2).getValueType() }; N->getOperand(2).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true); CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0), return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::FMA_F32, RTLIB::FMA_F32,
RTLIB::FMA_F64, RTLIB::FMA_F64,
RTLIB::FMA_F80, RTLIB::FMA_F80,
RTLIB::FMA_F128, RTLIB::FMA_F128,
RTLIB::FMA_PPCF128), RTLIB::FMA_PPCF128),
NVT, Ops, CallOptions, SDLoc(N)).first; NVT, Ops, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FMUL(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FMUL(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Binary(N, GetFPLibCall(N->getValueType(0),
SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
GetSoftenedFloat(N->getOperand(1)) };
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[2] = { N->getOperand(0).getValueType(),
N->getOperand(1).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::MUL_F32, RTLIB::MUL_F32,
RTLIB::MUL_F64, RTLIB::MUL_F64,
RTLIB::MUL_F80, RTLIB::MUL_F80,
RTLIB::MUL_F128, RTLIB::MUL_F128,
RTLIB::MUL_PPCF128), RTLIB::MUL_PPCF128));
NVT, Ops, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FNEARBYINT(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FNEARBYINT(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::NEARBYINT_F32, RTLIB::NEARBYINT_F32,
RTLIB::NEARBYINT_F64, RTLIB::NEARBYINT_F64,
RTLIB::NEARBYINT_F80, RTLIB::NEARBYINT_F80,
RTLIB::NEARBYINT_F128, RTLIB::NEARBYINT_F128,
RTLIB::NEARBYINT_PPCF128), RTLIB::NEARBYINT_PPCF128));
NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FNEG(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FNEG(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0));
SDLoc dl(N); SDLoc dl(N);
EVT FloatVT = N->getValueType(0); EVT FloatVT = N->getValueType(0);
if (FloatVT == MVT::f32 || FloatVT == MVT::f64 || FloatVT == MVT::f128) { if (FloatVT == MVT::f32 || FloatVT == MVT::f64 || FloatVT == MVT::f128) {
▲ Show 20 Lines • Show All 78 Lines • ▼ Show 20 LinesSDValue DAGTypeLegalizer::SoftenFloatRes_FP_ROUND(SDNode *N) {
assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND!"); assert(LC != RTLIB::UNKNOWN_LIBCALL && "Unsupported FP_ROUND!");
TargetLowering::MakeLibCallOptions CallOptions; TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() }; EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true); CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, LC, NVT, Op, CallOptions, SDLoc(N)).first; return TLI.makeLibCall(DAG, LC, NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FPOW(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FPOW(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Binary(N, GetFPLibCall(N->getValueType(0),
SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
GetSoftenedFloat(N->getOperand(1)) };
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[2] = { N->getOperand(0).getValueType(),
N->getOperand(1).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::POW_F32, RTLIB::POW_F32,
RTLIB::POW_F64, RTLIB::POW_F64,
RTLIB::POW_F80, RTLIB::POW_F80,
RTLIB::POW_F128, RTLIB::POW_F128,
RTLIB::POW_PPCF128), RTLIB::POW_PPCF128));
NVT, Ops, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FPOWI(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FPOWI(SDNode *N) {
assert(N->getOperand(1).getValueType() == MVT::i32 && assert(N->getOperand(1).getValueType() == MVT::i32 &&
"Unsupported power type!"); "Unsupported power type!");
RTLIB::Libcall LC = GetFPLibCall(N->getValueType(0), RTLIB::Libcall LC = GetFPLibCall(N->getValueType(0),
RTLIB::POWI_F32, RTLIB::POWI_F32,
RTLIB::POWI_F64, RTLIB::POWI_F64,
Show All 12 LinesSDValue DAGTypeLegalizer::SoftenFloatRes_FPOWI(SDNode *N) {
TargetLowering::MakeLibCallOptions CallOptions; TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[2] = { N->getOperand(0).getValueType(), EVT OpsVT[2] = { N->getOperand(0).getValueType(),
N->getOperand(1).getValueType() }; N->getOperand(1).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true); CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, LC, NVT, Ops, CallOptions, SDLoc(N)).first; return TLI.makeLibCall(DAG, LC, NVT, Ops, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FREM(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FREM(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Binary(N, GetFPLibCall(N->getValueType(0),
SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
GetSoftenedFloat(N->getOperand(1)) };
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[2] = { N->getOperand(0).getValueType(),
N->getOperand(1).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::REM_F32, RTLIB::REM_F32,
RTLIB::REM_F64, RTLIB::REM_F64,
RTLIB::REM_F80, RTLIB::REM_F80,
RTLIB::REM_F128, RTLIB::REM_F128,
RTLIB::REM_PPCF128), RTLIB::REM_PPCF128));
NVT, Ops, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FRINT(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FRINT(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::RINT_F32, RTLIB::RINT_F32,
RTLIB::RINT_F64, RTLIB::RINT_F64,
RTLIB::RINT_F80, RTLIB::RINT_F80,
RTLIB::RINT_F128, RTLIB::RINT_F128,
RTLIB::RINT_PPCF128), RTLIB::RINT_PPCF128));
NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FROUND(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FROUND(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::ROUND_F32, RTLIB::ROUND_F32,
RTLIB::ROUND_F64, RTLIB::ROUND_F64,
RTLIB::ROUND_F80, RTLIB::ROUND_F80,
RTLIB::ROUND_F128, RTLIB::ROUND_F128,
RTLIB::ROUND_PPCF128), RTLIB::ROUND_PPCF128));
NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FSIN(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FSIN(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::SIN_F32, RTLIB::SIN_F32,
RTLIB::SIN_F64, RTLIB::SIN_F64,
RTLIB::SIN_F80, RTLIB::SIN_F80,
RTLIB::SIN_F128, RTLIB::SIN_F128,
RTLIB::SIN_PPCF128), RTLIB::SIN_PPCF128));
NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FSQRT(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FSQRT(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::SQRT_F32, RTLIB::SQRT_F32,
RTLIB::SQRT_F64, RTLIB::SQRT_F64,
RTLIB::SQRT_F80, RTLIB::SQRT_F80,
RTLIB::SQRT_F128, RTLIB::SQRT_F128,
RTLIB::SQRT_PPCF128), RTLIB::SQRT_PPCF128));
NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FSUB(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FSUB(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Binary(N, GetFPLibCall(N->getValueType(0),
SDValue Ops[2] = { GetSoftenedFloat(N->getOperand(0)),
GetSoftenedFloat(N->getOperand(1)) };
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[2] = { N->getOperand(0).getValueType(),
N->getOperand(1).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::SUB_F32, RTLIB::SUB_F32,
RTLIB::SUB_F64, RTLIB::SUB_F64,
RTLIB::SUB_F80, RTLIB::SUB_F80,
RTLIB::SUB_F128, RTLIB::SUB_F128,
RTLIB::SUB_PPCF128), RTLIB::SUB_PPCF128));
NVT, Ops, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_FTRUNC(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_FTRUNC(SDNode *N) {
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), N->getValueType(0)); return SoftenFloatRes_Unary(N, GetFPLibCall(N->getValueType(0),
SDValue Op = GetSoftenedFloat(N->getOperand(0));
TargetLowering::MakeLibCallOptions CallOptions;
EVT OpsVT[1] = { N->getOperand(0).getValueType() };
CallOptions.setTypeListBeforeSoften(OpsVT, N->getValueType(0), true);
return TLI.makeLibCall(DAG, GetFPLibCall(N->getValueType(0),
RTLIB::TRUNC_F32, RTLIB::TRUNC_F32,
RTLIB::TRUNC_F64, RTLIB::TRUNC_F64,
RTLIB::TRUNC_F80, RTLIB::TRUNC_F80,
RTLIB::TRUNC_F128, RTLIB::TRUNC_F128,
RTLIB::TRUNC_PPCF128), RTLIB::TRUNC_PPCF128));
NVT, Op, CallOptions, SDLoc(N)).first;
} }
SDValue DAGTypeLegalizer::SoftenFloatRes_LOAD(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatRes_LOAD(SDNode *N) {
LoadSDNode *L = cast<LoadSDNode>(N); LoadSDNode *L = cast<LoadSDNode>(N);
EVT VT = N->getValueType(0); EVT VT = N->getValueType(0);
EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT); EVT NVT = TLI.getTypeToTransformTo(*DAG.getContext(), VT);
SDLoc dl(N); SDLoc dl(N);
▲ Show 20 Lines • Show All 134 Lines • ▼ Show 20 Lines#endif
if (!Res.getNode()) return false; if (!Res.getNode()) return false;
// If the result is N, the sub-method updated N in place. Tell the legalizer // If the result is N, the sub-method updated N in place. Tell the legalizer
// core about this to re-analyze. // core about this to re-analyze.
if (Res.getNode() == N) if (Res.getNode() == N)
return true; return true;
assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 && assert(Res.getValueType() == N->getValueType(0) && N->getNumValues() == 1 &&
"Invalid operand promotion"); "Invalid operand softening");
ReplaceValueWith(SDValue(N, 0), Res); ReplaceValueWith(SDValue(N, 0), Res);
return false; return false;
} }
SDValue DAGTypeLegalizer::SoftenFloatOp_BITCAST(SDNode *N) { SDValue DAGTypeLegalizer::SoftenFloatOp_BITCAST(SDNode *N) {
SDValue Op0 = GetSoftenedFloat(N->getOperand(0)); SDValue Op0 = GetSoftenedFloat(N->getOperand(0));
▲ Show 20 Lines • Show All 1,519 Lines • Show Last 20 Lines

llvm/lib/CodeGen/SelectionDAG/LegalizeTypes.h

Show First 20 Lines • Show All 477 Lines • ▼ Show 20 Lines SDValue GetSoftenedFloat(SDValue Op) {
SDValue SoftenedOp = getSDValue(Iter->second); SDValue SoftenedOp = getSDValue(Iter->second);
assert(SoftenedOp.getNode() && "Unconverted op in SoftenedFloats?"); assert(SoftenedOp.getNode() && "Unconverted op in SoftenedFloats?");
return SoftenedOp; return SoftenedOp;
} }
void SetSoftenedFloat(SDValue Op, SDValue Result); void SetSoftenedFloat(SDValue Op, SDValue Result);
// Convert Float Results to Integer. // Convert Float Results to Integer.
void SoftenFloatResult(SDNode *N, unsigned ResNo); void SoftenFloatResult(SDNode *N, unsigned ResNo);
SDValue SoftenFloatRes_Unary(SDNode *N, RTLIB::Libcall LC);
SDValue SoftenFloatRes_Binary(SDNode *N, RTLIB::Libcall LC);
SDValue SoftenFloatRes_MERGE_VALUES(SDNode *N, unsigned ResNo); SDValue SoftenFloatRes_MERGE_VALUES(SDNode *N, unsigned ResNo);
SDValue SoftenFloatRes_BITCAST(SDNode *N); SDValue SoftenFloatRes_BITCAST(SDNode *N);
SDValue SoftenFloatRes_BUILD_PAIR(SDNode *N); SDValue SoftenFloatRes_BUILD_PAIR(SDNode *N);
SDValue SoftenFloatRes_ConstantFP(SDNode *N); SDValue SoftenFloatRes_ConstantFP(SDNode *N);
SDValue SoftenFloatRes_EXTRACT_VECTOR_ELT(SDNode *N, unsigned ResNo); SDValue SoftenFloatRes_EXTRACT_VECTOR_ELT(SDNode *N, unsigned ResNo);
SDValue SoftenFloatRes_FABS(SDNode *N); SDValue SoftenFloatRes_FABS(SDNode *N);
SDValue SoftenFloatRes_FMINNUM(SDNode *N); SDValue SoftenFloatRes_FMINNUM(SDNode *N);
SDValue SoftenFloatRes_FMAXNUM(SDNode *N); SDValue SoftenFloatRes_FMAXNUM(SDNode *N);
▲ Show 20 Lines • Show All 469 Lines • Show Last 20 Lines