[llvm-branch-commits] [llvm] ARM: Use divmod type signatures from RuntimeLibcallsInfo (PR #217869)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri Aug 21 03:00:56 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-transforms
Author: Matt Arsenault (arsenm)
<details>
<summary>Changes</summary>
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@<!-- -->anthropic.com>
---
Full diff: https://github.com/llvm/llvm-project/pull/217869.diff
3 Files Affected:
- (modified) llvm/include/llvm/CodeGen/TargetLowering.h (+9)
- (modified) llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp (+86-28)
- (modified) llvm/lib/Target/ARM/ARMISelLowering.cpp (+38-41)
``````````diff
diff --git a/llvm/include/llvm/CodeGen/TargetLowering.h b/llvm/include/llvm/CodeGen/TargetLowering.h
index a91b575dc82d2..614d5735258ba 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>;
@@ -4288,6 +4289,14 @@ 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.
+ LLVM_ABI 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 cca7cdad0e2c8..eba32eafd3aa4 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 43013b1992b50..4abd2bcfad60d 100644
--- a/llvm/lib/Target/ARM/ARMISelLowering.cpp
+++ b/llvm/lib/Target/ARM/ARMISelLowering.cpp
@@ -20905,25 +20905,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 {
@@ -20950,8 +20952,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
@@ -20975,18 +20975,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);
@@ -21015,29 +21020,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 =
``````````
</details>
https://github.com/llvm/llvm-project/pull/217869
More information about the llvm-branch-commits
mailing list