From b5e94deae4c9a4a1ed53a56f66892120070bf3d9 Mon Sep 17 00:00:00 2001 From: Matt Arsenault Date: Mon, 23 Jun 2025 19:10:30 +0900 Subject: [PATCH 1/3] RuntimeLibcalls: Remove table of soft float compare cond codes Previously we had a table of entries for every Libcall for the comparison to use against an integer 0 if it was a soft float compare function. This was only relevant to a handful of opcodes, so it was wasteful. Now that we can distinguish the abstract libcall for the compare with the concrete implementation, we can just directly hardcode the comparison against the libcall impl without this configuration system. --- .../include/llvm/CodeGen/RuntimeLibcallUtil.h | 3 - llvm/include/llvm/CodeGen/TargetLowering.h | 17 +- llvm/include/llvm/IR/RuntimeLibcalls.h | 33 +--- .../CodeGen/SelectionDAG/TargetLowering.cpp | 16 +- llvm/lib/CodeGen/TargetLoweringBase.cpp | 107 +++++++---- llvm/lib/IR/RuntimeLibcalls.cpp | 31 --- llvm/lib/Target/ARM/ARMISelLowering.cpp | 176 +++++++++--------- 7 files changed, 182 insertions(+), 201 deletions(-) diff --git a/llvm/include/llvm/CodeGen/RuntimeLibcallUtil.h b/llvm/include/llvm/CodeGen/RuntimeLibcallUtil.h index f865b8c1583f8..a9e53bae897ad 100644 --- a/llvm/include/llvm/CodeGen/RuntimeLibcallUtil.h +++ b/llvm/include/llvm/CodeGen/RuntimeLibcallUtil.h @@ -117,9 +117,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 131aa8bf7faef..3913626b412cf 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_back(); } - /// 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 LLVM_ABI static const char *const LibCallImplNames[RTLIB::NumLibcallImpls]; @@ -200,8 +179,6 @@ struct RuntimeLibcallsInfo { /// Generated by tablegen. void setTargetRuntimeLibcallSets(const Triple &TT); - LLVM_ABI void initSoftFloatCmpLibcallPredicates(); - /// Set default libcall names. If a target wants to opt-out of a libcall it /// should be placed here. LLVM_ABI void initLibcalls(const Triple &TT, ExceptionHandling ExceptionModel, 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.isInteger()); CCCode = getSetCCInverse(CCCode, RetVT); @@ -434,6 +440,12 @@ void TargetLowering::softenSetCCOperands(SelectionDAG &DAG, EVT VT, // Update Chain. Chain = Call.second; } else { + RTLIB::LibcallImpl LC2Impl = getLibcallImpl(LC2); + if (LC2Impl == RTLIB::Unsupported) { + reportFatalUsageError( + "no libcall available to soften floating-point compare"); + } + assert(CCCode == (ShouldInvertCC ? ISD::SETEQ : ISD::SETNE) && "unordered call should be simple boolean"); @@ -446,7 +458,7 @@ void TargetLowering::softenSetCCOperands(SelectionDAG &DAG, EVT VT, SDValue Tmp = DAG.getSetCC(dl, SetCCVT, NewLHS, NewRHS, CCCode); auto Call2 = makeLibCall(DAG, LC2, RetVT, Ops, CallOptions, dl, Chain); - CCCode = getICmpCondCode(getSoftFloatCmpLibcallPredicate(LC2)); + CCCode = getSoftFloatCmpLibcallPredicate(LC2Impl); if (ShouldInvertCC) CCCode = getSetCCInverse(CCCode, RetVT); NewLHS = DAG.getSetCC(dl, SetCCVT, Call2.first, NewRHS, CCCode); diff --git a/llvm/lib/CodeGen/TargetLoweringBase.cpp b/llvm/lib/CodeGen/TargetLoweringBase.cpp index 85b148a466e52..e114272d17055 100644 --- a/llvm/lib/CodeGen/TargetLoweringBase.cpp +++ b/llvm/lib/CodeGen/TargetLoweringBase.cpp @@ -609,37 +609,80 @@ RTLIB::Libcall RTLIB::getMEMSET_ELEMENT_UNORDERED_ATOMIC(uint64_t ElementSize) { } } -void RTLIB::initCmpLibcallCCs(ISD::CondCode *CmpLibcallCCs) { - std::fill(CmpLibcallCCs, CmpLibcallCCs + RTLIB::UNKNOWN_LIBCALL, - ISD::SETCC_INVALID); - CmpLibcallCCs[RTLIB::OEQ_F32] = ISD::SETEQ; - CmpLibcallCCs[RTLIB::OEQ_F64] = ISD::SETEQ; - CmpLibcallCCs[RTLIB::OEQ_F128] = ISD::SETEQ; - CmpLibcallCCs[RTLIB::OEQ_PPCF128] = ISD::SETEQ; - CmpLibcallCCs[RTLIB::UNE_F32] = ISD::SETNE; - CmpLibcallCCs[RTLIB::UNE_F64] = ISD::SETNE; - CmpLibcallCCs[RTLIB::UNE_F128] = ISD::SETNE; - CmpLibcallCCs[RTLIB::UNE_PPCF128] = ISD::SETNE; - CmpLibcallCCs[RTLIB::OGE_F32] = ISD::SETGE; - CmpLibcallCCs[RTLIB::OGE_F64] = ISD::SETGE; - CmpLibcallCCs[RTLIB::OGE_F128] = ISD::SETGE; - CmpLibcallCCs[RTLIB::OGE_PPCF128] = ISD::SETGE; - CmpLibcallCCs[RTLIB::OLT_F32] = ISD::SETLT; - CmpLibcallCCs[RTLIB::OLT_F64] = ISD::SETLT; - CmpLibcallCCs[RTLIB::OLT_F128] = ISD::SETLT; - CmpLibcallCCs[RTLIB::OLT_PPCF128] = ISD::SETLT; - CmpLibcallCCs[RTLIB::OLE_F32] = ISD::SETLE; - CmpLibcallCCs[RTLIB::OLE_F64] = ISD::SETLE; - CmpLibcallCCs[RTLIB::OLE_F128] = ISD::SETLE; - CmpLibcallCCs[RTLIB::OLE_PPCF128] = ISD::SETLE; - CmpLibcallCCs[RTLIB::OGT_F32] = ISD::SETGT; - CmpLibcallCCs[RTLIB::OGT_F64] = ISD::SETGT; - CmpLibcallCCs[RTLIB::OGT_F128] = ISD::SETGT; - CmpLibcallCCs[RTLIB::OGT_PPCF128] = ISD::SETGT; - CmpLibcallCCs[RTLIB::UO_F32] = ISD::SETNE; - CmpLibcallCCs[RTLIB::UO_F64] = ISD::SETNE; - CmpLibcallCCs[RTLIB::UO_F128] = ISD::SETNE; - CmpLibcallCCs[RTLIB::UO_PPCF128] = ISD::SETNE; +ISD::CondCode TargetLoweringBase::getSoftFloatCmpLibcallPredicate( + RTLIB::LibcallImpl Impl) const { + switch (Impl) { + case RTLIB::__aeabi_dcmpeq__ne: + return ISD::SETNE; + case RTLIB::__aeabi_dcmpeq__eq: + return ISD::SETEQ; + case RTLIB::__aeabi_dcmplt: + return ISD::SETNE; + case RTLIB::__aeabi_dcmple: + return ISD::SETNE; + case RTLIB::__aeabi_dcmpge: + return ISD::SETNE; + case RTLIB::__aeabi_dcmpgt: + return ISD::SETNE; + case RTLIB::__aeabi_dcmpun: + return ISD::SETNE; + case RTLIB::__aeabi_fcmpeq__ne: + return ISD::SETNE; + case RTLIB::__aeabi_fcmpeq__eq: + return ISD::SETEQ; + case RTLIB::__aeabi_fcmplt: + return ISD::SETNE; + case RTLIB::__aeabi_fcmple: + return ISD::SETNE; + case RTLIB::__aeabi_fcmpge: + return ISD::SETNE; + case RTLIB::__aeabi_fcmpgt: + return ISD::SETNE; + default: + break; + } + + // Assume libgcc/compiler-rt behavior + RTLIB::Libcall LC = RTLIB::RuntimeLibcallsInfo::getLibcallFromImpl(Impl); + switch (LC) { + case RTLIB::OEQ_F32: + case RTLIB::OEQ_F64: + case RTLIB::OEQ_F128: + case RTLIB::OEQ_PPCF128: + return ISD::SETEQ; + case RTLIB::UNE_F32: + case RTLIB::UNE_F64: + case RTLIB::UNE_F128: + case RTLIB::UNE_PPCF128: + return ISD::SETNE; + case RTLIB::OGE_F32: + case RTLIB::OGE_F64: + case RTLIB::OGE_F128: + case RTLIB::OGE_PPCF128: + return ISD::SETGE; + case RTLIB::OLT_F32: + case RTLIB::OLT_F64: + case RTLIB::OLT_F128: + case RTLIB::OLT_PPCF128: + return ISD::SETLT; + case RTLIB::OLE_F32: + case RTLIB::OLE_F64: + case RTLIB::OLE_F128: + case RTLIB::OLE_PPCF128: + return ISD::SETLE; + case RTLIB::OGT_F32: + case RTLIB::OGT_F64: + case RTLIB::OGT_F128: + case RTLIB::OGT_PPCF128: + return ISD::SETGT; + case RTLIB::UO_F32: + case RTLIB::UO_F64: + case RTLIB::UO_F128: + case RTLIB::UO_PPCF128: + return ISD::SETNE; + default: + llvm_unreachable("not a compare libcall"); + } } /// NOTE: The TargetMachine owns TLOF. @@ -678,8 +721,6 @@ TargetLoweringBase::TargetLoweringBase(const TargetMachine &tm) MinCmpXchgSizeInBits = 0; SupportsUnalignedAtomics = false; - - RTLIB::initCmpLibcallCCs(CmpLibcallCCs); } // Define the virtual destructor out-of-line to act as a key method to anchor diff --git a/llvm/lib/IR/RuntimeLibcalls.cpp b/llvm/lib/IR/RuntimeLibcalls.cpp index 376b9888c399a..2c7d21956eec7 100644 --- a/llvm/lib/IR/RuntimeLibcalls.cpp +++ b/llvm/lib/IR/RuntimeLibcalls.cpp @@ -100,37 +100,6 @@ static void setARMLibcallNames(RuntimeLibcallsInfo &Info, const Triple &TT, } } -void RuntimeLibcallsInfo::initSoftFloatCmpLibcallPredicates() { - SoftFloatCompareLibcallPredicates[RTLIB::OEQ_F32] = CmpInst::ICMP_EQ; - SoftFloatCompareLibcallPredicates[RTLIB::OEQ_F64] = CmpInst::ICMP_EQ; - SoftFloatCompareLibcallPredicates[RTLIB::OEQ_F128] = CmpInst::ICMP_EQ; - SoftFloatCompareLibcallPredicates[RTLIB::OEQ_PPCF128] = CmpInst::ICMP_EQ; - SoftFloatCompareLibcallPredicates[RTLIB::UNE_F32] = CmpInst::ICMP_NE; - SoftFloatCompareLibcallPredicates[RTLIB::UNE_F64] = CmpInst::ICMP_NE; - SoftFloatCompareLibcallPredicates[RTLIB::UNE_F128] = CmpInst::ICMP_NE; - SoftFloatCompareLibcallPredicates[RTLIB::UNE_PPCF128] = CmpInst::ICMP_NE; - SoftFloatCompareLibcallPredicates[RTLIB::OGE_F32] = CmpInst::ICMP_SGE; - SoftFloatCompareLibcallPredicates[RTLIB::OGE_F64] = CmpInst::ICMP_SGE; - SoftFloatCompareLibcallPredicates[RTLIB::OGE_F128] = CmpInst::ICMP_SGE; - SoftFloatCompareLibcallPredicates[RTLIB::OGE_PPCF128] = CmpInst::ICMP_SGE; - SoftFloatCompareLibcallPredicates[RTLIB::OLT_F32] = CmpInst::ICMP_SLT; - SoftFloatCompareLibcallPredicates[RTLIB::OLT_F64] = CmpInst::ICMP_SLT; - SoftFloatCompareLibcallPredicates[RTLIB::OLT_F128] = CmpInst::ICMP_SLT; - SoftFloatCompareLibcallPredicates[RTLIB::OLT_PPCF128] = CmpInst::ICMP_SLT; - SoftFloatCompareLibcallPredicates[RTLIB::OLE_F32] = CmpInst::ICMP_SLE; - SoftFloatCompareLibcallPredicates[RTLIB::OLE_F64] = CmpInst::ICMP_SLE; - SoftFloatCompareLibcallPredicates[RTLIB::OLE_F128] = CmpInst::ICMP_SLE; - SoftFloatCompareLibcallPredicates[RTLIB::OLE_PPCF128] = CmpInst::ICMP_SLE; - SoftFloatCompareLibcallPredicates[RTLIB::OGT_F32] = CmpInst::ICMP_SGT; - SoftFloatCompareLibcallPredicates[RTLIB::OGT_F64] = CmpInst::ICMP_SGT; - SoftFloatCompareLibcallPredicates[RTLIB::OGT_F128] = CmpInst::ICMP_SGT; - SoftFloatCompareLibcallPredicates[RTLIB::OGT_PPCF128] = CmpInst::ICMP_SGT; - SoftFloatCompareLibcallPredicates[RTLIB::UO_F32] = CmpInst::ICMP_NE; - SoftFloatCompareLibcallPredicates[RTLIB::UO_F64] = CmpInst::ICMP_NE; - SoftFloatCompareLibcallPredicates[RTLIB::UO_F128] = CmpInst::ICMP_NE; - SoftFloatCompareLibcallPredicates[RTLIB::UO_PPCF128] = CmpInst::ICMP_NE; -} - static void setLongDoubleIsF128Libm(RuntimeLibcallsInfo &Info, bool FiniteOnlyFuncs = false) { Info.setLibcallImpl(RTLIB::REM_F128, RTLIB::fmodf128); diff --git a/llvm/lib/Target/ARM/ARMISelLowering.cpp b/llvm/lib/Target/ARM/ARMISelLowering.cpp index 6b85e62d2eb8b..3ebf95615f780 100644 --- a/llvm/lib/Target/ARM/ARMISelLowering.cpp +++ b/llvm/lib/Target/ARM/ARMISelLowering.cpp @@ -523,66 +523,63 @@ ARMTargetLowering::ARMTargetLowering(const TargetMachine &TM_, static const struct { const RTLIB::Libcall Op; const RTLIB::LibcallImpl Impl; - const CmpInst::Predicate Cond; } LibraryCalls[] = { // Single-precision floating-point arithmetic. - { RTLIB::ADD_F32, RTLIB::__addsf3vfp, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::SUB_F32, RTLIB::__subsf3vfp, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::MUL_F32, RTLIB::__mulsf3vfp, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::DIV_F32, RTLIB::__divsf3vfp, CmpInst::BAD_ICMP_PREDICATE }, + { RTLIB::ADD_F32, RTLIB::__addsf3vfp }, + { RTLIB::SUB_F32, RTLIB::__subsf3vfp }, + { RTLIB::MUL_F32, RTLIB::__mulsf3vfp }, + { RTLIB::DIV_F32, RTLIB::__divsf3vfp }, // Double-precision floating-point arithmetic. - { RTLIB::ADD_F64, RTLIB::__adddf3vfp, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::SUB_F64, RTLIB::__subdf3vfp, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::MUL_F64, RTLIB::__muldf3vfp, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::DIV_F64, RTLIB::__divdf3vfp, CmpInst::BAD_ICMP_PREDICATE }, + { RTLIB::ADD_F64, RTLIB::__adddf3vfp }, + { RTLIB::SUB_F64, RTLIB::__subdf3vfp }, + { RTLIB::MUL_F64, RTLIB::__muldf3vfp }, + { RTLIB::DIV_F64, RTLIB::__divdf3vfp }, // Single-precision comparisons. - { RTLIB::OEQ_F32, RTLIB::__eqsf2vfp, CmpInst::ICMP_NE }, - { RTLIB::UNE_F32, RTLIB::__nesf2vfp, CmpInst::ICMP_NE }, - { RTLIB::OLT_F32, RTLIB::__ltsf2vfp, CmpInst::ICMP_NE }, - { RTLIB::OLE_F32, RTLIB::__lesf2vfp, CmpInst::ICMP_NE }, - { RTLIB::OGE_F32, RTLIB::__gesf2vfp, CmpInst::ICMP_NE }, - { RTLIB::OGT_F32, RTLIB::__gtsf2vfp, CmpInst::ICMP_NE }, - { RTLIB::UO_F32, RTLIB::__unordsf2vfp, CmpInst::ICMP_NE }, + { RTLIB::OEQ_F32, RTLIB::__eqsf2vfp }, + { RTLIB::UNE_F32, RTLIB::__nesf2vfp }, + { RTLIB::OLT_F32, RTLIB::__ltsf2vfp }, + { RTLIB::OLE_F32, RTLIB::__lesf2vfp }, + { RTLIB::OGE_F32, RTLIB::__gesf2vfp }, + { RTLIB::OGT_F32, RTLIB::__gtsf2vfp }, + { RTLIB::UO_F32, RTLIB::__unordsf2vfp }, // Double-precision comparisons. - { RTLIB::OEQ_F64, RTLIB::__eqdf2vfp, CmpInst::ICMP_NE }, - { RTLIB::UNE_F64, RTLIB::__nedf2vfp, CmpInst::ICMP_NE }, - { RTLIB::OLT_F64, RTLIB::__ltdf2vfp, CmpInst::ICMP_NE }, - { RTLIB::OLE_F64, RTLIB::__ledf2vfp, CmpInst::ICMP_NE }, - { RTLIB::OGE_F64, RTLIB::__gedf2vfp, CmpInst::ICMP_NE }, - { RTLIB::OGT_F64, RTLIB::__gtdf2vfp, CmpInst::ICMP_NE }, - { RTLIB::UO_F64, RTLIB::__unorddf2vfp, CmpInst::ICMP_NE }, + { RTLIB::OEQ_F64, RTLIB::__eqdf2vfp }, + { RTLIB::UNE_F64, RTLIB::__nedf2vfp }, + { RTLIB::OLT_F64, RTLIB::__ltdf2vfp }, + { RTLIB::OLE_F64, RTLIB::__ledf2vfp }, + { RTLIB::OGE_F64, RTLIB::__gedf2vfp }, + { RTLIB::OGT_F64, RTLIB::__gtdf2vfp }, + { RTLIB::UO_F64, RTLIB::__unorddf2vfp }, // Floating-point to integer conversions. // i64 conversions are done via library routines even when generating VFP // instructions, so use the same ones. - { RTLIB::FPTOSINT_F64_I32, RTLIB::__fixdfsivfp, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::FPTOUINT_F64_I32, RTLIB::__fixunsdfsivfp, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::FPTOSINT_F32_I32, RTLIB::__fixsfsivfp, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::FPTOUINT_F32_I32, RTLIB::__fixunssfsivfp, CmpInst::BAD_ICMP_PREDICATE }, + { RTLIB::FPTOSINT_F64_I32, RTLIB::__fixdfsivfp }, + { RTLIB::FPTOUINT_F64_I32, RTLIB::__fixunsdfsivfp }, + { RTLIB::FPTOSINT_F32_I32, RTLIB::__fixsfsivfp }, + { RTLIB::FPTOUINT_F32_I32, RTLIB::__fixunssfsivfp }, // Conversions between floating types. - { RTLIB::FPROUND_F64_F32, RTLIB::__truncdfsf2vfp, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::FPEXT_F32_F64, RTLIB::__extendsfdf2vfp, CmpInst::BAD_ICMP_PREDICATE }, + { RTLIB::FPROUND_F64_F32, RTLIB::__truncdfsf2vfp }, + { RTLIB::FPEXT_F32_F64, RTLIB::__extendsfdf2vfp }, // Integer to floating-point conversions. // i64 conversions are done via library routines even when generating VFP // instructions, so use the same ones. // FIXME: There appears to be some naming inconsistency in ARM libgcc: // e.g., __floatunsidf vs. __floatunssidfvfp. - { RTLIB::SINTTOFP_I32_F64, RTLIB::__floatsidfvfp, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::UINTTOFP_I32_F64, RTLIB::__floatunssidfvfp, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::SINTTOFP_I32_F32, RTLIB::__floatsisfvfp, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::UINTTOFP_I32_F32, RTLIB::__floatunssisfvfp, CmpInst::BAD_ICMP_PREDICATE }, + { RTLIB::SINTTOFP_I32_F64, RTLIB::__floatsidfvfp }, + { RTLIB::UINTTOFP_I32_F64, RTLIB::__floatunssidfvfp }, + { RTLIB::SINTTOFP_I32_F32, RTLIB::__floatsisfvfp }, + { RTLIB::UINTTOFP_I32_F32, RTLIB::__floatunssisfvfp }, }; // clang-format on for (const auto &LC : LibraryCalls) { setLibcallImpl(LC.Op, LC.Impl); - if (LC.Cond != CmpInst::BAD_ICMP_PREDICATE) - setCmpLibcallCC(LC.Op, LC.Cond); } } } @@ -598,95 +595,92 @@ ARMTargetLowering::ARMTargetLowering(const TargetMachine &TM_, const RTLIB::Libcall Op; const RTLIB::LibcallImpl Impl; const CallingConv::ID CC; - const CmpInst::Predicate Cond; } LibraryCalls[] = { // Double-precision floating-point arithmetic helper functions // RTABI chapter 4.1.2, Table 2 - { RTLIB::ADD_F64, RTLIB::__aeabi_dadd, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::DIV_F64, RTLIB::__aeabi_ddiv, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::MUL_F64, RTLIB::__aeabi_dmul, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::SUB_F64, RTLIB::__aeabi_dsub, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, + { RTLIB::ADD_F64, RTLIB::__aeabi_dadd, CallingConv::ARM_AAPCS }, + { RTLIB::DIV_F64, RTLIB::__aeabi_ddiv, CallingConv::ARM_AAPCS }, + { RTLIB::MUL_F64, RTLIB::__aeabi_dmul, CallingConv::ARM_AAPCS }, + { RTLIB::SUB_F64, RTLIB::__aeabi_dsub, CallingConv::ARM_AAPCS }, // Double-precision floating-point comparison helper functions // RTABI chapter 4.1.2, Table 3 - { RTLIB::OEQ_F64, RTLIB::__aeabi_dcmpeq__ne, CallingConv::ARM_AAPCS, CmpInst::ICMP_NE }, - { RTLIB::UNE_F64, RTLIB::__aeabi_dcmpeq__eq, CallingConv::ARM_AAPCS, CmpInst::ICMP_EQ }, - { RTLIB::OLT_F64, RTLIB::__aeabi_dcmplt, CallingConv::ARM_AAPCS, CmpInst::ICMP_NE }, - { RTLIB::OLE_F64, RTLIB::__aeabi_dcmple, CallingConv::ARM_AAPCS, CmpInst::ICMP_NE }, - { RTLIB::OGE_F64, RTLIB::__aeabi_dcmpge, CallingConv::ARM_AAPCS, CmpInst::ICMP_NE }, - { RTLIB::OGT_F64, RTLIB::__aeabi_dcmpgt, CallingConv::ARM_AAPCS, CmpInst::ICMP_NE }, - { RTLIB::UO_F64, RTLIB::__aeabi_dcmpun, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, + { RTLIB::OEQ_F64, RTLIB::__aeabi_dcmpeq__ne, CallingConv::ARM_AAPCS }, + { RTLIB::UNE_F64, RTLIB::__aeabi_dcmpeq__eq, CallingConv::ARM_AAPCS }, + { RTLIB::OLT_F64, RTLIB::__aeabi_dcmplt, CallingConv::ARM_AAPCS }, + { RTLIB::OLE_F64, RTLIB::__aeabi_dcmple, CallingConv::ARM_AAPCS }, + { RTLIB::OGE_F64, RTLIB::__aeabi_dcmpge, CallingConv::ARM_AAPCS }, + { RTLIB::OGT_F64, RTLIB::__aeabi_dcmpgt, CallingConv::ARM_AAPCS }, + { RTLIB::UO_F64, RTLIB::__aeabi_dcmpun, CallingConv::ARM_AAPCS }, // Single-precision floating-point arithmetic helper functions // RTABI chapter 4.1.2, Table 4 - { RTLIB::ADD_F32, RTLIB::__aeabi_fadd, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::DIV_F32, RTLIB::__aeabi_fdiv, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::MUL_F32, RTLIB::__aeabi_fmul, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::SUB_F32, RTLIB::__aeabi_fsub, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, + { RTLIB::ADD_F32, RTLIB::__aeabi_fadd, CallingConv::ARM_AAPCS }, + { RTLIB::DIV_F32, RTLIB::__aeabi_fdiv, CallingConv::ARM_AAPCS }, + { RTLIB::MUL_F32, RTLIB::__aeabi_fmul, CallingConv::ARM_AAPCS }, + { RTLIB::SUB_F32, RTLIB::__aeabi_fsub, CallingConv::ARM_AAPCS }, // Single-precision floating-point comparison helper functions // RTABI chapter 4.1.2, Table 5 - { RTLIB::OEQ_F32, RTLIB::__aeabi_fcmpeq__ne, CallingConv::ARM_AAPCS, CmpInst::ICMP_NE }, - { RTLIB::UNE_F32, RTLIB::__aeabi_fcmpeq__eq, CallingConv::ARM_AAPCS, CmpInst::ICMP_EQ }, - { RTLIB::OLT_F32, RTLIB::__aeabi_fcmplt, CallingConv::ARM_AAPCS, CmpInst::ICMP_NE }, - { RTLIB::OLE_F32, RTLIB::__aeabi_fcmple, CallingConv::ARM_AAPCS, CmpInst::ICMP_NE }, - { RTLIB::OGE_F32, RTLIB::__aeabi_fcmpge, CallingConv::ARM_AAPCS, CmpInst::ICMP_NE }, - { RTLIB::OGT_F32, RTLIB::__aeabi_fcmpgt, CallingConv::ARM_AAPCS, CmpInst::ICMP_NE }, - { RTLIB::UO_F32, RTLIB::__aeabi_fcmpun, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, + { RTLIB::OEQ_F32, RTLIB::__aeabi_fcmpeq__ne, CallingConv::ARM_AAPCS }, + { RTLIB::UNE_F32, RTLIB::__aeabi_fcmpeq__eq, CallingConv::ARM_AAPCS }, + { RTLIB::OLT_F32, RTLIB::__aeabi_fcmplt, CallingConv::ARM_AAPCS}, + { RTLIB::OLE_F32, RTLIB::__aeabi_fcmple, CallingConv::ARM_AAPCS }, + { RTLIB::OGE_F32, RTLIB::__aeabi_fcmpge, CallingConv::ARM_AAPCS }, + { RTLIB::OGT_F32, RTLIB::__aeabi_fcmpgt, CallingConv::ARM_AAPCS }, + { RTLIB::UO_F32, RTLIB::__aeabi_fcmpun, CallingConv::ARM_AAPCS }, // Floating-point to integer conversions. // RTABI chapter 4.1.2, Table 6 - { RTLIB::FPTOSINT_F64_I32, RTLIB::__aeabi_d2iz, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::FPTOUINT_F64_I32, RTLIB::__aeabi_d2uiz, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::FPTOSINT_F64_I64, RTLIB::__aeabi_d2lz, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::FPTOUINT_F64_I64, RTLIB::__aeabi_d2ulz, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::FPTOSINT_F32_I32, RTLIB::__aeabi_f2iz, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::FPTOUINT_F32_I32, RTLIB::__aeabi_f2uiz, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::FPTOSINT_F32_I64, RTLIB::__aeabi_f2lz, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::FPTOUINT_F32_I64, RTLIB::__aeabi_f2ulz, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, + { RTLIB::FPTOSINT_F64_I32, RTLIB::__aeabi_d2iz, CallingConv::ARM_AAPCS }, + { RTLIB::FPTOUINT_F64_I32, RTLIB::__aeabi_d2uiz, CallingConv::ARM_AAPCS }, + { RTLIB::FPTOSINT_F64_I64, RTLIB::__aeabi_d2lz, CallingConv::ARM_AAPCS }, + { RTLIB::FPTOUINT_F64_I64, RTLIB::__aeabi_d2ulz, CallingConv::ARM_AAPCS }, + { RTLIB::FPTOSINT_F32_I32, RTLIB::__aeabi_f2iz, CallingConv::ARM_AAPCS }, + { RTLIB::FPTOUINT_F32_I32, RTLIB::__aeabi_f2uiz, CallingConv::ARM_AAPCS }, + { RTLIB::FPTOSINT_F32_I64, RTLIB::__aeabi_f2lz, CallingConv::ARM_AAPCS }, + { RTLIB::FPTOUINT_F32_I64, RTLIB::__aeabi_f2ulz, CallingConv::ARM_AAPCS }, // Conversions between floating types. // RTABI chapter 4.1.2, Table 7 - { RTLIB::FPROUND_F64_F32, RTLIB::__aeabi_d2f, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::FPROUND_F64_F16, RTLIB::__aeabi_d2h, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::FPEXT_F32_F64, RTLIB::__aeabi_f2d, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, + { RTLIB::FPROUND_F64_F32, RTLIB::__aeabi_d2f, CallingConv::ARM_AAPCS }, + { RTLIB::FPROUND_F64_F16, RTLIB::__aeabi_d2h, CallingConv::ARM_AAPCS }, + { RTLIB::FPEXT_F32_F64, RTLIB::__aeabi_f2d, CallingConv::ARM_AAPCS }, // Integer to floating-point conversions. // RTABI chapter 4.1.2, Table 8 - { RTLIB::SINTTOFP_I32_F64, RTLIB::__aeabi_i2d, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::UINTTOFP_I32_F64, RTLIB::__aeabi_ui2d, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::SINTTOFP_I64_F64, RTLIB::__aeabi_l2d, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::UINTTOFP_I64_F64, RTLIB::__aeabi_ul2d, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::SINTTOFP_I32_F32, RTLIB::__aeabi_i2f, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::UINTTOFP_I32_F32, RTLIB::__aeabi_ui2f, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::SINTTOFP_I64_F32, RTLIB::__aeabi_l2f, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::UINTTOFP_I64_F32, RTLIB::__aeabi_ul2f, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, + { RTLIB::SINTTOFP_I32_F64, RTLIB::__aeabi_i2d, CallingConv::ARM_AAPCS }, + { RTLIB::UINTTOFP_I32_F64, RTLIB::__aeabi_ui2d, CallingConv::ARM_AAPCS }, + { RTLIB::SINTTOFP_I64_F64, RTLIB::__aeabi_l2d, CallingConv::ARM_AAPCS }, + { RTLIB::UINTTOFP_I64_F64, RTLIB::__aeabi_ul2d, CallingConv::ARM_AAPCS }, + { RTLIB::SINTTOFP_I32_F32, RTLIB::__aeabi_i2f, CallingConv::ARM_AAPCS }, + { RTLIB::UINTTOFP_I32_F32, RTLIB::__aeabi_ui2f, CallingConv::ARM_AAPCS }, + { RTLIB::SINTTOFP_I64_F32, RTLIB::__aeabi_l2f, CallingConv::ARM_AAPCS }, + { RTLIB::UINTTOFP_I64_F32, RTLIB::__aeabi_ul2f, CallingConv::ARM_AAPCS }, // Long long helper functions // RTABI chapter 4.2, Table 9 - { RTLIB::MUL_I64, RTLIB::__aeabi_lmul, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::SHL_I64, RTLIB::__aeabi_llsl, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::SRL_I64, RTLIB::__aeabi_llsr, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::SRA_I64, RTLIB::__aeabi_lasr, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, + { RTLIB::MUL_I64, RTLIB::__aeabi_lmul, CallingConv::ARM_AAPCS }, + { RTLIB::SHL_I64, RTLIB::__aeabi_llsl, CallingConv::ARM_AAPCS }, + { RTLIB::SRL_I64, RTLIB::__aeabi_llsr, CallingConv::ARM_AAPCS }, + { RTLIB::SRA_I64, RTLIB::__aeabi_lasr, CallingConv::ARM_AAPCS }, // Integer division functions // RTABI chapter 4.3.1 - { RTLIB::SDIV_I8, RTLIB::__aeabi_idiv__i8, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::SDIV_I16, RTLIB::__aeabi_idiv__i16, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::SDIV_I32, RTLIB::__aeabi_idiv__i32, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::SDIV_I64, RTLIB::__aeabi_ldivmod, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::UDIV_I8, RTLIB::__aeabi_uidiv__i8, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::UDIV_I16, RTLIB::__aeabi_uidiv__i16, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::UDIV_I32, RTLIB::__aeabi_uidiv__i32, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, - { RTLIB::UDIV_I64, RTLIB::__aeabi_uldivmod, CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE }, + { RTLIB::SDIV_I8, RTLIB::__aeabi_idiv__i8, CallingConv::ARM_AAPCS }, + { RTLIB::SDIV_I16, RTLIB::__aeabi_idiv__i16, CallingConv::ARM_AAPCS }, + { RTLIB::SDIV_I32, RTLIB::__aeabi_idiv__i32, CallingConv::ARM_AAPCS }, + { RTLIB::SDIV_I64, RTLIB::__aeabi_ldivmod, CallingConv::ARM_AAPCS }, + { RTLIB::UDIV_I8, RTLIB::__aeabi_uidiv__i8, CallingConv::ARM_AAPCS }, + { RTLIB::UDIV_I16, RTLIB::__aeabi_uidiv__i16, CallingConv::ARM_AAPCS }, + { RTLIB::UDIV_I32, RTLIB::__aeabi_uidiv__i32, CallingConv::ARM_AAPCS }, + { RTLIB::UDIV_I64, RTLIB::__aeabi_uldivmod, CallingConv::ARM_AAPCS }, }; // clang-format on for (const auto &LC : LibraryCalls) { setLibcallImpl(LC.Op, LC.Impl); setLibcallImplCallingConv(LC.Impl, LC.CC); - if (LC.Cond != CmpInst::BAD_ICMP_PREDICATE) - setCmpLibcallCC(LC.Op, LC.Cond); } // EABI dependent RTLIB From e1068454e167f58f0315d07dbbeff7725e3adbc2 Mon Sep 17 00:00:00 2001 From: Matt Arsenault Date: Tue, 8 Jul 2025 21:41:02 +0900 Subject: [PATCH 2/3] Add comments for scheme --- llvm/lib/CodeGen/TargetLoweringBase.cpp | 29 ++++++++++++------------- 1 file changed, 14 insertions(+), 15 deletions(-) diff --git a/llvm/lib/CodeGen/TargetLoweringBase.cpp b/llvm/lib/CodeGen/TargetLoweringBase.cpp index e114272d17055..57a8f2962fcf0 100644 --- a/llvm/lib/CodeGen/TargetLoweringBase.cpp +++ b/llvm/lib/CodeGen/TargetLoweringBase.cpp @@ -612,37 +612,36 @@ RTLIB::Libcall RTLIB::getMEMSET_ELEMENT_UNORDERED_ATOMIC(uint64_t ElementSize) { ISD::CondCode TargetLoweringBase::getSoftFloatCmpLibcallPredicate( RTLIB::LibcallImpl Impl) const { switch (Impl) { - case RTLIB::__aeabi_dcmpeq__ne: - return ISD::SETNE; case RTLIB::__aeabi_dcmpeq__eq: + case RTLIB::__aeabi_fcmpeq__eq: + // Usage in the eq case, so we have to invert the comparison. return ISD::SETEQ; - case RTLIB::__aeabi_dcmplt: + case RTLIB::__aeabi_dcmpeq__ne: + case RTLIB::__aeabi_fcmpeq__ne: + // Normal comparison to boolean value. return ISD::SETNE; + case RTLIB::__aeabi_dcmplt: case RTLIB::__aeabi_dcmple: - return ISD::SETNE; case RTLIB::__aeabi_dcmpge: - return ISD::SETNE; case RTLIB::__aeabi_dcmpgt: - return ISD::SETNE; case RTLIB::__aeabi_dcmpun: - return ISD::SETNE; - case RTLIB::__aeabi_fcmpeq__ne: - return ISD::SETNE; - case RTLIB::__aeabi_fcmpeq__eq: - return ISD::SETEQ; case RTLIB::__aeabi_fcmplt: - return ISD::SETNE; case RTLIB::__aeabi_fcmple: - return ISD::SETNE; case RTLIB::__aeabi_fcmpge: - return ISD::SETNE; case RTLIB::__aeabi_fcmpgt: + /// The AEABI versions return a typical boolean value, so we can compare + /// against the integer result as simply != 0. return ISD::SETNE; default: break; } - // Assume libgcc/compiler-rt behavior + // Assume libgcc/compiler-rt behavior. Most of the cases are really aliases of + // each other, and return a 3-way comparison style result of -1, 0, or 1 + // depending on lt/eq/gt. + // + // FIXME: It would be cleaner to directly express this as a 3-way comparison + // soft FP libcall instead of individual compares. RTLIB::Libcall LC = RTLIB::RuntimeLibcallsInfo::getLibcallFromImpl(Impl); switch (LC) { case RTLIB::OEQ_F32: From 139162076edf4ca4602414a3435c1f1ddb30cda3 Mon Sep 17 00:00:00 2001 From: Matt Arsenault Date: Tue, 8 Jul 2025 21:52:56 +0900 Subject: [PATCH 3/3] Rename double entries for cmpeq aeabi calls --- llvm/include/llvm/IR/RuntimeLibcalls.td | 8 ++++---- llvm/lib/CodeGen/TargetLoweringBase.cpp | 8 ++++---- llvm/lib/Target/ARM/ARMISelLowering.cpp | 8 ++++---- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td index 403d98912653d..a954dde9fb223 100644 --- a/llvm/include/llvm/IR/RuntimeLibcalls.td +++ b/llvm/include/llvm/IR/RuntimeLibcalls.td @@ -1176,8 +1176,8 @@ def __aeabi_dsub : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS // Double-precision floating-point comparison helper functions // RTABI chapter 4.1.2, Table 3 -def __aeabi_dcmpeq__ne : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS, CmpInst::ICMP_NE -def __aeabi_dcmpeq__eq : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS, CmpInst::ICMP_EQ +def __aeabi_dcmpeq__oeq : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS, CmpInst::ICMP_NE +def __aeabi_dcmpeq__une : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS, CmpInst::ICMP_EQ def __aeabi_dcmplt : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS, CmpInst::ICMP_NE def __aeabi_dcmple : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS, CmpInst::ICMP_NE def __aeabi_dcmpge : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS, CmpInst::ICMP_NE @@ -1193,8 +1193,8 @@ def __aeabi_fsub : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS // Single-precision floating-point comparison helper functions // RTABI chapter 4.1.2, Table 5 -def __aeabi_fcmpeq__ne : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS, CmpInst::ICMP_NE -def __aeabi_fcmpeq__eq : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS, CmpInst::ICMP_EQ +def __aeabi_fcmpeq__oeq : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS, CmpInst::ICMP_NE +def __aeabi_fcmpeq__une : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS, CmpInst::ICMP_EQ def __aeabi_fcmplt : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS, CmpInst::ICMP_NE def __aeabi_fcmple : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS, CmpInst::ICMP_NE def __aeabi_fcmpge : RuntimeLibcallImpl; // CallingConv::ARM_AAPCS, CmpInst::ICMP_NE diff --git a/llvm/lib/CodeGen/TargetLoweringBase.cpp b/llvm/lib/CodeGen/TargetLoweringBase.cpp index 57a8f2962fcf0..0a077b7b61437 100644 --- a/llvm/lib/CodeGen/TargetLoweringBase.cpp +++ b/llvm/lib/CodeGen/TargetLoweringBase.cpp @@ -612,12 +612,12 @@ RTLIB::Libcall RTLIB::getMEMSET_ELEMENT_UNORDERED_ATOMIC(uint64_t ElementSize) { ISD::CondCode TargetLoweringBase::getSoftFloatCmpLibcallPredicate( RTLIB::LibcallImpl Impl) const { switch (Impl) { - case RTLIB::__aeabi_dcmpeq__eq: - case RTLIB::__aeabi_fcmpeq__eq: + case RTLIB::__aeabi_dcmpeq__une: + case RTLIB::__aeabi_fcmpeq__une: // Usage in the eq case, so we have to invert the comparison. return ISD::SETEQ; - case RTLIB::__aeabi_dcmpeq__ne: - case RTLIB::__aeabi_fcmpeq__ne: + case RTLIB::__aeabi_dcmpeq__oeq: + case RTLIB::__aeabi_fcmpeq__oeq: // Normal comparison to boolean value. return ISD::SETNE; case RTLIB::__aeabi_dcmplt: diff --git a/llvm/lib/Target/ARM/ARMISelLowering.cpp b/llvm/lib/Target/ARM/ARMISelLowering.cpp index 3ebf95615f780..4d2b75ef6ee71 100644 --- a/llvm/lib/Target/ARM/ARMISelLowering.cpp +++ b/llvm/lib/Target/ARM/ARMISelLowering.cpp @@ -605,8 +605,8 @@ ARMTargetLowering::ARMTargetLowering(const TargetMachine &TM_, // Double-precision floating-point comparison helper functions // RTABI chapter 4.1.2, Table 3 - { RTLIB::OEQ_F64, RTLIB::__aeabi_dcmpeq__ne, CallingConv::ARM_AAPCS }, - { RTLIB::UNE_F64, RTLIB::__aeabi_dcmpeq__eq, CallingConv::ARM_AAPCS }, + { RTLIB::OEQ_F64, RTLIB::__aeabi_dcmpeq__oeq, CallingConv::ARM_AAPCS }, + { RTLIB::UNE_F64, RTLIB::__aeabi_dcmpeq__une, CallingConv::ARM_AAPCS }, { RTLIB::OLT_F64, RTLIB::__aeabi_dcmplt, CallingConv::ARM_AAPCS }, { RTLIB::OLE_F64, RTLIB::__aeabi_dcmple, CallingConv::ARM_AAPCS }, { RTLIB::OGE_F64, RTLIB::__aeabi_dcmpge, CallingConv::ARM_AAPCS }, @@ -622,8 +622,8 @@ ARMTargetLowering::ARMTargetLowering(const TargetMachine &TM_, // Single-precision floating-point comparison helper functions // RTABI chapter 4.1.2, Table 5 - { RTLIB::OEQ_F32, RTLIB::__aeabi_fcmpeq__ne, CallingConv::ARM_AAPCS }, - { RTLIB::UNE_F32, RTLIB::__aeabi_fcmpeq__eq, CallingConv::ARM_AAPCS }, + { RTLIB::OEQ_F32, RTLIB::__aeabi_fcmpeq__oeq, CallingConv::ARM_AAPCS }, + { RTLIB::UNE_F32, RTLIB::__aeabi_fcmpeq__une, CallingConv::ARM_AAPCS }, { RTLIB::OLT_F32, RTLIB::__aeabi_fcmplt, CallingConv::ARM_AAPCS}, { RTLIB::OLE_F32, RTLIB::__aeabi_fcmple, CallingConv::ARM_AAPCS }, { RTLIB::OGE_F32, RTLIB::__aeabi_fcmpge, CallingConv::ARM_AAPCS },