[SelectionDAG] Move EVTToAPFloatSemantics to MVT/EVT #103001
Closed
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
llvmbot
added
backend:AArch64
backend:AMDGPU
backend:RISC-V
backend:X86
llvm:SelectionDAG
|
@llvm/pr-subscribers-backend-amdgpu @llvm/pr-subscribers-backend-aarch64 Author: Craig Topper (topperc) ChangesAdd a new getFltSemantics method to MVT and EVT. Use these new methods to replace SelectionDAG::EVTToAPFloatSemantics. Patch is 28.24 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/103001.diff 14 Files Affected:
diff --git a/llvm/include/llvm/CodeGen/SelectionDAG.h b/llvm/include/llvm/CodeGen/SelectionDAG.h
index 1d0124ec755352..8524ae42a0070b 100644
--- a/llvm/include/llvm/CodeGen/SelectionDAG.h
+++ b/llvm/include/llvm/CodeGen/SelectionDAG.h
@@ -14,7 +14,6 @@
#ifndef LLVM_CODEGEN_SELECTIONDAG_H
#define LLVM_CODEGEN_SELECTIONDAG_H
-#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/ADT/DenseMap.h"
@@ -1824,21 +1823,6 @@ class SelectionDAG {
AllNodes.insert(Position, AllNodes.remove(N));
}
- /// Returns an APFloat semantics tag appropriate for the given type. If VT is
- /// a vector type, the element semantics are returned.
- static const fltSemantics &EVTToAPFloatSemantics(EVT VT) {
- switch (VT.getScalarType().getSimpleVT().SimpleTy) {
- default: llvm_unreachable("Unknown FP format");
- case MVT::f16: return APFloat::IEEEhalf();
- case MVT::bf16: return APFloat::BFloat();
- case MVT::f32: return APFloat::IEEEsingle();
- case MVT::f64: return APFloat::IEEEdouble();
- case MVT::f80: return APFloat::x87DoubleExtended();
- case MVT::f128: return APFloat::IEEEquad();
- case MVT::ppcf128: return APFloat::PPCDoubleDouble();
- }
- }
-
/// Add a dbg_value SDNode. If SD is non-null that means the
/// value is produced by SD.
void AddDbgValue(SDDbgValue *DB, bool isParameter);
@@ -2379,7 +2363,7 @@ class SelectionDAG {
/// Return the current function's default denormal handling kind for the given
/// floating point type.
DenormalMode getDenormalMode(EVT VT) const {
- return MF->getDenormalMode(EVTToAPFloatSemantics(VT));
+ return MF->getDenormalMode(VT.getFltSemantics());
}
bool shouldOptForSize() const;
diff --git a/llvm/include/llvm/CodeGen/ValueTypes.h b/llvm/include/llvm/CodeGen/ValueTypes.h
index dab6c421bf6e6d..c7cad3d509750e 100644
--- a/llvm/include/llvm/CodeGen/ValueTypes.h
+++ b/llvm/include/llvm/CodeGen/ValueTypes.h
@@ -27,6 +27,7 @@ namespace llvm {
class LLVMContext;
class Type;
+ struct fltSemantics;
/// Extended Value Type. Capable of holding value types which are not native
/// for any processor (such as the i12345 type), as well as the types an MVT
@@ -512,6 +513,10 @@ namespace llvm {
}
};
+ /// Returns an APFloat semantics tag appropriate for the value type. If this
+ /// is a vector type, the element semantics are returned.
+ const fltSemantics &getFltSemantics() const;
+
private:
// Methods for handling the Extended-type case in functions above.
// These are all out-of-line to prevent users of this header file
diff --git a/llvm/include/llvm/CodeGenTypes/MachineValueType.h b/llvm/include/llvm/CodeGenTypes/MachineValueType.h
index 556531c3147e5d..8bffdc31e5cdc5 100644
--- a/llvm/include/llvm/CodeGenTypes/MachineValueType.h
+++ b/llvm/include/llvm/CodeGenTypes/MachineValueType.h
@@ -26,6 +26,7 @@
namespace llvm {
class Type;
+ struct fltSemantics;
class raw_ostream;
/// Machine Value Type. Every type that is supported natively by some
@@ -476,6 +477,10 @@ namespace llvm {
/// to a concrete value type.
static MVT getVT(Type *Ty, bool HandleUnknown = false);
+ /// Returns an APFloat semantics tag appropriate for the value type. If this
+ /// is a vector type, the element semantics are returned.
+ const fltSemantics &getFltSemantics() const;
+
public:
/// SimpleValueType Iteration
/// @{
diff --git a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
index 1b9277a0fa509c..4c657a4ee3f653 100644
--- a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp
@@ -17804,7 +17804,7 @@ static SDValue FoldIntToFPToInt(SDNode *N, SelectionDAG &DAG) {
unsigned InputSize = (int)SrcVT.getScalarSizeInBits() - IsInputSigned;
unsigned OutputSize = (int)VT.getScalarSizeInBits();
unsigned ActualSize = std::min(InputSize, OutputSize);
- const fltSemantics &sem = DAG.EVTToAPFloatSemantics(N0.getValueType());
+ const fltSemantics &sem = N0.getValueType().getFltSemantics();
// We can only fold away the float conversion if the input range can be
// represented exactly in the float range.
@@ -22599,7 +22599,7 @@ SDValue DAGCombiner::visitEXTRACT_VECTOR_ELT(SDNode *N) {
KnownBits KnownElt = DAG.computeKnownBits(VecOp, EltMask);
if (KnownElt.isConstant()) {
APFloat CstFP =
- APFloat(DAG.EVTToAPFloatSemantics(ScalarVT), KnownElt.getConstant());
+ APFloat(ScalarVT.getFltSemantics(), KnownElt.getConstant());
if (TLI.isFPImmLegal(CstFP, ScalarVT))
return DAG.getConstantFP(CstFP, DL, ScalarVT);
}
diff --git a/llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
index f4b3d1a41c681b..3eadfbf51ddaa1 100644
--- a/llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
@@ -2435,7 +2435,7 @@ SDValue SelectionDAGLegalize::expandLdexp(SDNode *Node) const {
EVT SetCCVT =
TLI.getSetCCResultType(DAG.getDataLayout(), *DAG.getContext(), ExpVT);
- const fltSemantics &FltSem = SelectionDAG::EVTToAPFloatSemantics(VT);
+ const fltSemantics &FltSem = VT.getFltSemantics();
const APFloat::ExponentType MaxExpVal = APFloat::semanticsMaxExponent(FltSem);
const APFloat::ExponentType MinExpVal = APFloat::semanticsMinExponent(FltSem);
@@ -2535,7 +2535,7 @@ SDValue SelectionDAGLegalize::expandFrexp(SDNode *Node) const {
if (AsIntVT == EVT()) // TODO: How to handle f80?
return SDValue();
- const fltSemantics &FltSem = SelectionDAG::EVTToAPFloatSemantics(VT);
+ const fltSemantics &FltSem = VT.getFltSemantics();
const APFloat::ExponentType MinExpVal = APFloat::semanticsMinExponent(FltSem);
const unsigned Precision = APFloat::semanticsPrecision(FltSem);
const unsigned BitSize = VT.getScalarSizeInBits();
@@ -2797,7 +2797,7 @@ SDValue SelectionDAGLegalize::ExpandLegalINT_TO_FP(SDNode *Node,
// The following optimization is valid only if every value in SrcVT (when
// treated as signed) is representable in DestVT. Check that the mantissa
// size of DestVT is >= than the number of bits in SrcVT -1.
- assert(APFloat::semanticsPrecision(DAG.EVTToAPFloatSemantics(DestVT)) >=
+ assert(APFloat::semanticsPrecision(DestVT.getFltSemantics()) >=
SrcVT.getSizeInBits() - 1 &&
"Cannot perform lossless SINT_TO_FP!");
diff --git a/llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp b/llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp
index edebb5ee87001b..7c1cf129d5462f 100644
--- a/llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp
@@ -1493,12 +1493,9 @@ void DAGTypeLegalizer::ExpandFloatRes_ConstantFP(SDNode *N, SDValue &Lo,
"Do not know how to expand this float constant!");
APInt C = cast<ConstantFPSDNode>(N)->getValueAPF().bitcastToAPInt();
SDLoc dl(N);
- Lo = DAG.getConstantFP(APFloat(DAG.EVTToAPFloatSemantics(NVT),
- APInt(64, C.getRawData()[1])),
- dl, NVT);
- Hi = DAG.getConstantFP(APFloat(DAG.EVTToAPFloatSemantics(NVT),
- APInt(64, C.getRawData()[0])),
- dl, NVT);
+ const fltSemantics &Sem = NVT.getFltSemantics();
+ Lo = DAG.getConstantFP(APFloat(Sem, APInt(64, C.getRawData()[1])), dl, NVT);
+ Hi = DAG.getConstantFP(APFloat(Sem, APInt(64, C.getRawData()[0])), dl, NVT);
}
void DAGTypeLegalizer::ExpandFloatRes_Unary(SDNode *N, RTLIB::Libcall LC,
@@ -1777,8 +1774,8 @@ void DAGTypeLegalizer::ExpandFloatRes_FP_EXTEND(SDNode *N, SDValue &Lo,
Hi = DAG.getNode(ISD::FP_EXTEND, dl, NVT, N->getOperand(0));
}
- Lo = DAG.getConstantFP(APFloat(DAG.EVTToAPFloatSemantics(NVT),
- APInt(NVT.getSizeInBits(), 0)), dl, NVT);
+ Lo = DAG.getConstantFP(
+ APFloat(NVT.getFltSemantics(), APInt(NVT.getSizeInBits(), 0)), dl, NVT);
if (IsStrict)
ReplaceValueWith(SDValue(N, 1), Chain);
@@ -1934,8 +1931,8 @@ void DAGTypeLegalizer::ExpandFloatRes_LOAD(SDNode *N, SDValue &Lo,
Chain = Hi.getValue(1);
// The low part is zero.
- Lo = DAG.getConstantFP(APFloat(DAG.EVTToAPFloatSemantics(NVT),
- APInt(NVT.getSizeInBits(), 0)), dl, NVT);
+ Lo = DAG.getConstantFP(
+ APFloat(NVT.getFltSemantics(), APInt(NVT.getSizeInBits(), 0)), dl, NVT);
// Modified the chain - switch anything that used the old chain to use the
// new one.
@@ -1964,8 +1961,8 @@ void DAGTypeLegalizer::ExpandFloatRes_XINT_TO_FP(SDNode *N, SDValue &Lo,
// though.
if (SrcVT.bitsLE(MVT::i32)) {
// The integer can be represented exactly in an f64.
- Lo = DAG.getConstantFP(APFloat(DAG.EVTToAPFloatSemantics(NVT),
- APInt(NVT.getSizeInBits(), 0)), dl, NVT);
+ Lo = DAG.getConstantFP(
+ APFloat(NVT.getFltSemantics(), APInt(NVT.getSizeInBits(), 0)), dl, NVT);
if (Strict) {
Hi = DAG.getNode(N->getOpcode(), dl, DAG.getVTList(NVT, MVT::Other),
{Chain, Src}, Flags);
diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
index c3a7df5361cd45..4ac169708bee95 100644
--- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp
@@ -132,9 +132,8 @@ bool ConstantFPSDNode::isValueValidForType(EVT VT,
// convert modifies in place, so make a copy.
APFloat Val2 = APFloat(Val);
bool losesInfo;
- (void) Val2.convert(SelectionDAG::EVTToAPFloatSemantics(VT),
- APFloat::rmNearestTiesToEven,
- &losesInfo);
+ (void)Val2.convert(VT.getFltSemantics(), APFloat::rmNearestTiesToEven,
+ &losesInfo);
return !losesInfo;
}
@@ -1820,7 +1819,7 @@ SDValue SelectionDAG::getConstantFP(double Val, const SDLoc &DL, EVT VT,
EltVT == MVT::f16 || EltVT == MVT::bf16) {
bool Ignored;
APFloat APF = APFloat(Val);
- APF.convert(EVTToAPFloatSemantics(EltVT), APFloat::rmNearestTiesToEven,
+ APF.convert(EltVT.getFltSemantics(), APFloat::rmNearestTiesToEven,
&Ignored);
return getConstantFP(APF, DL, VT, isTarget);
}
@@ -6449,8 +6448,7 @@ SDValue SelectionDAG::FoldConstantArithmetic(unsigned Opcode, const SDLoc &DL,
C->isOpaque());
case ISD::UINT_TO_FP:
case ISD::SINT_TO_FP: {
- APFloat apf(EVTToAPFloatSemantics(VT),
- APInt::getZero(VT.getSizeInBits()));
+ APFloat apf(VT.getFltSemantics(), APInt::getZero(VT.getSizeInBits()));
(void)apf.convertFromAPInt(Val, Opcode == ISD::SINT_TO_FP,
APFloat::rmNearestTiesToEven);
return getConstantFP(apf, DL, VT);
@@ -6464,8 +6462,8 @@ SDValue SelectionDAG::FoldConstantArithmetic(unsigned Opcode, const SDLoc &DL,
// This can return overflow, underflow, or inexact; we don't care.
// FIXME need to be more flexible about rounding mode.
- (void)FPV.convert(EVTToAPFloatSemantics(VT),
- APFloat::rmNearestTiesToEven, &Ignored);
+ (void)FPV.convert(VT.getFltSemantics(), APFloat::rmNearestTiesToEven,
+ &Ignored);
return getConstantFP(FPV, DL, VT);
}
case ISD::STEP_VECTOR:
@@ -6517,7 +6515,7 @@ SDValue SelectionDAG::FoldConstantArithmetic(unsigned Opcode, const SDLoc &DL,
bool ignored;
// This can return overflow, underflow, or inexact; we don't care.
// FIXME need to be more flexible about rounding mode.
- (void)V.convert(EVTToAPFloatSemantics(VT), APFloat::rmNearestTiesToEven,
+ (void)V.convert(VT.getFltSemantics(), APFloat::rmNearestTiesToEven,
&ignored);
return getConstantFP(V, DL, VT);
}
@@ -6816,8 +6814,8 @@ SDValue SelectionDAG::foldConstantFPMath(unsigned Opcode, const SDLoc &DL,
bool Unused;
// This can return overflow, underflow, or inexact; we don't care.
// FIXME need to be more flexible about rounding mode.
- (void) C1.convert(EVTToAPFloatSemantics(VT), APFloat::rmNearestTiesToEven,
- &Unused);
+ (void)C1.convert(VT.getFltSemantics(), APFloat::rmNearestTiesToEven,
+ &Unused);
return getConstantFP(C1, DL, VT);
}
@@ -6838,7 +6836,7 @@ SDValue SelectionDAG::foldConstantFPMath(unsigned Opcode, const SDLoc &DL,
if (N1.isUndef() && N2.isUndef())
return getUNDEF(VT);
if (N1.isUndef() || N2.isUndef())
- return getConstantFP(APFloat::getNaN(EVTToAPFloatSemantics(VT)), DL, VT);
+ return getConstantFP(APFloat::getNaN(VT.getFltSemantics()), DL, VT);
}
return SDValue();
}
@@ -7663,8 +7661,7 @@ static SDValue getMemsetValue(SDValue Value, EVT VT, SelectionDAG &DAG,
!DAG.getTargetLoweringInfo().isLegalStoreImmediate(C->getSExtValue());
return DAG.getConstant(Val, dl, VT, false, IsOpaque);
}
- return DAG.getConstantFP(APFloat(DAG.EVTToAPFloatSemantics(VT), Val), dl,
- VT);
+ return DAG.getConstantFP(APFloat(VT.getFltSemantics(), Val), dl, VT);
}
assert(Value.getValueType() == MVT::i8 && "memset with non-byte fill value?");
@@ -11954,7 +11951,7 @@ bool llvm::isNeutralConstant(unsigned Opcode, SDNodeFlags Flags, SDValue V,
case ISD::FMAXNUM: {
// Neutral element for fminnum is NaN, Inf or FLT_MAX, depending on FMF.
EVT VT = V.getValueType();
- const fltSemantics &Semantics = SelectionDAG::EVTToAPFloatSemantics(VT);
+ const fltSemantics &Semantics = VT.getFltSemantics();
APFloat NeutralAF = !Flags.hasNoNaNs()
? APFloat::getQNaN(Semantics)
: !Flags.hasNoInfs()
@@ -13230,7 +13227,7 @@ SDValue SelectionDAG::getNeutralElement(unsigned Opcode, const SDLoc &DL,
case ISD::FMINNUM:
case ISD::FMAXNUM: {
// Neutral element for fminnum is NaN, Inf or FLT_MAX, depending on FMF.
- const fltSemantics &Semantics = EVTToAPFloatSemantics(VT);
+ const fltSemantics &Semantics = VT.getFltSemantics();
APFloat NeutralAF = !Flags.hasNoNaNs() ? APFloat::getQNaN(Semantics) :
!Flags.hasNoInfs() ? APFloat::getInf(Semantics) :
APFloat::getLargest(Semantics);
@@ -13242,7 +13239,7 @@ SDValue SelectionDAG::getNeutralElement(unsigned Opcode, const SDLoc &DL,
case ISD::FMINIMUM:
case ISD::FMAXIMUM: {
// Neutral element for fminimum is Inf or FLT_MAX, depending on FMF.
- const fltSemantics &Semantics = EVTToAPFloatSemantics(VT);
+ const fltSemantics &Semantics = VT.getFltSemantics();
APFloat NeutralAF = !Flags.hasNoInfs() ? APFloat::getInf(Semantics)
: APFloat::getLargest(Semantics);
if (Opcode == ISD::FMAXIMUM)
diff --git a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
index 21d7a777653f1d..c4f4261a708fda 100644
--- a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
@@ -2958,9 +2958,8 @@ bool TargetLowering::SimplifyDemandedBits(
return TLO.CombineTo(Op, TLO.DAG.getConstant(Known.One, dl, VT));
if (VT.isFloatingPoint())
return TLO.CombineTo(
- Op,
- TLO.DAG.getConstantFP(
- APFloat(TLO.DAG.EVTToAPFloatSemantics(VT), Known.One), dl, VT));
+ Op, TLO.DAG.getConstantFP(APFloat(VT.getFltSemantics(), Known.One),
+ dl, VT));
}
// A multi use 'all demanded elts' simplify failed to find any knownbits.
@@ -7236,7 +7235,7 @@ SDValue TargetLowering::getSqrtInputTest(SDValue Op, SelectionDAG &DAG,
// Testing it with denormal inputs to avoid wrong estimate.
//
// Test = fabs(X) < SmallestNormal
- const fltSemantics &FltSem = DAG.EVTToAPFloatSemantics(VT);
+ const fltSemantics &FltSem = VT.getFltSemantics();
APFloat SmallestNorm = APFloat::getSmallestNormalized(FltSem);
SDValue NormC = DAG.getConstantFP(SmallestNorm, DL, VT);
SDValue Fabs = DAG.getNode(ISD::FABS, DL, VT, Op);
@@ -8273,7 +8272,7 @@ bool TargetLowering::expandFP_TO_UINT(SDNode *Node, SDValue &Result,
// If the maximum float value is smaller then the signed integer range,
// the destination signmask can't be represented by the float, so we can
// just use FP_TO_SINT directly.
- const fltSemantics &APFSem = DAG.EVTToAPFloatSemantics(SrcVT);
+ const fltSemantics &APFSem = SrcVT.getFltSemantics();
APFloat APF(APFSem, APInt::getZero(SrcVT.getScalarSizeInBits()));
APInt SignMask = APInt::getSignMask(DstVT.getScalarSizeInBits());
if (APFloat::opOverflow &
@@ -8518,8 +8517,8 @@ SDValue TargetLowering::expandFMINIMUM_FMAXIMUM(SDNode *N,
// Propagate any NaN of both operands
if (!N->getFlags().hasNoNaNs() &&
(!DAG.isKnownNeverNaN(RHS) || !DAG.isKnownNeverNaN(LHS))) {
- ConstantFP *FPNaN = ConstantFP::get(
- *DAG.getContext(), APFloat::getNaN(DAG.EVTToAPFloatSemantics(VT)));
+ ConstantFP *FPNaN = ConstantFP::get(*DAG.getContext(),
+ APFloat::getNaN(VT.getFltSemantics()));
MinMax = DAG.getSelect(DL, VT, DAG.getSetCC(DL, CCVT, LHS, RHS, ISD::SETUO),
DAG.getConstantFP(*FPNaN, DL, VT), MinMax, Flags);
}
@@ -11263,8 +11262,9 @@ SDValue TargetLowering::expandFP_TO_INT_SAT(SDNode *Node,
SrcVT = Src.getValueType();
}
- APFloat MinFloat(DAG.EVTToAPFloatSemantics(SrcVT));
- APFloat MaxFloat(DAG.EVTToAPFloatSemantics(SrcVT));
+ const fltSemantics &Sem = SrcVT.getFltSemantics();
+ APFloat MinFloat(Sem);
+ APFloat MaxFloat(Sem);
APFloat::opStatus MinStatus =
MinFloat.convertFromAPInt(MinInt, IsSigned, APFloat::rmTowardZero);
diff --git a/llvm/lib/CodeGen/ValueTypes.cpp b/llvm/lib/CodeGen/ValueTypes.cpp
index 0c6b726a28a242..c74ea5879acb54 100644
--- a/llvm/lib/CodeGen/ValueTypes.cpp
+++ b/llvm/lib/CodeGen/ValueTypes.cpp
@@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "llvm/CodeGen/ValueTypes.h"
+#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Type.h"
@@ -289,6 +290,23 @@ EVT EVT::getEVT(Type *Ty, bool HandleUnknown){
}
}
+const fltSemantics &MVT::getFltSemantics() const {
+ switch (getScalarType().SimpleTy) {
+ default: llvm_unreachable("Unknown FP format");
+ case MVT::f16: return APFloat::IEEEhalf();
+ case MVT::bf16: return APFloat::BFloat();
+ case MVT::f32: return APFloat::IEEEsingle();
+ case MVT::f64: return APFloat::IEEEdouble();
+ case MVT::f80: return APFloat::x87DoubleExtended();
+ case MVT::f128: return APFloat::IEEEquad();
+ case MVT::ppcf128: return APFloat::PPCDoubleDouble();
+ }
+}
+
+const fltSemantics &EVT::getFltSemantics() const {
+ return getScalarType().getSimpleVT().getFltSemantics();
+}
+
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
void MVT::dump() const {
print(dbgs());
diff --git a/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp b/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
index efc1703221d21e..d855fb0676fb04 100644
--- a/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
+++ b/llvm/lib/Target/AArch64/AArch64ISelLowering.cpp
@@ -11356,8 +11356,7 @@ static SDValue getEstimate(const AArch64Subtarget *ST, unsigned Opcode,
// the result for float (23 mantissa bits) is 2 and for double (52
// mantissa bits) is 3.
constexpr unsigned AccurateBits = 8;
- unsigned DesiredBits =
- APFloat::semanticsPrecision(DAG.EVTToAPFloatSemantics(VT));
+ unsigned DesiredBits = APFloat::semanticsPrecision(VT.getFltSemantics());
ExtraSteps = DesiredBits <= AccurateBits
? 0
: Log2_64_Ceil(DesiredBits) - Log2_64_Ceil(AccurateBits);
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp b/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp
index c82d1e26899785..8c8950957dd819 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp
@@ -2590,7 +2590,7 @@ SDValue AMDGPUTarg...
[truncated]
|
You can test this locally with the following command:git-clang-format --diff d4dfeb373e95b09ef86865cb33cae21213488afe 46a9c57794dfb43197995ade0642be6bafb5b54e --extensions cpp,h -- llvm/include/llvm/CodeGen/SelectionDAG.h llvm/include/llvm/CodeGen/ValueTypes.h llvm/include/llvm/CodeGenTypes/MachineValueType.h llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp llvm/lib/CodeGen/SelectionDAG/LegalizeFloatTypes.cpp llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp llvm/lib/CodeGen/ValueTypes.cpp llvm/lib/Target/AArch64/AArch64ISelLowering.cpp llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp llvm/lib/Target/AMDGPU/SIISelLowering.cpp llvm/lib/Target/RISCV/RISCVISelLowering.cpp llvm/lib/Target/X86/X86ISelLowering.cppView the diff from clang-format here.diff --git a/llvm/lib/CodeGen/ValueTypes.cpp b/llvm/lib/CodeGen/ValueTypes.cpp
index c74ea5879a..458fdfd59f 100644
--- a/llvm/lib/CodeGen/ValueTypes.cpp
+++ b/llvm/lib/CodeGen/ValueTypes.cpp
@@ -292,14 +292,22 @@ EVT EVT::getEVT(Type *Ty, bool HandleUnknown){
const fltSemantics &MVT::getFltSemantics() const {
switch (getScalarType().SimpleTy) {
- default: llvm_unreachable("Unknown FP format");
- case MVT::f16: return APFloat::IEEEhalf();
- case MVT::bf16: return APFloat::BFloat();
- case MVT::f32: return APFloat::IEEEsingle();
- case MVT::f64: return APFloat::IEEEdouble();
- case MVT::f80: return APFloat::x87DoubleExtended();
- case MVT::f128: return APFloat::IEEEquad();
- case MVT::ppcf128: return APFloat::PPCDoubleDouble();
+ default:
+ llvm_unreachable("Unknown FP format");
+ case MVT::f16:
+ return APFloat::IEEEhalf();
+ case MVT::bf16:
+ return APFloat::BFloat();
+ case MVT::f32:
+ return APFloat::IEEEsingle();
+ case MVT::f64:
+ return APFloat::IEEEdouble();
+ case MVT::f80:
+ return APFloat::x87DoubleExtended();
+ case MVT::f128:
+ return APFloat::IEEEquad();
+ case MVT::ppcf128:
+ return APFloat::PPCDoubleDouble();
}
}
|
s-barannikov
approved these changes
Aug 13, 2024
| @@ -6449,8 +6448,7 @@ SDValue SelectionDAG::FoldConstantArithmetic(unsigned Opcode, const SDLoc &DL, | |||
| C->isOpaque()); | |||
| case ISD::UINT_TO_FP: | |||
| case ISD::SINT_TO_FP: { | |||
| APFloat apf(EVTToAPFloatSemantics(VT), | |||
| APInt::getZero(VT.getSizeInBits())); | |||
| APFloat apf(VT.getFltSemantics(), APInt::getZero(VT.getSizeInBits())); | |||
There was a problem hiding this comment.
(nit) Might be a good chance to capitalize some variable names (here and in the other places).
arsenm
approved these changes
Aug 13, 2024
topperc
added a commit
that referenced
this pull request
Aug 13, 2024
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
Add a new getFltSemantics method to MVT and EVT. Use these new methods to replace SelectionDAG::EVTToAPFloatSemantics.