[llvm-branch-commits] [llvm] RuntimeLibcalls: Use explicit types for F80, F128 and PPCF128 libcalls (PR #235145)
via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Fri Oct 23 22:10:09 PDT 2026
llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-llvm-transforms
Author: Matt Arsenault (arsenm)
<details>
<summary>Changes</summary>
LDbl only makes sense for encoding the long double libm functions. Other
functions have need of the specific type. Separately, LDbl brokenly assumes
double instead of checking the module's long double format. Some functions
are inappropriately using a specific type instead of LDbl. I'll fix both
of these issues separately.
Co-authored-by: Claude Opus 5.5 <noreply@<!-- -->anthropic.com>
---
Patch is 56.67 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/235145.diff
7 Files Affected:
- (modified) llvm/include/llvm/IR/RuntimeLibcalls.td (+3-3)
- (modified) llvm/include/llvm/IR/RuntimeLibcallsImpl.td (+8)
- (modified) llvm/lib/IR/RuntimeLibcalls.cpp (+6)
- (modified) llvm/test/TableGen/RuntimeLibcallEmitter.td (+3)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/bsd.ll (+39-39)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ppc.ll (+96-96)
- (modified) llvm/test/Transforms/Util/DeclareRuntimeLibcalls/windows.ll (+39-39)
``````````diff
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index 21febe8d2270e..dba6f1c0e8404 100644
--- a/llvm/include/llvm/IR/RuntimeLibcalls.td
+++ b/llvm/include/llvm/IR/RuntimeLibcalls.td
@@ -259,9 +259,9 @@ class TypeSuffix<string S, FuncArgType Ty> {
}
def F32 : TypeSuffix<"F32", Flt>;
def F64 : TypeSuffix<"F64", Dbl>;
-def F80 : TypeSuffix<"F80", LDbl>;
-def F128 : TypeSuffix<"F128", LDbl>;
-def PPCF128 : TypeSuffix<"PPCF128", LDbl>;
+def F80 : TypeSuffix<"F80", X86FP80>;
+def F128 : TypeSuffix<"F128", FP128>;
+def PPCF128 : TypeSuffix<"PPCF128", PPCFP128>;
foreach FPTy = [F32, F64, F80, F128, PPCF128] in {
def ADD_#FPTy.Suffix : RuntimeLibcall;
diff --git a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
index 5d3af2516b8dc..0f734a00b0103 100644
--- a/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
+++ b/llvm/include/llvm/IR/RuntimeLibcallsImpl.td
@@ -86,6 +86,9 @@ def SSizeT : FuncArgType; // POSIX ssize_t.
def Flt : FuncArgType; // IEEE float.
def Dbl : FuncArgType; // IEEE double.
def LDbl : FuncArgType; // Any floating type (TODO: tighten this up).
+def X86FP80 : FuncArgType;
+def FP128 : FuncArgType;
+def PPCFP128 : FuncArgType;
def Floating : FuncArgType; // Any floating type.
def Ptr : FuncArgType; // Any pointer type.
def Struct : FuncArgType; // Any struct type.
@@ -170,6 +173,11 @@ class LongDoubleLibcallImpl<string libcall_basename, string Name = NAME>
RuntimeLibcall ProvidesF128 = !cast<RuntimeLibcall>(libcall_basename#"_F128");
RuntimeLibcall ProvidesPPCF128 =
!cast<RuntimeLibcall>(libcall_basename#"_PPCF128");
+
+ let ReturnType = !if(!eq(ProvidesF128.ReturnType, FP128), LDbl,
+ ProvidesF128.ReturnType);
+ let ArgumentTypes = !foreach(Ty, ProvidesF128.ArgumentTypes,
+ !if(!eq(Ty, FP128), LDbl, Ty));
}
/// A family of runtime libcalls implementing one floating-point operation, used
diff --git a/llvm/lib/IR/RuntimeLibcalls.cpp b/llvm/lib/IR/RuntimeLibcalls.cpp
index a614c498fafce..57b25b73dfee3 100644
--- a/llvm/lib/IR/RuntimeLibcalls.cpp
+++ b/llvm/lib/IR/RuntimeLibcalls.cpp
@@ -229,6 +229,12 @@ convertToIRTypeAndAttr(FuncArgTypeID ID, LLVMContext &Ctx, const DataLayout &DL,
return {Type::getDoubleTy(Ctx), Attribute()};
case LDbl:
return {getLongDoubleType(Ctx, LdblFormat), Attribute()};
+ case X86FP80:
+ return {Type::getX86_FP80Ty(Ctx), Attribute()};
+ case FP128:
+ return {Type::getFP128Ty(Ctx), Attribute()};
+ case PPCFP128:
+ return {Type::getPPC_FP128Ty(Ctx), Attribute()};
case Ptr:
return {PointerType::get(Ctx, 0), Attribute()};
case V2F32:
diff --git a/llvm/test/TableGen/RuntimeLibcallEmitter.td b/llvm/test/TableGen/RuntimeLibcallEmitter.td
index b2ecee11353ad..34a820484f0ec 100644
--- a/llvm/test/TableGen/RuntimeLibcallEmitter.td
+++ b/llvm/test/TableGen/RuntimeLibcallEmitter.td
@@ -122,6 +122,7 @@ def BlahLibrary : SystemRuntimeLibrary<isBlahArch, ["libc"]>;
// CHECK-NEXT: Bool,
// CHECK-NEXT: Dbl,
// CHECK-NEXT: Ellip,
+// CHECK-NEXT: FP128,
// CHECK-NEXT: Floating,
// CHECK-NEXT: Flt,
// CHECK-NEXT: Int,
@@ -141,6 +142,7 @@ def BlahLibrary : SystemRuntimeLibrary<isBlahArch, ["libc"]>;
// CHECK-NEXT: NXV4F32,
// CHECK-NEXT: NXV4I1,
// CHECK-NEXT: NXV4I32,
+// CHECK-NEXT: PPCFP128,
// CHECK-NEXT: Ptr,
// CHECK-NEXT: SSizeT,
// CHECK-NEXT: Same,
@@ -166,6 +168,7 @@ def BlahLibrary : SystemRuntimeLibrary<isBlahArch, ["libc"]>;
// CHECK-NEXT: V16F32,
// CHECK-NEXT: V16I32,
// CHECK-NEXT: Void,
+// CHECK-NEXT: X86FP80,
// CHECK-NEXT:};
// CHECK-EMPTY:
// CHECK-NEXT: enum class RuntimeLibrary : unsigned char {
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/bsd.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/bsd.ll
index 8ce7c87f34e21..d55e04d1bafa7 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/bsd.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/bsd.ll
@@ -89,13 +89,13 @@
; LINUX-NEXT: declare void @__eqdf2(...)
; LINUX-NEXT: declare void @__eqsf2(...)
; LINUX-NEXT: declare void @__eqtf2(...)
-; LINUX-NEXT: declare x86_fp80 @__exp10f128_finite(x86_fp80)
+; LINUX-NEXT: declare fp128 @__exp10f128_finite(fp128)
; LINUX-NEXT: declare double @__exp2_finite(double)
-; LINUX-NEXT: declare x86_fp80 @__exp2f128_finite(x86_fp80)
+; LINUX-NEXT: declare fp128 @__exp2f128_finite(fp128)
; LINUX-NEXT: declare float @__exp2f_finite(float)
; LINUX-NEXT: declare x86_fp80 @__exp2l_finite(x86_fp80)
; LINUX-NEXT: declare double @__exp_finite(double)
-; LINUX-NEXT: declare x86_fp80 @__expf128_finite(x86_fp80)
+; LINUX-NEXT: declare fp128 @__expf128_finite(fp128)
; LINUX-NEXT: declare float @__expf_finite(float)
; LINUX-NEXT: declare x86_fp80 @__expl_finite(x86_fp80)
; LINUX-NEXT: declare void @__extendbfsf2(...)
@@ -195,15 +195,15 @@
; LINUX-NEXT: declare void @__llvm_memset_element_unordered_atomic_4(...)
; LINUX-NEXT: declare void @__llvm_memset_element_unordered_atomic_8(...)
; LINUX-NEXT: declare double @__log10_finite(double)
-; LINUX-NEXT: declare x86_fp80 @__log10f128_finite(x86_fp80)
+; LINUX-NEXT: declare fp128 @__log10f128_finite(fp128)
; LINUX-NEXT: declare float @__log10f_finite(float)
; LINUX-NEXT: declare x86_fp80 @__log10l_finite(x86_fp80)
; LINUX-NEXT: declare double @__log2_finite(double)
-; LINUX-NEXT: declare x86_fp80 @__log2f128_finite(x86_fp80)
+; LINUX-NEXT: declare fp128 @__log2f128_finite(fp128)
; LINUX-NEXT: declare float @__log2f_finite(float)
; LINUX-NEXT: declare x86_fp80 @__log2l_finite(x86_fp80)
; LINUX-NEXT: declare double @__log_finite(double)
-; LINUX-NEXT: declare x86_fp80 @__logf128_finite(x86_fp80)
+; LINUX-NEXT: declare fp128 @__logf128_finite(fp128)
; LINUX-NEXT: declare float @__logf_finite(float)
; LINUX-NEXT: declare x86_fp80 @__logl_finite(x86_fp80)
; LINUX-NEXT: declare void @__lshrdi3(...)
@@ -238,7 +238,7 @@
; LINUX-NEXT: declare void @__popcountsi2(...)
; LINUX-NEXT: declare void @__popcountti2(...)
; LINUX-NEXT: declare double @__pow_finite(double, double)
-; LINUX-NEXT: declare x86_fp80 @__powf128_finite(x86_fp80, x86_fp80)
+; LINUX-NEXT: declare fp128 @__powf128_finite(fp128, fp128)
; LINUX-NEXT: declare float @__powf_finite(float, float)
; LINUX-NEXT: declare void @__powidf2(...)
; LINUX-NEXT: declare void @__powisf2(...)
@@ -339,19 +339,19 @@
; LINUX-NEXT: declare void @__unordtf2(...)
; LINUX-NEXT: declare double @acos(double)
; LINUX-NEXT: declare float @acosf(float)
-; LINUX-NEXT: declare x86_fp80 @acosf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @acosf128(fp128)
; LINUX-NEXT: declare x86_fp80 @acosl(x86_fp80)
; LINUX-NEXT: declare double @asin(double)
; LINUX-NEXT: declare float @asinf(float)
-; LINUX-NEXT: declare x86_fp80 @asinf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @asinf128(fp128)
; LINUX-NEXT: declare x86_fp80 @asinl(x86_fp80)
; LINUX-NEXT: declare double @atan(double)
; LINUX-NEXT: declare double @atan2(double, double)
; LINUX-NEXT: declare float @atan2f(float, float)
-; LINUX-NEXT: declare x86_fp80 @atan2f128(x86_fp80, x86_fp80)
+; LINUX-NEXT: declare fp128 @atan2f128(fp128, fp128)
; LINUX-NEXT: declare x86_fp80 @atan2l(x86_fp80, x86_fp80)
; LINUX-NEXT: declare float @atanf(float)
-; LINUX-NEXT: declare x86_fp80 @atanf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @atanf128(fp128)
; LINUX-NEXT: declare x86_fp80 @atanl(x86_fp80)
; LINUX-NEXT: declare void @cabs(...)
; LINUX-NEXT: declare void @cabsf(...)
@@ -359,35 +359,35 @@
; LINUX-NEXT: declare noalias noundef ptr @calloc(i64 noundef, i64 noundef) [[CALLOC_ATTRS:#[0-9]+]]
; LINUX-NEXT: declare double @cbrt(double)
; LINUX-NEXT: declare float @cbrtf(float)
-; LINUX-NEXT: declare x86_fp80 @cbrtf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @cbrtf128(fp128)
; LINUX-NEXT: declare x86_fp80 @cbrtl(x86_fp80)
; LINUX-NEXT: declare double @ceil(double)
; LINUX-NEXT: declare float @ceilf(float)
-; LINUX-NEXT: declare x86_fp80 @ceilf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @ceilf128(fp128)
; LINUX-NEXT: declare x86_fp80 @ceill(x86_fp80)
; LINUX-NEXT: declare double @copysign(double, double)
; LINUX-NEXT: declare float @copysignf(float, float)
-; LINUX-NEXT: declare x86_fp80 @copysignf128(x86_fp80, x86_fp80)
+; LINUX-NEXT: declare fp128 @copysignf128(fp128, fp128)
; LINUX-NEXT: declare x86_fp80 @copysignl(x86_fp80, x86_fp80)
; LINUX-NEXT: declare double @cos(double)
; LINUX-NEXT: declare float @cosf(float)
-; LINUX-NEXT: declare x86_fp80 @cosf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @cosf128(fp128)
; LINUX-NEXT: declare double @cosh(double)
; LINUX-NEXT: declare float @coshf(float)
-; LINUX-NEXT: declare x86_fp80 @coshf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @coshf128(fp128)
; LINUX-NEXT: declare x86_fp80 @coshl(x86_fp80)
; LINUX-NEXT: declare x86_fp80 @cosl(x86_fp80)
; LINUX-NEXT: declare double @exp(double)
; LINUX-NEXT: declare double @exp10(double)
; LINUX-NEXT: declare float @exp10f(float)
-; LINUX-NEXT: declare x86_fp80 @exp10f128(x86_fp80)
+; LINUX-NEXT: declare fp128 @exp10f128(fp128)
; LINUX-NEXT: declare x86_fp80 @exp10l(x86_fp80)
; LINUX-NEXT: declare double @exp2(double)
; LINUX-NEXT: declare float @exp2f(float)
-; LINUX-NEXT: declare x86_fp80 @exp2f128(x86_fp80)
+; LINUX-NEXT: declare fp128 @exp2f128(fp128)
; LINUX-NEXT: declare x86_fp80 @exp2l(x86_fp80)
; LINUX-NEXT: declare float @expf(float)
-; LINUX-NEXT: declare x86_fp80 @expf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @expf128(fp128)
; LINUX-NEXT: declare x86_fp80 @expl(x86_fp80)
; LINUX-NEXT: declare double @fdim(double, double)
; LINUX-NEXT: declare float @fdimf(float, float)
@@ -398,7 +398,7 @@
; LINUX-NEXT: declare void @fesetmode(...)
; LINUX-NEXT: declare double @floor(double)
; LINUX-NEXT: declare float @floorf(float)
-; LINUX-NEXT: declare x86_fp80 @floorf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @floorf128(fp128)
; LINUX-NEXT: declare x86_fp80 @floorl(x86_fp80)
; LINUX-NEXT: declare void @fma(...)
; LINUX-NEXT: declare void @fmaf(...)
@@ -430,16 +430,16 @@
; LINUX-NEXT: declare float @fminl(float, float)
; LINUX-NEXT: declare double @fmod(double, double)
; LINUX-NEXT: declare float @fmodf(float, float)
-; LINUX-NEXT: declare x86_fp80 @fmodf128(x86_fp80, x86_fp80)
+; LINUX-NEXT: declare fp128 @fmodf128(fp128, fp128)
; LINUX-NEXT: declare x86_fp80 @fmodl(x86_fp80, x86_fp80)
; LINUX-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
; LINUX-NEXT: declare double @frexp(double, ptr)
; LINUX-NEXT: declare float @frexpf(float, ptr)
-; LINUX-NEXT: declare x86_fp80 @frexpf128(x86_fp80, ptr)
+; LINUX-NEXT: declare fp128 @frexpf128(fp128, ptr)
; LINUX-NEXT: declare x86_fp80 @frexpl(x86_fp80, ptr)
; LINUX-NEXT: declare double @ldexp(double, i32)
; LINUX-NEXT: declare float @ldexpf(float, i32)
-; LINUX-NEXT: declare x86_fp80 @ldexpf128(x86_fp80, i32)
+; LINUX-NEXT: declare fp128 @ldexpf128(fp128, i32)
; LINUX-NEXT: declare x86_fp80 @ldexpl(x86_fp80, i32)
; LINUX-NEXT: declare void @llrint(...)
; LINUX-NEXT: declare void @llrintf(...)
@@ -452,14 +452,14 @@
; LINUX-NEXT: declare double @log(double)
; LINUX-NEXT: declare double @log10(double)
; LINUX-NEXT: declare float @log10f(float)
-; LINUX-NEXT: declare x86_fp80 @log10f128(x86_fp80)
+; LINUX-NEXT: declare fp128 @log10f128(fp128)
; LINUX-NEXT: declare x86_fp80 @log10l(x86_fp80)
; LINUX-NEXT: declare double @log2(double)
; LINUX-NEXT: declare float @log2f(float)
-; LINUX-NEXT: declare x86_fp80 @log2f128(x86_fp80)
+; LINUX-NEXT: declare fp128 @log2f128(fp128)
; LINUX-NEXT: declare x86_fp80 @log2l(x86_fp80)
; LINUX-NEXT: declare float @logf(float)
-; LINUX-NEXT: declare x86_fp80 @logf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @logf128(fp128)
; LINUX-NEXT: declare x86_fp80 @logl(x86_fp80)
; LINUX-NEXT: declare void @lrint(...)
; LINUX-NEXT: declare void @lrintf(...)
@@ -475,21 +475,21 @@
; LINUX-NEXT: declare ptr @memset(ptr, i32, i64)
; LINUX-NEXT: declare double @modf(double, ptr)
; LINUX-NEXT: declare float @modff(float, ptr)
-; LINUX-NEXT: declare x86_fp80 @modff128(x86_fp80, ptr)
+; LINUX-NEXT: declare fp128 @modff128(fp128, ptr)
; LINUX-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr)
; LINUX-NEXT: declare double @nan(ptr)
; LINUX-NEXT: declare float @nanf(ptr)
; LINUX-NEXT: declare x86_fp80 @nanl(ptr)
; LINUX-NEXT: declare double @nearbyint(double)
; LINUX-NEXT: declare float @nearbyintf(float)
-; LINUX-NEXT: declare x86_fp80 @nearbyintf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @nearbyintf128(fp128)
; LINUX-NEXT: declare x86_fp80 @nearbyintl(x86_fp80)
; LINUX-NEXT: declare double @nexttoward(double, x86_fp80)
; LINUX-NEXT: declare float @nexttowardf(float, x86_fp80)
; LINUX-NEXT: declare x86_fp80 @nexttowardl(x86_fp80, x86_fp80)
; LINUX-NEXT: declare double @pow(double, double)
; LINUX-NEXT: declare float @powf(float, float)
-; LINUX-NEXT: declare x86_fp80 @powf128(x86_fp80, x86_fp80)
+; LINUX-NEXT: declare fp128 @powf128(fp128, fp128)
; LINUX-NEXT: declare x86_fp80 @powl(x86_fp80, x86_fp80)
; LINUX-NEXT: declare double @remainder(double, double)
; LINUX-NEXT: declare float @remainderf(float, float)
@@ -499,15 +499,15 @@
; LINUX-NEXT: declare x86_fp80 @remquol(x86_fp80, x86_fp80, ptr)
; LINUX-NEXT: declare double @rint(double)
; LINUX-NEXT: declare float @rintf(float)
-; LINUX-NEXT: declare x86_fp80 @rintf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @rintf128(fp128)
; LINUX-NEXT: declare x86_fp80 @rintl(x86_fp80)
; LINUX-NEXT: declare double @round(double)
; LINUX-NEXT: declare double @roundeven(double)
; LINUX-NEXT: declare float @roundevenf(float)
-; LINUX-NEXT: declare x86_fp80 @roundevenf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @roundevenf128(fp128)
; LINUX-NEXT: declare x86_fp80 @roundevenl(x86_fp80)
; LINUX-NEXT: declare float @roundf(float)
-; LINUX-NEXT: declare x86_fp80 @roundf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @roundf128(fp128)
; LINUX-NEXT: declare x86_fp80 @roundl(x86_fp80)
; LINUX-NEXT: declare double @scalbln(double, i32)
; LINUX-NEXT: declare float @scalblnf(float, i32)
@@ -518,25 +518,25 @@
; LINUX-NEXT: declare double @sin(double)
; LINUX-NEXT: declare void @sincos(double, ptr, ptr)
; LINUX-NEXT: declare void @sincosf(float, ptr, ptr)
-; LINUX-NEXT: declare void @sincosf128(x86_fp80, ptr, ptr)
+; LINUX-NEXT: declare void @sincosf128(fp128, ptr, ptr)
; LINUX-NEXT: declare void @sincosl(x86_fp80, ptr, ptr)
; LINUX-NEXT: declare float @sinf(float)
-; LINUX-NEXT: declare x86_fp80 @sinf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @sinf128(fp128)
; LINUX-NEXT: declare double @sinh(double)
; LINUX-NEXT: declare float @sinhf(float)
-; LINUX-NEXT: declare x86_fp80 @sinhf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @sinhf128(fp128)
; LINUX-NEXT: declare x86_fp80 @sinhl(x86_fp80)
; LINUX-NEXT: declare x86_fp80 @sinl(x86_fp80)
; LINUX-NEXT: declare nofpclass(ninf nsub nnorm) double @sqrt(double) [[SQRT_ATTRS:#[0-9]+]]
; LINUX-NEXT: declare nofpclass(ninf nsub nnorm) float @sqrtf(float) [[SQRT_ATTRS:#[0-9]+]]
-; LINUX-NEXT: declare x86_fp80 @sqrtf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @sqrtf128(fp128)
; LINUX-NEXT: declare x86_fp80 @sqrtl(x86_fp80)
; LINUX-NEXT: declare double @tan(double)
; LINUX-NEXT: declare float @tanf(float)
-; LINUX-NEXT: declare x86_fp80 @tanf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @tanf128(fp128)
; LINUX-NEXT: declare double @tanh(double)
; LINUX-NEXT: declare float @tanhf(float)
-; LINUX-NEXT: declare x86_fp80 @tanhf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @tanhf128(fp128)
; LINUX-NEXT: declare x86_fp80 @tanhl(x86_fp80)
; LINUX-NEXT: declare x86_fp80 @tanl(x86_fp80)
; LINUX-NEXT: declare double @tgamma(double)
@@ -544,7 +544,7 @@
; LINUX-NEXT: declare x86_fp80 @tgammal(x86_fp80)
; LINUX-NEXT: declare double @trunc(double)
; LINUX-NEXT: declare float @truncf(float)
-; LINUX-NEXT: declare x86_fp80 @truncf128(x86_fp80)
+; LINUX-NEXT: declare fp128 @truncf128(fp128)
; LINUX-NEXT: declare x86_fp80 @truncl(x86_fp80)
; LINUX-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
; LINUX-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
diff --git a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ppc.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ppc.ll
index 1b34e0bac9b4c..09fbb40f0c4b5 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ppc.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/ppc.ll
@@ -346,19 +346,19 @@
; AIX32-NEXT: declare void @__unordsf2(...)
; AIX32-NEXT: declare double @acos(double)
; AIX32-NEXT: declare float @acosf(float)
-; AIX32-NEXT: declare double @acosf128(double)
+; AIX32-NEXT: declare fp128 @acosf128(fp128)
; AIX32-NEXT: declare double @acosl(double)
; AIX32-NEXT: declare double @asin(double)
; AIX32-NEXT: declare float @asinf(float)
-; AIX32-NEXT: declare double @asinf128(double)
+; AIX32-NEXT: declare fp128 @asinf128(fp128)
; AIX32-NEXT: declare double @asinl(double)
; AIX32-NEXT: declare double @atan(double)
; AIX32-NEXT: declare double @atan2(double, double)
; AIX32-NEXT: declare float @atan2f(float, float)
-; AIX32-NEXT: declare double @atan2f128(double, double)
+; AIX32-NEXT: declare fp128 @atan2f128(fp128, fp128)
; AIX32-NEXT: declare double @atan2l(double, double)
; AIX32-NEXT: declare float @atanf(float)
-; AIX32-NEXT: declare double @atanf128(double)
+; AIX32-NEXT: declare fp128 @atanf128(fp128)
; AIX32-NEXT: declare double @atanl(double)
; AIX32-NEXT: declare void @cabs(...)
; AIX32-NEXT: declare void @cabsf(...)
@@ -366,35 +366,35 @@
; AIX32-NEXT: declare noalias noundef ptr @calloc(i32 noundef, i32 noundef) [[CALLOC_ATTRS:#[0-9]+]]
; AIX32-NEXT: declare double @cbrt(double)
; AIX32-NEXT: declare float @cbrtf(float)
-; AIX32-NEXT: declare double @cbrtf128(double)
+; AIX32-NEXT: declare fp128 @cbrtf128(fp128)
; AIX32-NEXT: declare double @cbrtl(double)
; AIX32-NEXT: declare double @ceil(double)
; AIX32-NEXT: declare float @ceilf(float)
-; AIX32-NEXT: declare double @ceilf128(double)
+; AIX32-NEXT: declare fp128 @ceilf128(fp128)
; AIX32-NEXT: declare double @ceill(double)
; AIX32-NEXT: declare double @copysign(double, double)
; AIX32-NEXT: declare float @copysignf(float, float)
-; AIX32-NEXT: declare double @copysignf128(double, double)
+; AIX32-NEXT: declare fp128 @copysignf128(fp128, fp128)
; AIX32-NEXT: declare double @copysignl(double, double)
; AIX32-NEXT: declare double @cos(double)
; AIX32-NEXT: declare float @cosf(float)
-; AIX32-NEXT: declare double @cosf128(double)
+; AIX32-NEXT: declare fp128 @cosf128(fp128)
; AIX32-NEXT: declare double @cosh(double)
; AIX32-NEXT: declare float @coshf(float)
-; AIX32-NEXT: declare double @coshf128(double)
+; AIX32-NEXT: declare fp128 @coshf128(fp128)
; AIX32-NEXT: declare double @coshl(double)
; AIX32-NEXT: declare double @cosl(double)
; AIX32-NEXT: declare double @exp(double)
; AIX32-NEXT: declare double @exp10(double)
; AIX32-NEXT: declare float @exp10f(float)
-; AIX32-NEXT: declare double @exp10f128(double)
+; AIX32-NEXT: declare fp128 @exp10f128(fp128)
; AIX32-NEXT: declare double @exp10l(double)
; AIX32-NEXT: declare double @exp2(double)
; AIX32-NEXT: declare float @exp2f(float)
-; AIX32-NEXT: declare double @exp2f128(double)
+; AIX32-NEXT: declare fp128 @exp2f128(fp128)
; AIX32-NEXT: declare double @exp2l(double)
; AIX32-NEXT: declare float @expf(float)
-; AIX32-NEXT: declare double @expf128(double)
+; AIX32-NEXT: declare fp128 @expf128(fp128)
; AIX32-NEXT: declare double @expl(double)
; AIX32-NEXT: declare double @fdim(double, double)
; AIX32-NEXT: declare float @fdimf(float, float)
@@ -405,7 +405,7 @@
; AIX32-NEXT: declare void @fesetmode(...)
; AIX32-NEXT: declare double @floor(double)
; AIX32-NEXT: declare float @floorf(float)
-; AIX32-NEXT: declare double @floorf128(double)
+; AIX32-NEXT: declare fp128 @floorf128(fp128)
; AIX32-NEXT: declare double @floorl(double)
; AIX32-NEXT: declare void @fma(...)
; AIX32-NEXT: declare void @fmaf(...)
@@ -437,16 +437,16 @@
; AIX32-NEXT: declare float @fminl(float, float)
; AIX32-NEXT: declare double @fmod(double, double)
; AIX32-NEXT: declare float @fmodf(float, float)
-; AIX32-NEXT: declare double @fmodf128(double, double)
+; AIX32-NEXT: declare fp128 @fmodf128(fp128, fp128)
; AIX32-NEXT: declare double @fmodl(double,...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/235145
More information about the llvm-branch-commits
mailing list