[Clang] Support conversion between PPC double-double and IEEE float128

[qiucf]

Summary

The motivation is that we may encounter cases determining if 'long double' is compatible with either __float128 or __ibm128 type. Marking such conversion as legal helps when handling such cases.

[hubert.reinterpretcast]

clang/test/CodeGen/ibm128-cast.c

59

It's controversial enough to consider, as well-formed, a case requiring application of the usual arithmetic conversions to a pair of operands with floating types that each have distinct values not representable by the type of the other operand; it is even more controversial to consider the type with the narrower finite range to be the common real type.

[qiucf]

Restrict implicit conversion in arithmetic and comparison

[hubert.reinterpretcast]

clang/lib/Sema/SemaExpr.cpp

1542

GCC does not allow compound assignments either and that is is a context where the "usual arithmetic conversions" apply. Allowing them means this patch is going to need to be inventive with the semantics, because the type in with the calculation is to be performed is supposed to be the same one that would occur for the non-assigning version of the arithmetic operation.

Noting as well that "Conditional" is also a case where the "usual arithmetic conversions" apply. GCC seems to be happy with that particular case for some reason, but I don't think it makes sense to allow it for Clang: GCC's implementation has questionable semantics like choosing whatever type is not the same format as the ABI's 128-bit long double as the common type (in other words, the common type is IEEE for -mabi=ibmlongdouble and IBM for -mabi=ieeelongdouble).

GCC behaviour: x is "long double" and the conditional is __float128:

gcc -fsyntax-only -xc -<<<$'__ibm128 x;\n__float128 y;\nvoid q(int b) {\n  x + (b ? x : y);\n}'
<stdin>: In function ‘q’:
<stdin>:4:5: error: __float128 and long double cannot be used in the same expression

GCC behaviour: y is "long double" and the conditional is __ibm128:

gcc -fsyntax-only -xc -<<<$'__ibm128 x;\n__float128 y;\nvoid q(int b) {\n  y + (b ? x : y);\n}' -mabi=ieeelongdouble
cc1: warning: Using IEEE extended precision ‘long double’ [-Wpsabi]
<stdin>: In function ‘q’:
<stdin>:4:5: error: __ibm128 and long double cannot be used in the same expression

If we go with the GCC behaviour, there should be lots of explaining done. If we don't then, making the case an error avoids the inconsistency of making a choice regarding the common type for conditionals but not other applications of the usual arithmetic conversions.

clang/test/Sema/float128-ld-incompatibility.cpp

39

There's no tests for compound assignment...

[hubert.reinterpretcast]

It doesn't seem like the cases of implicit conversion that are expected to be allowed have been tested with C++?

$ ./bin/clang -fsyntax-only -mcpu=pwr9 -mfloat128 -xc -<<<$'__ibm128 x; __float128 y; void f(void) { y = x; }'
Return:  0x00:0   Tue Nov  9 11:53:23 2021 EST
$ ./bin/clang -fsyntax-only -mcpu=pwr9 -mfloat128 -xc++ -<<<$'__ibm128 x; __float128 y; void f(void) { y = x; }'
<stdin>:1:46: error: assigning to '__float128' from incompatible type '__ibm128'
__ibm128 x; __float128 y; void f(void) { y = x; }
                                             ^
1 error generated.
Return:  0x01:1   Tue Nov  9 11:53:43 2021 EST

[hubert.reinterpretcast]

@qiucf, I'm on vacation (for 3 weeks). For the C++ side, I suggest having a test for the narrowing conversion diagnostic in C++. My recollection is that GCC's odd behaviour around the conditional operator has an analogue in its implementation of narrowing conversion detection (it's probably the same bug).

[nemanjai]

Please provide a description for this patch which includes justification for why we want to allow conversion between the two types.
I am of the impression that allowing the two types to coexist in completely disjoint code should be fine, but I really don't see a compelling reason to allow conversions between the two types.

[qiucf]

In D109751#3131169, @nemanjai wrote:

Please provide a description for this patch which includes justification for why we want to allow conversion between the two types.
I am of the impression that allowing the two types to coexist in completely disjoint code should be fine, but I really don't see a compelling reason to allow conversions between the two types.

The motivating case is failure after D92815: clang compiler-rt/test/builtins/Unit/multc3_test.c -I compiler-rt/lib/builtins/ -mfloat128 -mcpu=power9 -lm

compiler-rt/test/builtins/Unit/multc3_test.c:24:15: error: passing 'long double' to parameter of incompatible type '_Float128' (aka '__float128')

Because the piece of code will be expanded to:

long double _Complex x;

if ((__builtin_types_compatible_p(__typeof(creall(x)), _Float128)
         ? __isinff128(creall(x))
         : __builtin_isinf_sign(creall(x))) ||
    (__builtin_types_compatible_p(__typeof(cimagl(x)), _Float128)
         ? __isinff128(cimagl(x))
         : __builtin_isinf_sign(cimagl(x))))
  return inf;

which requires 'long double' (the same semantics to __ibm128 by default) and '_Float128' are compatible.

[qiucf]

Disallow conversion in compound and conditional

[qiucf]

Fix C++ tests

[hubert.reinterpretcast]

In D109751#3136543, @qiucf wrote:

Because the piece of code will be expanded to:

long double _Complex x;

if ((__builtin_types_compatible_p(__typeof(creall(x)), _Float128)
         ? __isinff128(creall(x))
         : __builtin_isinf_sign(creall(x))) ||
    (__builtin_types_compatible_p(__typeof(cimagl(x)), _Float128)
         ? __isinff128(cimagl(x))
         : __builtin_isinf_sign(cimagl(x))))
  return inf;

which requires 'long double' (the same semantics to __ibm128 by default) and '_Float128' are compatible.

Noting that the way the types are implemented in Clang, the conversion isn't the first problem with the above code. The types with the same representation are not considered "compatible" by Clang:

extern char x[__builtin_types_compatible_p(long double, __ibm128) ? 1 : -1]; // errors
extern char x[__builtin_types_compatible_p(long double, __ieee128) ? 1 : -1]; // errors too

Compiler Explorer link: https://godbolt.org/z/fP3MfdexM

[hubert.reinterpretcast]

clang/lib/Sema/SemaExpr.cpp

1540

The ternary operator seems to be something other than (straightforward) "arithmetic or comparison".

clang/test/CodeGen/ibm128-cast.c

115

Should have compound assignment tests for C as well.

115

Should have compound assignment tests for C as well.

clang/test/Sema/float128-ld-incompatibility.cpp

14

Should also test __ibm128 cases.

[hubert.reinterpretcast]

clang/test/Sema/float128-ld-incompatibility.cpp

14

The C++ committee has advised that this implicit conversion should be considered ill-formed (see other comment).

Note that the allowed implicit conversion from __ibm128 to long double (and vice versa) is still a conversion, which means that overload resolution is still a problem:

void f(__ibm128);
void f(int);
void g(long double d) { return f(d); } // okay with GCC but not Clang; https://godbolt.org/z/fonsEbbY1

37–38

The C++ committee has advised that these are not okay as implicit conversions:
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p1467r7.html#implicit

Additional lines testing static_cast would be appropriate.

[hubert.reinterpretcast]

clang/test/Sema/float128-ld-incompatibility.cpp

14

Even if the implicit conversion is to be allowed, there is not much reason why this is not considered narrowing (given the revised definition of narrowing conversions).

GCC's behaviour around the narrowing check has limited value as a reference point: Which of __float128 or __ibm128 is considered by GCC on Power to be the "wider type" depends on the -mabi option. That is, the behaviour is not consistent with there being a principled decision made by the GCC developers as to which representation format is "wider".

37–38

I guess this could be controversial since converting from __float128 to float (for example) would also be prohibited (if __float128 were to be considered to be an extended floating-point type).

[qiucf]

Update some cases

[qiucf]

In D109751#3168982, @hubert.reinterpretcast wrote:

In D109751#3136543, @qiucf wrote:

Because the piece of code will be expanded to:

long double _Complex x;

if ((__builtin_types_compatible_p(__typeof(creall(x)), _Float128)
         ? __isinff128(creall(x))
         : __builtin_isinf_sign(creall(x))) ||
    (__builtin_types_compatible_p(__typeof(cimagl(x)), _Float128)
         ? __isinff128(cimagl(x))
         : __builtin_isinf_sign(cimagl(x))))
  return inf;

which requires 'long double' (the same semantics to __ibm128 by default) and '_Float128' are compatible.

Noting that the way the types are implemented in Clang, the conversion isn't the first problem with the above code. The types with the same representation are not considered "compatible" by Clang:

extern char x[__builtin_types_compatible_p(long double, __ibm128) ? 1 : -1]; // errors
extern char x[__builtin_types_compatible_p(long double, __ieee128) ? 1 : -1]; // errors too

Compiler Explorer link: https://godbolt.org/z/fP3MfdexM

Thanks for the reminder. Here GCC and Clang diverges in the handling of __ibm128/__float128 and long double. Not sure whether GCC will 'fix' the behavior, but here (and in most of the use case in glibc headers) it's __builtin_types_compatible_p(..., _Float128) where GCC/Clang behaves the same.

clang/test/Sema/float128-ld-incompatibility.cpp

14

Thanks for the information. The behavior of GCC looks somewhat reasonable but I notice the naming convention of support functions is interesting: __ibm128 to __float128 is 'extend', __float128 to __ibm128 'truncate'.

[hubert.reinterpretcast]

In D109751#3178494, @qiucf wrote:

Thanks for the reminder. Here GCC and Clang diverges in the handling of __ibm128/__float128 and long double. Not sure whether GCC will 'fix' the behavior, but here (and in most of the use case in glibc headers) it's __builtin_types_compatible_p(..., _Float128) where GCC/Clang behaves the same.

I thought Clang doesn't have _Float128 yet; that's D111382, which makes _Float128 act like __float128 (and, in turn, like __ieee128).

With -mabi=ieeelongdouble:

extern char x[__builtin_types_compatible_p(long double, __float128) ? 1 : -1]; // GCC accepts; Clang rejects

https://godbolt.org/z/fGbY1Y1PT

clang/test/Sema/float128-ld-incompatibility.cpp

14

Did you try GCC with -mabi=ieeelongdouble and -pedantic-errors?

extern __ibm128 x;
long double q{ x }; // narrowing error

https://godbolt.org/z/3YazKv9f7

[hubert.reinterpretcast]

@qiucf, fyi, have vacation until January.

[qiucf]

In D109751#3191148, @hubert.reinterpretcast wrote:

In D109751#3178494, @qiucf wrote:

Thanks for the reminder. Here GCC and Clang diverges in the handling of __ibm128/__float128 and long double. Not sure whether GCC will 'fix' the behavior, but here (and in most of the use case in glibc headers) it's __builtin_types_compatible_p(..., _Float128) where GCC/Clang behaves the same.

I thought Clang doesn't have _Float128 yet; that's D111382, which makes _Float128 act like __float128 (and, in turn, like __ieee128).

With -mabi=ieeelongdouble:

extern char x[__builtin_types_compatible_p(long double, __float128) ? 1 : -1]; // GCC accepts; Clang rejects

https://godbolt.org/z/fGbY1Y1PT

I tried making them 'compatible', but that only affects to C (and C++ doesn't have this builtin), std::is_same<long double, __float128> still says they're different. Should that be an issue?

[qiucf]

There's a glibc patch in review to fix the motivation error in math.h (thanks to @tuliom ): https://patchwork.sourceware.org/project/glibc/patch/[e-mail]/ I think this revision can be closed.

clang/lib/CodeGen/CGExprScalar.cpp

       } else {
         Src = Builder.CreateFPExt(Src, CGF.CGM.FloatTy, "conv");
       }
       SrcType = CGF.getContext().FloatTy;
       SrcTy = CGF.FloatTy;
     }
   }
 
+  if (SrcType->isFloatingType() && DstType->isFloatingType()) {
+    // Handle cast between PPC double-double and IEEE 128-bit float types.
+    const auto *SrcSemantics = &CGF.getContext().getFloatTypeSemantics(SrcType);
+    const auto *DstSemantics = &CGF.getContext().getFloatTypeSemantics(DstType);
+    if (SrcSemantics == &llvm::APFloat::PPCDoubleDouble() &&
+        DstSemantics == &llvm::APFloat::IEEEquad())
+      return Builder.CreateCall(
+          CGF.CGM.getIntrinsic(llvm::Intrinsic::ppc_convert_ppcf128_to_f128),
+          Src);
+    if (SrcSemantics == &llvm::APFloat::IEEEquad() &&
+        DstSemantics == &llvm::APFloat::PPCDoubleDouble())
+      return Builder.CreateCall(
+          CGF.CGM.getIntrinsic(llvm::Intrinsic::ppc_convert_f128_to_ppcf128),
+          Src);
+  }
+
   // Ignore conversions like int -> uint.
   if (SrcTy == DstTy) {
     if (Opts.EmitImplicitIntegerSignChangeChecks)
       EmitIntegerSignChangeCheck(Src, NoncanonicalSrcType, Src,
                                  NoncanonicalDstType, Loc);
 
     return Src;
   }

clang/lib/Sema/SemaExpr.cpp

                                       /*ConvertInt=*/ true);
   }
   assert(RHSFloat);
   return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType,
                                     /*ConvertFloat=*/ true,
                                     /*ConvertInt=*/!IsCompAssign);
 }
 
-/// Diagnose attempts to convert between __float128, __ibm128 and
-/// long double if there is no support for such conversion.
-/// Helper function of UsualArithmeticConversions().
-static bool unsupportedTypeConversion(const Sema &S, QualType LHSType,
-                                      QualType RHSType) {
-  // No issue if either is not a floating point type.
-  if (!LHSType->isFloatingType() || !RHSType->isFloatingType())
-    return false;
-
-  // No issue if both have the same 128-bit float semantics.
-  auto *LHSComplex = LHSType->getAs<ComplexType>();
-  auto *RHSComplex = RHSType->getAs<ComplexType>();
-
-  QualType LHSElem = LHSComplex ? LHSComplex->getElementType() : LHSType;
-  QualType RHSElem = RHSComplex ? RHSComplex->getElementType() : RHSType;
-
-  const llvm::fltSemantics &LHSSem = S.Context.getFloatTypeSemantics(LHSElem);
-  const llvm::fltSemantics &RHSSem = S.Context.getFloatTypeSemantics(RHSElem);
-
-  if ((&LHSSem != &llvm::APFloat::PPCDoubleDouble() ||
-       &RHSSem != &llvm::APFloat::IEEEquad()) &&
-      (&LHSSem != &llvm::APFloat::IEEEquad() ||
-       &RHSSem != &llvm::APFloat::PPCDoubleDouble()))
-    return false;
-
-  return true;
-}
-
 typedef ExprResult PerformCastFn(Sema &S, Expr *operand, QualType toType);
 
 namespace {
 /// These helper callbacks are placed in an anonymous namespace to
 /// permit their use as function template parameters.
 ExprResult doIntegralCast(Sema &S, Expr *op, QualType toType) {
   return S.ImpCastExprToType(op, toType, CK_IntegralCast);
 }

     LHS = ImpCastExprToType(LHS.get(), LHSType, CK_IntegralCast);
 
   // If both types are identical, no conversion is needed.
   if (LHSType == RHSType)
     return LHSType;
 
   // At this point, we have two different arithmetic types.
 
-  // Diagnose attempts to convert between __ibm128, __float128 and long double
-  // where such conversions currently can't be handled.
-  if (unsupportedTypeConversion(*this, LHSType, RHSType))
-    return QualType();
-
   // Handle complex types first (C99 6.3.1.8p1).
   if (LHSType->isComplexType() || RHSType->isComplexType())
     return handleComplexFloatConversion(*this, LHS, RHS, LHSType, RHSType,
                                         ACK == ACK_CompAssign);
 
   // Now handle "real" floating types (i.e. float, double, long double).
   if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType())
     return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType,

 //===----------------------------------------------------------------------===//
 //  Semantic Analysis for various Expression Types
 //===----------------------------------------------------------------------===//
 
 
 ExprResult
 Sema::ActOnGenericSelectionExpr(SourceLocation KeyLoc,
                                 SourceLocation DefaultLoc,
                                 SourceLocation RParenLoc,
                                 Expr *ControllingExpr,
                                 ArrayRef<ParsedType> ArgTypes,
                                 ArrayRef<Expr *> ArgExprs) {
   unsigned NumAssocs = ArgTypes.size();
   assert(NumAssocs == ArgExprs.size());
 
   TypeSourceInfo **Types = new TypeSourceInfo*[NumAssocs];
   for (unsigned i = 0; i < NumAssocs; ++i) {
     if (ArgTypes[i])
       (void) GetTypeFromParser(ArgTypes[i], &Types[i]);

   QualType ResTy =
       UsualArithmeticConversions(LHS, RHS, QuestionLoc, ACK_Conditional);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
 
   QualType LHSTy = LHS.get()->getType();
   QualType RHSTy = RHS.get()->getType();
 
-  // Diagnose attempts to convert between __ibm128, __float128 and long double
-  // where such conversions currently can't be handled.
-  if (unsupportedTypeConversion(*this, LHSTy, RHSTy)) {
-    Diag(QuestionLoc,
-         diag::err_typecheck_cond_incompatible_operands) << LHSTy << RHSTy
-      << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();
-    return QualType();
-  }
-
   // OpenCL v2.0 s6.12.5 - Blocks cannot be used as expressions of the ternary
   // selection operator (?:).
   if (getLangOpts().OpenCL &&
       (checkBlockType(*this, LHS.get()) | checkBlockType(*this, RHS.get()))) {
     return QualType();
   }
 
   // If both operands have arithmetic type, do the usual arithmetic conversions

           Context.areLaxCompatibleSveTypes(LHSType, RHSType)) {
         Kind = CK_BitCast;
         return Compatible;
       }
 
     return Incompatible;
   }
 
-  // Diagnose attempts to convert between __ibm128, __float128 and long double
-  // where such conversions currently can't be handled.
-  if (unsupportedTypeConversion(*this, LHSType, RHSType))
-    return Incompatible;
-
   // Disallow assigning a _Complex to a real type in C++ mode since it simply
   // discards the imaginary part.
   if (getLangOpts().CPlusPlus && RHSType->getAs<ComplexType>() &&
       !LHSType->getAs<ComplexType>())
     return Incompatible;
 
   // Arithmetic conversions.
   if (LHSType->isArithmeticType() && RHSType->isArithmeticType() &&

clang/test/CodeGen/ibm128-cast.c

-// RUN: %clang_cc1 -emit-llvm -triple powerpc64le-unknown-unknown -verify \
-// RUN:   -target-feature +float128 -mabi=ieeelongdouble -fsyntax-only -Wno-unused %s
-// RUN: %clang_cc1 -emit-llvm -triple powerpc64le-unknown-unknown -verify \
-// RUN:   -target-feature +float128 -fsyntax-only -Wno-unused %s
-
-__float128 cast1(__ibm128 x) { return x; } // expected-error {{returning '__ibm128' from a function with incompatible result type '__float128'}}
-
-__ibm128 cast2(__float128 x) { return x; } // expected-error {{returning '__float128' from a function with incompatible result type '__ibm128'}}
+// RUN: %clang_cc1 -S -emit-llvm -triple powerpc64le-unknown-unknown \
+// RUN:   -target-feature +float128 -mabi=ieeelongdouble -Wno-unused %s \
+// RUN:   -o - | FileCheck %s --check-prefix=IEEE
+// RUN: %clang_cc1 -S -emit-llvm -triple powerpc64le-unknown-unknown \
+// RUN:   -target-feature +float128 -Wno-unused %s -o - | FileCheck %s
+
+// CHECK: define dso_local fp128 @cast1(ppc_fp128 %{{.+}})
+// CHECK: %{{.+}} = call fp128 @llvm.ppc.convert.ppcf128.to.f128(ppc_fp128 %{{.+}})
+// IEEE: define dso_local fp128 @cast1(ppc_fp128 %{{.+}})
+// IEEE: %{{.+}} = call fp128 @llvm.ppc.convert.ppcf128.to.f128(ppc_fp128 %{{.+}})
+__float128 cast1(__ibm128 x) { return x; }
+
+// CHECK: define dso_local ppc_fp128 @cast2(fp128 %{{.+}})
+// CHECK: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+// IEEE: define dso_local ppc_fp128 @cast2(fp128 %{{.+}})
+// IEEE: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+__ibm128 cast2(__float128 x) { return x; }
 
 __ibm128 gf;
 
+// CHECK: define dso_local void @narrow(double* %{{.+}}, float* %{{.+}})
+// IEEE: define dso_local void @narrow(double* %{{.+}}, float* %{{.+}})
 void narrow(double *d, float *f) {
   __ibm128 v = gf;
-  gf = *d;      // expected-no-error {{assigning to '__ibm128' from incompatible type 'double'}}
-  *f = v;       // expected-no-error {{assigning to 'float' from incompatible type '__ibm128'}}
-  *d = gf + *f; // expected-no-error {{invalid operands to binary expression ('__ibm128' and 'float')}}
-}
-
-#ifdef __LONG_DOUBLE_IEEE128__
-long double cast3(__ibm128 x) { return x; } // expected-error {{returning '__ibm128' from a function with incompatible result type 'long double'}}
-
-__ibm128 cast4(long double x) { return x; } // expected-error {{returning 'long double' from a function with incompatible result type '__ibm128'}}
-
-void imp_cast(__ibm128 w, __float128 q, long double l, _Bool b) {
-  w + q;      // expected-error {{invalid operands to binary expression ('__ibm128' and '__float128')}}
-  l + w;      // expected-error {{invalid operands to binary expression ('long double' and '__ibm128')}}
-  q - w;      // expected-error {{invalid operands to binary expression ('__float128' and '__ibm128')}}
-  w - l;      // expected-error {{invalid operands to binary expression ('__ibm128' and 'long double')}}
-  w *l;       // expected-error {{invalid operands to binary expression ('__ibm128' and 'long double')}}
-  q *w;       // expected-error {{invalid operands to binary expression ('__float128' and '__ibm128')}}
-  q / w;      // expected-error {{invalid operands to binary expression ('__float128' and '__ibm128')}}
-  w / l;      // expected-error {{invalid operands to binary expression ('__ibm128' and 'long double')}}
-  w = q;      // expected-error {{assigning to '__ibm128' from incompatible type '__float128'}}
-  q = w;      // expected-error {{assigning to '__float128' from incompatible type '__ibm128'}}
-  l = w;      // expected-error {{assigning to 'long double' from incompatible type '__ibm128'}}
-  w = l;      // expected-error {{assigning to '__ibm128' from incompatible type 'long double'}}
-  b ? q : w;  // expected-error {{incompatible operand types ('__float128' and '__ibm128')}}
-  !b ? w : l; // expected-error {{incompatible operand types ('__ibm128' and 'long double')}}
+  // CHECK: %{{.+}} = fpext double %{{.+}} to ppc_fp128
+  // IEEE: %{{.+}} = fpext double %{{.+}} to ppc_fp128
+  gf = *d;
+  // CHECK: %{{.+}} = fptrunc ppc_fp128 %{{.+}} to float
+  // IEEE: %{{.+}} = fptrunc ppc_fp128 %{{.+}} to float
+  *f = v;
+  // CHECK: %{{.+}} = fpext float %{{.+}} to ppc_fp128
+  // CHECK: %{{.+}} = fadd ppc_fp128 %{{.+}}, %{{.+}}
+  // CHECK: %{{.+}} = fptrunc ppc_fp128 %{{.+}} to double
+  // IEEE: %{{.+}} = fpext float %{{.+}} to ppc_fp128
+  // IEEE: %{{.+}} = fadd ppc_fp128 %{{.+}}, %{{.+}}
+  // IEEE: %{{.+}} = fptrunc ppc_fp128 %{{.+}} to double
+  *d = gf + *f;
 }
-#elif __LONG_DOUBLE_IBM128__
-long double cast3(__ibm128 x) { return x; } // expected-no-error {{returning '__ibm128' from a function with incompatible result type 'long double'}}
 
-__ibm128 cast4(long double x) { return x; } // expected-no-error {{returning 'long double' from a function with incompatible result type '__ibm128'}}
+// CHECK: define dso_local ppc_fp128 @cast3(ppc_fp128 %{{.+}})
+// CHECK-NOT: call ppc_fp128
+// IEEE: define dso_local fp128 @cast3(ppc_fp128 %{{.+}})
+// IEEE: %{{.+}} = call fp128 @llvm.ppc.convert.ppcf128.to.f128(ppc_fp128 %{{.+}})
+long double cast3(__ibm128 x) { return x; }
+
+// CHECK: define dso_local ppc_fp128 @cast4(ppc_fp128 %{{.+}})
+// CHECK-NOT: %{{.+}} = call ppc_fp128
+// IEEE: define dso_local ppc_fp128 @cast4(fp128 %{{.+}})
+// IEEE: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+__ibm128 cast4(long double x) { return x; }
 
+// CHECK: define dso_local void @imp_cast(ppc_fp128 %{{.+}}, fp128 %{{.+}}, ppc_fp128 %{{.+}}, i1 zeroext %{{.+}})
+// IEEE: define dso_local void @imp_cast(ppc_fp128 %{{.+}}, fp128 %{{.+}}, fp128 %{{.+}}, i1 zeroext %{{.+}})
 void imp_cast(__ibm128 w, __float128 q, long double l, _Bool b) {
-  w + q;      // expected-error {{invalid operands to binary expression ('__ibm128' and '__float128')}}
-  l + w;      // expected-no-error {{invalid operands to binary expression ('long double' and '__ibm128')}}
-  q - w;      // expected-error {{invalid operands to binary expression ('__float128' and '__ibm128')}}
-  w - l;      // expected-no-error {{invalid operands to binary expression ('__ibm128' and 'long double')}}
-  w *l;       // expected-no-error {{invalid operands to binary expression ('__ibm128' and 'long double')}}
-  q *w;       // expected-error {{invalid operands to binary expression ('__float128' and '__ibm128')}}
-  q / w;      // expected-error {{invalid operands to binary expression ('__float128' and '__ibm128')}}
-  w / l;      // expected-no-error {{invalid operands to binary expression ('__ibm128' and 'long double')}}
-  w = q;      // expected-error {{assigning to '__ibm128' from incompatible type '__float128'}}
-  q = w;      // expected-error {{assigning to '__float128' from incompatible type '__ibm128'}}
-  l = w;      // expected-no-error {{assigning to 'long double' from incompatible type '__ibm128'}}
-  w = l;      // expected-no-error {{assigning to '__ibm128' from incompatible type 'long double'}}
-  b ? q : w;  // expected-error {{incompatible operand types ('__float128' and '__ibm128')}}
-  !b ? w : l; // expected-no-error {{incompatible operand types ('__ibm128' and 'long double')}}
+  // CHECK: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // CHECK: %{{.+}} = fadd ppc_fp128 %{{.+}}, %{{.+}}
+  // IEEE: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // IEEE: %{{.+}} = fadd ppc_fp128 %{{.+}}, %{{.+}}
+  w + q;
+  // CHECK: %{{.+}} = fadd ppc_fp128 %{{.+}}, %{{.+}}
+  // IEEE: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // IEEE: %{{.+}} = fadd ppc_fp128 %{{.+}}, %{{.+}}
+  l + w;
+  // CHECK: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // CHECK: %{{.+}} = fsub ppc_fp128 %{{.+}}, %{{.+}}
+  // IEEE: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // IEEE: %{{.+}} = fsub ppc_fp128 %{{.+}}, %{{.+}}
+  q - w;
+  // CHECK: %{{.+}} = fsub ppc_fp128 %{{.+}}, %{{.+}}
+  // IEEE: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // IEEE: %{{.+}} = fsub ppc_fp128 %{{.+}}, %{{.+}}
+  w - l;
+  // CHECK: %{{.+}} = fmul ppc_fp128 %{{.+}}, %{{.+}}
+  // IEEE: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // IEEE: %{{.+}} = fmul ppc_fp128 %{{.+}}, %{{.+}}
+  w *l;
+  // CHECK: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // CHECK: %{{.+}} = fmul ppc_fp128 %{{.+}}, %{{.+}}
+  // IEEE: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // IEEE: %{{.+}} = fmul ppc_fp128 %{{.+}}, %{{.+}}
+  q *w;
+  // CHECK: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // CHECK: %{{.+}} = fdiv ppc_fp128 %{{.+}}, %{{.+}}
+  // IEEE: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // IEEE: %{{.+}} = fdiv ppc_fp128 %{{.+}}, %{{.+}}
+  q / w;
+  // CHECK: %{{.+}} = fdiv ppc_fp128 %{{.+}}, %{{.+}}
+  // IEEE: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // IEEE: %{{.+}} = fdiv ppc_fp128 %{{.+}}, %{{.+}}
+  w / l;
+  // CHECK: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // CHECK: store ppc_fp128 %{{.+}}, ppc_fp128* %{{.+}}, align 16
+  // IEEE: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // IEEE: store ppc_fp128 %{{.+}}, ppc_fp128* %{{.+}}, align 16
+  w = q;
+  // CHECK: %{{.+}} = call fp128 @llvm.ppc.convert.ppcf128.to.f128(ppc_fp128 %{{.+}})
+  // CHECK: store fp128 %{{.+}}, fp128* %{{.+}}, align 16
+  // IEEE: %{{.+}} = call fp128 @llvm.ppc.convert.ppcf128.to.f128(ppc_fp128 %{{.+}})
+  // IEEE: store fp128 %{{.+}}, fp128* %{{.+}}, align 16
+  q = w;
+  // CHECK: store ppc_fp128 %{{.+}}, ppc_fp128* %{{.+}}, align 16
+  // IEEE: %{{.+}} = call fp128 @llvm.ppc.convert.ppcf128.to.f128(ppc_fp128 %{{.+}})
+  // IEEE: store fp128 %{{.+}}, fp128* %{{.+}}, align 16
+  l = w;
+  // CHECK: store ppc_fp128 %{{.+}}, ppc_fp128* %{{.+}}, align 16
+  // IEEE: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // IEEE: store ppc_fp128 %{{.+}}, ppc_fp128* %{{.+}}, align 16
+  w = l;
+  // CHECK: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  // IEEE: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  b ? q : w;
+  // CHECK-NOT: call ppc_fp128
+  // IEEE: %{{.+}} = call ppc_fp128 @llvm.ppc.convert.f128.to.ppcf128(fp128 %{{.+}})
+  !b ? w : l;
 }
-#endif

clang/test/Sema/float128-ld-incompatibility.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 \
 // RUN: -triple powerpc64le-unknown-linux-gnu -target-cpu pwr9 \
-// RUN: -target-feature +float128 %s
+// RUN: -Wno-unused-value -Wno-parentheses -target-feature +float128 %s
 // RUN: %clang_cc1 -fsyntax-only -std=c++11 -triple x86_64-unknown-linux-gnu -Wno-unused-value -Wno-parentheses %s
 
 __float128 qf();
 long double ldf();
 
 #ifdef __PPC__
 // FIXME: once operations between long double and __float128 are implemented for
 //        targets where the types are different, these next two will change
 long double ld{qf()}; // expected-error {{cannot initialize a variable of type 'long double' with an rvalue of type '__float128'}}
 __float128 q{ldf()};  // expected-error {{cannot initialize a variable of type '__float128' with an rvalue of type 'long double'}}
 
-auto test1(__float128 q, long double ld) -> decltype(q + ld) { // expected-error {{invalid operands to binary expression ('__float128' and 'long double')}}
-  return q + ld;      // expected-error {{invalid operands to binary expression ('__float128' and 'long double')}}
+auto test1(__float128 q, long double ld) -> decltype(q + ld) { // expected-no-error {{invalid operands to binary expression ('__float128' and 'long double')}}
+  return q + ld;      // expected-no-error {{invalid operands to binary expression ('__float128' and 'long double')}}
 }
 
-auto test2(long double a, __float128 b) -> decltype(a + b) { // expected-error {{invalid operands to binary expression ('long double' and '__float128')}}
-  return a + b;      // expected-error {{invalid operands to binary expression ('long double' and '__float128')}}
+auto test2(long double a, __float128 b) -> decltype(a + b) { // expected-eno-rror {{invalid operands to binary expression ('long double' and '__float128')}}
+  return a + b;      // expected-no-error {{invalid operands to binary expression ('long double' and '__float128')}}
 }
 #endif
 
 void test3(bool b) {
   long double ld;
   __float128 q;
 
-  ld + q; // expected-error {{invalid operands to binary expression ('long double' and '__float128')}}
-  q + ld; // expected-error {{invalid operands to binary expression ('__float128' and 'long double')}}
-  ld - q; // expected-error {{invalid operands to binary expression ('long double' and '__float128')}}
-  q - ld; // expected-error {{invalid operands to binary expression ('__float128' and 'long double')}}
-  ld * q; // expected-error {{invalid operands to binary expression ('long double' and '__float128')}}
-  q * ld; // expected-error {{invalid operands to binary expression ('__float128' and 'long double')}}
-  ld / q; // expected-error {{invalid operands to binary expression ('long double' and '__float128')}}
-  q / ld; // expected-error {{invalid operands to binary expression ('__float128' and 'long double')}}
+  ld + q; // expected-no-error {{invalid operands to binary expression ('long double' and '__float128')}}
+  q + ld; // expected-no-error {{invalid operands to binary expression ('__float128' and 'long double')}}
+  ld - q; // expected-no-error {{invalid operands to binary expression ('long double' and '__float128')}}
+  q - ld; // expected-no-error {{invalid operands to binary expression ('__float128' and 'long double')}}
+  ld * q; // expected-no-error {{invalid operands to binary expression ('long double' and '__float128')}}
+  q * ld; // expected-no-error {{invalid operands to binary expression ('__float128' and 'long double')}}
+  ld / q; // expected-no-error {{invalid operands to binary expression ('long double' and '__float128')}}
+  q / ld; // expected-no-error {{invalid operands to binary expression ('__float128' and 'long double')}}
   ld = q; // expected-error {{assigning to 'long double' from incompatible type '__float128'}}
   q = ld; // expected-error {{assigning to '__float128' from incompatible type 'long double'}}
-  q + b ? q : ld; // expected-error {{incompatible operand types ('__float128' and 'long double')}}
+  q + b ? q : ld; // expected-no-error {{incompatible operand types ('__float128' and 'long double')}}
 }