[llvm-branch-commits] [llvm] DAG: Move soft float predicate management into RuntimeLibcalls (PR #142905)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Wed Jun 4 23:26:56 PDT 2025
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-arm
Author: Matt Arsenault (arsenm)
<details>
<summary>Changes</summary>
Work towards making RuntimeLibcalls the centralized location for
all libcall information. This requires changing the encoding from
tracking the ISD::CondCode to using CmpInst::Predicate.
---
Patch is 35.53 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/142905.diff
6 Files Affected:
- (modified) llvm/include/llvm/CodeGen/TargetLowering.h (+6-8)
- (modified) llvm/include/llvm/IR/RuntimeLibcalls.h (+25)
- (modified) llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp (+3-2)
- (modified) llvm/lib/IR/RuntimeLibcalls.cpp (+36)
- (modified) llvm/lib/Target/ARM/ARMISelLowering.cpp (+89-89)
- (modified) llvm/lib/Target/MSP430/MSP430ISelLowering.cpp (+65-65)
``````````diff
diff --git a/llvm/include/llvm/CodeGen/TargetLowering.h b/llvm/include/llvm/CodeGen/TargetLowering.h
index 9c453f51e129d..0d157de479141 100644
--- a/llvm/include/llvm/CodeGen/TargetLowering.h
+++ b/llvm/include/llvm/CodeGen/TargetLowering.h
@@ -3572,20 +3572,18 @@ class LLVM_ABI TargetLoweringBase {
/// Override the default CondCode to be used to test the result of the
/// comparison libcall against zero.
- /// FIXME: This can't be merged with 'RuntimeLibcallsInfo' because of the ISD.
- void setCmpLibcallCC(RTLIB::Libcall Call, ISD::CondCode CC) {
- CmpLibcallCCs[Call] = CC;
+ /// 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.
- /// FIXME: This can't be merged with 'RuntimeLibcallsInfo' because of the ISD.
- ISD::CondCode getCmpLibcallCC(RTLIB::Libcall Call) const {
- return CmpLibcallCCs[Call];
+ CmpInst::Predicate
+ getSoftFloatCmpLibcallPredicate(RTLIB::Libcall Call) const {
+ return Libcalls.getSoftFloatCmpLibcallPredicate(Call);
}
-
/// Set the CallingConv that should be used for the specified libcall.
void setLibcallCallingConv(RTLIB::Libcall Call, CallingConv::ID CC) {
Libcalls.setLibcallCallingConv(Call, CC);
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.h b/llvm/include/llvm/IR/RuntimeLibcalls.h
index 26c085031a48a..6cc65fabfcc99 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.h
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.h
@@ -16,6 +16,7 @@
#include "llvm/ADT/ArrayRef.h"
#include "llvm/IR/CallingConv.h"
+#include "llvm/IR/InstrTypes.h"
#include "llvm/Support/AtomicOrdering.h"
#include "llvm/Support/Compiler.h"
#include "llvm/TargetParser/Triple.h"
@@ -73,6 +74,20 @@ struct RuntimeLibcallsInfo {
LibcallRoutineNames + RTLIB::UNKNOWN_LIBCALL);
}
+ /// 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.
+ CmpInst::Predicate
+ getSoftFloatCmpLibcallPredicate(RTLIB::Libcall Call) const {
+ return SoftFloatCompareLibcallPredicates[Call];
+ }
+
+ // FIXME: This should be removed. This should be private constant.
+ void setSoftFloatCmpLibcallPredicate(RTLIB::Libcall Call,
+ CmpInst::Predicate Pred) {
+ SoftFloatCompareLibcallPredicates[Call] = Pred;
+ }
+
private:
/// Stores the name each libcall.
const char *LibcallRoutineNames[RTLIB::UNKNOWN_LIBCALL + 1];
@@ -80,6 +95,14 @@ struct RuntimeLibcallsInfo {
/// Stores the CallingConv that should be used for each libcall.
CallingConv::ID LibcallCallingConvs[RTLIB::UNKNOWN_LIBCALL];
+ /// 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];
+
static bool darwinHasSinCos(const Triple &TT) {
assert(TT.isOSDarwin() && "should be called with darwin triple");
// Don't bother with 32 bit x86.
@@ -95,6 +118,8 @@ struct RuntimeLibcallsInfo {
return true;
}
+ 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);
diff --git a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
index a3c4cb4ea0582..5b1c6236afc32 100644
--- a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
@@ -14,6 +14,7 @@
#include "llvm/ADT/STLExtras.h"
#include "llvm/Analysis/ValueTracking.h"
#include "llvm/Analysis/VectorUtils.h"
+#include "llvm/CodeGen/Analysis.h"
#include "llvm/CodeGen/CallingConvLower.h"
#include "llvm/CodeGen/CodeGenCommonISel.h"
#include "llvm/CodeGen/MachineFrameInfo.h"
@@ -419,7 +420,7 @@ void TargetLowering::softenSetCCOperands(SelectionDAG &DAG, EVT VT,
NewLHS = Call.first;
NewRHS = DAG.getConstant(0, dl, RetVT);
- CCCode = getCmpLibcallCC(LC1);
+ CCCode = getICmpCondCode(getSoftFloatCmpLibcallPredicate(LC1));
if (ShouldInvertCC) {
assert(RetVT.isInteger());
CCCode = getSetCCInverse(CCCode, RetVT);
@@ -445,7 +446,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 = getCmpLibcallCC(LC2);
+ CCCode = getICmpCondCode(getSoftFloatCmpLibcallPredicate(LC2));
if (ShouldInvertCC)
CCCode = getSetCCInverse(CCCode, RetVT);
NewLHS = DAG.getSetCC(dl, SetCCVT, Call2.first, NewRHS, CCCode);
diff --git a/llvm/lib/IR/RuntimeLibcalls.cpp b/llvm/lib/IR/RuntimeLibcalls.cpp
index ca45cd4b7b13c..91f303c9e3d3c 100644
--- a/llvm/lib/IR/RuntimeLibcalls.cpp
+++ b/llvm/lib/IR/RuntimeLibcalls.cpp
@@ -11,12 +11,48 @@
using namespace llvm;
using namespace RTLIB;
+void RuntimeLibcallsInfo::initSoftFloatCmpLibcallPredicates() {
+ std::fill(SoftFloatCompareLibcallPredicates,
+ SoftFloatCompareLibcallPredicates + RTLIB::UNKNOWN_LIBCALL,
+ CmpInst::BAD_ICMP_PREDICATE);
+ 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;
+}
+
/// Set default libcall names. If a target wants to opt-out of a libcall it
/// should be placed here.
void RuntimeLibcallsInfo::initLibcalls(const Triple &TT) {
std::fill(std::begin(LibcallRoutineNames), std::end(LibcallRoutineNames),
nullptr);
+ initSoftFloatCmpLibcallPredicates();
+
#define HANDLE_LIBCALL(code, name) setLibcallName(RTLIB::code, name);
#include "llvm/IR/RuntimeLibcalls.def"
#undef HANDLE_LIBCALL
diff --git a/llvm/lib/Target/ARM/ARMISelLowering.cpp b/llvm/lib/Target/ARM/ARMISelLowering.cpp
index e97df268f13f9..5dddf6ae99531 100644
--- a/llvm/lib/Target/ARM/ARMISelLowering.cpp
+++ b/llvm/lib/Target/ARM/ARMISelLowering.cpp
@@ -524,64 +524,64 @@ ARMTargetLowering::ARMTargetLowering(const TargetMachine &TM,
static const struct {
const RTLIB::Libcall Op;
const char * const Name;
- const ISD::CondCode Cond;
+ const CmpInst::Predicate Cond;
} LibraryCalls[] = {
// Single-precision floating-point arithmetic.
- { RTLIB::ADD_F32, "__addsf3vfp", ISD::SETCC_INVALID },
- { RTLIB::SUB_F32, "__subsf3vfp", ISD::SETCC_INVALID },
- { RTLIB::MUL_F32, "__mulsf3vfp", ISD::SETCC_INVALID },
- { RTLIB::DIV_F32, "__divsf3vfp", ISD::SETCC_INVALID },
+ { RTLIB::ADD_F32, "__addsf3vfp", CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::SUB_F32, "__subsf3vfp", CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::MUL_F32, "__mulsf3vfp", CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::DIV_F32, "__divsf3vfp", CmpInst::BAD_ICMP_PREDICATE },
// Double-precision floating-point arithmetic.
- { RTLIB::ADD_F64, "__adddf3vfp", ISD::SETCC_INVALID },
- { RTLIB::SUB_F64, "__subdf3vfp", ISD::SETCC_INVALID },
- { RTLIB::MUL_F64, "__muldf3vfp", ISD::SETCC_INVALID },
- { RTLIB::DIV_F64, "__divdf3vfp", ISD::SETCC_INVALID },
+ { RTLIB::ADD_F64, "__adddf3vfp", CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::SUB_F64, "__subdf3vfp", CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::MUL_F64, "__muldf3vfp", CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::DIV_F64, "__divdf3vfp", CmpInst::BAD_ICMP_PREDICATE },
// Single-precision comparisons.
- { RTLIB::OEQ_F32, "__eqsf2vfp", ISD::SETNE },
- { RTLIB::UNE_F32, "__nesf2vfp", ISD::SETNE },
- { RTLIB::OLT_F32, "__ltsf2vfp", ISD::SETNE },
- { RTLIB::OLE_F32, "__lesf2vfp", ISD::SETNE },
- { RTLIB::OGE_F32, "__gesf2vfp", ISD::SETNE },
- { RTLIB::OGT_F32, "__gtsf2vfp", ISD::SETNE },
- { RTLIB::UO_F32, "__unordsf2vfp", ISD::SETNE },
+ { RTLIB::OEQ_F32, "__eqsf2vfp", CmpInst::ICMP_NE },
+ { RTLIB::UNE_F32, "__nesf2vfp", CmpInst::ICMP_NE },
+ { RTLIB::OLT_F32, "__ltsf2vfp", CmpInst::ICMP_NE },
+ { RTLIB::OLE_F32, "__lesf2vfp", CmpInst::ICMP_NE },
+ { RTLIB::OGE_F32, "__gesf2vfp", CmpInst::ICMP_NE },
+ { RTLIB::OGT_F32, "__gtsf2vfp", CmpInst::ICMP_NE },
+ { RTLIB::UO_F32, "__unordsf2vfp", CmpInst::ICMP_NE },
// Double-precision comparisons.
- { RTLIB::OEQ_F64, "__eqdf2vfp", ISD::SETNE },
- { RTLIB::UNE_F64, "__nedf2vfp", ISD::SETNE },
- { RTLIB::OLT_F64, "__ltdf2vfp", ISD::SETNE },
- { RTLIB::OLE_F64, "__ledf2vfp", ISD::SETNE },
- { RTLIB::OGE_F64, "__gedf2vfp", ISD::SETNE },
- { RTLIB::OGT_F64, "__gtdf2vfp", ISD::SETNE },
- { RTLIB::UO_F64, "__unorddf2vfp", ISD::SETNE },
+ { RTLIB::OEQ_F64, "__eqdf2vfp", CmpInst::ICMP_NE },
+ { RTLIB::UNE_F64, "__nedf2vfp", CmpInst::ICMP_NE },
+ { RTLIB::OLT_F64, "__ltdf2vfp", CmpInst::ICMP_NE },
+ { RTLIB::OLE_F64, "__ledf2vfp", CmpInst::ICMP_NE },
+ { RTLIB::OGE_F64, "__gedf2vfp", CmpInst::ICMP_NE },
+ { RTLIB::OGT_F64, "__gtdf2vfp", CmpInst::ICMP_NE },
+ { RTLIB::UO_F64, "__unorddf2vfp", CmpInst::ICMP_NE },
// 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, "__fixdfsivfp", ISD::SETCC_INVALID },
- { RTLIB::FPTOUINT_F64_I32, "__fixunsdfsivfp", ISD::SETCC_INVALID },
- { RTLIB::FPTOSINT_F32_I32, "__fixsfsivfp", ISD::SETCC_INVALID },
- { RTLIB::FPTOUINT_F32_I32, "__fixunssfsivfp", ISD::SETCC_INVALID },
+ { RTLIB::FPTOSINT_F64_I32, "__fixdfsivfp", CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::FPTOUINT_F64_I32, "__fixunsdfsivfp", CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::FPTOSINT_F32_I32, "__fixsfsivfp", CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::FPTOUINT_F32_I32, "__fixunssfsivfp", CmpInst::BAD_ICMP_PREDICATE },
// Conversions between floating types.
- { RTLIB::FPROUND_F64_F32, "__truncdfsf2vfp", ISD::SETCC_INVALID },
- { RTLIB::FPEXT_F32_F64, "__extendsfdf2vfp", ISD::SETCC_INVALID },
+ { RTLIB::FPROUND_F64_F32, "__truncdfsf2vfp", CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::FPEXT_F32_F64, "__extendsfdf2vfp", CmpInst::BAD_ICMP_PREDICATE },
// 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, "__floatsidfvfp", ISD::SETCC_INVALID },
- { RTLIB::UINTTOFP_I32_F64, "__floatunssidfvfp", ISD::SETCC_INVALID },
- { RTLIB::SINTTOFP_I32_F32, "__floatsisfvfp", ISD::SETCC_INVALID },
- { RTLIB::UINTTOFP_I32_F32, "__floatunssisfvfp", ISD::SETCC_INVALID },
+ { RTLIB::SINTTOFP_I32_F64, "__floatsidfvfp", CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::UINTTOFP_I32_F64, "__floatunssidfvfp", CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::SINTTOFP_I32_F32, "__floatsisfvfp", CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::UINTTOFP_I32_F32, "__floatunssisfvfp", CmpInst::BAD_ICMP_PREDICATE },
};
for (const auto &LC : LibraryCalls) {
setLibcallName(LC.Op, LC.Name);
- if (LC.Cond != ISD::SETCC_INVALID)
+ if (LC.Cond != CmpInst::BAD_ICMP_PREDICATE)
setCmpLibcallCC(LC.Op, LC.Cond);
}
}
@@ -595,93 +595,93 @@ ARMTargetLowering::ARMTargetLowering(const TargetMachine &TM,
const RTLIB::Libcall Op;
const char * const Name;
const CallingConv::ID CC;
- const ISD::CondCode Cond;
+ const CmpInst::Predicate Cond;
} LibraryCalls[] = {
// Double-precision floating-point arithmetic helper functions
// RTABI chapter 4.1.2, Table 2
- { RTLIB::ADD_F64, "__aeabi_dadd", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
- { RTLIB::DIV_F64, "__aeabi_ddiv", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
- { RTLIB::MUL_F64, "__aeabi_dmul", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
- { RTLIB::SUB_F64, "__aeabi_dsub", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
+ { RTLIB::ADD_F64, "__aeabi_dadd", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::DIV_F64, "__aeabi_ddiv", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::MUL_F64, "__aeabi_dmul", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::SUB_F64, "__aeabi_dsub", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
// Double-precision floating-point comparison helper functions
// RTABI chapter 4.1.2, Table 3
- { RTLIB::OEQ_F64, "__aeabi_dcmpeq", CallingConv::ARM_AAPCS, ISD::SETNE },
- { RTLIB::UNE_F64, "__aeabi_dcmpeq", CallingConv::ARM_AAPCS, ISD::SETEQ },
- { RTLIB::OLT_F64, "__aeabi_dcmplt", CallingConv::ARM_AAPCS, ISD::SETNE },
- { RTLIB::OLE_F64, "__aeabi_dcmple", CallingConv::ARM_AAPCS, ISD::SETNE },
- { RTLIB::OGE_F64, "__aeabi_dcmpge", CallingConv::ARM_AAPCS, ISD::SETNE },
- { RTLIB::OGT_F64, "__aeabi_dcmpgt", CallingConv::ARM_AAPCS, ISD::SETNE },
- { RTLIB::UO_F64, "__aeabi_dcmpun", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
+ { RTLIB::OEQ_F64, "__aeabi_dcmpeq", CallingConv::ARM_AAPCS, CmpInst::ICMP_NE },
+ { RTLIB::UNE_F64, "__aeabi_dcmpeq", CallingConv::ARM_AAPCS, CmpInst::ICMP_EQ },
+ { RTLIB::OLT_F64, "__aeabi_dcmplt", CallingConv::ARM_AAPCS, CmpInst::ICMP_NE },
+ { RTLIB::OLE_F64, "__aeabi_dcmple", CallingConv::ARM_AAPCS, CmpInst::ICMP_NE },
+ { RTLIB::OGE_F64, "__aeabi_dcmpge", CallingConv::ARM_AAPCS, CmpInst::ICMP_NE },
+ { RTLIB::OGT_F64, "__aeabi_dcmpgt", CallingConv::ARM_AAPCS, CmpInst::ICMP_NE },
+ { RTLIB::UO_F64, "__aeabi_dcmpun", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
// Single-precision floating-point arithmetic helper functions
// RTABI chapter 4.1.2, Table 4
- { RTLIB::ADD_F32, "__aeabi_fadd", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
- { RTLIB::DIV_F32, "__aeabi_fdiv", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
- { RTLIB::MUL_F32, "__aeabi_fmul", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
- { RTLIB::SUB_F32, "__aeabi_fsub", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
+ { RTLIB::ADD_F32, "__aeabi_fadd", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::DIV_F32, "__aeabi_fdiv", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::MUL_F32, "__aeabi_fmul", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::SUB_F32, "__aeabi_fsub", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
// Single-precision floating-point comparison helper functions
// RTABI chapter 4.1.2, Table 5
- { RTLIB::OEQ_F32, "__aeabi_fcmpeq", CallingConv::ARM_AAPCS, ISD::SETNE },
- { RTLIB::UNE_F32, "__aeabi_fcmpeq", CallingConv::ARM_AAPCS, ISD::SETEQ },
- { RTLIB::OLT_F32, "__aeabi_fcmplt", CallingConv::ARM_AAPCS, ISD::SETNE },
- { RTLIB::OLE_F32, "__aeabi_fcmple", CallingConv::ARM_AAPCS, ISD::SETNE },
- { RTLIB::OGE_F32, "__aeabi_fcmpge", CallingConv::ARM_AAPCS, ISD::SETNE },
- { RTLIB::OGT_F32, "__aeabi_fcmpgt", CallingConv::ARM_AAPCS, ISD::SETNE },
- { RTLIB::UO_F32, "__aeabi_fcmpun", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
+ { RTLIB::OEQ_F32, "__aeabi_fcmpeq", CallingConv::ARM_AAPCS, CmpInst::ICMP_NE },
+ { RTLIB::UNE_F32, "__aeabi_fcmpeq", CallingConv::ARM_AAPCS, CmpInst::ICMP_EQ },
+ { RTLIB::OLT_F32, "__aeabi_fcmplt", CallingConv::ARM_AAPCS, CmpInst::ICMP_NE },
+ { RTLIB::OLE_F32, "__aeabi_fcmple", CallingConv::ARM_AAPCS, CmpInst::ICMP_NE },
+ { RTLIB::OGE_F32, "__aeabi_fcmpge", CallingConv::ARM_AAPCS, CmpInst::ICMP_NE },
+ { RTLIB::OGT_F32, "__aeabi_fcmpgt", CallingConv::ARM_AAPCS, CmpInst::ICMP_NE },
+ { RTLIB::UO_F32, "__aeabi_fcmpun", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
// Floating-point to integer conversions.
// RTABI chapter 4.1.2, Table 6
- { RTLIB::FPTOSINT_F64_I32, "__aeabi_d2iz", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
- { RTLIB::FPTOUINT_F64_I32, "__aeabi_d2uiz", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
- { RTLIB::FPTOSINT_F64_I64, "__aeabi_d2lz", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
- { RTLIB::FPTOUINT_F64_I64, "__aeabi_d2ulz", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
- { RTLIB::FPTOSINT_F32_I32, "__aeabi_f2iz", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
- { RTLIB::FPTOUINT_F32_I32, "__aeabi_f2uiz", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
- { RTLIB::FPTOSINT_F32_I64, "__aeabi_f2lz", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
- { RTLIB::FPTOUINT_F32_I64, "__aeabi_f2ulz", CallingConv::ARM_AAPCS, ISD::SETCC_INVALID },
+ { RTLIB::FPTOSINT_F64_I32, "__aeabi_d2iz", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::FPTOUINT_F64_I32, "__aeabi_d2uiz", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::FPTOSINT_F64_I64, "__aeabi_d2lz", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::FPTOUINT_F64_I64, "__aeabi_d2ulz", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::FPTOSINT_F32_I32, "__aeabi_f2iz", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::FPTOUINT_F32_I32, "__aeabi_f2uiz", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::FPTOSINT_F32_I64, "__aeabi_f2lz", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
+ { RTLIB::FPTOUINT_F32_I64, "__aeabi_f2ulz", CallingConv::ARM_AAPCS, CmpInst::BAD_ICMP_PREDICATE },
// Conversions between floating t...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/142905
More information about the llvm-branch-commits
mailing list