https://github.com/arsenm updated
https://github.com/llvm/llvm-project/pull/146084
>From 0daf2fa9aa2e36d9d7c08a2cf7c404b94541f177 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <matthew.arsena...@amd.com>
Date: Mon, 23 Jun 2025 19:10:30 +0900
Subject: [PATCH 1/5] 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 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..99931f75fcda6 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];
@@ -200,8 +179,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 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 4f722005f4056..19eba45c4f502 100644
--- a/llvm/lib/CodeGen/TargetLoweringBase.cpp
+++ b/llvm/lib/CodeGen/TargetLoweringBase.cpp
@@ -601,37 +601,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.
@@ -670,8 +713,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 c8ec606cb68011cb6b3325578cba85baf09166a5 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <matthew.arsena...@amd.com>
Date: Mon, 23 Jun 2025 20:14:11 +0900
Subject: [PATCH 2/5] ARM: Unconditionally set eabi libcall calling convs in
RuntimeLibcalls
This fully consolidates all the calling convention configuration into
RuntimeLibcallInfo. I'm assuming that __aeabi functions have a universal
calling convention, and on other ABIs just don't use them. This will
enable splitting of RuntimeLibcallInfo into the ABI and lowering component.
---
llvm/lib/IR/RuntimeLibcalls.cpp | 39 ++++++
llvm/lib/Target/ARM/ARMISelLowering.cpp | 159 +++++++++++-------------
2 files changed, 110 insertions(+), 88 deletions(-)
diff --git a/llvm/lib/IR/RuntimeLibcalls.cpp b/llvm/lib/IR/RuntimeLibcalls.cpp
index 2c7d21956eec7..6f4ba543f446b 100644
--- a/llvm/lib/IR/RuntimeLibcalls.cpp
+++ b/llvm/lib/IR/RuntimeLibcalls.cpp
@@ -98,6 +98,45 @@ static void setARMLibcallNames(RuntimeLibcallsInfo &Info,
const Triple &TT,
Info.setLibcallImpl(RTLIB::SDIVREM_I32, RTLIB::__divmodsi4);
Info.setLibcallImpl(RTLIB::UDIVREM_I32, RTLIB::__udivmodsi4);
}
+
+ static const RTLIB::LibcallImpl AAPCS_Libcalls[] = {
+ RTLIB::__aeabi_dadd, RTLIB::__aeabi_ddiv,
+ RTLIB::__aeabi_dmul, RTLIB::__aeabi_dsub,
+ RTLIB::__aeabi_dcmpeq__ne, RTLIB::__aeabi_dcmpeq__eq,
+ RTLIB::__aeabi_dcmplt, RTLIB::__aeabi_dcmple,
+ RTLIB::__aeabi_dcmpge, RTLIB::__aeabi_dcmpgt,
+ RTLIB::__aeabi_dcmpun, RTLIB::__aeabi_fadd,
+ RTLIB::__aeabi_fdiv, RTLIB::__aeabi_fmul,
+ RTLIB::__aeabi_fsub, RTLIB::__aeabi_fcmpeq__ne,
+ RTLIB::__aeabi_fcmpeq__eq, RTLIB::__aeabi_fcmplt,
+ RTLIB::__aeabi_fcmple, RTLIB::__aeabi_fcmpge,
+ RTLIB::__aeabi_fcmpgt, RTLIB::__aeabi_fcmpun,
+ RTLIB::__aeabi_d2iz, RTLIB::__aeabi_d2uiz,
+ RTLIB::__aeabi_d2lz, RTLIB::__aeabi_d2ulz,
+ RTLIB::__aeabi_f2iz, RTLIB::__aeabi_f2uiz,
+ RTLIB::__aeabi_f2lz, RTLIB::__aeabi_f2ulz,
+ RTLIB::__aeabi_d2f, RTLIB::__aeabi_d2h,
+ RTLIB::__aeabi_f2d, RTLIB::__aeabi_i2d,
+ RTLIB::__aeabi_ui2d, RTLIB::__aeabi_l2d,
+ RTLIB::__aeabi_ul2d, RTLIB::__aeabi_i2f,
+ RTLIB::__aeabi_ui2f, RTLIB::__aeabi_l2f,
+ RTLIB::__aeabi_ul2f, RTLIB::__aeabi_lmul,
+ RTLIB::__aeabi_llsl, RTLIB::__aeabi_llsr,
+ RTLIB::__aeabi_lasr, RTLIB::__aeabi_idiv__i8,
+ RTLIB::__aeabi_idiv__i16, RTLIB::__aeabi_idiv__i32,
+ RTLIB::__aeabi_ldivmod, RTLIB::__aeabi_uidiv__i8,
+ RTLIB::__aeabi_uidiv__i16, RTLIB::__aeabi_uidiv__i32,
+ RTLIB::__aeabi_uldivmod, RTLIB::__aeabi_f2h,
+ RTLIB::__aeabi_d2h, RTLIB::__aeabi_h2f,
+ RTLIB::__aeabi_memcpy, RTLIB::__aeabi_memmove,
+ RTLIB::__aeabi_memset, RTLIB::__aeabi_memcpy4,
+ RTLIB::__aeabi_memcpy8, RTLIB::__aeabi_memmove4,
+ RTLIB::__aeabi_memmove8, RTLIB::__aeabi_memset4,
+ RTLIB::__aeabi_memset8, RTLIB::__aeabi_memclr,
+ RTLIB::__aeabi_memclr4, RTLIB::__aeabi_memclr8};
+
+ for (RTLIB::LibcallImpl Impl : AAPCS_Libcalls)
+ Info.setLibcallImplCallingConv(Impl, CallingConv::ARM_AAPCS);
}
static void setLongDoubleIsF128Libm(RuntimeLibcallsInfo &Info,
diff --git a/llvm/lib/Target/ARM/ARMISelLowering.cpp
b/llvm/lib/Target/ARM/ARMISelLowering.cpp
index 3ebf95615f780..cffc381e49d1f 100644
--- a/llvm/lib/Target/ARM/ARMISelLowering.cpp
+++ b/llvm/lib/Target/ARM/ARMISelLowering.cpp
@@ -578,9 +578,8 @@ ARMTargetLowering::ARMTargetLowering(const TargetMachine
&TM_,
};
// clang-format on
- for (const auto &LC : LibraryCalls) {
+ for (const auto &LC : LibraryCalls)
setLibcallImpl(LC.Op, LC.Impl);
- }
}
}
@@ -594,94 +593,91 @@ ARMTargetLowering::ARMTargetLowering(const TargetMachine
&TM_,
static const struct {
const RTLIB::Libcall Op;
const RTLIB::LibcallImpl Impl;
- const CallingConv::ID CC;
} LibraryCalls[] = {
// Double-precision floating-point arithmetic helper functions
// RTABI chapter 4.1.2, Table 2
- { 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 },
+ { RTLIB::ADD_F64, RTLIB::__aeabi_dadd },
+ { RTLIB::DIV_F64, RTLIB::__aeabi_ddiv },
+ { RTLIB::MUL_F64, RTLIB::__aeabi_dmul },
+ { RTLIB::SUB_F64, RTLIB::__aeabi_dsub },
// 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::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 },
+ { RTLIB::OEQ_F64, RTLIB::__aeabi_dcmpeq__ne },
+ { RTLIB::UNE_F64, RTLIB::__aeabi_dcmpeq__eq },
+ { RTLIB::OLT_F64, RTLIB::__aeabi_dcmplt },
+ { RTLIB::OLE_F64, RTLIB::__aeabi_dcmple },
+ { RTLIB::OGE_F64, RTLIB::__aeabi_dcmpge },
+ { RTLIB::OGT_F64, RTLIB::__aeabi_dcmpgt },
+ { RTLIB::UO_F64, RTLIB::__aeabi_dcmpun },
// Single-precision floating-point arithmetic helper functions
// RTABI chapter 4.1.2, Table 4
- { 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 },
+ { RTLIB::ADD_F32, RTLIB::__aeabi_fadd },
+ { RTLIB::DIV_F32, RTLIB::__aeabi_fdiv },
+ { RTLIB::MUL_F32, RTLIB::__aeabi_fmul },
+ { RTLIB::SUB_F32, RTLIB::__aeabi_fsub },
// 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::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 },
+ { RTLIB::OEQ_F32, RTLIB::__aeabi_fcmpeq__ne },
+ { RTLIB::UNE_F32, RTLIB::__aeabi_fcmpeq__eq },
+ { RTLIB::OLT_F32, RTLIB::__aeabi_fcmplt},
+ { RTLIB::OLE_F32, RTLIB::__aeabi_fcmple },
+ { RTLIB::OGE_F32, RTLIB::__aeabi_fcmpge },
+ { RTLIB::OGT_F32, RTLIB::__aeabi_fcmpgt },
+ { RTLIB::UO_F32, RTLIB::__aeabi_fcmpun },
// Floating-point to integer conversions.
// RTABI chapter 4.1.2, Table 6
- { 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
},
+ { RTLIB::FPTOSINT_F64_I32, RTLIB::__aeabi_d2iz },
+ { RTLIB::FPTOUINT_F64_I32, RTLIB::__aeabi_d2uiz },
+ { RTLIB::FPTOSINT_F64_I64, RTLIB::__aeabi_d2lz },
+ { RTLIB::FPTOUINT_F64_I64, RTLIB::__aeabi_d2ulz },
+ { RTLIB::FPTOSINT_F32_I32, RTLIB::__aeabi_f2iz },
+ { RTLIB::FPTOUINT_F32_I32, RTLIB::__aeabi_f2uiz },
+ { RTLIB::FPTOSINT_F32_I64, RTLIB::__aeabi_f2lz },
+ { RTLIB::FPTOUINT_F32_I64, RTLIB::__aeabi_f2ulz },
// Conversions between floating types.
// RTABI chapter 4.1.2, Table 7
- { 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 },
+ { RTLIB::FPROUND_F64_F32, RTLIB::__aeabi_d2f },
+ { RTLIB::FPROUND_F64_F16, RTLIB::__aeabi_d2h },
+ { RTLIB::FPEXT_F32_F64, RTLIB::__aeabi_f2d },
// Integer to floating-point conversions.
// RTABI chapter 4.1.2, Table 8
- { 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 },
+ { RTLIB::SINTTOFP_I32_F64, RTLIB::__aeabi_i2d },
+ { RTLIB::UINTTOFP_I32_F64, RTLIB::__aeabi_ui2d },
+ { RTLIB::SINTTOFP_I64_F64, RTLIB::__aeabi_l2d },
+ { RTLIB::UINTTOFP_I64_F64, RTLIB::__aeabi_ul2d },
+ { RTLIB::SINTTOFP_I32_F32, RTLIB::__aeabi_i2f },
+ { RTLIB::UINTTOFP_I32_F32, RTLIB::__aeabi_ui2f },
+ { RTLIB::SINTTOFP_I64_F32, RTLIB::__aeabi_l2f },
+ { RTLIB::UINTTOFP_I64_F32, RTLIB::__aeabi_ul2f },
// Long long helper functions
// RTABI chapter 4.2, Table 9
- { 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 },
+ { RTLIB::MUL_I64, RTLIB::__aeabi_lmul },
+ { RTLIB::SHL_I64, RTLIB::__aeabi_llsl },
+ { RTLIB::SRL_I64, RTLIB::__aeabi_llsr },
+ { RTLIB::SRA_I64, RTLIB::__aeabi_lasr },
// Integer division functions
// RTABI chapter 4.3.1
- { 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 },
+ { RTLIB::SDIV_I8, RTLIB::__aeabi_idiv__i8 },
+ { RTLIB::SDIV_I16, RTLIB::__aeabi_idiv__i16 },
+ { RTLIB::SDIV_I32, RTLIB::__aeabi_idiv__i32},
+ { RTLIB::SDIV_I64, RTLIB::__aeabi_ldivmod },
+ { RTLIB::UDIV_I8, RTLIB::__aeabi_uidiv__i8 },
+ { RTLIB::UDIV_I16, RTLIB::__aeabi_uidiv__i16 },
+ { RTLIB::UDIV_I32, RTLIB::__aeabi_uidiv__i32 },
+ { RTLIB::UDIV_I64, RTLIB::__aeabi_uldivmod },
};
// clang-format on
- for (const auto &LC : LibraryCalls) {
+ for (const auto &LC : LibraryCalls)
setLibcallImpl(LC.Op, LC.Impl);
- setLibcallImplCallingConv(LC.Impl, LC.CC);
- }
// EABI dependent RTLIB
if (TM.Options.EABIVersion == EABI::EABI4 ||
@@ -689,36 +685,25 @@ ARMTargetLowering::ARMTargetLowering(const TargetMachine
&TM_,
static const struct {
const RTLIB::Libcall Op;
const RTLIB::LibcallImpl Impl;
- const CallingConv::ID CC;
} MemOpsLibraryCalls[] = {
// Memory operations
// RTABI chapter 4.3.4
- {RTLIB::MEMCPY, RTLIB::__aeabi_memcpy, CallingConv::ARM_AAPCS},
- {RTLIB::MEMMOVE, RTLIB::__aeabi_memmove, CallingConv::ARM_AAPCS},
- {RTLIB::MEMSET, RTLIB::__aeabi_memset, CallingConv::ARM_AAPCS},
- {RTLIB::AEABI_MEMCPY4, RTLIB::__aeabi_memcpy4,
- CallingConv::ARM_AAPCS},
- {RTLIB::AEABI_MEMCPY8, RTLIB::__aeabi_memcpy8,
- CallingConv::ARM_AAPCS},
- {RTLIB::AEABI_MEMMOVE4, RTLIB::__aeabi_memmove4,
- CallingConv::ARM_AAPCS},
- {RTLIB::AEABI_MEMMOVE8, RTLIB::__aeabi_memmove8,
- CallingConv::ARM_AAPCS},
- {RTLIB::AEABI_MEMSET4, RTLIB::__aeabi_memset4,
- CallingConv::ARM_AAPCS},
- {RTLIB::AEABI_MEMSET8, RTLIB::__aeabi_memset8,
- CallingConv::ARM_AAPCS},
- {RTLIB::AEABI_MEMCLR, RTLIB::__aeabi_memclr, CallingConv::ARM_AAPCS},
- {RTLIB::AEABI_MEMCLR4, RTLIB::__aeabi_memclr4,
- CallingConv::ARM_AAPCS},
- {RTLIB::AEABI_MEMCLR8, RTLIB::__aeabi_memclr8,
- CallingConv::ARM_AAPCS},
+ {RTLIB::MEMCPY, RTLIB::__aeabi_memcpy},
+ {RTLIB::MEMMOVE, RTLIB::__aeabi_memmove},
+ {RTLIB::MEMSET, RTLIB::__aeabi_memset},
+ {RTLIB::AEABI_MEMCPY4, RTLIB::__aeabi_memcpy4},
+ {RTLIB::AEABI_MEMCPY8, RTLIB::__aeabi_memcpy8},
+ {RTLIB::AEABI_MEMMOVE4, RTLIB::__aeabi_memmove4},
+ {RTLIB::AEABI_MEMMOVE8, RTLIB::__aeabi_memmove8},
+ {RTLIB::AEABI_MEMSET4, RTLIB::__aeabi_memset4},
+ {RTLIB::AEABI_MEMSET8, RTLIB::__aeabi_memset8},
+ {RTLIB::AEABI_MEMCLR, RTLIB::__aeabi_memclr},
+ {RTLIB::AEABI_MEMCLR4, RTLIB::__aeabi_memclr4},
+ {RTLIB::AEABI_MEMCLR8, RTLIB::__aeabi_memclr8},
};
- for (const auto &LC : MemOpsLibraryCalls) {
+ for (const auto &LC : MemOpsLibraryCalls)
setLibcallImpl(LC.Op, LC.Impl);
- setLibcallImplCallingConv(LC.Impl, LC.CC);
- }
}
}
@@ -746,16 +731,14 @@ ARMTargetLowering::ARMTargetLowering(const TargetMachine
&TM_,
static const struct {
const RTLIB::Libcall Op;
const RTLIB::LibcallImpl Impl;
- const CallingConv::ID CC;
} LibraryCalls[] = {
- {RTLIB::FPROUND_F32_F16, RTLIB::__aeabi_f2h, CallingConv::ARM_AAPCS},
- {RTLIB::FPROUND_F64_F16, RTLIB::__aeabi_d2h, CallingConv::ARM_AAPCS},
- {RTLIB::FPEXT_F16_F32, RTLIB::__aeabi_h2f, CallingConv::ARM_AAPCS},
+ {RTLIB::FPROUND_F32_F16, RTLIB::__aeabi_f2h},
+ {RTLIB::FPROUND_F64_F16, RTLIB::__aeabi_d2h},
+ {RTLIB::FPEXT_F16_F32, RTLIB::__aeabi_h2f},
};
for (const auto &LC : LibraryCalls) {
setLibcallImpl(LC.Op, LC.Impl);
- setLibcallImplCallingConv(LC.Impl, LC.CC);
}
} else if (!TT.isOSBinFormatMachO()) {
setLibcallImpl(RTLIB::FPROUND_F32_F16, RTLIB::__gnu_f2h_ieee);
>From e96c43c33ee4e9ddc1d73d8b536309a22d92c4b7 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <matthew.arsena...@amd.com>
Date: Sat, 28 Jun 2025 11:42:52 +0900
Subject: [PATCH 3/5] Add missed __aeabi_idivmod and __aeabi_uidivmod cases
---
llvm/lib/IR/RuntimeLibcalls.cpp | 1 +
1 file changed, 1 insertion(+)
diff --git a/llvm/lib/IR/RuntimeLibcalls.cpp b/llvm/lib/IR/RuntimeLibcalls.cpp
index 6f4ba543f446b..ca2de2e1aecec 100644
--- a/llvm/lib/IR/RuntimeLibcalls.cpp
+++ b/llvm/lib/IR/RuntimeLibcalls.cpp
@@ -124,6 +124,7 @@ static void setARMLibcallNames(RuntimeLibcallsInfo &Info,
const Triple &TT,
RTLIB::__aeabi_llsl, RTLIB::__aeabi_llsr,
RTLIB::__aeabi_lasr, RTLIB::__aeabi_idiv__i8,
RTLIB::__aeabi_idiv__i16, RTLIB::__aeabi_idiv__i32,
+ RTLIB::__aeabi_idivmod, RTLIB::__aeabi_uidivmod,
RTLIB::__aeabi_ldivmod, RTLIB::__aeabi_uidiv__i8,
RTLIB::__aeabi_uidiv__i16, RTLIB::__aeabi_uidiv__i32,
RTLIB::__aeabi_uldivmod, RTLIB::__aeabi_f2h,
>From 57f1f297ffd9485b22b02c5d07493ea2c1bda535 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <matthew.arsena...@amd.com>
Date: Sat, 28 Jun 2025 11:48:27 +0900
Subject: [PATCH 4/5] Remove CC from other div table
---
llvm/lib/IR/RuntimeLibcalls.cpp | 13 +++++--------
1 file changed, 5 insertions(+), 8 deletions(-)
diff --git a/llvm/lib/IR/RuntimeLibcalls.cpp b/llvm/lib/IR/RuntimeLibcalls.cpp
index ca2de2e1aecec..449afb05e0af5 100644
--- a/llvm/lib/IR/RuntimeLibcalls.cpp
+++ b/llvm/lib/IR/RuntimeLibcalls.cpp
@@ -56,18 +56,15 @@ static void setARMLibcallNames(RuntimeLibcallsInfo &Info,
const Triple &TT,
const struct {
const RTLIB::Libcall Op;
const RTLIB::LibcallImpl Impl;
- const CallingConv::ID CC;
} LibraryCalls[] = {
- {RTLIB::SDIVREM_I32, RTLIB::__aeabi_idivmod, CallingConv::ARM_AAPCS},
- {RTLIB::SDIVREM_I64, RTLIB::__aeabi_ldivmod, CallingConv::ARM_AAPCS},
- {RTLIB::UDIVREM_I32, RTLIB::__aeabi_uidivmod,
CallingConv::ARM_AAPCS},
- {RTLIB::UDIVREM_I64, RTLIB::__aeabi_uldivmod,
CallingConv::ARM_AAPCS},
+ {RTLIB::SDIVREM_I32, RTLIB::__aeabi_idivmod},
+ {RTLIB::SDIVREM_I64, RTLIB::__aeabi_ldivmod},
+ {RTLIB::UDIVREM_I32, RTLIB::__aeabi_uidivmod},
+ {RTLIB::UDIVREM_I64, RTLIB::__aeabi_uldivmod},
};
- for (const auto &LC : LibraryCalls) {
+ for (const auto &LC : LibraryCalls)
Info.setLibcallImpl(LC.Op, LC.Impl);
- Info.setLibcallImplCallingConv(LC.Impl, LC.CC);
- }
}
}
>From 98fdafab18ee309bc36c6e062ebe8b1562b9a634 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <matthew.arsena...@amd.com>
Date: Mon, 23 Jun 2025 23:23:01 +0900
Subject: [PATCH 5/5] ARM: Start moving runtime libcalls into tablegen
We still need to manually set the calling conventions of
some libcalls until the lowering is separated out.
---
llvm/include/llvm/IR/RuntimeLibcalls.h | 3 +-
llvm/include/llvm/IR/RuntimeLibcalls.td | 48 ++++++++++++
llvm/lib/IR/RuntimeLibcalls.cpp | 73 +------------------
.../RuntimeLibcallEmitter-calling-conv.td | 2 +-
llvm/test/TableGen/RuntimeLibcallEmitter.td | 2 +-
.../TableGen/Basic/RuntimeLibcallsEmitter.cpp | 2 +-
6 files changed, 54 insertions(+), 76 deletions(-)
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.h
b/llvm/include/llvm/IR/RuntimeLibcalls.h
index 99931f75fcda6..e8ddaf1707bae 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.h
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.h
@@ -177,7 +177,8 @@ struct RuntimeLibcallsInfo {
void initDefaultLibCallImpls();
/// Generated by tablegen.
- void setTargetRuntimeLibcallSets(const Triple &TT);
+ 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..0237c8b41ae8c 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)">;
@@ -1272,6 +1273,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 +1282,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 +1309,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
//===----------------------------------------------------------------------===//
diff --git a/llvm/lib/IR/RuntimeLibcalls.cpp b/llvm/lib/IR/RuntimeLibcalls.cpp
index 449afb05e0af5..f85479edaa33e 100644
--- a/llvm/lib/IR/RuntimeLibcalls.cpp
+++ b/llvm/lib/IR/RuntimeLibcalls.cpp
@@ -25,77 +25,6 @@ static cl::opt<bool>
static void setARMLibcallNames(RuntimeLibcallsInfo &Info, const Triple &TT,
FloatABI::ABIType FloatABIType,
EABI EABIVersion) {
- if (!TT.isOSDarwin() && !TT.isiOS() && !TT.isWatchOS() && !TT.isDriverKit())
{
- CallingConv::ID DefaultCC = FloatABIType == FloatABI::Hard
- ? CallingConv::ARM_AAPCS_VFP
- : CallingConv::ARM_AAPCS;
- for (RTLIB::LibcallImpl LC : RTLIB::libcall_impls())
- Info.setLibcallImplCallingConv(LC, DefaultCC);
- }
-
- // Register based DivRem for AEABI (RTABI 4.2)
- if (TT.isTargetAEABI() || TT.isAndroid() || TT.isTargetGNUAEABI() ||
- TT.isTargetMuslAEABI() || TT.isOSWindows()) {
- if (TT.isOSWindows()) {
- const struct {
- const RTLIB::Libcall Op;
- const RTLIB::LibcallImpl Impl;
- const CallingConv::ID CC;
- } LibraryCalls[] = {
- {RTLIB::SDIVREM_I32, RTLIB::__rt_sdiv, CallingConv::ARM_AAPCS},
- {RTLIB::SDIVREM_I64, RTLIB::__rt_sdiv64, CallingConv::ARM_AAPCS},
- {RTLIB::UDIVREM_I32, RTLIB::__rt_udiv, CallingConv::ARM_AAPCS},
- {RTLIB::UDIVREM_I64, RTLIB::__rt_udiv64, CallingConv::ARM_AAPCS},
- };
-
- for (const auto &LC : LibraryCalls) {
- Info.setLibcallImpl(LC.Op, LC.Impl);
- Info.setLibcallImplCallingConv(LC.Impl, LC.CC);
- }
- } else {
- const struct {
- const RTLIB::Libcall Op;
- const RTLIB::LibcallImpl Impl;
- } LibraryCalls[] = {
- {RTLIB::SDIVREM_I32, RTLIB::__aeabi_idivmod},
- {RTLIB::SDIVREM_I64, RTLIB::__aeabi_ldivmod},
- {RTLIB::UDIVREM_I32, RTLIB::__aeabi_uidivmod},
- {RTLIB::UDIVREM_I64, RTLIB::__aeabi_uldivmod},
- };
-
- for (const auto &LC : LibraryCalls)
- Info.setLibcallImpl(LC.Op, LC.Impl);
- }
- }
-
- if (TT.isOSWindows()) {
- static const struct {
- const RTLIB::Libcall Op;
- const RTLIB::LibcallImpl Impl;
- const CallingConv::ID CC;
- } LibraryCalls[] = {
- {RTLIB::FPTOSINT_F32_I64, RTLIB::__stoi64, CallingConv::ARM_AAPCS_VFP},
- {RTLIB::FPTOSINT_F64_I64, RTLIB::__dtoi64, CallingConv::ARM_AAPCS_VFP},
- {RTLIB::FPTOUINT_F32_I64, RTLIB::__stou64, CallingConv::ARM_AAPCS_VFP},
- {RTLIB::FPTOUINT_F64_I64, RTLIB::__dtou64, CallingConv::ARM_AAPCS_VFP},
- {RTLIB::SINTTOFP_I64_F32, RTLIB::__i64tos, CallingConv::ARM_AAPCS_VFP},
- {RTLIB::SINTTOFP_I64_F64, RTLIB::__i64tod, CallingConv::ARM_AAPCS_VFP},
- {RTLIB::UINTTOFP_I64_F32, RTLIB::__u64tos, CallingConv::ARM_AAPCS_VFP},
- {RTLIB::UINTTOFP_I64_F64, RTLIB::__u64tod, CallingConv::ARM_AAPCS_VFP},
- };
-
- for (const auto &LC : LibraryCalls) {
- Info.setLibcallImpl(LC.Op, LC.Impl);
- Info.setLibcallImplCallingConv(LC.Impl, LC.CC);
- }
- }
-
- // Use divmod compiler-rt calls for iOS 5.0 and later.
- if (TT.isOSBinFormatMachO() && (!TT.isiOS() || !TT.isOSVersionLT(5, 0))) {
- Info.setLibcallImpl(RTLIB::SDIVREM_I32, RTLIB::__divmodsi4);
- Info.setLibcallImpl(RTLIB::UDIVREM_I32, RTLIB::__udivmodsi4);
- }
-
static const RTLIB::LibcallImpl AAPCS_Libcalls[] = {
RTLIB::__aeabi_dadd, RTLIB::__aeabi_ddiv,
RTLIB::__aeabi_dmul, RTLIB::__aeabi_dsub,
@@ -212,7 +141,7 @@ void RuntimeLibcallsInfo::initLibcalls(const Triple &TT,
ExceptionHandling ExceptionModel,
FloatABI::ABIType FloatABI,
EABI EABIVersion, StringRef ABIName) {
- setTargetRuntimeLibcallSets(TT);
+ setTargetRuntimeLibcallSets(TT, FloatABI);
// Use the f128 variants of math functions on x86
if (TT.isX86() && TT.isGNUEnvironment())
diff --git a/llvm/test/TableGen/RuntimeLibcallEmitter-calling-conv.td
b/llvm/test/TableGen/RuntimeLibcallEmitter-calling-conv.td
index f825ece6cf4bb..49d5ecaa0e5c5 100644
--- a/llvm/test/TableGen/RuntimeLibcallEmitter-calling-conv.td
+++ b/llvm/test/TableGen/RuntimeLibcallEmitter-calling-conv.td
@@ -41,7 +41,7 @@ def MSP430LibraryWithCondCC : SystemRuntimeLibrary<isMSP430,
>;
-// CHECK: void
llvm::RTLIB::RuntimeLibcallsInfo::setTargetRuntimeLibcallSets(const
llvm::Triple &TT) {
+// CHECK: void
llvm::RTLIB::RuntimeLibcallsInfo::setTargetRuntimeLibcallSets(const
llvm::Triple &TT, FloatABI::ABIType FloatABI) {
// CHECK: if (TT.getArch() == Triple::avr && TT.isOSHurd()) {
// CHECK-NEXT: const CallingConv::ID DefaultCC = isFoo() ? CallingConv::Fast
: CallingConv::GHC;
// CHECK-NEXT: for (CallingConv::ID &Entry : LibcallImplCallingConvs) {
diff --git a/llvm/test/TableGen/RuntimeLibcallEmitter.td
b/llvm/test/TableGen/RuntimeLibcallEmitter.td
index 0d7a69165d6f9..a0061afab1db0 100644
--- a/llvm/test/TableGen/RuntimeLibcallEmitter.td
+++ b/llvm/test/TableGen/RuntimeLibcallEmitter.td
@@ -141,7 +141,7 @@ def BlahLibrary : SystemRuntimeLibrary<isBlahArch, (add
calloc, LibraryWithCondi
// CHECK-NEXT: };
-// CHECK: void
llvm::RTLIB::RuntimeLibcallsInfo::setTargetRuntimeLibcallSets(const
llvm::Triple &TT) {
+// CHECK: void
llvm::RTLIB::RuntimeLibcallsInfo::setTargetRuntimeLibcallSets(const
llvm::Triple &TT, FloatABI::ABIType FloatABI) {
// CHECK-NEXT: struct LibcallImplPair {
// CHECK-NEXT: RTLIB::Libcall Func;
// CHECK-NEXT: RTLIB::LibcallImpl Impl;
diff --git a/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
b/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
index 81b7d4119d8e5..7e3ca0734f3c2 100644
--- a/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
+++ b/llvm/utils/TableGen/Basic/RuntimeLibcallsEmitter.cpp
@@ -362,7 +362,7 @@ void RuntimeLibcallEmitter::emitGetInitRuntimeLibcallNames(
void RuntimeLibcallEmitter::emitSystemRuntimeLibrarySetCalls(
raw_ostream &OS) const {
OS << "void llvm::RTLIB::RuntimeLibcallsInfo::setTargetRuntimeLibcallSets("
- "const llvm::Triple &TT) {\n"
+ "const llvm::Triple &TT, FloatABI::ABIType FloatABI) {\n"
" struct LibcallImplPair {\n"
" RTLIB::Libcall Func;\n"
" RTLIB::LibcallImpl Impl;\n"
_______________________________________________
llvm-branch-commits mailing list
llvm-branch-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
