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 <[email protected]>
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 <[email protected]>
---
 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" }

_______________________________________________
llvm-branch-commits mailing list
[email protected]
https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits

Reply via email to