DAG: Use fast variants of fast math libcalls #147481
Open
+501
−60
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
This was referenced Jul 8, 2025
This was referenced Jul 8, 2025
arsenm
added
backend:Hexagon
llvm:SelectionDAG
Graphite App
|
@llvm/pr-subscribers-tablegen @llvm/pr-subscribers-backend-hexagon Author: Matt Arsenault (arsenm) ChangesHexagon currently has an untested global flag to control fast Patch is 67.92 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/147481.diff 13 Files Affected:
diff --git a/llvm/include/llvm/CodeGen/RuntimeLibcallUtil.h b/llvm/include/llvm/CodeGen/RuntimeLibcallUtil.h
index 451459eda25e9..edbfc1ec6b326 100644
--- a/llvm/include/llvm/CodeGen/RuntimeLibcallUtil.h
+++ b/llvm/include/llvm/CodeGen/RuntimeLibcallUtil.h
@@ -109,9 +109,6 @@ LLVM_ABI Libcall getMEMMOVE_ELEMENT_UNORDERED_ATOMIC(uint64_t ElementSize);
/// UNKNOW_LIBCALL if there is none.
LLVM_ABI Libcall getMEMSET_ELEMENT_UNORDERED_ATOMIC(uint64_t ElementSize);
-/// Initialize the default condition code on the libcalls.
-LLVM_ABI void initCmpLibcallCCs(ISD::CondCode *CmpLibcallCCs);
-
} // namespace RTLIB
} // namespace llvm
diff --git a/llvm/include/llvm/CodeGen/TargetLowering.h b/llvm/include/llvm/CodeGen/TargetLowering.h
index fee94cc167363..fa46d296bf533 100644
--- a/llvm/include/llvm/CodeGen/TargetLowering.h
+++ b/llvm/include/llvm/CodeGen/TargetLowering.h
@@ -3571,19 +3571,10 @@ class LLVM_ABI TargetLoweringBase {
const char *getMemcpyName() const { return Libcalls.getMemcpyName(); }
- /// Override the default CondCode to be used to test the result of the
- /// comparison libcall against zero.
- /// FIXME: This should be removed
- void setCmpLibcallCC(RTLIB::Libcall Call, CmpInst::Predicate Pred) {
- Libcalls.setSoftFloatCmpLibcallPredicate(Call, Pred);
- }
-
- /// Get the CondCode that's to be used to test the result of the comparison
- /// libcall against zero.
- CmpInst::Predicate
- getSoftFloatCmpLibcallPredicate(RTLIB::Libcall Call) const {
- return Libcalls.getSoftFloatCmpLibcallPredicate(Call);
- }
+ /// Get the comparison predicate that's to be used to test the result of the
+ /// comparison libcall against zero. This should only be used with
+ /// floating-point compare libcalls.
+ ISD::CondCode getSoftFloatCmpLibcallPredicate(RTLIB::LibcallImpl Call) const;
/// Set the CallingConv that should be used for the specified libcall.
void setLibcallImplCallingConv(RTLIB::LibcallImpl Call, CallingConv::ID CC) {
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.h b/llvm/include/llvm/IR/RuntimeLibcalls.h
index e9db7d1259009..e8ddaf1707bae 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.h
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.h
@@ -59,8 +59,6 @@ struct RuntimeLibcallsInfo {
ExceptionHandling ExceptionModel = ExceptionHandling::None,
FloatABI::ABIType FloatABI = FloatABI::Default,
EABI EABIVersion = EABI::Default, StringRef ABIName = "") {
- initSoftFloatCmpLibcallPredicates();
-
// FIXME: The ExceptionModel parameter is to handle the field in
// TargetOptions. This interface fails to distinguish the forced disable
// case for targets which support exceptions by default. This should
@@ -114,22 +112,6 @@ struct RuntimeLibcallsInfo {
return ArrayRef(LibcallImpls).drop_front();
}
- /// Get the comparison predicate that's to be used to test the result of the
- /// comparison libcall against zero. This should only be used with
- /// floating-point compare libcalls.
- // FIXME: This should be a function of RTLIB::LibcallImpl
- CmpInst::Predicate
- getSoftFloatCmpLibcallPredicate(RTLIB::Libcall Call) const {
- return SoftFloatCompareLibcallPredicates[Call];
- }
-
- // FIXME: This should be removed. This should be private constant.
- // FIXME: This should be a function of RTLIB::LibcallImpl
- void setSoftFloatCmpLibcallPredicate(RTLIB::Libcall Call,
- CmpInst::Predicate Pred) {
- SoftFloatCompareLibcallPredicates[Call] = Pred;
- }
-
/// Return a function name compatible with RTLIB::MEMCPY, or nullptr if fully
/// unsupported.
const char *getMemcpyName() const {
@@ -140,6 +122,11 @@ struct RuntimeLibcallsInfo {
return getLibcallName(RTLIB::MEMMOVE);
}
+ /// Return the libcall provided by \p Impl
+ static RTLIB::Libcall getLibcallFromImpl(RTLIB::LibcallImpl Impl) {
+ return ImplToLibcall[Impl];
+ }
+
private:
static const RTLIB::LibcallImpl
DefaultLibcallImpls[RTLIB::UNKNOWN_LIBCALL + 1];
@@ -155,14 +142,6 @@ struct RuntimeLibcallsInfo {
/// implementation.;
CallingConv::ID LibcallImplCallingConvs[RTLIB::NumLibcallImpls] = {};
- /// The condition type that should be used to test the result of each of the
- /// soft floating-point comparison libcall against integer zero.
- ///
- // FIXME: This is only relevant for the handful of floating-point comparison
- // runtime calls; it's excessive to have a table entry for every single
- // opcode.
- CmpInst::Predicate SoftFloatCompareLibcallPredicates[RTLIB::UNKNOWN_LIBCALL];
-
/// Names of concrete implementations of runtime calls. e.g. __ashlsi3 for
/// SHL_I32
static const char *const LibCallImplNames[RTLIB::NumLibcallImpls];
@@ -198,9 +177,8 @@ struct RuntimeLibcallsInfo {
void initDefaultLibCallImpls();
/// Generated by tablegen.
- void setTargetRuntimeLibcallSets(const Triple &TT);
-
- void initSoftFloatCmpLibcallPredicates();
+ void setTargetRuntimeLibcallSets(const Triple &TT,
+ FloatABI::ABIType FloatABI);
/// Set default libcall names. If a target wants to opt-out of a libcall it
/// should be placed here.
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index c15ffa0653335..2099aae877861 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -17,6 +17,7 @@ class DuplicateLibcallImplWithPrefix<RuntimeLibcallImpl Impl, string prefix>
/// Libcall Predicates
def isOSDarwin : RuntimeLibcallPredicate<"TT.isOSDarwin()">;
+def isOSWindows : RuntimeLibcallPredicate<"TT.isOSWindows()">;
def darwinHasSinCosStret : RuntimeLibcallPredicate<"darwinHasSinCosStret(TT)">;
def darwinHasExp10 : RuntimeLibcallPredicate<"darwinHasExp10(TT)">;
@@ -61,13 +62,24 @@ foreach IntTy = ["I32", "I64", "I128"] in {
foreach FPTy = ["F32", "F64", "F80", "F128", "PPCF128"] in {
def ADD_#FPTy : RuntimeLibcall;
+ def FAST_ADD_#FPTy : RuntimeLibcall;
+
def SUB_#FPTy : RuntimeLibcall;
+ def FAST_SUB_#FPTy : RuntimeLibcall;
+
def MUL_#FPTy : RuntimeLibcall;
+ def FAST_MUL_#FPTy : RuntimeLibcall;
+
def DIV_#FPTy : RuntimeLibcall;
+ def FAST_DIV_#FPTy : RuntimeLibcall;
+
def REM_#FPTy : RuntimeLibcall;
def FMA_#FPTy : RuntimeLibcall;
def POWI_#FPTy : RuntimeLibcall;
+
def SQRT_#FPTy : RuntimeLibcall;
+ def FAST_SQRT_#FPTy : RuntimeLibcall;
+
def CBRT_#FPTy : RuntimeLibcall;
def LOG_#FPTy : RuntimeLibcall;
def LOG_FINITE_#FPTy : RuntimeLibcall;
@@ -1272,6 +1284,7 @@ def __aeabi_memclr4 : RuntimeLibcallImpl<AEABI_MEMCLR4>;
def __aeabi_memclr8 : RuntimeLibcallImpl<AEABI_MEMCLR8>;
// isTargetWindows()
+defset list<RuntimeLibcallImpl> WindowsFPIntCastLibcalls = {
def __stoi64 : RuntimeLibcallImpl<FPTOSINT_F32_I64>; // CallingConv::ARM_AAPCS_VFP
def __dtoi64 : RuntimeLibcallImpl<FPTOSINT_F64_I64>; // CallingConv::ARM_AAPCS_VFP
def __stou64 : RuntimeLibcallImpl<FPTOUINT_F32_I64>; // CallingConv::ARM_AAPCS_VFP
@@ -1280,6 +1293,7 @@ def __i64tos : RuntimeLibcallImpl<SINTTOFP_I64_F32>; // CallingConv::ARM_AAPCS_V
def __i64tod : RuntimeLibcallImpl<SINTTOFP_I64_F64>; // CallingConv::ARM_AAPCS_VFP
def __u64tos : RuntimeLibcallImpl<UINTTOFP_I64_F32>; // CallingConv::ARM_AAPCS_VFP
def __u64tod : RuntimeLibcallImpl<UINTTOFP_I64_F64>; // CallingConv::ARM_AAPCS_VFP
+}
def __rt_sdiv : RuntimeLibcallImpl<SDIVREM_I32>; // CallingConv::ARM_AAPCS
def __rt_sdiv64 : RuntimeLibcallImpl<SDIVREM_I64>; // CallingConv::ARM_AAPCS
@@ -1306,6 +1320,51 @@ def __aeabi_h2f : RuntimeLibcallImpl<FPEXT_F16_F32>; // CallingConv::ARM_AAPCS
def __gnu_f2h_ieee : RuntimeLibcallImpl<FPROUND_F32_F16>;
def __gnu_h2f_ieee : RuntimeLibcallImpl<FPEXT_F16_F32>;
+
+def WindowARMDivRemCalls : LibcallImpls<
+ (add __rt_sdiv, __rt_sdiv64, __rt_udiv, __rt_udiv64),
+ isOSWindows> {
+ let CallingConv = ARM_AAPCS;
+}
+
+def WindowARMFPIntCasts : LibcallImpls<
+ (add WindowsFPIntCastLibcalls),
+ isOSWindows> {
+ let CallingConv = ARM_AAPCS_VFP;
+}
+
+
+// Register based DivRem for AEABI (RTABI 4.2)
+def AEABIDivRemCalls : LibcallImpls<
+ (add __aeabi_idivmod, __aeabi_ldivmod,
+ __aeabi_uidivmod, __aeabi_uldivmod),
+ RuntimeLibcallPredicate<[{TT.isTargetAEABI() || TT.isAndroid() || TT.isTargetGNUAEABI() ||
+ TT.isTargetMuslAEABI()}]>> {
+ let CallingConv = ARM_AAPCS;
+}
+
+def isARMOrThumb : RuntimeLibcallPredicate<"TT.isARM() || TT.isThumb()">;
+
+def ARMSystemLibrary
+ : SystemRuntimeLibrary<isARMOrThumb,
+ (add DefaultLibcallImpls32,
+ WindowARMDivRemCalls,
+ WindowARMFPIntCasts,
+ AEABIDivRemCalls,
+ DarwinSinCosStret, DarwinExp10,
+
+ // Use divmod compiler-rt calls for iOS 5.0 and later.
+ LibcallImpls<(add __divmodsi4, __udivmodsi4),
+ RuntimeLibcallPredicate<[{TT.isOSBinFormatMachO() &&
+ (!TT.isiOS() || !TT.isOSVersionLT(5, 0))}]>>)> {
+ let DefaultLibcallCallingConv = LibcallCallingConv<[{
+ (!TT.isOSDarwin() && !TT.isiOS() && !TT.isWatchOS() && !TT.isDriverKit()) ?
+ (FloatABI == FloatABI::Hard ? CallingConv::ARM_AAPCS_VFP
+ : CallingConv::ARM_AAPCS) :
+ CallingConv::C
+ }]>;
+}
+
//===----------------------------------------------------------------------===//
// AVR Runtime Libcalls
//===----------------------------------------------------------------------===//
@@ -1364,27 +1423,26 @@ def __hexagon_moddi3 : RuntimeLibcallImpl<SREM_I64>;
def __hexagon_umodsi3 : RuntimeLibcallImpl<UREM_I32>;
def __hexagon_umoddi3 : RuntimeLibcallImpl<UREM_I64>;
-// FIXME: "Fast" versions should be treated as a separate RTLIB::FAST_* function
def __hexagon_adddf3 : RuntimeLibcallImpl<ADD_F64>;
-def __hexagon_fast_adddf3 : RuntimeLibcallImpl<ADD_F64>;
+def __hexagon_fast_adddf3 : RuntimeLibcallImpl<FAST_ADD_F64>;
def __hexagon_subdf3 : RuntimeLibcallImpl<SUB_F64>;
-def __hexagon_fast_subdf3 : RuntimeLibcallImpl<SUB_F64>;
+def __hexagon_fast_subdf3 : RuntimeLibcallImpl<FAST_SUB_F64>;
def __hexagon_muldf3 : RuntimeLibcallImpl<MUL_F64>;
-def __hexagon_fast_muldf3 : RuntimeLibcallImpl<MUL_F64>;
+def __hexagon_fast_muldf3 : RuntimeLibcallImpl<FAST_MUL_F64>;
def __hexagon_divdf3 : RuntimeLibcallImpl<DIV_F64>;
-def __hexagon_fast_divdf3 : RuntimeLibcallImpl<DIV_F64>;
+def __hexagon_fast_divdf3 : RuntimeLibcallImpl<FAST_DIV_F64>;
def __hexagon_divsf3 : RuntimeLibcallImpl<DIV_F32>;
-def __hexagon_fast_divsf3 : RuntimeLibcallImpl<DIV_F32>;
+def __hexagon_fast_divsf3 : RuntimeLibcallImpl<FAST_DIV_F32>;
def __hexagon_sqrtf : RuntimeLibcallImpl<SQRT_F32>;
-def __hexagon_fast2_sqrtf : RuntimeLibcallImpl<SQRT_F32>;
+def __hexagon_fast2_sqrtf : RuntimeLibcallImpl<FAST_SQRT_F32>;
// This is the only fast library function for sqrtd.
-def __hexagon_fast2_sqrtdf2 : RuntimeLibcallImpl<SQRT_F64>;
+def __hexagon_fast2_sqrtdf2 : RuntimeLibcallImpl<FAST_SQRT_F64>;
def __hexagon_memcpy_likely_aligned_min32bytes_mult8bytes
: RuntimeLibcallImpl<HEXAGON_MEMCPY_LIKELY_ALIGNED_MIN32BYTES_MULT8BYTES>;
diff --git a/llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
index f5f4d71236fee..76432d4d760f3 100644
--- a/llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
@@ -140,12 +140,19 @@ class SelectionDAGLegalize {
RTLIB::Libcall Call_F128,
RTLIB::Libcall Call_PPCF128,
SmallVectorImpl<SDValue> &Results);
- SDValue ExpandIntLibCall(SDNode *Node, bool isSigned,
- RTLIB::Libcall Call_I8,
- RTLIB::Libcall Call_I16,
- RTLIB::Libcall Call_I32,
- RTLIB::Libcall Call_I64,
- RTLIB::Libcall Call_I128);
+
+ void
+ ExpandFastFPLibCall(SDNode *Node, bool IsFast,
+ std::pair<RTLIB::Libcall, RTLIB::Libcall> Call_F32,
+ std::pair<RTLIB::Libcall, RTLIB::Libcall> Call_F64,
+ std::pair<RTLIB::Libcall, RTLIB::Libcall> Call_F80,
+ std::pair<RTLIB::Libcall, RTLIB::Libcall> Call_F128,
+ std::pair<RTLIB::Libcall, RTLIB::Libcall> Call_PPCF128,
+ SmallVectorImpl<SDValue> &Results);
+
+ SDValue ExpandIntLibCall(SDNode *Node, bool isSigned, RTLIB::Libcall Call_I8,
+ RTLIB::Libcall Call_I16, RTLIB::Libcall Call_I32,
+ RTLIB::Libcall Call_I64, RTLIB::Libcall Call_I128);
void ExpandArgFPLibCall(SDNode *Node,
RTLIB::Libcall Call_F32, RTLIB::Libcall Call_F64,
RTLIB::Libcall Call_F80, RTLIB::Libcall Call_F128,
@@ -2229,6 +2236,37 @@ void SelectionDAGLegalize::ExpandFPLibCall(SDNode* Node,
ExpandFPLibCall(Node, LC, Results);
}
+void SelectionDAGLegalize::ExpandFastFPLibCall(
+ SDNode *Node, bool IsFast,
+ std::pair<RTLIB::Libcall, RTLIB::Libcall> Call_F32,
+ std::pair<RTLIB::Libcall, RTLIB::Libcall> Call_F64,
+ std::pair<RTLIB::Libcall, RTLIB::Libcall> Call_F80,
+ std::pair<RTLIB::Libcall, RTLIB::Libcall> Call_F128,
+ std::pair<RTLIB::Libcall, RTLIB::Libcall> Call_PPCF128,
+ SmallVectorImpl<SDValue> &Results) {
+
+ EVT VT = Node->getSimpleValueType(0);
+
+ RTLIB::Libcall LC;
+
+ // FIXME: Probably should define fast to respect nan/inf and only be
+ // approximate functions.
+
+ if (IsFast) {
+ LC = RTLIB::getFPLibCall(VT, Call_F32.first, Call_F64.first, Call_F80.first,
+ Call_F128.first, Call_PPCF128.first);
+ }
+
+ if (!IsFast || TLI.getLibcallImpl(LC) == RTLIB::Unsupported) {
+ // Fall back if we don't have a fast implementation.
+ LC = RTLIB::getFPLibCall(VT, Call_F32.second, Call_F64.second,
+ Call_F80.second, Call_F128.second,
+ Call_PPCF128.second);
+ }
+
+ ExpandFPLibCall(Node, LC, Results);
+}
+
SDValue SelectionDAGLegalize::ExpandIntLibCall(SDNode* Node, bool isSigned,
RTLIB::Libcall Call_I8,
RTLIB::Libcall Call_I16,
@@ -4489,6 +4527,18 @@ bool SelectionDAGLegalize::ExpandNode(SDNode *Node) {
return true;
}
+/// Return if we can use the FAST_* variant of a math libcall for the node.
+/// FIXME: This is just guessing, we probably should have unique specific sets
+/// flags required per libcall.
+static bool canUseFastMathLibcall(const SDNode *Node) {
+ // FIXME: Probably should define fast to respect nan/inf and only be
+ // approximate functions.
+
+ SDNodeFlags Flags = Node->getFlags();
+ return Flags.hasApproximateFuncs() && Flags.hasNoNaNs() &&
+ Flags.hasNoInfs() && Flags.hasNoSignedZeros();
+}
+
void SelectionDAGLegalize::ConvertNodeToLibcall(SDNode *Node) {
LLVM_DEBUG(dbgs() << "Trying to convert node to libcall\n");
SmallVector<SDValue, 8> Results;
@@ -4609,11 +4659,18 @@ void SelectionDAGLegalize::ConvertNodeToLibcall(SDNode *Node) {
RTLIB::FMAXIMUM_NUM_PPCF128, Results);
break;
case ISD::FSQRT:
- case ISD::STRICT_FSQRT:
- ExpandFPLibCall(Node, RTLIB::SQRT_F32, RTLIB::SQRT_F64,
- RTLIB::SQRT_F80, RTLIB::SQRT_F128,
- RTLIB::SQRT_PPCF128, Results);
+ case ISD::STRICT_FSQRT: {
+ // FIXME: Probably should define fast to respect nan/inf and only be
+ // approximate functions.
+ ExpandFastFPLibCall(Node, canUseFastMathLibcall(Node),
+ {RTLIB::FAST_SQRT_F32, RTLIB::SQRT_F32},
+ {RTLIB::FAST_SQRT_F64, RTLIB::SQRT_F64},
+ {RTLIB::FAST_SQRT_F80, RTLIB::SQRT_F80},
+ {RTLIB::FAST_SQRT_F128, RTLIB::SQRT_F128},
+ {RTLIB::FAST_SQRT_PPCF128, RTLIB::SQRT_PPCF128},
+ Results);
break;
+ }
case ISD::FCBRT:
ExpandFPLibCall(Node, RTLIB::CBRT_F32, RTLIB::CBRT_F64,
RTLIB::CBRT_F80, RTLIB::CBRT_F128,
@@ -4850,11 +4907,15 @@ void SelectionDAGLegalize::ConvertNodeToLibcall(SDNode *Node) {
RTLIB::LLRINT_PPCF128, Results);
break;
case ISD::FDIV:
- case ISD::STRICT_FDIV:
- ExpandFPLibCall(Node, RTLIB::DIV_F32, RTLIB::DIV_F64,
- RTLIB::DIV_F80, RTLIB::DIV_F128,
- RTLIB::DIV_PPCF128, Results);
+ case ISD::STRICT_FDIV: {
+ ExpandFastFPLibCall(Node, canUseFastMathLibcall(Node),
+ {RTLIB::FAST_DIV_F32, RTLIB::DIV_F32},
+ {RTLIB::FAST_DIV_F64, RTLIB::DIV_F64},
+ {RTLIB::FAST_DIV_F80, RTLIB::DIV_F80},
+ {RTLIB::FAST_DIV_F128, RTLIB::DIV_F128},
+ {RTLIB::FAST_DIV_PPCF128, RTLIB::DIV_PPCF128}, Results);
break;
+ }
case ISD::FREM:
case ISD::STRICT_FREM:
ExpandFPLibCall(Node, RTLIB::REM_F32, RTLIB::REM_F64,
@@ -4868,17 +4929,25 @@ void SelectionDAGLegalize::ConvertNodeToLibcall(SDNode *Node) {
RTLIB::FMA_PPCF128, Results);
break;
case ISD::FADD:
- case ISD::STRICT_FADD:
- ExpandFPLibCall(Node, RTLIB::ADD_F32, RTLIB::ADD_F64,
- RTLIB::ADD_F80, RTLIB::ADD_F128,
- RTLIB::ADD_PPCF128, Results);
+ case ISD::STRICT_FADD: {
+ ExpandFastFPLibCall(Node, canUseFastMathLibcall(Node),
+ {RTLIB::FAST_ADD_F32, RTLIB::ADD_F32},
+ {RTLIB::FAST_ADD_F64, RTLIB::ADD_F64},
+ {RTLIB::FAST_ADD_F80, RTLIB::ADD_F80},
+ {RTLIB::FAST_ADD_F128, RTLIB::ADD_F128},
+ {RTLIB::FAST_ADD_PPCF128, RTLIB::ADD_PPCF128}, Results);
break;
+ }
case ISD::FMUL:
- case ISD::STRICT_FMUL:
- ExpandFPLibCall(Node, RTLIB::MUL_F32, RTLIB::MUL_F64,
- RTLIB::MUL_F80, RTLIB::MUL_F128,
- RTLIB::MUL_PPCF128, Results);
+ case ISD::STRICT_FMUL: {
+ ExpandFastFPLibCall(Node, canUseFastMathLibcall(Node),
+ {RTLIB::FAST_MUL_F32, RTLIB::MUL_F32},
+ {RTLIB::FAST_MUL_F64, RTLIB::MUL_F64},
+ {RTLIB::FAST_MUL_F80, RTLIB::MUL_F80},
+ {RTLIB::FAST_MUL_F128, RTLIB::MUL_F128},
+ {RTLIB::FAST_MUL_PPCF128, RTLIB::MUL_PPCF128}, Results);
break;
+ }
case ISD::FP16_TO_FP:
if (Node->getValueType(0) == MVT::f32) {
Results.push_back(ExpandLibCall(RTLIB::FPEXT_F16_F32, Node, false).first);
@@ -5051,11 +5120,15 @@ void SelectionDAGLegalize::ConvertNodeToLibcall(SDNode *Node) {
break;
}
case ISD::FSUB:
- case ISD::STRICT_FSUB:
- ExpandFPLibCall(Node, RTLIB::SUB_F32, RTLIB::SUB_F64,
- RTLIB::SUB_F80, RTLIB::SUB_F128,
- RTLIB::SUB_PPCF128, Results);
+ case ISD::STRICT_FSUB: {
+ ExpandFastFPLibCall(Node, canUseFastMathLibcall(Node),
+ {RTLIB::FAST_SUB_F32, RTLIB::SUB_F32},
+ {RTLIB::FAST_SUB_F64, RTLIB::SUB_F64},
+ {RTLIB::FAST_SUB_F80, RTLIB::SUB_F80},
+ {RTLIB::FAST_SUB_F128, RTLIB::SUB_F128},
+ {RTLIB::FAST_SUB_PPCF128, RTLIB::SUB_PPCF128}, Results);
break;
+ }
case ISD::SREM:
Results.push_back(ExpandIntLibCall(Node, true,
RTLIB::SREM_I8,
diff --git a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
index 45ab7526c3a32..b90c80002151f 100644
--- a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
@@ -424,7 +424,13 @@ void TargetLowering::softenSetCCOperands(SelectionDAG &DAG, EVT VT,
NewLHS = Call.first;
NewRHS = DAG.getConstant(0, dl, RetVT);
- CCCode = getICmpCondCode(getSoftFloatCmpLibcallPredicate(LC1));
+ RTLIB::LibcallImpl LC1Impl = getLibcallImpl(LC1);
+ if (LC1Impl == RTLIB::Unsupported) {
+ reportFatalUsageError(
+ "no libcall available to soften floating-point compare");
+ }
+
+ CCCode = getSoftFloatCmpLibcallPredicate(LC1Impl);
if (ShouldInvertCC) {
assert(RetVT.isIn...
[truncated]
|
arsenm
requested review from
aankit-ca,
androm3da,
kparzysz,
RKSimon and
SundeepKushwaha
arsenm
force-pushed
the
users/arsenm/arm/start-moving-runtime-libcalls-into-tablegen
branch
from
98fdafa to
711189f
Compare
arsenm
force-pushed
the
users/arsenm/dag/use-fast-variants-math-libcalls
branch
from
920b061 to
24ff719
Compare
arsenm
force-pushed
the
users/arsenm/arm/start-moving-runtime-libcalls-into-tablegen
branch
from
711189f to
2a67f3f
Compare
arsenm
force-pushed
the
users/arsenm/dag/use-fast-variants-math-libcalls
branch
from
24ff719 to
714bcdf
Compare
This was referenced Jul 9, 2025
arsenm
force-pushed
the
users/arsenm/arm/start-moving-runtime-libcalls-into-tablegen
branch
from
2a67f3f to
469114e
Compare
Hexagon currently has an untested global flag to control fast math variants of libcalls. Add fast variants as explicit libcall options so this can be a flag based lowering decision, and implement it. I have no idea what fast math flags the hexagon case requires, so I picked the maximally potentially relevant set of flags although this probably is refinable per call. Looking in compiler-rt, I'm not sure if the fast variants are anything more than aliases.
arsenm
force-pushed
the
users/arsenm/dag/use-fast-variants-math-libcalls
branch
from
714bcdf to
83257ed
Compare
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.
Hexagon currently has an untested global flag to control fast
math variants of libcalls. Add fast variants as explicit libcall
options so this can be a flag based lowering decision, and implement
it. I have no idea what fast math flags the hexagon case requires,
so I picked the maximally potentially relevant set of flags although
this probably is refinable per call. Looking in compiler-rt, I'm not
sure if the fast variants are anything more than aliases.