[llvm] df26d54 - ARM: Use divmod type signatures from RuntimeLibcallsInfo (#217869)
via llvm-commits
llvm-commits at lists.llvm.org
Fri Sep 25 05:26:28 PDT 2026
Author: Matt Arsenault
Date: 2026-09-25T12:26:22Z
New Revision: df26d549b9115ff7c32b6fb9031250994d0f3515
URL: https://github.com/llvm/llvm-project/commit/df26d549b9115ff7c32b6fb9031250994d0f3515
DIFF: https://github.com/llvm/llvm-project/commit/df26d549b9115ff7c32b6fb9031250994d0f3515.diff
LOG: ARM: Use divmod type signatures from RuntimeLibcallsInfo (#217869)
Start moving towards an API to emit calls from RuntimeLibcallsInfo's
knowledge about the type signature of a function instead of manually
computing an IR type from the EVT of the operation.
Also change the swap of arguments to be based on the libcall impl,
rather than the ABI since it's logically a property of the function
itself.
Co-authored-by: Claude (Claude-Opus-4.8) <noreply at anthropic.com>
Added:
Modified:
llvm/include/llvm/CodeGen/TargetLowering.h
llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
llvm/lib/Target/ARM/ARMISelLowering.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/CodeGen/TargetLowering.h b/llvm/include/llvm/CodeGen/TargetLowering.h
index c08d0e53ec34b..283b0f811dc2f 100644
--- a/llvm/include/llvm/CodeGen/TargetLowering.h
+++ b/llvm/include/llvm/CodeGen/TargetLowering.h
@@ -366,6 +366,7 @@ class LLVM_ABI TargetLoweringBase {
ArgListEntry(SDValue Node, Type *Ty) : ArgListEntry(nullptr, Node, Ty) {}
LLVM_ABI void setAttributes(const CallBase *Call, unsigned ArgIdx);
+ LLVM_ABI void setAttributes(const AttributeList &Attrs, unsigned ArgIdx);
};
using ArgListTy = std::vector<ArgListEntry>;
@@ -4350,6 +4351,13 @@ class LLVM_ABI TargetLowering : public TargetLoweringBase {
Chain);
}
+ /// Build a call argument list for \p FuncTy, taking the argument node values
+ /// from \p Ops and the parameter types and ABI attributes from \p FuncTy and
+ /// \p FuncAttrs. \p Ops must have one entry per parameter of \p FuncTy.
+ static ArgListTy getArgListForFunctionType(FunctionType *FuncTy,
+ const AttributeList &FuncAttrs,
+ ArrayRef<SDValue> Ops);
+
/// Check whether parameters to a call that are passed in callee saved
/// registers are the same as from the calling function. This needs to be
/// checked for tail call eligibility.
diff --git a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
index f5402812659fe..014976420ef33 100644
--- a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
+++ b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp
@@ -115,38 +115,96 @@ bool TargetLowering::parametersInCSRMatch(const MachineRegisterInfo &MRI,
return true;
}
+static bool paramHasAttr(const CallBase &Call, unsigned ArgIdx,
+ Attribute::AttrKind Kind) {
+ return Call.paramHasAttr(ArgIdx, Kind);
+}
+
+static bool paramHasAttr(const AttributeList &Attrs, unsigned ArgIdx,
+ Attribute::AttrKind Kind) {
+ return Attrs.hasParamAttr(ArgIdx, Kind);
+}
+
+static MaybeAlign getParamStackAlign(const CallBase &Call, unsigned ArgIdx) {
+ return Call.getParamStackAlign(ArgIdx);
+}
+
+static MaybeAlign getParamStackAlign(const AttributeList &Attrs,
+ unsigned ArgIdx) {
+ return Attrs.getParamStackAlignment(ArgIdx);
+}
+
+static MaybeAlign getParamAlign(const CallBase &Call, unsigned ArgIdx) {
+ return Call.getParamAlign(ArgIdx);
+}
+
+static MaybeAlign getParamAlign(const AttributeList &Attrs, unsigned ArgIdx) {
+ return Attrs.getParamAlignment(ArgIdx);
+}
+
/// Set CallLoweringInfo attribute flags based on a call instruction
/// and called function attributes.
+template <typename SourceT>
+static void setArgListEntryAttributes(TargetLoweringBase::ArgListEntry &Entry,
+ const SourceT &Src, unsigned ArgIdx) {
+ Entry.IsSExt = paramHasAttr(Src, ArgIdx, Attribute::SExt);
+ Entry.IsZExt = paramHasAttr(Src, ArgIdx, Attribute::ZExt);
+ Entry.IsNoExt = paramHasAttr(Src, ArgIdx, Attribute::NoExt);
+ Entry.IsInReg = paramHasAttr(Src, ArgIdx, Attribute::InReg);
+ Entry.IsSRet = paramHasAttr(Src, ArgIdx, Attribute::StructRet);
+ Entry.IsNest = paramHasAttr(Src, ArgIdx, Attribute::Nest);
+ Entry.IsByVal = paramHasAttr(Src, ArgIdx, Attribute::ByVal);
+ Entry.IsPreallocated = paramHasAttr(Src, ArgIdx, Attribute::Preallocated);
+ Entry.IsInAlloca = paramHasAttr(Src, ArgIdx, Attribute::InAlloca);
+ Entry.IsReturned = paramHasAttr(Src, ArgIdx, Attribute::Returned);
+ Entry.IsSwiftSelf = paramHasAttr(Src, ArgIdx, Attribute::SwiftSelf);
+ Entry.IsSwiftAsync = paramHasAttr(Src, ArgIdx, Attribute::SwiftAsync);
+ Entry.IsSwiftError = paramHasAttr(Src, ArgIdx, Attribute::SwiftError);
+ Entry.Alignment = getParamStackAlign(Src, ArgIdx);
+ Entry.IndirectType = nullptr;
+ assert(Entry.IsByVal + Entry.IsPreallocated + Entry.IsInAlloca +
+ Entry.IsSRet <=
+ 1 &&
+ "multiple ABI attributes?");
+ if (Entry.IsByVal) {
+ Entry.IndirectType = Src.getParamByValType(ArgIdx);
+ if (!Entry.Alignment)
+ Entry.Alignment = getParamAlign(Src, ArgIdx);
+ }
+ if (Entry.IsPreallocated)
+ Entry.IndirectType = Src.getParamPreallocatedType(ArgIdx);
+ if (Entry.IsInAlloca)
+ Entry.IndirectType = Src.getParamInAllocaType(ArgIdx);
+ if (Entry.IsSRet)
+ Entry.IndirectType = Src.getParamStructRetType(ArgIdx);
+}
+
void TargetLoweringBase::ArgListEntry::setAttributes(const CallBase *Call,
unsigned ArgIdx) {
- IsSExt = Call->paramHasAttr(ArgIdx, Attribute::SExt);
- IsZExt = Call->paramHasAttr(ArgIdx, Attribute::ZExt);
- IsNoExt = Call->paramHasAttr(ArgIdx, Attribute::NoExt);
- IsInReg = Call->paramHasAttr(ArgIdx, Attribute::InReg);
- IsSRet = Call->paramHasAttr(ArgIdx, Attribute::StructRet);
- IsNest = Call->paramHasAttr(ArgIdx, Attribute::Nest);
- IsByVal = Call->paramHasAttr(ArgIdx, Attribute::ByVal);
- IsPreallocated = Call->paramHasAttr(ArgIdx, Attribute::Preallocated);
- IsInAlloca = Call->paramHasAttr(ArgIdx, Attribute::InAlloca);
- IsReturned = Call->paramHasAttr(ArgIdx, Attribute::Returned);
- IsSwiftSelf = Call->paramHasAttr(ArgIdx, Attribute::SwiftSelf);
- IsSwiftAsync = Call->paramHasAttr(ArgIdx, Attribute::SwiftAsync);
- IsSwiftError = Call->paramHasAttr(ArgIdx, Attribute::SwiftError);
- Alignment = Call->getParamStackAlign(ArgIdx);
- IndirectType = nullptr;
- assert(IsByVal + IsPreallocated + IsInAlloca + IsSRet <= 1 &&
- "multiple ABI attributes?");
- if (IsByVal) {
- IndirectType = Call->getParamByValType(ArgIdx);
- if (!Alignment)
- Alignment = Call->getParamAlign(ArgIdx);
- }
- if (IsPreallocated)
- IndirectType = Call->getParamPreallocatedType(ArgIdx);
- if (IsInAlloca)
- IndirectType = Call->getParamInAllocaType(ArgIdx);
- if (IsSRet)
- IndirectType = Call->getParamStructRetType(ArgIdx);
+ setArgListEntryAttributes(*this, *Call, ArgIdx);
+}
+
+void TargetLoweringBase::ArgListEntry::setAttributes(const AttributeList &Attrs,
+ unsigned ArgIdx) {
+ setArgListEntryAttributes(*this, Attrs, ArgIdx);
+}
+
+TargetLowering::ArgListTy
+TargetLowering::getArgListForFunctionType(FunctionType *FuncTy,
+ const AttributeList &FuncAttrs,
+ ArrayRef<SDValue> Ops) {
+ // TODO: This assumes each parameter maps to exactly one operand node, which
+ // does not hold when an argument requires type splitting.
+ assert(Ops.size() == FuncTy->getNumParams() &&
+ "argument count does not match the function type");
+ ArgListTy Args;
+ Args.reserve(Ops.size());
+ for (unsigned I = 0, E = FuncTy->getNumParams(); I != E; ++I) {
+ ArgListEntry Entry(Ops[I], FuncTy->getParamType(I));
+ Entry.setAttributes(FuncAttrs, I);
+ Args.push_back(Entry);
+ }
+ return Args;
}
/// Generate a libcall taking the given operands as arguments and returning a
diff --git a/llvm/lib/Target/ARM/ARMISelLowering.cpp b/llvm/lib/Target/ARM/ARMISelLowering.cpp
index 194b597bc77ba..7e5f6134fc88b 100644
--- a/llvm/lib/Target/ARM/ARMISelLowering.cpp
+++ b/llvm/lib/Target/ARM/ARMISelLowering.cpp
@@ -20901,25 +20901,27 @@ static RTLIB::Libcall getDivRemLibcall(
return LC;
}
-static TargetLowering::ArgListTy getDivRemArgList(
- const SDNode *N, LLVMContext *Context, const ARMSubtarget *Subtarget) {
+static TargetLowering::ArgListTy
+getDivRemArgList(const SDNode *N, FunctionType *FuncTy,
+ const AttributeList &FuncAttrs, RTLIB::LibcallImpl LCImpl) {
assert((N->getOpcode() == ISD::SDIVREM || N->getOpcode() == ISD::UDIVREM ||
N->getOpcode() == ISD::SREM || N->getOpcode() == ISD::UREM) &&
"Unhandled Opcode in getDivRemArgList");
- bool isSigned = N->getOpcode() == ISD::SDIVREM ||
- N->getOpcode() == ISD::SREM;
- TargetLowering::ArgListTy Args;
- for (unsigned i = 0, e = N->getNumOperands(); i != e; ++i) {
- EVT ArgVT = N->getOperand(i).getValueType();
- Type *ArgTy = ArgVT.getTypeForEVT(*Context);
- TargetLowering::ArgListEntry Entry(N->getOperand(i), ArgTy);
- Entry.IsSExt = isSigned;
- Entry.IsZExt = !isSigned;
- Args.push_back(Entry);
+ SDValue Ops[2] = {N->getOperand(0), N->getOperand(1)};
+
+ // The Windows __rt_*div* helpers take the divisor before the dividend.
+ switch (LCImpl) {
+ case RTLIB::impl___rt_sdiv:
+ case RTLIB::impl___rt_udiv:
+ case RTLIB::impl___rt_sdiv64:
+ case RTLIB::impl___rt_udiv64:
+ std::swap(Ops[0], Ops[1]);
+ break;
+ default:
+ break;
}
- if (Subtarget->getTargetTriple().isOSWindows() && Args.size() >= 2)
- std::swap(Args[0], Args[1]);
- return Args;
+
+ return TargetLowering::getArgListForFunctionType(FuncTy, FuncAttrs, Ops);
}
SDValue ARMTargetLowering::LowerDivRem(SDValue Op, SelectionDAG &DAG) const {
@@ -20946,8 +20948,6 @@ SDValue ARMTargetLowering::LowerDivRem(SDValue Op, SelectionDAG &DAG) const {
}
}
- Type *Ty = VT.getTypeForEVT(*DAG.getContext());
-
// If the target has hardware divide, use divide + multiply + subtract:
// div = a / b
// rem = a - b * div
@@ -20971,18 +20971,23 @@ SDValue ARMTargetLowering::LowerDivRem(SDValue Op, SelectionDAG &DAG) const {
RTLIB::Libcall LC = getDivRemLibcall(Op.getNode(),
VT.getSimpleVT().SimpleTy);
RTLIB::LibcallImpl LCImpl = DAG.getLibcalls().getLibcallImpl(LC);
+ if (LCImpl == RTLIB::Unsupported)
+ return SDValue();
+
+ auto [FuncTy, FuncAttrs] =
+ DAG.getLibcalls().getRuntimeLibcallsInfo().getFunctionTy(
+ *DAG.getContext(), getTM().getTargetTriple(), DAG.getDataLayout(),
+ LCImpl);
+ Type *RetTy = FuncTy->getReturnType();
SDValue InChain = DAG.getEntryNode();
- TargetLowering::ArgListTy Args = getDivRemArgList(Op.getNode(),
- DAG.getContext(),
- Subtarget);
+ TargetLowering::ArgListTy Args =
+ getDivRemArgList(Op.getNode(), FuncTy, FuncAttrs, LCImpl);
SDValue Callee =
DAG.getExternalSymbol(LCImpl, getPointerTy(DAG.getDataLayout()));
- Type *RetTy = StructType::get(Ty, Ty);
-
if (getTM().getTargetTriple().isOSWindows())
InChain = WinDBZCheckDenominator(DAG, Op.getNode(), InChain);
@@ -21011,29 +21016,21 @@ SDValue ARMTargetLowering::LowerREM(SDNode *N, SelectionDAG &DAG) const {
Result[0], Result[1]);
}
- // Build return types (div and rem)
- std::vector<Type*> RetTyParams;
- Type *RetTyElement;
-
- switch (VT.getSimpleVT().SimpleTy) {
- default: llvm_unreachable("Unexpected request for libcall!");
- case MVT::i8: RetTyElement = Type::getInt8Ty(*DAG.getContext()); break;
- case MVT::i16: RetTyElement = Type::getInt16Ty(*DAG.getContext()); break;
- case MVT::i32: RetTyElement = Type::getInt32Ty(*DAG.getContext()); break;
- case MVT::i64: RetTyElement = Type::getInt64Ty(*DAG.getContext()); break;
- }
-
- RetTyParams.push_back(RetTyElement);
- RetTyParams.push_back(RetTyElement);
- ArrayRef<Type*> ret = ArrayRef<Type*>(RetTyParams);
- Type *RetTy = StructType::get(*DAG.getContext(), ret);
-
RTLIB::Libcall LC = getDivRemLibcall(N, N->getValueType(0).getSimpleVT().
SimpleTy);
RTLIB::LibcallImpl LCImpl = DAG.getLibcalls().getLibcallImpl(LC);
+ if (LCImpl == RTLIB::Unsupported)
+ return SDValue();
+
+ auto [FuncTy, FuncAttrs] =
+ DAG.getLibcalls().getRuntimeLibcallsInfo().getFunctionTy(
+ *DAG.getContext(), getTM().getTargetTriple(), DAG.getDataLayout(),
+ LCImpl);
+ Type *RetTy = FuncTy->getReturnType();
+
SDValue InChain = DAG.getEntryNode();
- TargetLowering::ArgListTy Args = getDivRemArgList(N, DAG.getContext(),
- Subtarget);
+ TargetLowering::ArgListTy Args =
+ getDivRemArgList(N, FuncTy, FuncAttrs, LCImpl);
bool isSigned = N->getOpcode() == ISD::SREM;
SDValue Callee =
More information about the llvm-commits
mailing list