[llvm-branch-commits] [llvm] RuntimeLibcalls: Use explicit types for F80, F128 and PPCF128 libcalls (PR #235145)
Matt Arsenault via llvm-branch-commits
llvm-branch-commits at lists.llvm.org
Thu Oct 29 12:49:01 PDT 2026
https://github.com/arsenm updated https://github.com/llvm/llvm-project/pull/235145
>From 9f65756260a057903fead961cf1f8614f42547f4 Mon Sep 17 00:00:00 2001
From: Matt Arsenault <Matthew.Arsenault at amd.com>
Date: Tue, 20 Oct 2026 00:18:10 +0200
Subject: [PATCH] RuntimeLibcalls: Use explicit types for F80, F128 and PPCF128
libcalls
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 at anthropic.com>
---
llvm/include/llvm/IR/RuntimeLibcalls.td | 6 +-
llvm/include/llvm/IR/RuntimeLibcallsImpl.td | 8 +
llvm/lib/IR/RuntimeLibcalls.cpp | 6 +
llvm/test/TableGen/RuntimeLibcallEmitter.td | 3 +
.../Util/DeclareRuntimeLibcalls/bsd.ll | 78 +++----
.../Util/DeclareRuntimeLibcalls/ppc.ll | 192 +++++++++---------
.../Util/DeclareRuntimeLibcalls/windows.ll | 78 +++----
7 files changed, 194 insertions(+), 177 deletions(-)
diff --git a/llvm/include/llvm/IR/RuntimeLibcalls.td b/llvm/include/llvm/IR/RuntimeLibcalls.td
index 21febe8d2270e2..dba6f1c0e8404d 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 5d3af2516b8dc9..0f734a00b01031 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 7a83391f44b0c0..48e61ec974835e 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 b2ecee11353adb..34a820484f0ecc 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 8ce7c87f34e214..d55e04d1bafa7b 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 1b34e0bac9b4c1..09fbb40f0c4b5c 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, double)
; AIX32-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
; AIX32-NEXT: declare double @frexp(double, ptr)
; AIX32-NEXT: declare float @frexpf(float, ptr)
-; AIX32-NEXT: declare double @frexpf128(double, ptr)
+; AIX32-NEXT: declare fp128 @frexpf128(fp128, ptr)
; AIX32-NEXT: declare double @frexpl(double, ptr)
; AIX32-NEXT: declare double @ldexp(double, i32)
; AIX32-NEXT: declare float @ldexpf(float, i32)
-; AIX32-NEXT: declare double @ldexpf128(double, i32)
+; AIX32-NEXT: declare fp128 @ldexpf128(fp128, i32)
; AIX32-NEXT: declare double @ldexpl(double, i32)
; AIX32-NEXT: declare void @llrint(...)
; AIX32-NEXT: declare void @llrintf(...)
@@ -459,14 +459,14 @@
; AIX32-NEXT: declare double @log(double)
; AIX32-NEXT: declare double @log10(double)
; AIX32-NEXT: declare float @log10f(float)
-; AIX32-NEXT: declare double @log10f128(double)
+; AIX32-NEXT: declare fp128 @log10f128(fp128)
; AIX32-NEXT: declare double @log10l(double)
; AIX32-NEXT: declare double @log2(double)
; AIX32-NEXT: declare float @log2f(float)
-; AIX32-NEXT: declare double @log2f128(double)
+; AIX32-NEXT: declare fp128 @log2f128(fp128)
; AIX32-NEXT: declare double @log2l(double)
; AIX32-NEXT: declare float @logf(float)
-; AIX32-NEXT: declare double @logf128(double)
+; AIX32-NEXT: declare fp128 @logf128(fp128)
; AIX32-NEXT: declare double @logl(double)
; AIX32-NEXT: declare void @lrint(...)
; AIX32-NEXT: declare void @lrintf(...)
@@ -481,21 +481,21 @@
; AIX32-NEXT: declare ptr @memset(ptr, i32, i32)
; AIX32-NEXT: declare double @modf(double, ptr)
; AIX32-NEXT: declare float @modff(float, ptr)
-; AIX32-NEXT: declare double @modff128(double, ptr)
+; AIX32-NEXT: declare fp128 @modff128(fp128, ptr)
; AIX32-NEXT: declare double @modfl(double, ptr)
; AIX32-NEXT: declare double @nan(ptr)
; AIX32-NEXT: declare float @nanf(ptr)
; AIX32-NEXT: declare double @nanl(ptr)
; AIX32-NEXT: declare double @nearbyint(double)
; AIX32-NEXT: declare float @nearbyintf(float)
-; AIX32-NEXT: declare double @nearbyintf128(double)
+; AIX32-NEXT: declare fp128 @nearbyintf128(fp128)
; AIX32-NEXT: declare double @nearbyintl(double)
; AIX32-NEXT: declare double @nexttoward(double, double)
; AIX32-NEXT: declare float @nexttowardf(float, double)
; AIX32-NEXT: declare double @nexttowardl(double, double)
; AIX32-NEXT: declare double @pow(double, double)
; AIX32-NEXT: declare float @powf(float, float)
-; AIX32-NEXT: declare double @powf128(double, double)
+; AIX32-NEXT: declare fp128 @powf128(fp128, fp128)
; AIX32-NEXT: declare double @powl(double, double)
; AIX32-NEXT: declare double @remainder(double, double)
; AIX32-NEXT: declare float @remainderf(float, float)
@@ -505,15 +505,15 @@
; AIX32-NEXT: declare double @remquol(double, double, ptr)
; AIX32-NEXT: declare double @rint(double)
; AIX32-NEXT: declare float @rintf(float)
-; AIX32-NEXT: declare double @rintf128(double)
+; AIX32-NEXT: declare fp128 @rintf128(fp128)
; AIX32-NEXT: declare double @rintl(double)
; AIX32-NEXT: declare double @round(double)
; AIX32-NEXT: declare double @roundeven(double)
; AIX32-NEXT: declare float @roundevenf(float)
-; AIX32-NEXT: declare double @roundevenf128(double)
+; AIX32-NEXT: declare fp128 @roundevenf128(fp128)
; AIX32-NEXT: declare double @roundevenl(double)
; AIX32-NEXT: declare float @roundf(float)
-; AIX32-NEXT: declare double @roundf128(double)
+; AIX32-NEXT: declare fp128 @roundf128(fp128)
; AIX32-NEXT: declare double @roundl(double)
; AIX32-NEXT: declare double @scalbln(double, i32)
; AIX32-NEXT: declare float @scalblnf(float, i32)
@@ -522,24 +522,24 @@
; AIX32-NEXT: declare float @scalbnf(float, i32)
; AIX32-NEXT: declare double @scalbnl(double, i32)
; AIX32-NEXT: declare double @sin(double)
-; AIX32-NEXT: declare void @sincosf128(double, ptr, ptr)
+; AIX32-NEXT: declare void @sincosf128(fp128, ptr, ptr)
; AIX32-NEXT: declare float @sinf(float)
-; AIX32-NEXT: declare double @sinf128(double)
+; AIX32-NEXT: declare fp128 @sinf128(fp128)
; AIX32-NEXT: declare double @sinh(double)
; AIX32-NEXT: declare float @sinhf(float)
-; AIX32-NEXT: declare double @sinhf128(double)
+; AIX32-NEXT: declare fp128 @sinhf128(fp128)
; AIX32-NEXT: declare double @sinhl(double)
; AIX32-NEXT: declare double @sinl(double)
; AIX32-NEXT: declare nofpclass(ninf nsub nnorm) double @sqrt(double) [[SQRT_ATTRS:#[0-9]+]]
; AIX32-NEXT: declare nofpclass(ninf nsub nnorm) float @sqrtf(float) [[SQRT_ATTRS:#[0-9]+]]
-; AIX32-NEXT: declare double @sqrtf128(double)
+; AIX32-NEXT: declare fp128 @sqrtf128(fp128)
; AIX32-NEXT: declare double @sqrtl(double)
; AIX32-NEXT: declare double @tan(double)
; AIX32-NEXT: declare float @tanf(float)
-; AIX32-NEXT: declare double @tanf128(double)
+; AIX32-NEXT: declare fp128 @tanf128(fp128)
; AIX32-NEXT: declare double @tanh(double)
; AIX32-NEXT: declare float @tanhf(float)
-; AIX32-NEXT: declare double @tanhf128(double)
+; AIX32-NEXT: declare fp128 @tanhf128(fp128)
; AIX32-NEXT: declare double @tanhl(double)
; AIX32-NEXT: declare double @tanl(double)
; AIX32-NEXT: declare double @tgamma(double)
@@ -547,7 +547,7 @@
; AIX32-NEXT: declare double @tgammal(double)
; AIX32-NEXT: declare double @trunc(double)
; AIX32-NEXT: declare float @truncf(float)
-; AIX32-NEXT: declare double @truncf128(double)
+; AIX32-NEXT: declare fp128 @truncf128(fp128)
; AIX32-NEXT: declare double @truncl(double)
; AIX32-NEXT: declare ptr @vec_calloc(i32, i32)
; AIX32-NEXT: declare void @vec_free(ptr)
@@ -902,19 +902,19 @@
; AIX64-NEXT: declare void @__unordsf2(...)
; AIX64-NEXT: declare double @acos(double)
; AIX64-NEXT: declare float @acosf(float)
-; AIX64-NEXT: declare double @acosf128(double)
+; AIX64-NEXT: declare fp128 @acosf128(fp128)
; AIX64-NEXT: declare double @acosl(double)
; AIX64-NEXT: declare double @asin(double)
; AIX64-NEXT: declare float @asinf(float)
-; AIX64-NEXT: declare double @asinf128(double)
+; AIX64-NEXT: declare fp128 @asinf128(fp128)
; AIX64-NEXT: declare double @asinl(double)
; AIX64-NEXT: declare double @atan(double)
; AIX64-NEXT: declare double @atan2(double, double)
; AIX64-NEXT: declare float @atan2f(float, float)
-; AIX64-NEXT: declare double @atan2f128(double, double)
+; AIX64-NEXT: declare fp128 @atan2f128(fp128, fp128)
; AIX64-NEXT: declare double @atan2l(double, double)
; AIX64-NEXT: declare float @atanf(float)
-; AIX64-NEXT: declare double @atanf128(double)
+; AIX64-NEXT: declare fp128 @atanf128(fp128)
; AIX64-NEXT: declare double @atanl(double)
; AIX64-NEXT: declare void @cabs(...)
; AIX64-NEXT: declare void @cabsf(...)
@@ -922,35 +922,35 @@
; AIX64-NEXT: declare noalias noundef ptr @calloc(i64 noundef, i64 noundef) [[CALLOC_ATTRS:#[0-9]+]]
; AIX64-NEXT: declare double @cbrt(double)
; AIX64-NEXT: declare float @cbrtf(float)
-; AIX64-NEXT: declare double @cbrtf128(double)
+; AIX64-NEXT: declare fp128 @cbrtf128(fp128)
; AIX64-NEXT: declare double @cbrtl(double)
; AIX64-NEXT: declare double @ceil(double)
; AIX64-NEXT: declare float @ceilf(float)
-; AIX64-NEXT: declare double @ceilf128(double)
+; AIX64-NEXT: declare fp128 @ceilf128(fp128)
; AIX64-NEXT: declare double @ceill(double)
; AIX64-NEXT: declare double @copysign(double, double)
; AIX64-NEXT: declare float @copysignf(float, float)
-; AIX64-NEXT: declare double @copysignf128(double, double)
+; AIX64-NEXT: declare fp128 @copysignf128(fp128, fp128)
; AIX64-NEXT: declare double @copysignl(double, double)
; AIX64-NEXT: declare double @cos(double)
; AIX64-NEXT: declare float @cosf(float)
-; AIX64-NEXT: declare double @cosf128(double)
+; AIX64-NEXT: declare fp128 @cosf128(fp128)
; AIX64-NEXT: declare double @cosh(double)
; AIX64-NEXT: declare float @coshf(float)
-; AIX64-NEXT: declare double @coshf128(double)
+; AIX64-NEXT: declare fp128 @coshf128(fp128)
; AIX64-NEXT: declare double @coshl(double)
; AIX64-NEXT: declare double @cosl(double)
; AIX64-NEXT: declare double @exp(double)
; AIX64-NEXT: declare double @exp10(double)
; AIX64-NEXT: declare float @exp10f(float)
-; AIX64-NEXT: declare double @exp10f128(double)
+; AIX64-NEXT: declare fp128 @exp10f128(fp128)
; AIX64-NEXT: declare double @exp10l(double)
; AIX64-NEXT: declare double @exp2(double)
; AIX64-NEXT: declare float @exp2f(float)
-; AIX64-NEXT: declare double @exp2f128(double)
+; AIX64-NEXT: declare fp128 @exp2f128(fp128)
; AIX64-NEXT: declare double @exp2l(double)
; AIX64-NEXT: declare float @expf(float)
-; AIX64-NEXT: declare double @expf128(double)
+; AIX64-NEXT: declare fp128 @expf128(fp128)
; AIX64-NEXT: declare double @expl(double)
; AIX64-NEXT: declare double @fdim(double, double)
; AIX64-NEXT: declare float @fdimf(float, float)
@@ -961,7 +961,7 @@
; AIX64-NEXT: declare void @fesetmode(...)
; AIX64-NEXT: declare double @floor(double)
; AIX64-NEXT: declare float @floorf(float)
-; AIX64-NEXT: declare double @floorf128(double)
+; AIX64-NEXT: declare fp128 @floorf128(fp128)
; AIX64-NEXT: declare double @floorl(double)
; AIX64-NEXT: declare void @fma(...)
; AIX64-NEXT: declare void @fmaf(...)
@@ -993,16 +993,16 @@
; AIX64-NEXT: declare float @fminl(float, float)
; AIX64-NEXT: declare double @fmod(double, double)
; AIX64-NEXT: declare float @fmodf(float, float)
-; AIX64-NEXT: declare double @fmodf128(double, double)
+; AIX64-NEXT: declare fp128 @fmodf128(fp128, fp128)
; AIX64-NEXT: declare double @fmodl(double, double)
; AIX64-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
; AIX64-NEXT: declare double @frexp(double, ptr)
; AIX64-NEXT: declare float @frexpf(float, ptr)
-; AIX64-NEXT: declare double @frexpf128(double, ptr)
+; AIX64-NEXT: declare fp128 @frexpf128(fp128, ptr)
; AIX64-NEXT: declare double @frexpl(double, ptr)
; AIX64-NEXT: declare double @ldexp(double, i32)
; AIX64-NEXT: declare float @ldexpf(float, i32)
-; AIX64-NEXT: declare double @ldexpf128(double, i32)
+; AIX64-NEXT: declare fp128 @ldexpf128(fp128, i32)
; AIX64-NEXT: declare double @ldexpl(double, i32)
; AIX64-NEXT: declare void @llrint(...)
; AIX64-NEXT: declare void @llrintf(...)
@@ -1015,14 +1015,14 @@
; AIX64-NEXT: declare double @log(double)
; AIX64-NEXT: declare double @log10(double)
; AIX64-NEXT: declare float @log10f(float)
-; AIX64-NEXT: declare double @log10f128(double)
+; AIX64-NEXT: declare fp128 @log10f128(fp128)
; AIX64-NEXT: declare double @log10l(double)
; AIX64-NEXT: declare double @log2(double)
; AIX64-NEXT: declare float @log2f(float)
-; AIX64-NEXT: declare double @log2f128(double)
+; AIX64-NEXT: declare fp128 @log2f128(fp128)
; AIX64-NEXT: declare double @log2l(double)
; AIX64-NEXT: declare float @logf(float)
-; AIX64-NEXT: declare double @logf128(double)
+; AIX64-NEXT: declare fp128 @logf128(fp128)
; AIX64-NEXT: declare double @logl(double)
; AIX64-NEXT: declare void @lrint(...)
; AIX64-NEXT: declare void @lrintf(...)
@@ -1037,21 +1037,21 @@
; AIX64-NEXT: declare ptr @memset(ptr, i32, i64)
; AIX64-NEXT: declare double @modf(double, ptr)
; AIX64-NEXT: declare float @modff(float, ptr)
-; AIX64-NEXT: declare double @modff128(double, ptr)
+; AIX64-NEXT: declare fp128 @modff128(fp128, ptr)
; AIX64-NEXT: declare double @modfl(double, ptr)
; AIX64-NEXT: declare double @nan(ptr)
; AIX64-NEXT: declare float @nanf(ptr)
; AIX64-NEXT: declare double @nanl(ptr)
; AIX64-NEXT: declare double @nearbyint(double)
; AIX64-NEXT: declare float @nearbyintf(float)
-; AIX64-NEXT: declare double @nearbyintf128(double)
+; AIX64-NEXT: declare fp128 @nearbyintf128(fp128)
; AIX64-NEXT: declare double @nearbyintl(double)
; AIX64-NEXT: declare double @nexttoward(double, double)
; AIX64-NEXT: declare float @nexttowardf(float, double)
; AIX64-NEXT: declare double @nexttowardl(double, double)
; AIX64-NEXT: declare double @pow(double, double)
; AIX64-NEXT: declare float @powf(float, float)
-; AIX64-NEXT: declare double @powf128(double, double)
+; AIX64-NEXT: declare fp128 @powf128(fp128, fp128)
; AIX64-NEXT: declare double @powl(double, double)
; AIX64-NEXT: declare double @remainder(double, double)
; AIX64-NEXT: declare float @remainderf(float, float)
@@ -1061,15 +1061,15 @@
; AIX64-NEXT: declare double @remquol(double, double, ptr)
; AIX64-NEXT: declare double @rint(double)
; AIX64-NEXT: declare float @rintf(float)
-; AIX64-NEXT: declare double @rintf128(double)
+; AIX64-NEXT: declare fp128 @rintf128(fp128)
; AIX64-NEXT: declare double @rintl(double)
; AIX64-NEXT: declare double @round(double)
; AIX64-NEXT: declare double @roundeven(double)
; AIX64-NEXT: declare float @roundevenf(float)
-; AIX64-NEXT: declare double @roundevenf128(double)
+; AIX64-NEXT: declare fp128 @roundevenf128(fp128)
; AIX64-NEXT: declare double @roundevenl(double)
; AIX64-NEXT: declare float @roundf(float)
-; AIX64-NEXT: declare double @roundf128(double)
+; AIX64-NEXT: declare fp128 @roundf128(fp128)
; AIX64-NEXT: declare double @roundl(double)
; AIX64-NEXT: declare double @scalbln(double, i32)
; AIX64-NEXT: declare float @scalblnf(float, i32)
@@ -1078,24 +1078,24 @@
; AIX64-NEXT: declare float @scalbnf(float, i32)
; AIX64-NEXT: declare double @scalbnl(double, i32)
; AIX64-NEXT: declare double @sin(double)
-; AIX64-NEXT: declare void @sincosf128(double, ptr, ptr)
+; AIX64-NEXT: declare void @sincosf128(fp128, ptr, ptr)
; AIX64-NEXT: declare float @sinf(float)
-; AIX64-NEXT: declare double @sinf128(double)
+; AIX64-NEXT: declare fp128 @sinf128(fp128)
; AIX64-NEXT: declare double @sinh(double)
; AIX64-NEXT: declare float @sinhf(float)
-; AIX64-NEXT: declare double @sinhf128(double)
+; AIX64-NEXT: declare fp128 @sinhf128(fp128)
; AIX64-NEXT: declare double @sinhl(double)
; AIX64-NEXT: declare double @sinl(double)
; AIX64-NEXT: declare nofpclass(ninf nsub nnorm) double @sqrt(double) [[SQRT_ATTRS:#[0-9]+]]
; AIX64-NEXT: declare nofpclass(ninf nsub nnorm) float @sqrtf(float) [[SQRT_ATTRS:#[0-9]+]]
-; AIX64-NEXT: declare double @sqrtf128(double)
+; AIX64-NEXT: declare fp128 @sqrtf128(fp128)
; AIX64-NEXT: declare double @sqrtl(double)
; AIX64-NEXT: declare double @tan(double)
; AIX64-NEXT: declare float @tanf(float)
-; AIX64-NEXT: declare double @tanf128(double)
+; AIX64-NEXT: declare fp128 @tanf128(fp128)
; AIX64-NEXT: declare double @tanh(double)
; AIX64-NEXT: declare float @tanhf(float)
-; AIX64-NEXT: declare double @tanhf128(double)
+; AIX64-NEXT: declare fp128 @tanhf128(fp128)
; AIX64-NEXT: declare double @tanhl(double)
; AIX64-NEXT: declare double @tanl(double)
; AIX64-NEXT: declare double @tgamma(double)
@@ -1103,7 +1103,7 @@
; AIX64-NEXT: declare double @tgammal(double)
; AIX64-NEXT: declare double @trunc(double)
; AIX64-NEXT: declare float @truncf(float)
-; AIX64-NEXT: declare double @truncf128(double)
+; AIX64-NEXT: declare fp128 @truncf128(fp128)
; AIX64-NEXT: declare double @truncl(double)
; AIX64-NEXT: declare ptr @vec_calloc(i64, i64)
; AIX64-NEXT: declare void @vec_free(ptr)
@@ -1449,19 +1449,19 @@
; LINUX-NEXT: declare void @__unordsf2(...)
; LINUX-NEXT: declare double @acos(double)
; LINUX-NEXT: declare float @acosf(float)
-; LINUX-NEXT: declare ppc_fp128 @acosf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @acosf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @acosl(ppc_fp128)
; LINUX-NEXT: declare double @asin(double)
; LINUX-NEXT: declare float @asinf(float)
-; LINUX-NEXT: declare ppc_fp128 @asinf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @asinf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @asinl(ppc_fp128)
; LINUX-NEXT: declare double @atan(double)
; LINUX-NEXT: declare double @atan2(double, double)
; LINUX-NEXT: declare float @atan2f(float, float)
-; LINUX-NEXT: declare ppc_fp128 @atan2f128(ppc_fp128, ppc_fp128)
+; LINUX-NEXT: declare fp128 @atan2f128(fp128, fp128)
; LINUX-NEXT: declare ppc_fp128 @atan2l(ppc_fp128, ppc_fp128)
; LINUX-NEXT: declare float @atanf(float)
-; LINUX-NEXT: declare ppc_fp128 @atanf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @atanf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @atanl(ppc_fp128)
; LINUX-NEXT: declare void @cabs(...)
; LINUX-NEXT: declare void @cabsf(...)
@@ -1469,35 +1469,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 ppc_fp128 @cbrtf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @cbrtf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @cbrtl(ppc_fp128)
; LINUX-NEXT: declare double @ceil(double)
; LINUX-NEXT: declare float @ceilf(float)
-; LINUX-NEXT: declare ppc_fp128 @ceilf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @ceilf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @ceill(ppc_fp128)
; LINUX-NEXT: declare double @copysign(double, double)
; LINUX-NEXT: declare float @copysignf(float, float)
-; LINUX-NEXT: declare ppc_fp128 @copysignf128(ppc_fp128, ppc_fp128)
+; LINUX-NEXT: declare fp128 @copysignf128(fp128, fp128)
; LINUX-NEXT: declare ppc_fp128 @copysignl(ppc_fp128, ppc_fp128)
; LINUX-NEXT: declare double @cos(double)
; LINUX-NEXT: declare float @cosf(float)
-; LINUX-NEXT: declare ppc_fp128 @cosf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @cosf128(fp128)
; LINUX-NEXT: declare double @cosh(double)
; LINUX-NEXT: declare float @coshf(float)
-; LINUX-NEXT: declare ppc_fp128 @coshf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @coshf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @coshl(ppc_fp128)
; LINUX-NEXT: declare ppc_fp128 @cosl(ppc_fp128)
; LINUX-NEXT: declare double @exp(double)
; LINUX-NEXT: declare double @exp10(double)
; LINUX-NEXT: declare float @exp10f(float)
-; LINUX-NEXT: declare ppc_fp128 @exp10f128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @exp10f128(fp128)
; LINUX-NEXT: declare ppc_fp128 @exp10l(ppc_fp128)
; LINUX-NEXT: declare double @exp2(double)
; LINUX-NEXT: declare float @exp2f(float)
-; LINUX-NEXT: declare ppc_fp128 @exp2f128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @exp2f128(fp128)
; LINUX-NEXT: declare ppc_fp128 @exp2l(ppc_fp128)
; LINUX-NEXT: declare float @expf(float)
-; LINUX-NEXT: declare ppc_fp128 @expf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @expf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @expl(ppc_fp128)
; LINUX-NEXT: declare double @fdim(double, double)
; LINUX-NEXT: declare float @fdimf(float, float)
@@ -1508,7 +1508,7 @@
; LINUX-NEXT: declare void @fesetmode(...)
; LINUX-NEXT: declare double @floor(double)
; LINUX-NEXT: declare float @floorf(float)
-; LINUX-NEXT: declare ppc_fp128 @floorf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @floorf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @floorl(ppc_fp128)
; LINUX-NEXT: declare void @fma(...)
; LINUX-NEXT: declare void @fmaf(...)
@@ -1540,16 +1540,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 ppc_fp128 @fmodf128(ppc_fp128, ppc_fp128)
+; LINUX-NEXT: declare fp128 @fmodf128(fp128, fp128)
; LINUX-NEXT: declare ppc_fp128 @fmodl(ppc_fp128, ppc_fp128)
; 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 ppc_fp128 @frexpf128(ppc_fp128, ptr)
+; LINUX-NEXT: declare fp128 @frexpf128(fp128, ptr)
; LINUX-NEXT: declare ppc_fp128 @frexpl(ppc_fp128, ptr)
; LINUX-NEXT: declare double @ldexp(double, i32)
; LINUX-NEXT: declare float @ldexpf(float, i32)
-; LINUX-NEXT: declare ppc_fp128 @ldexpf128(ppc_fp128, i32)
+; LINUX-NEXT: declare fp128 @ldexpf128(fp128, i32)
; LINUX-NEXT: declare ppc_fp128 @ldexpl(ppc_fp128, i32)
; LINUX-NEXT: declare void @llrint(...)
; LINUX-NEXT: declare void @llrintf(...)
@@ -1562,14 +1562,14 @@
; LINUX-NEXT: declare double @log(double)
; LINUX-NEXT: declare double @log10(double)
; LINUX-NEXT: declare float @log10f(float)
-; LINUX-NEXT: declare ppc_fp128 @log10f128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @log10f128(fp128)
; LINUX-NEXT: declare ppc_fp128 @log10l(ppc_fp128)
; LINUX-NEXT: declare double @log2(double)
; LINUX-NEXT: declare float @log2f(float)
-; LINUX-NEXT: declare ppc_fp128 @log2f128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @log2f128(fp128)
; LINUX-NEXT: declare ppc_fp128 @log2l(ppc_fp128)
; LINUX-NEXT: declare float @logf(float)
-; LINUX-NEXT: declare ppc_fp128 @logf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @logf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @logl(ppc_fp128)
; LINUX-NEXT: declare void @lrint(...)
; LINUX-NEXT: declare void @lrintf(...)
@@ -1585,21 +1585,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 ppc_fp128 @modff128(ppc_fp128, ptr)
+; LINUX-NEXT: declare fp128 @modff128(fp128, ptr)
; LINUX-NEXT: declare ppc_fp128 @modfl(ppc_fp128, ptr)
; LINUX-NEXT: declare double @nan(ptr)
; LINUX-NEXT: declare float @nanf(ptr)
; LINUX-NEXT: declare ppc_fp128 @nanl(ptr)
; LINUX-NEXT: declare double @nearbyint(double)
; LINUX-NEXT: declare float @nearbyintf(float)
-; LINUX-NEXT: declare ppc_fp128 @nearbyintf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @nearbyintf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @nearbyintl(ppc_fp128)
; LINUX-NEXT: declare double @nexttoward(double, ppc_fp128)
; LINUX-NEXT: declare float @nexttowardf(float, ppc_fp128)
; LINUX-NEXT: declare ppc_fp128 @nexttowardl(ppc_fp128, ppc_fp128)
; LINUX-NEXT: declare double @pow(double, double)
; LINUX-NEXT: declare float @powf(float, float)
-; LINUX-NEXT: declare ppc_fp128 @powf128(ppc_fp128, ppc_fp128)
+; LINUX-NEXT: declare fp128 @powf128(fp128, fp128)
; LINUX-NEXT: declare ppc_fp128 @powl(ppc_fp128, ppc_fp128)
; LINUX-NEXT: declare double @remainder(double, double)
; LINUX-NEXT: declare float @remainderf(float, float)
@@ -1609,15 +1609,15 @@
; LINUX-NEXT: declare ppc_fp128 @remquol(ppc_fp128, ppc_fp128, ptr)
; LINUX-NEXT: declare double @rint(double)
; LINUX-NEXT: declare float @rintf(float)
-; LINUX-NEXT: declare ppc_fp128 @rintf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @rintf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @rintl(ppc_fp128)
; LINUX-NEXT: declare double @round(double)
; LINUX-NEXT: declare double @roundeven(double)
; LINUX-NEXT: declare float @roundevenf(float)
-; LINUX-NEXT: declare ppc_fp128 @roundevenf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @roundevenf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @roundevenl(ppc_fp128)
; LINUX-NEXT: declare float @roundf(float)
-; LINUX-NEXT: declare ppc_fp128 @roundf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @roundf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @roundl(ppc_fp128)
; LINUX-NEXT: declare double @scalbln(double, i32)
; LINUX-NEXT: declare float @scalblnf(float, i32)
@@ -1628,25 +1628,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(ppc_fp128, ptr, ptr)
+; LINUX-NEXT: declare void @sincosf128(fp128, ptr, ptr)
; LINUX-NEXT: declare void @sincosl(ppc_fp128, ptr, ptr)
; LINUX-NEXT: declare float @sinf(float)
-; LINUX-NEXT: declare ppc_fp128 @sinf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @sinf128(fp128)
; LINUX-NEXT: declare double @sinh(double)
; LINUX-NEXT: declare float @sinhf(float)
-; LINUX-NEXT: declare ppc_fp128 @sinhf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @sinhf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @sinhl(ppc_fp128)
; LINUX-NEXT: declare ppc_fp128 @sinl(ppc_fp128)
; 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 ppc_fp128 @sqrtf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @sqrtf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @sqrtl(ppc_fp128)
; LINUX-NEXT: declare double @tan(double)
; LINUX-NEXT: declare float @tanf(float)
-; LINUX-NEXT: declare ppc_fp128 @tanf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @tanf128(fp128)
; LINUX-NEXT: declare double @tanh(double)
; LINUX-NEXT: declare float @tanhf(float)
-; LINUX-NEXT: declare ppc_fp128 @tanhf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @tanhf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @tanhl(ppc_fp128)
; LINUX-NEXT: declare ppc_fp128 @tanl(ppc_fp128)
; LINUX-NEXT: declare double @tgamma(double)
@@ -1654,7 +1654,7 @@
; LINUX-NEXT: declare ppc_fp128 @tgammal(ppc_fp128)
; LINUX-NEXT: declare double @trunc(double)
; LINUX-NEXT: declare float @truncf(float)
-; LINUX-NEXT: declare ppc_fp128 @truncf128(ppc_fp128)
+; LINUX-NEXT: declare fp128 @truncf128(fp128)
; LINUX-NEXT: declare ppc_fp128 @truncl(ppc_fp128)
; 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/windows.ll b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/windows.ll
index 9800a0d431c51d..994694ab6bd14a 100644
--- a/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/windows.ll
+++ b/llvm/test/Transforms/Util/DeclareRuntimeLibcalls/windows.ll
@@ -521,13 +521,13 @@
; MINGW-NEXT: declare void @__eqdf2(...)
; MINGW-NEXT: declare void @__eqsf2(...)
; MINGW-NEXT: declare void @__eqtf2(...)
-; MINGW-NEXT: declare x86_fp80 @__exp10f128_finite(x86_fp80)
+; MINGW-NEXT: declare fp128 @__exp10f128_finite(fp128)
; MINGW-NEXT: declare double @__exp2_finite(double)
-; MINGW-NEXT: declare x86_fp80 @__exp2f128_finite(x86_fp80)
+; MINGW-NEXT: declare fp128 @__exp2f128_finite(fp128)
; MINGW-NEXT: declare float @__exp2f_finite(float)
; MINGW-NEXT: declare x86_fp80 @__exp2l_finite(x86_fp80)
; MINGW-NEXT: declare double @__exp_finite(double)
-; MINGW-NEXT: declare x86_fp80 @__expf128_finite(x86_fp80)
+; MINGW-NEXT: declare fp128 @__expf128_finite(fp128)
; MINGW-NEXT: declare float @__expf_finite(float)
; MINGW-NEXT: declare x86_fp80 @__expl_finite(x86_fp80)
; MINGW-NEXT: declare void @__extendbfsf2(...)
@@ -627,15 +627,15 @@
; MINGW-NEXT: declare void @__llvm_memset_element_unordered_atomic_4(...)
; MINGW-NEXT: declare void @__llvm_memset_element_unordered_atomic_8(...)
; MINGW-NEXT: declare double @__log10_finite(double)
-; MINGW-NEXT: declare x86_fp80 @__log10f128_finite(x86_fp80)
+; MINGW-NEXT: declare fp128 @__log10f128_finite(fp128)
; MINGW-NEXT: declare float @__log10f_finite(float)
; MINGW-NEXT: declare x86_fp80 @__log10l_finite(x86_fp80)
; MINGW-NEXT: declare double @__log2_finite(double)
-; MINGW-NEXT: declare x86_fp80 @__log2f128_finite(x86_fp80)
+; MINGW-NEXT: declare fp128 @__log2f128_finite(fp128)
; MINGW-NEXT: declare float @__log2f_finite(float)
; MINGW-NEXT: declare x86_fp80 @__log2l_finite(x86_fp80)
; MINGW-NEXT: declare double @__log_finite(double)
-; MINGW-NEXT: declare x86_fp80 @__logf128_finite(x86_fp80)
+; MINGW-NEXT: declare fp128 @__logf128_finite(fp128)
; MINGW-NEXT: declare float @__logf_finite(float)
; MINGW-NEXT: declare x86_fp80 @__logl_finite(x86_fp80)
; MINGW-NEXT: declare void @__lshrdi3(...)
@@ -670,7 +670,7 @@
; MINGW-NEXT: declare void @__popcountsi2(...)
; MINGW-NEXT: declare void @__popcountti2(...)
; MINGW-NEXT: declare double @__pow_finite(double, double)
-; MINGW-NEXT: declare x86_fp80 @__powf128_finite(x86_fp80, x86_fp80)
+; MINGW-NEXT: declare fp128 @__powf128_finite(fp128, fp128)
; MINGW-NEXT: declare float @__powf_finite(float, float)
; MINGW-NEXT: declare void @__powixf2(...)
; MINGW-NEXT: declare x86_fp80 @__powl_finite(x86_fp80, x86_fp80)
@@ -768,19 +768,19 @@
; MINGW-NEXT: declare void @__unordtf2(...)
; MINGW-NEXT: declare double @acos(double)
; MINGW-NEXT: declare float @acosf(float)
-; MINGW-NEXT: declare x86_fp80 @acosf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @acosf128(fp128)
; MINGW-NEXT: declare x86_fp80 @acosl(x86_fp80)
; MINGW-NEXT: declare double @asin(double)
; MINGW-NEXT: declare float @asinf(float)
-; MINGW-NEXT: declare x86_fp80 @asinf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @asinf128(fp128)
; MINGW-NEXT: declare x86_fp80 @asinl(x86_fp80)
; MINGW-NEXT: declare double @atan(double)
; MINGW-NEXT: declare double @atan2(double, double)
; MINGW-NEXT: declare float @atan2f(float, float)
-; MINGW-NEXT: declare x86_fp80 @atan2f128(x86_fp80, x86_fp80)
+; MINGW-NEXT: declare fp128 @atan2f128(fp128, fp128)
; MINGW-NEXT: declare x86_fp80 @atan2l(x86_fp80, x86_fp80)
; MINGW-NEXT: declare float @atanf(float)
-; MINGW-NEXT: declare x86_fp80 @atanf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @atanf128(fp128)
; MINGW-NEXT: declare x86_fp80 @atanl(x86_fp80)
; MINGW-NEXT: declare void @cabs(...)
; MINGW-NEXT: declare void @cabsf(...)
@@ -788,35 +788,35 @@
; MINGW-NEXT: declare noalias noundef ptr @calloc(i64 noundef, i64 noundef) [[CALLOC_ATTRS:#[0-9]+]]
; MINGW-NEXT: declare double @cbrt(double)
; MINGW-NEXT: declare float @cbrtf(float)
-; MINGW-NEXT: declare x86_fp80 @cbrtf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @cbrtf128(fp128)
; MINGW-NEXT: declare x86_fp80 @cbrtl(x86_fp80)
; MINGW-NEXT: declare double @ceil(double)
; MINGW-NEXT: declare float @ceilf(float)
-; MINGW-NEXT: declare x86_fp80 @ceilf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @ceilf128(fp128)
; MINGW-NEXT: declare x86_fp80 @ceill(x86_fp80)
; MINGW-NEXT: declare double @copysign(double, double)
; MINGW-NEXT: declare float @copysignf(float, float)
-; MINGW-NEXT: declare x86_fp80 @copysignf128(x86_fp80, x86_fp80)
+; MINGW-NEXT: declare fp128 @copysignf128(fp128, fp128)
; MINGW-NEXT: declare x86_fp80 @copysignl(x86_fp80, x86_fp80)
; MINGW-NEXT: declare double @cos(double)
; MINGW-NEXT: declare float @cosf(float)
-; MINGW-NEXT: declare x86_fp80 @cosf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @cosf128(fp128)
; MINGW-NEXT: declare double @cosh(double)
; MINGW-NEXT: declare float @coshf(float)
-; MINGW-NEXT: declare x86_fp80 @coshf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @coshf128(fp128)
; MINGW-NEXT: declare x86_fp80 @coshl(x86_fp80)
; MINGW-NEXT: declare x86_fp80 @cosl(x86_fp80)
; MINGW-NEXT: declare double @exp(double)
; MINGW-NEXT: declare double @exp10(double)
; MINGW-NEXT: declare float @exp10f(float)
-; MINGW-NEXT: declare x86_fp80 @exp10f128(x86_fp80)
+; MINGW-NEXT: declare fp128 @exp10f128(fp128)
; MINGW-NEXT: declare x86_fp80 @exp10l(x86_fp80)
; MINGW-NEXT: declare double @exp2(double)
; MINGW-NEXT: declare float @exp2f(float)
-; MINGW-NEXT: declare x86_fp80 @exp2f128(x86_fp80)
+; MINGW-NEXT: declare fp128 @exp2f128(fp128)
; MINGW-NEXT: declare x86_fp80 @exp2l(x86_fp80)
; MINGW-NEXT: declare float @expf(float)
-; MINGW-NEXT: declare x86_fp80 @expf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @expf128(fp128)
; MINGW-NEXT: declare x86_fp80 @expl(x86_fp80)
; MINGW-NEXT: declare double @fdim(double, double)
; MINGW-NEXT: declare float @fdimf(float, float)
@@ -827,7 +827,7 @@
; MINGW-NEXT: declare void @fesetmode(...)
; MINGW-NEXT: declare double @floor(double)
; MINGW-NEXT: declare float @floorf(float)
-; MINGW-NEXT: declare x86_fp80 @floorf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @floorf128(fp128)
; MINGW-NEXT: declare x86_fp80 @floorl(x86_fp80)
; MINGW-NEXT: declare void @fma(...)
; MINGW-NEXT: declare void @fmaf(...)
@@ -859,16 +859,16 @@
; MINGW-NEXT: declare float @fminl(float, float)
; MINGW-NEXT: declare double @fmod(double, double)
; MINGW-NEXT: declare float @fmodf(float, float)
-; MINGW-NEXT: declare x86_fp80 @fmodf128(x86_fp80, x86_fp80)
+; MINGW-NEXT: declare fp128 @fmodf128(fp128, fp128)
; MINGW-NEXT: declare x86_fp80 @fmodl(x86_fp80, x86_fp80)
; MINGW-NEXT: declare void @free(ptr allocptr noundef captures(none)) [[FREE_ATTRS:#[0-9]+]]
; MINGW-NEXT: declare double @frexp(double, ptr)
; MINGW-NEXT: declare float @frexpf(float, ptr)
-; MINGW-NEXT: declare x86_fp80 @frexpf128(x86_fp80, ptr)
+; MINGW-NEXT: declare fp128 @frexpf128(fp128, ptr)
; MINGW-NEXT: declare x86_fp80 @frexpl(x86_fp80, ptr)
; MINGW-NEXT: declare double @ldexp(double, i32)
; MINGW-NEXT: declare float @ldexpf(float, i32)
-; MINGW-NEXT: declare x86_fp80 @ldexpf128(x86_fp80, i32)
+; MINGW-NEXT: declare fp128 @ldexpf128(fp128, i32)
; MINGW-NEXT: declare x86_fp80 @ldexpl(x86_fp80, i32)
; MINGW-NEXT: declare void @llrint(...)
; MINGW-NEXT: declare void @llrintf(...)
@@ -881,14 +881,14 @@
; MINGW-NEXT: declare double @log(double)
; MINGW-NEXT: declare double @log10(double)
; MINGW-NEXT: declare float @log10f(float)
-; MINGW-NEXT: declare x86_fp80 @log10f128(x86_fp80)
+; MINGW-NEXT: declare fp128 @log10f128(fp128)
; MINGW-NEXT: declare x86_fp80 @log10l(x86_fp80)
; MINGW-NEXT: declare double @log2(double)
; MINGW-NEXT: declare float @log2f(float)
-; MINGW-NEXT: declare x86_fp80 @log2f128(x86_fp80)
+; MINGW-NEXT: declare fp128 @log2f128(fp128)
; MINGW-NEXT: declare x86_fp80 @log2l(x86_fp80)
; MINGW-NEXT: declare float @logf(float)
-; MINGW-NEXT: declare x86_fp80 @logf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @logf128(fp128)
; MINGW-NEXT: declare x86_fp80 @logl(x86_fp80)
; MINGW-NEXT: declare void @lrint(...)
; MINGW-NEXT: declare void @lrintf(...)
@@ -904,21 +904,21 @@
; MINGW-NEXT: declare ptr @memset(ptr, i32, i64)
; MINGW-NEXT: declare double @modf(double, ptr)
; MINGW-NEXT: declare float @modff(float, ptr)
-; MINGW-NEXT: declare x86_fp80 @modff128(x86_fp80, ptr)
+; MINGW-NEXT: declare fp128 @modff128(fp128, ptr)
; MINGW-NEXT: declare x86_fp80 @modfl(x86_fp80, ptr)
; MINGW-NEXT: declare double @nan(ptr)
; MINGW-NEXT: declare float @nanf(ptr)
; MINGW-NEXT: declare x86_fp80 @nanl(ptr)
; MINGW-NEXT: declare double @nearbyint(double)
; MINGW-NEXT: declare float @nearbyintf(float)
-; MINGW-NEXT: declare x86_fp80 @nearbyintf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @nearbyintf128(fp128)
; MINGW-NEXT: declare x86_fp80 @nearbyintl(x86_fp80)
; MINGW-NEXT: declare double @nexttoward(double, x86_fp80)
; MINGW-NEXT: declare float @nexttowardf(float, x86_fp80)
; MINGW-NEXT: declare x86_fp80 @nexttowardl(x86_fp80, x86_fp80)
; MINGW-NEXT: declare double @pow(double, double)
; MINGW-NEXT: declare float @powf(float, float)
-; MINGW-NEXT: declare x86_fp80 @powf128(x86_fp80, x86_fp80)
+; MINGW-NEXT: declare fp128 @powf128(fp128, fp128)
; MINGW-NEXT: declare x86_fp80 @powl(x86_fp80, x86_fp80)
; MINGW-NEXT: declare double @remainder(double, double)
; MINGW-NEXT: declare float @remainderf(float, float)
@@ -928,15 +928,15 @@
; MINGW-NEXT: declare x86_fp80 @remquol(x86_fp80, x86_fp80, ptr)
; MINGW-NEXT: declare double @rint(double)
; MINGW-NEXT: declare float @rintf(float)
-; MINGW-NEXT: declare x86_fp80 @rintf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @rintf128(fp128)
; MINGW-NEXT: declare x86_fp80 @rintl(x86_fp80)
; MINGW-NEXT: declare double @round(double)
; MINGW-NEXT: declare double @roundeven(double)
; MINGW-NEXT: declare float @roundevenf(float)
-; MINGW-NEXT: declare x86_fp80 @roundevenf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @roundevenf128(fp128)
; MINGW-NEXT: declare x86_fp80 @roundevenl(x86_fp80)
; MINGW-NEXT: declare float @roundf(float)
-; MINGW-NEXT: declare x86_fp80 @roundf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @roundf128(fp128)
; MINGW-NEXT: declare x86_fp80 @roundl(x86_fp80)
; MINGW-NEXT: declare double @scalbln(double, i32)
; MINGW-NEXT: declare float @scalblnf(float, i32)
@@ -947,25 +947,25 @@
; MINGW-NEXT: declare double @sin(double)
; MINGW-NEXT: declare void @sincos(double, ptr, ptr)
; MINGW-NEXT: declare void @sincosf(float, ptr, ptr)
-; MINGW-NEXT: declare void @sincosf128(x86_fp80, ptr, ptr)
+; MINGW-NEXT: declare void @sincosf128(fp128, ptr, ptr)
; MINGW-NEXT: declare void @sincosl(x86_fp80, ptr, ptr)
; MINGW-NEXT: declare float @sinf(float)
-; MINGW-NEXT: declare x86_fp80 @sinf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @sinf128(fp128)
; MINGW-NEXT: declare double @sinh(double)
; MINGW-NEXT: declare float @sinhf(float)
-; MINGW-NEXT: declare x86_fp80 @sinhf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @sinhf128(fp128)
; MINGW-NEXT: declare x86_fp80 @sinhl(x86_fp80)
; MINGW-NEXT: declare x86_fp80 @sinl(x86_fp80)
; MINGW-NEXT: declare nofpclass(ninf nsub nnorm) double @sqrt(double) [[SQRT_ATTRS:#[0-9]+]]
; MINGW-NEXT: declare nofpclass(ninf nsub nnorm) float @sqrtf(float) [[SQRT_ATTRS:#[0-9]+]]
-; MINGW-NEXT: declare x86_fp80 @sqrtf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @sqrtf128(fp128)
; MINGW-NEXT: declare x86_fp80 @sqrtl(x86_fp80)
; MINGW-NEXT: declare double @tan(double)
; MINGW-NEXT: declare float @tanf(float)
-; MINGW-NEXT: declare x86_fp80 @tanf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @tanf128(fp128)
; MINGW-NEXT: declare double @tanh(double)
; MINGW-NEXT: declare float @tanhf(float)
-; MINGW-NEXT: declare x86_fp80 @tanhf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @tanhf128(fp128)
; MINGW-NEXT: declare x86_fp80 @tanhl(x86_fp80)
; MINGW-NEXT: declare x86_fp80 @tanl(x86_fp80)
; MINGW-NEXT: declare double @tgamma(double)
@@ -973,7 +973,7 @@
; MINGW-NEXT: declare x86_fp80 @tgammal(x86_fp80)
; MINGW-NEXT: declare double @trunc(double)
; MINGW-NEXT: declare float @truncf(float)
-; MINGW-NEXT: declare x86_fp80 @truncf128(x86_fp80)
+; MINGW-NEXT: declare fp128 @truncf128(fp128)
; MINGW-NEXT: declare x86_fp80 @truncl(x86_fp80)
; MINGW-NEXT: attributes [[CALLOC_ATTRS]] = { nofree nounwind willreturn allockind("alloc") allocsize(0,1) "alloc-family"="malloc" }
; MINGW-NEXT: attributes [[FREE_ATTRS]] = { nounwind willreturn allockind("free") "alloc-family"="malloc" }
More information about the llvm-branch-commits
mailing list