maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

[TargetLowering] Add code size information on isFPImmLegal. NFC 

This allows better code size for aarch64 floating point materialization
in a future patch.

Reviewers: evandro

Differential Revision: https://reviews.llvm.org/D58690

llvm-svn: 356389
This commit is contained in:
Adhemerval Zanella 2019-03-18 18:40:07 +00:00
parent f6a53d63a1
commit 664c1ef528
19 changed files with 97 additions and 56 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
llvm/include/llvm/CodeGen/TargetLowering.h
View File

@ -781,7 +781,8 @@ public:
/// Returns true if the target can instruction select the specified FP /// Returns true if the target can instruction select the specified FP
/// immediate natively. If false, the legalizer will materialize the FP /// immediate natively. If false, the legalizer will materialize the FP
/// immediate as a load from a constant pool. /// immediate as a load from a constant pool.
virtual bool isFPImmLegal(const APFloat &/*Imm*/, EVT /*VT*/) const { virtual bool isFPImmLegal(const APFloat &/*Imm*/, EVT /*VT*/,
bool ForCodeSize = false) const {
return false; return false;
} }

99
llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
View File

@ -697,6 +697,7 @@ void DAGCombiner::deleteAndRecombine(SDNode *N) {
static char isNegatibleForFree(SDValue Op, bool LegalOperations, static char isNegatibleForFree(SDValue Op, bool LegalOperations,
const TargetLowering &TLI, const TargetLowering &TLI,
const TargetOptions *Options, const TargetOptions *Options,
bool ForCodeSize,
unsigned Depth = 0) { unsigned Depth = 0) {
// fneg is removable even if it has multiple uses. // fneg is removable even if it has multiple uses.
if (Op.getOpcode() == ISD::FNEG) return 2; if (Op.getOpcode() == ISD::FNEG) return 2;
@ -721,7 +722,8 @@ static char isNegatibleForFree(SDValue Op, bool LegalOperations,
// Don't invert constant FP values after legalization unless the target says // Don't invert constant FP values after legalization unless the target says
// the negated constant is legal. // the negated constant is legal.
return TLI.isOperationLegal(ISD::ConstantFP, VT) || return TLI.isOperationLegal(ISD::ConstantFP, VT) ||
TLI.isFPImmLegal(neg(cast<ConstantFPSDNode>(Op)->getValueAPF()), VT); TLI.isFPImmLegal(neg(cast<ConstantFPSDNode>(Op)->getValueAPF()), VT,
ForCodeSize);
} }
case ISD::FADD: case ISD::FADD:
if (!Options->UnsafeFPMath && !Flags.hasNoSignedZeros()) if (!Options->UnsafeFPMath && !Flags.hasNoSignedZeros())
@ -733,11 +735,11 @@ static char isNegatibleForFree(SDValue Op, bool LegalOperations,
// fold (fneg (fadd A, B)) -> (fsub (fneg A), B) // fold (fneg (fadd A, B)) -> (fsub (fneg A), B)
if (char V = isNegatibleForFree(Op.getOperand(0), LegalOperations, TLI, if (char V = isNegatibleForFree(Op.getOperand(0), LegalOperations, TLI,
Options, Depth + 1)) Options, ForCodeSize, Depth + 1))
return V; return V;
// fold (fneg (fadd A, B)) -> (fsub (fneg B), A) // fold (fneg (fadd A, B)) -> (fsub (fneg B), A)
return isNegatibleForFree(Op.getOperand(1), LegalOperations, TLI, Options, return isNegatibleForFree(Op.getOperand(1), LegalOperations, TLI, Options,
Depth + 1); ForCodeSize, Depth + 1);
case ISD::FSUB: case ISD::FSUB:
// We can't turn -(A-B) into B-A when we honor signed zeros. // We can't turn -(A-B) into B-A when we honor signed zeros.
if (!Options->NoSignedZerosFPMath && if (!Options->NoSignedZerosFPMath &&
@ -751,23 +753,24 @@ static char isNegatibleForFree(SDValue Op, bool LegalOperations,
case ISD::FDIV: case ISD::FDIV:
// fold (fneg (fmul X, Y)) -> (fmul (fneg X), Y) or (fmul X, (fneg Y)) // fold (fneg (fmul X, Y)) -> (fmul (fneg X), Y) or (fmul X, (fneg Y))
if (char V = isNegatibleForFree(Op.getOperand(0), LegalOperations, TLI, if (char V = isNegatibleForFree(Op.getOperand(0), LegalOperations, TLI,
Options, Depth + 1)) Options, ForCodeSize, Depth + 1))
return V; return V;
return isNegatibleForFree(Op.getOperand(1), LegalOperations, TLI, Options, return isNegatibleForFree(Op.getOperand(1), LegalOperations, TLI, Options,
Depth + 1); ForCodeSize, Depth + 1);
case ISD::FP_EXTEND: case ISD::FP_EXTEND:
case ISD::FP_ROUND: case ISD::FP_ROUND:
case ISD::FSIN: case ISD::FSIN:
return isNegatibleForFree(Op.getOperand(0), LegalOperations, TLI, Options, return isNegatibleForFree(Op.getOperand(0), LegalOperations, TLI, Options,
Depth + 1); ForCodeSize, Depth + 1);
} }
} }
/// If isNegatibleForFree returns true, return the newly negated expression. /// If isNegatibleForFree returns true, return the newly negated expression.
static SDValue GetNegatedExpression(SDValue Op, SelectionDAG &DAG, static SDValue GetNegatedExpression(SDValue Op, SelectionDAG &DAG,
bool LegalOperations, unsigned Depth = 0) { bool LegalOperations, bool ForCodeSize,
unsigned Depth = 0) {
const TargetOptions &Options = DAG.getTarget().Options; const TargetOptions &Options = DAG.getTarget().Options;
// fneg is removable even if it has multiple uses. // fneg is removable even if it has multiple uses.
if (Op.getOpcode() == ISD::FNEG) return Op.getOperand(0); if (Op.getOpcode() == ISD::FNEG) return Op.getOperand(0);
@ -788,15 +791,18 @@ static SDValue GetNegatedExpression(SDValue Op, SelectionDAG &DAG,
// fold (fneg (fadd A, B)) -> (fsub (fneg A), B) // fold (fneg (fadd A, B)) -> (fsub (fneg A), B)
if (isNegatibleForFree(Op.getOperand(0), LegalOperations, if (isNegatibleForFree(Op.getOperand(0), LegalOperations,
DAG.getTargetLoweringInfo(), &Options, Depth+1)) DAG.getTargetLoweringInfo(), &Options, ForCodeSize,
Depth+1))
return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(), return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
GetNegatedExpression(Op.getOperand(0), DAG, GetNegatedExpression(Op.getOperand(0), DAG,
LegalOperations, Depth+1), LegalOperations, ForCodeSize,
Depth+1),
Op.getOperand(1), Flags); Op.getOperand(1), Flags);
// fold (fneg (fadd A, B)) -> (fsub (fneg B), A) // fold (fneg (fadd A, B)) -> (fsub (fneg B), A)
return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(), return DAG.getNode(ISD::FSUB, SDLoc(Op), Op.getValueType(),
GetNegatedExpression(Op.getOperand(1), DAG, GetNegatedExpression(Op.getOperand(1), DAG,
LegalOperations, Depth+1), LegalOperations, ForCodeSize,
Depth+1),
Op.getOperand(0), Flags); Op.getOperand(0), Flags);
case ISD::FSUB: case ISD::FSUB:
// fold (fneg (fsub 0, B)) -> B // fold (fneg (fsub 0, B)) -> B
@ -812,27 +818,32 @@ static SDValue GetNegatedExpression(SDValue Op, SelectionDAG &DAG,
case ISD::FDIV: case ISD::FDIV:
// fold (fneg (fmul X, Y)) -> (fmul (fneg X), Y) // fold (fneg (fmul X, Y)) -> (fmul (fneg X), Y)
if (isNegatibleForFree(Op.getOperand(0), LegalOperations, if (isNegatibleForFree(Op.getOperand(0), LegalOperations,
DAG.getTargetLoweringInfo(), &Options, Depth+1)) DAG.getTargetLoweringInfo(), &Options, ForCodeSize,
Depth+1))
return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(), return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
GetNegatedExpression(Op.getOperand(0), DAG, GetNegatedExpression(Op.getOperand(0), DAG,
LegalOperations, Depth+1), LegalOperations, ForCodeSize,
Depth+1),
Op.getOperand(1), Flags); Op.getOperand(1), Flags);
// fold (fneg (fmul X, Y)) -> (fmul X, (fneg Y)) // fold (fneg (fmul X, Y)) -> (fmul X, (fneg Y))
return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(), return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
Op.getOperand(0), Op.getOperand(0),
GetNegatedExpression(Op.getOperand(1), DAG, GetNegatedExpression(Op.getOperand(1), DAG,
LegalOperations, Depth+1), Flags); LegalOperations, ForCodeSize,
Depth+1), Flags);
case ISD::FP_EXTEND: case ISD::FP_EXTEND:
case ISD::FSIN: case ISD::FSIN:
return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(), return DAG.getNode(Op.getOpcode(), SDLoc(Op), Op.getValueType(),
GetNegatedExpression(Op.getOperand(0), DAG, GetNegatedExpression(Op.getOperand(0), DAG,
LegalOperations, Depth+1)); LegalOperations, ForCodeSize,
Depth+1));
case ISD::FP_ROUND: case ISD::FP_ROUND:
return DAG.getNode(ISD::FP_ROUND, SDLoc(Op), Op.getValueType(), return DAG.getNode(ISD::FP_ROUND, SDLoc(Op), Op.getValueType(),
GetNegatedExpression(Op.getOperand(0), DAG, GetNegatedExpression(Op.getOperand(0), DAG,
LegalOperations, Depth+1), LegalOperations, ForCodeSize,
Depth+1),
Op.getOperand(1)); Op.getOperand(1));
} }
} }
@ -11284,15 +11295,17 @@ SDValue DAGCombiner::visitFADD(SDNode *N) {
// fold (fadd A, (fneg B)) -> (fsub A, B) // fold (fadd A, (fneg B)) -> (fsub A, B)
if ((!LegalOperations || TLI.isOperationLegalOrCustom(ISD::FSUB, VT)) && if ((!LegalOperations || TLI.isOperationLegalOrCustom(ISD::FSUB, VT)) &&
isNegatibleForFree(N1, LegalOperations, TLI, &Options) == 2) isNegatibleForFree(N1, LegalOperations, TLI, &Options, ForCodeSize) == 2)
return DAG.getNode(ISD::FSUB, DL, VT, N0, return DAG.getNode(ISD::FSUB, DL, VT, N0,
GetNegatedExpression(N1, DAG, LegalOperations), Flags); GetNegatedExpression(N1, DAG, LegalOperations,
ForCodeSize), Flags);
// fold (fadd (fneg A), B) -> (fsub B, A) // fold (fadd (fneg A), B) -> (fsub B, A)
if ((!LegalOperations || TLI.isOperationLegalOrCustom(ISD::FSUB, VT)) && if ((!LegalOperations || TLI.isOperationLegalOrCustom(ISD::FSUB, VT)) &&
isNegatibleForFree(N0, LegalOperations, TLI, &Options) == 2) isNegatibleForFree(N0, LegalOperations, TLI, &Options, ForCodeSize) == 2)
return DAG.getNode(ISD::FSUB, DL, VT, N1, return DAG.getNode(ISD::FSUB, DL, VT, N1,
GetNegatedExpression(N0, DAG, LegalOperations), Flags); GetNegatedExpression(N0, DAG, LegalOperations,
ForCodeSize), Flags);
auto isFMulNegTwo = [](SDValue FMul) { auto isFMulNegTwo = [](SDValue FMul) {
if (!FMul.hasOneUse() || FMul.getOpcode() != ISD::FMUL) if (!FMul.hasOneUse() || FMul.getOpcode() != ISD::FMUL)
@ -11467,8 +11480,8 @@ SDValue DAGCombiner::visitFSUB(SDNode *N) {
if (N0CFP && N0CFP->isZero()) { if (N0CFP && N0CFP->isZero()) {
if (N0CFP->isNegative() || if (N0CFP->isNegative() ||
(Options.NoSignedZerosFPMath || Flags.hasNoSignedZeros())) { (Options.NoSignedZerosFPMath || Flags.hasNoSignedZeros())) {
if (isNegatibleForFree(N1, LegalOperations, TLI, &Options)) if (isNegatibleForFree(N1, LegalOperations, TLI, &Options, ForCodeSize))
return GetNegatedExpression(N1, DAG, LegalOperations); return GetNegatedExpression(N1, DAG, LegalOperations, ForCodeSize);
if (!LegalOperations || TLI.isOperationLegal(ISD::FNEG, VT)) if (!LegalOperations || TLI.isOperationLegal(ISD::FNEG, VT))
return DAG.getNode(ISD::FNEG, DL, VT, N1, Flags); return DAG.getNode(ISD::FNEG, DL, VT, N1, Flags);
} }
@ -11486,9 +11499,10 @@ SDValue DAGCombiner::visitFSUB(SDNode *N) {
} }
// fold (fsub A, (fneg B)) -> (fadd A, B) // fold (fsub A, (fneg B)) -> (fadd A, B)
if (isNegatibleForFree(N1, LegalOperations, TLI, &Options)) if (isNegatibleForFree(N1, LegalOperations, TLI, &Options, ForCodeSize))
return DAG.getNode(ISD::FADD, DL, VT, N0, return DAG.getNode(ISD::FADD, DL, VT, N0,
GetNegatedExpression(N1, DAG, LegalOperations), Flags); GetNegatedExpression(N1, DAG, LegalOperations,
ForCodeSize), Flags);
// FSUB -> FMA combines: // FSUB -> FMA combines:
if (SDValue Fused = visitFSUBForFMACombine(N)) { if (SDValue Fused = visitFSUBForFMACombine(N)) {
@ -11574,14 +11588,18 @@ SDValue DAGCombiner::visitFMUL(SDNode *N) {
return DAG.getNode(ISD::FNEG, DL, VT, N0); return DAG.getNode(ISD::FNEG, DL, VT, N0);
// fold (fmul (fneg X), (fneg Y)) -> (fmul X, Y) // fold (fmul (fneg X), (fneg Y)) -> (fmul X, Y)
if (char LHSNeg = isNegatibleForFree(N0, LegalOperations, TLI, &Options)) { if (char LHSNeg = isNegatibleForFree(N0, LegalOperations, TLI, &Options,
if (char RHSNeg = isNegatibleForFree(N1, LegalOperations, TLI, &Options)) { ForCodeSize)) {
if (char RHSNeg = isNegatibleForFree(N1, LegalOperations, TLI, &Options,
ForCodeSize)) {
// Both can be negated for free, check to see if at least one is cheaper // Both can be negated for free, check to see if at least one is cheaper
// negated. // negated.
if (LHSNeg == 2 || RHSNeg == 2) if (LHSNeg == 2 || RHSNeg == 2)
return DAG.getNode(ISD::FMUL, DL, VT, return DAG.getNode(ISD::FMUL, DL, VT,
GetNegatedExpression(N0, DAG, LegalOperations), GetNegatedExpression(N0, DAG, LegalOperations,
GetNegatedExpression(N1, DAG, LegalOperations), ForCodeSize),
GetNegatedExpression(N1, DAG, LegalOperations,
ForCodeSize),
Flags); Flags);
} }
} }
@ -11719,7 +11737,8 @@ SDValue DAGCombiner::visitFMA(SDNode *N) {
// fma (fneg x), K, y -> fma x -K, y // fma (fneg x), K, y -> fma x -K, y
if (N0.getOpcode() == ISD::FNEG && if (N0.getOpcode() == ISD::FNEG &&
(TLI.isOperationLegal(ISD::ConstantFP, VT) || (TLI.isOperationLegal(ISD::ConstantFP, VT) ||
(N1.hasOneUse() && !TLI.isFPImmLegal(N1CFP->getValueAPF(), VT)))) { (N1.hasOneUse() && !TLI.isFPImmLegal(N1CFP->getValueAPF(), VT,
ForCodeSize)))) {
return DAG.getNode(ISD::FMA, DL, VT, N0.getOperand(0), return DAG.getNode(ISD::FMA, DL, VT, N0.getOperand(0),
DAG.getNode(ISD::FNEG, DL, VT, N1, Flags), N2); DAG.getNode(ISD::FNEG, DL, VT, N1, Flags), N2);
} }
@ -11847,7 +11866,7 @@ SDValue DAGCombiner::visitFDIV(SDNode *N) {
// backend)... we should handle this gracefully after Legalize. // backend)... we should handle this gracefully after Legalize.
// TLI.isOperationLegalOrCustom(ISD::ConstantFP, VT) || // TLI.isOperationLegalOrCustom(ISD::ConstantFP, VT) ||
TLI.isOperationLegal(ISD::ConstantFP, VT) || TLI.isOperationLegal(ISD::ConstantFP, VT) ||
TLI.isFPImmLegal(Recip, VT))) TLI.isFPImmLegal(Recip, VT, ForCodeSize)))
return DAG.getNode(ISD::FMUL, DL, VT, N0, return DAG.getNode(ISD::FMUL, DL, VT, N0,
DAG.getConstantFP(Recip, DL, VT), Flags); DAG.getConstantFP(Recip, DL, VT), Flags);
} }
@ -11905,14 +11924,18 @@ SDValue DAGCombiner::visitFDIV(SDNode *N) {
} }
// (fdiv (fneg X), (fneg Y)) -> (fdiv X, Y) // (fdiv (fneg X), (fneg Y)) -> (fdiv X, Y)
if (char LHSNeg = isNegatibleForFree(N0, LegalOperations, TLI, &Options)) { if (char LHSNeg = isNegatibleForFree(N0, LegalOperations, TLI, &Options,
if (char RHSNeg = isNegatibleForFree(N1, LegalOperations, TLI, &Options)) { ForCodeSize)) {
if (char RHSNeg = isNegatibleForFree(N1, LegalOperations, TLI, &Options,
ForCodeSize)) {
// Both can be negated for free, check to see if at least one is cheaper // Both can be negated for free, check to see if at least one is cheaper
// negated. // negated.
if (LHSNeg == 2 || RHSNeg == 2) if (LHSNeg == 2 || RHSNeg == 2)
return DAG.getNode(ISD::FDIV, SDLoc(N), VT, return DAG.getNode(ISD::FDIV, SDLoc(N), VT,
GetNegatedExpression(N0, DAG, LegalOperations), GetNegatedExpression(N0, DAG, LegalOperations,
GetNegatedExpression(N1, DAG, LegalOperations), ForCodeSize),
GetNegatedExpression(N1, DAG, LegalOperations,
ForCodeSize),
Flags); Flags);
} }
} }
@ -12473,8 +12496,8 @@ SDValue DAGCombiner::visitFNEG(SDNode *N) {
return DAG.getNode(ISD::FNEG, SDLoc(N), VT, N0); return DAG.getNode(ISD::FNEG, SDLoc(N), VT, N0);
if (isNegatibleForFree(N0, LegalOperations, DAG.getTargetLoweringInfo(), if (isNegatibleForFree(N0, LegalOperations, DAG.getTargetLoweringInfo(),
&DAG.getTarget().Options)) &DAG.getTarget().Options, ForCodeSize))
return GetNegatedExpression(N0, DAG, LegalOperations); return GetNegatedExpression(N0, DAG, LegalOperations, ForCodeSize);
// Transform fneg(bitconvert(x)) -> bitconvert(x ^ sign) to avoid loading // Transform fneg(bitconvert(x)) -> bitconvert(x ^ sign) to avoid loading
// constant pool values. // constant pool values.
@ -12510,7 +12533,7 @@ SDValue DAGCombiner::visitFNEG(SDNode *N) {
APFloat CVal = CFP1->getValueAPF(); APFloat CVal = CFP1->getValueAPF();
CVal.changeSign(); CVal.changeSign();
if (Level >= AfterLegalizeDAG && if (Level >= AfterLegalizeDAG &&
(TLI.isFPImmLegal(CVal, VT) || (TLI.isFPImmLegal(CVal, VT, ForCodeSize) ||
TLI.isOperationLegal(ISD::ConstantFP, VT))) TLI.isOperationLegal(ISD::ConstantFP, VT)))
return DAG.getNode( return DAG.getNode(
ISD::FMUL, SDLoc(N), VT, N0.getOperand(0), ISD::FMUL, SDLoc(N), VT, N0.getOperand(0),
@ -18882,8 +18905,8 @@ SDValue DAGCombiner::convertSelectOfFPConstantsToLoadOffset(
// If a constant can be materialized without loads, this does not make sense. // If a constant can be materialized without loads, this does not make sense.
if (TLI.getOperationAction(ISD::ConstantFP, VT) == TargetLowering::Legal || if (TLI.getOperationAction(ISD::ConstantFP, VT) == TargetLowering::Legal ||
TLI.isFPImmLegal(TV->getValueAPF(), TV->getValueType(0)) || TLI.isFPImmLegal(TV->getValueAPF(), TV->getValueType(0), ForCodeSize) ||
TLI.isFPImmLegal(FV->getValueAPF(), FV->getValueType(0))) TLI.isFPImmLegal(FV->getValueAPF(), FV->getValueType(0), ForCodeSize))
return SDValue(); return SDValue();
// If both constants have multiple uses, then we won't need to do an extra // If both constants have multiple uses, then we won't need to do an extra

3
llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
View File

@ -3092,7 +3092,8 @@ bool SelectionDAGLegalize::ExpandNode(SDNode *Node) {
ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node); ConstantFPSDNode *CFP = cast<ConstantFPSDNode>(Node);
// Check to see if this FP immediate is already legal. // Check to see if this FP immediate is already legal.
// If this is a legal constant, turn it into a TargetConstantFP node. // If this is a legal constant, turn it into a TargetConstantFP node.
if (!TLI.isFPImmLegal(CFP->getValueAPF(), Node->getValueType(0))) if (!TLI.isFPImmLegal(CFP->getValueAPF(), Node->getValueType(0),
DAG.getMachineFunction().getFunction().optForSize()))
Results.push_back(ExpandConstantFP(CFP, true)); Results.push_back(ExpandConstantFP(CFP, true));
break; break;
} }

3
llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
View File

@ -5405,7 +5405,8 @@ bool AArch64TargetLowering::isOffsetFoldingLegal(
return false; return false;
} }
bool AArch64TargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const { bool AArch64TargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
bool OptForSize) const {
bool IsLegal = false; bool IsLegal = false;
// We can materialize #0.0 as fmov $Rd, XZR for 64-bit, 32-bit cases, and // We can materialize #0.0 as fmov $Rd, XZR for 64-bit, 32-bit cases, and
// 16-bit case when target has full fp16 support. // 16-bit case when target has full fp16 support.

3
llvm/lib/Target/AArch64/AArch64ISelLowering.h
View File

@ -286,7 +286,8 @@ public:
bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override; bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override;
bool isFPImmLegal(const APFloat &Imm, EVT VT) const override; bool isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const override;
/// Return true if the given shuffle mask can be codegen'd directly, or if it /// Return true if the given shuffle mask can be codegen'd directly, or if it
/// should be stack expanded. /// should be stack expanded.

3
llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp
View File

@ -639,7 +639,8 @@ bool AMDGPUTargetLowering::isSelectSupported(SelectSupportKind SelType) const {
// The backend supports 32 and 64 bit floating point immediates. // The backend supports 32 and 64 bit floating point immediates.
// FIXME: Why are we reporting vectors of FP immediates as legal? // FIXME: Why are we reporting vectors of FP immediates as legal?
bool AMDGPUTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const { bool AMDGPUTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const {
EVT ScalarVT = VT.getScalarType(); EVT ScalarVT = VT.getScalarType();
return (ScalarVT == MVT::f32 || ScalarVT == MVT::f64 || return (ScalarVT == MVT::f32 || ScalarVT == MVT::f64 ||
(ScalarVT == MVT::f16 && Subtarget->has16BitInsts())); (ScalarVT == MVT::f16 && Subtarget->has16BitInsts()));

3
llvm/lib/Target/AMDGPU/AMDGPUISelLowering.h
View File

@ -161,7 +161,8 @@ public:
MVT getVectorIdxTy(const DataLayout &) const override; MVT getVectorIdxTy(const DataLayout &) const override;
bool isSelectSupported(SelectSupportKind) const override; bool isSelectSupported(SelectSupportKind) const override;
bool isFPImmLegal(const APFloat &Imm, EVT VT) const override; bool isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const override;
bool ShouldShrinkFPConstant(EVT VT) const override; bool ShouldShrinkFPConstant(EVT VT) const override;
bool shouldReduceLoadWidth(SDNode *Load, bool shouldReduceLoadWidth(SDNode *Load,
ISD::LoadExtType ExtType, ISD::LoadExtType ExtType,

3
llvm/lib/Target/ARM/ARMISelLowering.cpp
View File

@ -14413,7 +14413,8 @@ bool ARM::isBitFieldInvertedMask(unsigned v) {
/// isFPImmLegal - Returns true if the target can instruction select the /// isFPImmLegal - Returns true if the target can instruction select the
/// specified FP immediate natively. If false, the legalizer will /// specified FP immediate natively. If false, the legalizer will
/// materialize the FP immediate as a load from a constant pool. /// materialize the FP immediate as a load from a constant pool.
bool ARMTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const { bool ARMTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const {
if (!Subtarget->hasVFP3()) if (!Subtarget->hasVFP3())
return false; return false;
if (VT == MVT::f16 && Subtarget->hasFullFP16()) if (VT == MVT::f16 && Subtarget->hasFullFP16())

3
llvm/lib/Target/ARM/ARMISelLowering.h
View File

@ -481,7 +481,8 @@ class VectorType;
/// isFPImmLegal - Returns true if the target can instruction select the /// isFPImmLegal - Returns true if the target can instruction select the
/// specified FP immediate natively. If false, the legalizer will /// specified FP immediate natively. If false, the legalizer will
/// materialize the FP immediate as a load from a constant pool. /// materialize the FP immediate as a load from a constant pool.
bool isFPImmLegal(const APFloat &Imm, EVT VT) const override; bool isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize = false) const override;
bool getTgtMemIntrinsic(IntrinsicInfo &Info, bool getTgtMemIntrinsic(IntrinsicInfo &Info,
const CallInst &I, const CallInst &I,

3
llvm/lib/Target/Hexagon/HexagonISelLowering.cpp
View File

@ -2924,7 +2924,8 @@ HexagonTargetLowering::getRegForInlineAsmConstraint(
/// isFPImmLegal - Returns true if the target can instruction select the /// isFPImmLegal - Returns true if the target can instruction select the
/// specified FP immediate natively. If false, the legalizer will /// specified FP immediate natively. If false, the legalizer will
/// materialize the FP immediate as a load from a constant pool. /// materialize the FP immediate as a load from a constant pool.
bool HexagonTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const { bool HexagonTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const {
return true; return true;
} }

3
llvm/lib/Target/Hexagon/HexagonISelLowering.h
View File

@ -284,7 +284,8 @@ namespace HexagonISD {
/// is legal. It is frequently not legal in PIC relocation models. /// is legal. It is frequently not legal in PIC relocation models.
bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override; bool isOffsetFoldingLegal(const GlobalAddressSDNode *GA) const override;
bool isFPImmLegal(const APFloat &Imm, EVT VT) const override; bool isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const override;
/// isLegalICmpImmediate - Return true if the specified immediate is legal /// isLegalICmpImmediate - Return true if the specified immediate is legal
/// icmp immediate, that is the target has icmp instructions which can /// icmp immediate, that is the target has icmp instructions which can

3
llvm/lib/Target/Mips/MipsISelLowering.cpp
View File

@ -4152,7 +4152,8 @@ EVT MipsTargetLowering::getOptimalMemOpType(uint64_t Size, unsigned DstAlign,
return MVT::i32; return MVT::i32;
} }
bool MipsTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const { bool MipsTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const {
if (VT != MVT::f32 && VT != MVT::f64) if (VT != MVT::f32 && VT != MVT::f64)
return false; return false;
if (Imm.isNegZero()) if (Imm.isNegZero())

3
llvm/lib/Target/Mips/MipsISelLowering.h
View File

@ -675,7 +675,8 @@ class TargetRegisterClass;
/// isFPImmLegal - Returns true if the target can instruction select the /// isFPImmLegal - Returns true if the target can instruction select the
/// specified FP immediate natively. If false, the legalizer will /// specified FP immediate natively. If false, the legalizer will
/// materialize the FP immediate as a load from a constant pool. /// materialize the FP immediate as a load from a constant pool.
bool isFPImmLegal(const APFloat &Imm, EVT VT) const override; bool isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const override;
unsigned getJumpTableEncoding() const override; unsigned getJumpTableEncoding() const override;
bool useSoftFloat() const override; bool useSoftFloat() const override;

3
llvm/lib/Target/PowerPC/PPCISelLowering.cpp
View File

@ -14322,7 +14322,8 @@ void PPCTargetLowering::insertSSPDeclarations(Module &M) const {
return TargetLowering::insertSSPDeclarations(M); return TargetLowering::insertSSPDeclarations(M);
} }
bool PPCTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const { bool PPCTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const {
if (!VT.isSimple() || !Subtarget.hasVSX()) if (!VT.isSimple() || !Subtarget.hasVSX())
return false; return false;

3
llvm/lib/Target/PowerPC/PPCISelLowering.h
View File

@ -887,7 +887,8 @@ namespace llvm {
bool useLoadStackGuardNode() const override; bool useLoadStackGuardNode() const override;
void insertSSPDeclarations(Module &M) const override; void insertSSPDeclarations(Module &M) const override;
bool isFPImmLegal(const APFloat &Imm, EVT VT) const override; bool isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const override;
unsigned getJumpTableEncoding() const override; unsigned getJumpTableEncoding() const override;
bool isJumpTableRelative() const override; bool isJumpTableRelative() const override;

3
llvm/lib/Target/SystemZ/SystemZISelLowering.cpp
View File

@ -691,7 +691,8 @@ SystemZVectorConstantInfo::SystemZVectorConstantInfo(BuildVectorSDNode *BVN) {
true); true);
} }
bool SystemZTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const { bool SystemZTargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const {
// We can load zero using LZ?R and negative zero using LZ?R;LC?BR. // We can load zero using LZ?R and negative zero using LZ?R;LC?BR.
if (Imm.isZero() || Imm.isNegZero()) if (Imm.isZero() || Imm.isNegZero())
return true; return true;

3
llvm/lib/Target/SystemZ/SystemZISelLowering.h
View File

@ -400,7 +400,8 @@ public:
EVT getSetCCResultType(const DataLayout &DL, LLVMContext &, EVT getSetCCResultType(const DataLayout &DL, LLVMContext &,
EVT) const override; EVT) const override;
bool isFMAFasterThanFMulAndFAdd(EVT VT) const override; bool isFMAFasterThanFMulAndFAdd(EVT VT) const override;
bool isFPImmLegal(const APFloat &Imm, EVT VT) const override; bool isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const override;
bool isLegalICmpImmediate(int64_t Imm) const override; bool isLegalICmpImmediate(int64_t Imm) const override;
bool isLegalAddImmediate(int64_t Imm) const override; bool isLegalAddImmediate(int64_t Imm) const override;
bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty, bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,

3
llvm/lib/Target/X86/X86ISelLowering.cpp
View File

@ -4801,7 +4801,8 @@ bool X86TargetLowering::getTgtMemIntrinsic(IntrinsicInfo &Info,
/// Returns true if the target can instruction select the /// Returns true if the target can instruction select the
/// specified FP immediate natively. If false, the legalizer will /// specified FP immediate natively. If false, the legalizer will
/// materialize the FP immediate as a load from a constant pool. /// materialize the FP immediate as a load from a constant pool.
bool X86TargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT) const { bool X86TargetLowering::isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const {
for (unsigned i = 0, e = LegalFPImmediates.size(); i != e; ++i) { for (unsigned i = 0, e = LegalFPImmediates.size(); i != e; ++i) {
if (Imm.bitwiseIsEqual(LegalFPImmediates[i])) if (Imm.bitwiseIsEqual(LegalFPImmediates[i]))
return true; return true;

3
llvm/lib/Target/X86/X86ISelLowering.h
View File

@ -1011,7 +1011,8 @@ namespace llvm {
/// Returns true if the target can instruction select the /// Returns true if the target can instruction select the
/// specified FP immediate natively. If false, the legalizer will /// specified FP immediate natively. If false, the legalizer will
/// materialize the FP immediate as a load from a constant pool. /// materialize the FP immediate as a load from a constant pool.
bool isFPImmLegal(const APFloat &Imm, EVT VT) const override; bool isFPImmLegal(const APFloat &Imm, EVT VT,
bool ForCodeSize) const override;
/// Targets can use this to indicate that they only support *some* /// Targets can use this to indicate that they only support *some*
/// VECTOR_SHUFFLE operations, those with specific masks. By default, if a /// VECTOR_SHUFFLE operations, those with specific masks. By default, if a