[llvm-branch-commits] [llvm] RuntimeLibcalls: Add signatures for more runtime functions (PR #237483)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri Oct 30 21:37:33 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-backend-mips
Author: Matt Arsenault (arsenm)
<details>
<summary>Changes</summary>
Add type missing signatures for assorted functions which were missing
type information.
Co-authored-by: Claude Opus 5.5 <noreply@<!-- -->anthropic.com>
---
Patch is 513.82 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/237483.diff
17 Files Affected:
- (modified) llvm/include/llvm/IR/RuntimeLibcalls.td (+123-109)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aarch64.ll (+474-474)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm.ll (+192-192)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/arm64ec.ll (+89-89)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/avr.ll (+71-71)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/basic.ll (+2-2)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/bsd.ll (+279-279)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/codegen-opt-flags.ll (+6-6)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/hexagon.ll (+186-186)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/m68k.ll (+85-85)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/mips.ll (+178-178)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/msp430.ll (+100-100)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ppc.ll (+305-305)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/riscv.ll (+184-184)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/sparc.ll (+187-187)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/systemz.ll (+198-198)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/windows.ll (+276-276)
``````````diff
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index ce6a3d4e90ef0..6805f2871c557 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -219,44 +219,55 @@ def ExceptionModelIsSjLj
// Declare all kinds of used libcalls
//--------------------------------------------------------------------
+class TypeSuffix<string S, FuncArgType Ty> {
+ string Suffix = S;
+ FuncArgType Type = Ty;
+}
+
// Integer
-foreach IntTy = ["I16", "I32", "I64", "I128"] in {
- def SHL_#IntTy : RuntimeLibcall;
- def SRL_#IntTy : RuntimeLibcall;
- def SRA_#IntTy : RuntimeLibcall;
+foreach IntTy = [TypeSuffix<"I16", Int16>, TypeSuffix<"I32", Int32>,
+ TypeSuffix<"I64", Int64>, TypeSuffix<"I128", Int128>] in {
+ def SHL_#IntTy.Suffix : RuntimeLibcall<IntTy.Type, [IntTy.Type, Int]>;
+ def SRL_#IntTy.Suffix : RuntimeLibcall<IntTy.Type, [IntTy.Type, Int]>;
+ def SRA_#IntTy.Suffix : RuntimeLibcall<IntTy.Type, [IntTy.Type, Int]>;
}
-foreach IntTy = ["I8", "I16", "I32", "I64", "I128"] in {
- def MUL_#IntTy : RuntimeLibcall;
+foreach IntTy = [TypeSuffix<"I8", Int8>, TypeSuffix<"I16", Int16>,
+ TypeSuffix<"I32", Int32>, TypeSuffix<"I64", Int64>,
+ TypeSuffix<"I128", Int128>] in {
+ def MUL_#IntTy.Suffix : RuntimeLibcall<IntTy.Type, [IntTy.Type, IntTy.Type]>;
+ def SDIV_#IntTy.Suffix : RuntimeLibcall<IntTy.Type, [IntTy.Type, IntTy.Type]>;
+ def SREM_#IntTy.Suffix : RuntimeLibcall<IntTy.Type, [IntTy.Type, IntTy.Type]>;
}
-foreach IntTy = ["I32", "I64", "I128" ] in {
- def MULO_#IntTy : RuntimeLibcall;
+foreach IntTy = [TypeSuffix<"I8", UInt8>, TypeSuffix<"I16", UInt16>,
+ TypeSuffix<"I32", UInt32>, TypeSuffix<"I64", UInt64>,
+ TypeSuffix<"I128", UInt128>] in {
+ def UDIV_#IntTy.Suffix : RuntimeLibcall<IntTy.Type, [IntTy.Type, IntTy.Type]>;
+ def UREM_#IntTy.Suffix : RuntimeLibcall<IntTy.Type, [IntTy.Type, IntTy.Type]>;
+}
+
+foreach IntTy = [TypeSuffix<"I32", Int32>, TypeSuffix<"I64", Int64>,
+ TypeSuffix<"I128", Int128>] in {
+ def MULO_#IntTy.Suffix
+ : RuntimeLibcall<IntTy.Type, [IntTy.Type, IntTy.Type, Ptr]>;
}
foreach IntTy = ["I8", "I16", "I32", "I64", "I128"] in {
- def SDIV_#IntTy : RuntimeLibcall;
- def UDIV_#IntTy : RuntimeLibcall;
- def SREM_#IntTy : RuntimeLibcall;
- def UREM_#IntTy : RuntimeLibcall;
def SDIVREM_#IntTy : RuntimeLibcall;
def UDIVREM_#IntTy : RuntimeLibcall;
}
-foreach IntTy = ["I32", "I64" ] in {
- def NEG_#IntTy : RuntimeLibcall;
+foreach IntTy = [TypeSuffix<"I32", Int32>, TypeSuffix<"I64", Int64>] in {
+ def NEG_#IntTy.Suffix : RuntimeLibcall<IntTy.Type, [IntTy.Type]>;
}
-foreach IntTy = ["I32", "I64", "I128"] in {
- def CTLZ_#IntTy : RuntimeLibcall;
- def CTPOP_#IntTy : RuntimeLibcall;
+foreach IntTy = [TypeSuffix<"I32", Int32>, TypeSuffix<"I64", Int64>,
+ TypeSuffix<"I128", Int128>] in {
+ def CTLZ_#IntTy.Suffix : RuntimeLibcall<Int, [IntTy.Type]>;
+ def CTPOP_#IntTy.Suffix : RuntimeLibcall<Int, [IntTy.Type]>;
}
-
-class TypeSuffix<string S, FuncArgType Ty> {
- string Suffix = S;
- FuncArgType Type = Ty;
-}
def F32 : TypeSuffix<"F32", Flt>;
def F64 : TypeSuffix<"F64", Dbl>;
def F80 : TypeSuffix<"F80", X86FP80>;
@@ -337,10 +348,10 @@ foreach FPTy = [F32, F64, F80, F128, PPCF128] in {
: RuntimeLibcall<FPTy.Type, [FPTy.Type, FPTy.Type]>;
def FMAXIMUM_NUM_#FPTy.Suffix
: RuntimeLibcall<FPTy.Type, [FPTy.Type, FPTy.Type]>;
- def LROUND_#FPTy.Suffix : RuntimeLibcall;
- def LLROUND_#FPTy.Suffix : RuntimeLibcall;
- def LRINT_#FPTy.Suffix : RuntimeLibcall;
- def LLRINT_#FPTy.Suffix : RuntimeLibcall;
+ def LROUND_#FPTy.Suffix : RuntimeLibcall<Long, [FPTy.Type]>;
+ def LLROUND_#FPTy.Suffix : RuntimeLibcall<LLong, [FPTy.Type]>;
+ def LRINT_#FPTy.Suffix : RuntimeLibcall<Long, [FPTy.Type]>;
+ def LLRINT_#FPTy.Suffix : RuntimeLibcall<LLong, [FPTy.Type]>;
def LDEXP_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, Int]>;
def FREXP_#FPTy.Suffix : RuntimeLibcall<FPTy.Type, [FPTy.Type, Ptr]>;
def SINCOSPI_#FPTy.Suffix : RuntimeLibcall<Void, [FPTy.Type, Ptr, Ptr]>;
@@ -480,11 +491,11 @@ foreach S = !listconcat(F32VectorSuffixes, F64VectorSuffixes) in {
defm ROUND : VectorMathLibcall<S, VT, [VT]>;
}
-def FEGETENV : RuntimeLibcall;
-def FESETENV : RuntimeLibcall;
+def FEGETENV : RuntimeLibcall<Int, [Ptr]>;
+def FESETENV : RuntimeLibcall<Int, [Ptr]>;
-def FEGETMODE : RuntimeLibcall;
-def FESETMODE : RuntimeLibcall;
+def FEGETMODE : RuntimeLibcall<Int, [Ptr]>;
+def FESETMODE : RuntimeLibcall<Int, [Ptr]>;
def FPEXT_BF16_F32 : RuntimeLibcall;
def FPEXT_F32_PPCF128 : RuntimeLibcall<PPCFP128, [Flt]>;
@@ -519,37 +530,37 @@ def FPTOSINT_F16_I64 : RuntimeLibcall;
def FPTOSINT_F16_I128 : RuntimeLibcall;
def FPTOSINT_F32_I32 : RuntimeLibcall<Int32, [Flt]>;
def FPTOSINT_F32_I64 : RuntimeLibcall<Int64, [Flt]>;
-def FPTOSINT_F32_I128 : RuntimeLibcall;
+def FPTOSINT_F32_I128 : RuntimeLibcall<Int128, [Flt]>;
def FPTOSINT_F64_I32 : RuntimeLibcall<Int32, [Dbl]>;
def FPTOSINT_F64_I64 : RuntimeLibcall<Int64, [Dbl]>;
-def FPTOSINT_F64_I128 : RuntimeLibcall;
+def FPTOSINT_F64_I128 : RuntimeLibcall<Int128, [Dbl]>;
def FPTOSINT_F80_I32 : RuntimeLibcall<Int32, [X86FP80]>;
def FPTOSINT_F80_I64 : RuntimeLibcall<Int64, [X86FP80]>;
-def FPTOSINT_F80_I128 : RuntimeLibcall;
+def FPTOSINT_F80_I128 : RuntimeLibcall<Int128, [X86FP80]>;
def FPTOSINT_F128_I32 : RuntimeLibcall<Int32, [FP128]>;
def FPTOSINT_F128_I64 : RuntimeLibcall<Int64, [FP128]>;
-def FPTOSINT_F128_I128 : RuntimeLibcall;
+def FPTOSINT_F128_I128 : RuntimeLibcall<Int128, [FP128]>;
def FPTOSINT_PPCF128_I32 : RuntimeLibcall<Int32, [PPCFP128]>;
def FPTOSINT_PPCF128_I64 : RuntimeLibcall<Int64, [PPCFP128]>;
-def FPTOSINT_PPCF128_I128 : RuntimeLibcall;
+def FPTOSINT_PPCF128_I128 : RuntimeLibcall<Int128, [PPCFP128]>;
def FPTOUINT_F16_I32 : RuntimeLibcall;
def FPTOUINT_F16_I64 : RuntimeLibcall;
def FPTOUINT_F16_I128 : RuntimeLibcall;
def FPTOUINT_F32_I32 : RuntimeLibcall<UInt32, [Flt]>;
def FPTOUINT_F32_I64 : RuntimeLibcall<UInt64, [Flt]>;
-def FPTOUINT_F32_I128 : RuntimeLibcall;
+def FPTOUINT_F32_I128 : RuntimeLibcall<UInt128, [Flt]>;
def FPTOUINT_F64_I32 : RuntimeLibcall<UInt32, [Dbl]>;
def FPTOUINT_F64_I64 : RuntimeLibcall<UInt64, [Dbl]>;
-def FPTOUINT_F64_I128 : RuntimeLibcall;
+def FPTOUINT_F64_I128 : RuntimeLibcall<UInt128, [Dbl]>;
def FPTOUINT_F80_I32 : RuntimeLibcall<UInt32, [X86FP80]>;
def FPTOUINT_F80_I64 : RuntimeLibcall<UInt64, [X86FP80]>;
-def FPTOUINT_F80_I128 : RuntimeLibcall;
+def FPTOUINT_F80_I128 : RuntimeLibcall<UInt128, [X86FP80]>;
def FPTOUINT_F128_I32 : RuntimeLibcall<UInt32, [FP128]>;
def FPTOUINT_F128_I64 : RuntimeLibcall<UInt64, [FP128]>;
-def FPTOUINT_F128_I128 : RuntimeLibcall;
+def FPTOUINT_F128_I128 : RuntimeLibcall<UInt128, [FP128]>;
def FPTOUINT_PPCF128_I32 : RuntimeLibcall<UInt32, [PPCFP128]>;
def FPTOUINT_PPCF128_I64 : RuntimeLibcall<UInt64, [PPCFP128]>;
-def FPTOUINT_PPCF128_I128 : RuntimeLibcall;
+def FPTOUINT_PPCF128_I128 : RuntimeLibcall<UInt128, [PPCFP128]>;
def SINTTOFP_I32_F16 : RuntimeLibcall;
def SINTTOFP_I32_F32 : RuntimeLibcall<Flt, [Int32]>;
def SINTTOFP_I32_F64 : RuntimeLibcall<Dbl, [Int32]>;
@@ -564,11 +575,11 @@ def SINTTOFP_I64_F80 : RuntimeLibcall<X86FP80, [Int64]>;
def SINTTOFP_I64_F128 : RuntimeLibcall<FP128, [Int64]>;
def SINTTOFP_I64_PPCF128 : RuntimeLibcall<PPCFP128, [Int64]>;
def SINTTOFP_I128_F16 : RuntimeLibcall;
-def SINTTOFP_I128_F32 : RuntimeLibcall;
-def SINTTOFP_I128_F64 : RuntimeLibcall;
-def SINTTOFP_I128_F80 : RuntimeLibcall;
-def SINTTOFP_I128_F128 : RuntimeLibcall;
-def SINTTOFP_I128_PPCF128 : RuntimeLibcall;
+def SINTTOFP_I128_F32 : RuntimeLibcall<Flt, [Int128]>;
+def SINTTOFP_I128_F64 : RuntimeLibcall<Dbl, [Int128]>;
+def SINTTOFP_I128_F80 : RuntimeLibcall<X86FP80, [Int128]>;
+def SINTTOFP_I128_F128 : RuntimeLibcall<FP128, [Int128]>;
+def SINTTOFP_I128_PPCF128 : RuntimeLibcall<PPCFP128, [Int128]>;
def UINTTOFP_I32_F16 : RuntimeLibcall;
def UINTTOFP_I32_F32 : RuntimeLibcall<Flt, [UInt32]>;
def UINTTOFP_I32_F64 : RuntimeLibcall<Dbl, [UInt32]>;
@@ -583,13 +594,13 @@ def UINTTOFP_I64_F80 : RuntimeLibcall<X86FP80, [UInt64]>;
def UINTTOFP_I64_F128 : RuntimeLibcall<FP128, [UInt64]>;
def UINTTOFP_I64_PPCF128 : RuntimeLibcall<PPCFP128, [UInt64]>;
def UINTTOFP_I128_F16 : RuntimeLibcall;
-def UINTTOFP_I128_F32 : RuntimeLibcall;
-def UINTTOFP_I128_F64 : RuntimeLibcall;
-def UINTTOFP_I128_F80 : RuntimeLibcall;
-def UINTTOFP_I128_F128 : RuntimeLibcall;
-def UINTTOFP_I128_PPCF128 : RuntimeLibcall;
-def CONVERT_F128_PPCF128 : RuntimeLibcall;
-def CONVERT_PPCF128_F128 : RuntimeLibcall;
+def UINTTOFP_I128_F32 : RuntimeLibcall<Flt, [UInt128]>;
+def UINTTOFP_I128_F64 : RuntimeLibcall<Dbl, [UInt128]>;
+def UINTTOFP_I128_F80 : RuntimeLibcall<X86FP80, [UInt128]>;
+def UINTTOFP_I128_F128 : RuntimeLibcall<FP128, [UInt128]>;
+def UINTTOFP_I128_PPCF128 : RuntimeLibcall<PPCFP128, [UInt128]>;
+def CONVERT_F128_PPCF128 : RuntimeLibcall<PPCFP128, [FP128]>;
+def CONVERT_PPCF128_F128 : RuntimeLibcall<FP128, [PPCFP128]>;
// Comparisons.
//
@@ -633,17 +644,20 @@ def STRLEN : RuntimeLibcall<SizeT, [Ptr]>;
// Element-wise unordered-atomic memory of different sizes
foreach MemSize = [1, 2, 4, 8, 16] in {
- def MEMCPY_ELEMENT_UNORDERED_ATOMIC_#MemSize : RuntimeLibcall;
- def MEMMOVE_ELEMENT_UNORDERED_ATOMIC_#MemSize : RuntimeLibcall;
- def MEMSET_ELEMENT_UNORDERED_ATOMIC_#MemSize : RuntimeLibcall;
+ def MEMCPY_ELEMENT_UNORDERED_ATOMIC_#MemSize
+ : RuntimeLibcall<Void, [Ptr, Ptr, SizeT]>;
+ def MEMMOVE_ELEMENT_UNORDERED_ATOMIC_#MemSize
+ : RuntimeLibcall<Void, [Ptr, Ptr, SizeT]>;
+ def MEMSET_ELEMENT_UNORDERED_ATOMIC_#MemSize
+ : RuntimeLibcall<Void, [Ptr, Int, SizeT]>;
}
// Exception handling
-def UNWIND_RESUME : RuntimeLibcall;
-def UNWIND_REGISTER : RuntimeLibcall;
-def UNWIND_UNREGISTER : RuntimeLibcall;
-def UNWIND_GET_WASM_LPAD_CONTEXT : RuntimeLibcall;
-def CXA_END_CLEANUP : RuntimeLibcall;
+def UNWIND_RESUME : RuntimeLibcall<Void, [Ptr]>;
+def UNWIND_REGISTER : RuntimeLibcall<Void, [Ptr]>;
+def UNWIND_UNREGISTER : RuntimeLibcall<Void, [Ptr]>;
+def UNWIND_GET_WASM_LPAD_CONTEXT : RuntimeLibcall<Ptr, []>;
+def CXA_END_CLEANUP : RuntimeLibcall<Void, []>;
// Note: there are two sets of atomics libcalls; see
// <https://llvm.org/docs/Atomics.html> for more info on the
@@ -759,31 +773,31 @@ defset list<RuntimeLibcall> LibCalls__OutOfLineAtomic = {
}
// Stack Protector Fail
-def STACKPROTECTOR_CHECK_FAIL : RuntimeLibcall;
+def STACKPROTECTOR_CHECK_FAIL : RuntimeLibcall<Void, []>;
def STACK_SMASH_HANDLER : RuntimeLibcall;
// Safe stack
-def SAFESTACK_POINTER_ADDRESS : RuntimeLibcall;
+def SAFESTACK_POINTER_ADDRESS : RuntimeLibcall<Ptr, []>;
// Really a global variable, not a function
def SAFESTACK_UNSAFE_STACK_PTR : RuntimeLibcall;
def STACK_PROBE : RuntimeLibcall;
-def SECURITY_CHECK_COOKIE : RuntimeLibcall;
+def SECURITY_CHECK_COOKIE : RuntimeLibcall<Void, [Ptr]>;
// Deoptimization
def DEOPTIMIZE : RuntimeLibcall;
// Return address
-def RETURN_ADDRESS : RuntimeLibcall;
+def RETURN_ADDRESS : RuntimeLibcall<Ptr, [Int]>;
// GPU profiling
def PROFILE_INSTRUMENT_GPU : RuntimeLibcall;
def PROFILE_SAMPLING_GPU : RuntimeLibcall;
// Clear cache
-def CLEAR_CACHE : RuntimeLibcall;
-def RISCV_FLUSH_ICACHE : RuntimeLibcall;
+def CLEAR_CACHE : RuntimeLibcall<Void, [Ptr, Ptr]>;
+def RISCV_FLUSH_ICACHE : RuntimeLibcall<Int, [Ptr, Ptr, ULong]>;
// Mips16 calls
def MIPS16_RET_DC : RuntimeLibcall;
@@ -808,10 +822,10 @@ multiclass LibmLibcallImpls<string libcall_basename = !toupper(NAME),
}
// AArch64 calls
-def SC_MEMCPY : RuntimeLibcall;
-def SC_MEMMOVE : RuntimeLibcall;
-def SC_MEMSET : RuntimeLibcall;
-def SC_MEMCHR: RuntimeLibcall;
+def SC_MEMCPY : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
+def SC_MEMMOVE : RuntimeLibcall<Ptr, [Ptr, Ptr, SizeT]>;
+def SC_MEMSET : RuntimeLibcall<Ptr, [Ptr, Int, SizeT]>;
+def SC_MEMCHR : RuntimeLibcall<Ptr, [Ptr, Int, SizeT]>;
// AArch64 SME ABI calls
def SMEABI_SME_STATE : RuntimeLibcall;
@@ -824,19 +838,19 @@ def SMEABI_SME_SAVE : RuntimeLibcall;
def SMEABI_SME_RESTORE : RuntimeLibcall;
// ARM EABI calls
-def AEABI_MEMCPY4 : RuntimeLibcall; // Align 4
-def AEABI_MEMCPY8 : RuntimeLibcall; // Align 8
-def AEABI_MEMMOVE4 : RuntimeLibcall;
-def AEABI_MEMMOVE8 : RuntimeLibcall;
-def AEABI_MEMSET4 : RuntimeLibcall;
-def AEABI_MEMSET8 : RuntimeLibcall;
-def AEABI_MEMCLR : RuntimeLibcall;
-def AEABI_MEMCLR4 : RuntimeLibcall;
-def AEABI_MEMCLR8 : RuntimeLibcall;
-def AEABI_UREAD4 : RuntimeLibcall;
-def AEABI_UREAD8 : RuntimeLibcall;
-def AEABI_UWRITE4 : RuntimeLibcall;
-def AEABI_UWRITE8 : RuntimeLibcall;
+def AEABI_MEMCPY4 : RuntimeLibcall<Void, [Ptr, Ptr, SizeT]>; // Align 4
+def AEABI_MEMCPY8 : RuntimeLibcall<Void, [Ptr, Ptr, SizeT]>; // Align 8
+def AEABI_MEMMOVE4 : RuntimeLibcall<Void, [Ptr, Ptr, SizeT]>;
+def AEABI_MEMMOVE8 : RuntimeLibcall<Void, [Ptr, Ptr, SizeT]>;
+def AEABI_MEMSET4 : RuntimeLibcall<Void, [Ptr, SizeT, Int]>;
+def AEABI_MEMSET8 : RuntimeLibcall<Void, [Ptr, SizeT, Int]>;
+def AEABI_MEMCLR : RuntimeLibcall<Void, [Ptr, SizeT]>;
+def AEABI_MEMCLR4 : RuntimeLibcall<Void, [Ptr, SizeT]>;
+def AEABI_MEMCLR8 : RuntimeLibcall<Void, [Ptr, SizeT]>;
+def AEABI_UREAD4 : RuntimeLibcall<Int, [Ptr]>;
+def AEABI_UREAD8 : RuntimeLibcall<LLong, [Ptr]>;
+def AEABI_UWRITE4 : RuntimeLibcall<Int, [Int, Ptr]>;
+def AEABI_UWRITE8 : RuntimeLibcall<LLong, [LLong, Ptr]>;
// Hexagon calls
def HEXAGON_MEMCPY_LIKELY_ALIGNED_MIN32BYTES_MULT8BYTES : RuntimeLibcall;
@@ -846,32 +860,32 @@ def HEXAGON_VOLATILE_MEMCPY : RuntimeLibcall;
def MEMCPY_ALIGN_4 : RuntimeLibcall;
// Objective-C calls
-def OBJC_AUTORELEASE : RuntimeLibcall;
-def OBJC_AUTORELEASEPOOLPOP : RuntimeLibcall;
-def OBJC_AUTORELEASEPOOLPUSH : RuntimeLibcall;
-def OBJC_AUTORELEASERETURNVALUE : RuntimeLibcall;
-def OBJC_COPYWEAK : RuntimeLibcall;
-def OBJC_DESTROYWEAK : RuntimeLibcall;
-def OBJC_INITWEAK : RuntimeLibcall;
-def OBJC_LOADWEAK : RuntimeLibcall;
-def OBJC_LOADWEAKRETAINED : RuntimeLibcall;
-def OBJC_MOVEWEAK : RuntimeLibcall;
-def OBJC_RELEASE : RuntimeLibcall;
-def OBJC_RETAIN : RuntimeLibcall;
-def OBJC_RETAINAUTORELEASE : RuntimeLibcall;
-def OBJC_RETAINAUTORELEASERETURNVALUE : RuntimeLibcall;
-def OBJC_RETAINAUTORELEASEDRETURNVALUE : RuntimeLibcall;
-def OBJC_CLAIMAUTORELEASEDRETURNVALUE : RuntimeLibcall;
-def OBJC_RETAINBLOCK : RuntimeLibcall;
-def OBJC_STORESTRONG : RuntimeLibcall;
-def OBJC_STOREWEAK : RuntimeLibcall;
-def OBJC_UNSAFECLAIMAUTORELEASEDRETURNVALUE : RuntimeLibcall;
-def OBJC_RETAINEDOBJECT : RuntimeLibcall;
-def OBJC_UNRETAINEDOBJECT : RuntimeLibcall;
-def OBJC_UNRETAINEDPOINTER : RuntimeLibcall;
-def OBJC_RETAIN_AUTORELEASE : RuntimeLibcall;
-def OBJC_SYNC_ENTER : RuntimeLibcall;
-def OBJC_SYNC_EXIT : RuntimeLibcall;
+def OBJC_AUTORELEASE : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_AUTORELEASEPOOLPOP : RuntimeLibcall<Void, [Ptr]>;
+def OBJC_AUTORELEASEPOOLPUSH : RuntimeLibcall<Ptr, []>;
+def OBJC_AUTORELEASERETURNVALUE : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_COPYWEAK : RuntimeLibcall<Void, [Ptr, Ptr]>;
+def OBJC_DESTROYWEAK : RuntimeLibcall<Void, [Ptr]>;
+def OBJC_INITWEAK : RuntimeLibcall<Ptr, [Ptr, Ptr]>;
+def OBJC_LOADWEAK : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_LOADWEAKRETAINED : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_MOVEWEAK : RuntimeLibcall<Void, [Ptr, Ptr]>;
+def OBJC_RELEASE : RuntimeLibcall<Void, [Ptr]>;
+def OBJC_RETAIN : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_RETAINAUTORELEASE : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_RETAINAUTORELEASERETURNVALUE : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_RETAINAUTORELEASEDRETURNVALUE : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_CLAIMAUTORELEASEDRETURNVALUE : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_RETAINBLOCK : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_STORESTRONG : RuntimeLibcall<Void, [Ptr, Ptr]>;
+def OBJC_STOREWEAK : RuntimeLibcall<Ptr, [Ptr, Ptr]>;
+def OBJC_UNSAFECLAIMAUTORELEASEDRETURNVALUE : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_RETAINEDOBJECT : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_UNRETAINEDOBJECT : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_UNRETAINEDPOINTER : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_RETAIN_AUTORELEASE : RuntimeLibcall<Ptr, [Ptr]>;
+def OBJC_SYNC_ENTER : RuntimeLibcall<Int, [Ptr]>;
+def OBJC_SYNC_EXIT : RuntimeLibcall<Int, [Ptr]>;
def ABORT : RuntimeLibcall<Void, []>;
def ABS : RuntimeLibcall<Int, [Int]>;
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aarch64.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aarch64.ll
index a364011b48751..1fbf9c241769f 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aarch64.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/aarch64.ll
@@ -8,7 +8,7 @@
; RUN: opt -S -passes=declare-runtime-libcalls -mtriple=aarch64-w64-windows-gnu < %s | sed '/^$/d;/^; Function Attrs:/d' | FileCheck -check-prefix=MINGW %s
; RUN: opt -S -passes=declare-runtime-libcalls -mtriple=aarch64-unknown-linux-android < %s | sed '/^$/d;/^; Function Attrs:/d' | FileCheck -check-prefix=ANDROID %s
-; LINUX: declare void @_Unwind_Resume(...)
+; LINUX: declare void @_Unwind_Resume(ptr)
; LINUX-NEXT: declare i128 @__aarch64_cas16_acq(i128, i128, ptr)
; LINUX-NEXT: declare i128 @__aarch64_cas16_acq_rel(i128, i128, ptr)
; LINUX-NEXT: declare i128 @__aarch64_cas16_rel(i128, i128, ptr)
@@ -113,10 +113,10 @@
; LINUX-NEXT: declare float @__addsf3(float, float)
; LINUX-NEXT: declare fp128 @__addtf3(fp128, fp128)
; LINUX-NEXT: declare aarch64_sme_preservemost_from_x1 void @__arm_get_current_vg(...)
-; LINUX-NEXT: declare void @__arm_sc_memchr(...)
-; LINUX-NEXT: declare void @__arm_sc_memcpy(...)
-; LINUX-NEXT: declare void @__arm_sc_memmove(...)
-; LINUX-NEXT: declare void @__arm_sc_memset(...)
+; LINUX-NEXT: declare ptr @__arm_sc_memchr(ptr, i32, i64)
+; LINUX-NEXT: declare ptr @__arm_sc_memcpy(ptr, ptr, i64)
+; LINUX-NEXT: declare ptr @__arm_sc_memmove(ptr, ptr, i64)
+; LINUX-NEXT: declare ptr @__arm_sc_memset(ptr, i32, i64)
; LINUX-NEXT: declare aarch64_sme_preservemost_from_x1 void @__arm_sme_restore(...)
; LINUX-NEXT: declare aarch64_sme_preservemost_from_x1 void @__arm_sme_save(...)
; LINUX-NEXT: declare aarch64_sme_preservemost_from_x2 void @__arm_sme_state(...)
@@ -124,14 +124,14 @@
; LINUX-NEXT: declare aarch64_sme_preservemost_from_x0 void @__arm_tpidr2_restore(...)
; LINUX-NEXT: declare aarch64_sme_preservemost_from_x0 void @__arm_tpidr2_save(...)
; LINUX-NEXT: declare aarch64_sme_preservemost_from_x0 void @__arm_za_disable(...)
-; LINUX-NEXT: declare void @__ashldi3(...)
-; LINUX-NEXT: declare void @__ashlhi3(...)
-; LINUX-NEXT: declare void @__ashlsi3(...)
-; LINUX-NEXT: declare void @__ashlti3(...)
-; LINUX-NEXT: declare void @__ashrdi3(...)
-; LINUX-NEXT: declare void @__ashrhi3(...)
-; LINUX-NEXT: declare void @__ashrsi3(...)
-; LINUX-NEXT: declare void @__ashrti3(...)
+; LINUX-NEXT: declare i64 @__ashldi3(i64, i32)
+; LINUX-NEXT: declare signext i16 @__ashlhi3(i16 signext, i32)
+; LINUX-NEXT: declare i32 @__ashlsi3(i32, i32)
+; LINUX-NEXT: declare i128 @__ashlti3(i128, i32)
+; LINUX-NEXT: declare i64 @__ashrdi3(i64, i32)
+; LINUX-NEXT: declare signext i16 @__ashrhi3(i16 signext, i32)
+; LINUX-NEXT: declare i32 @__ashrsi3(i32, i32)
+; LINUX-NEXT: declare i128 @__ashrti3(i128, i32)
; LINUX-NEXT: declare zeroext i1 @__atomic_compare_exchange(i64, ptr, ptr, ptr, i32, i32)
; LINUX-NEXT: declare zeroext i1 @__atomic_compare_exchange_1(ptr, ptr, i8 zeroext, i32, i32)
; LINUX-NEXT: declare zeroext i1 @__atomic_compare_exchange_16(ptr, ptr, i128, i32, i32)
@@ -186,19 +186,19 @@
; LINUX-NEXT: declare void @__atomic_store_2(ptr, i16 zeroext, i32)
; LINUX-NEXT: declare void @__atomic_store_4(ptr, i32, i32)
; LINUX-NEXT: declare void @__atomic_store_8(ptr, i64, i32)
-; LINUX-NEXT: declare void @__clear_cache(...)
-; LINUX-NEXT: declare void @__clzdi2(...)
-; LINUX-NEXT: declare void @__clzsi2(...)
-; LINUX-NEXT: declare void @__clzti2(...)
-; LINUX-NEXT: declare void @__cxa_end_cleanup(...)
+; LINUX-NEXT: declare void @__clear_cache(ptr, ptr)
+; LINUX-NEXT: declare i32 @__clzdi2(i64)
+; LINUX-NEXT: declare i32 @__clzsi2(i32)
+; LINUX-NEXT: declare i32 @__clzti2(i128)
+; LINUX-NEXT: declare void @__cxa_end_cleanup()
; LINUX-NEXT: declare double @__divdf3(double, double)
-; LINUX-NEXT: declare void @__divdi3(...)
-; LINUX-NEXT: ...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/237483
More information about the llvm-branch-commits
mailing list