[llvm-branch-commits] [llvm] RuntimeLibcalls: Remove table of soft float compare cond codes (PR #146082)
Matt Arsenault via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri Jun 27 19:36:03 PDT 2025
https://github.com/arsenm updated https://github.com/llvm/llvm-project/pull/146082
>From c76b2c4a2b11717d8c4b1607cbcd57de6e2da39b Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Mon, 23 Jun 2025 19:10:30 +0900
Subject: [PATCH] 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 | 32 +---
.../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(+), 200 deletions(-)
diff --git a/llvm/include/llvm/CodeGen/RuntimeLibcallUtil.h b/llvm/include/llvm/CodeGen/RuntimeLibcallUtil.h
index 7481ed5b80b3f..09a8151e9ec9c 100644
--- a/llvm/include/llvm/CodeGen/RuntimeLibcallUtil.h
+++ b/llvm/include/llvm/CodeGen/RuntimeLibcallUtil.h
@@ -105,9 +105,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 8e05c53dc513d..31bd0887e1b14 100644
--- a/llvm/include/llvm/CodeGen/TargetLowering.h
+++ b/llvm/include/llvm/CodeGen/TargetLowering.h
@@ -3574,19 +3574,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 8c11ce9ed2920..ecf20cbfd09f2 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.h
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.h
@@ -59,7 +59,6 @@ struct RuntimeLibcallsInfo {
ExceptionHandling ExceptionModel = ExceptionHandling::None,
FloatABI::ABIType FloatABI = FloatABI::Default,
EABI EABIVersion = EABI::Default, StringRef ABIName = "") {
- initSoftFloatCmpLibcallPredicates();
initLibcalls(TT, ExceptionModel, FloatABI, EABIVersion, ABIName);
}
@@ -106,22 +105,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 {
@@ -132,6 +115,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];
@@ -147,14 +135,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];
@@ -190,8 +170,6 @@ struct RuntimeLibcallsInfo {
/// Generated by tablegen.
void setTargetRuntimeLibcallSets(const Triple &TT);
- 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 000f8cc6786a5..5d391e8906dc6 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 cda41a91a372f..44558fd0dbe70 100644
--- a/llvm/lib/CodeGen/TargetLoweringBase.cpp
+++ b/llvm/lib/CodeGen/TargetLoweringBase.cpp
@@ -597,37 +597,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.
@@ -666,8 +709,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 a5605329c7d28..b08ee16791dfd 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 b2c3e915f0dc7..78ef3c23e8423 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
More information about the llvm-branch-commits
mailing list