[Clang] Add __ibm128 type to represent ppc_fp128

[qiucf]

Summary

Currently, we have no front-end type for ppc_fp128 type in IR. PowerPC target generates ppc_fp128 type from long double now, but there's option (-mabi=(ieee|ibm)longdouble) to control it and we're going to do transition from IBM extended double-double ppc_fp128 to IEEE fp128 in the future.

This patch adds type __ibm128 which always represents ppc_fp128 in IR, as what GCC did for that type. Without this type in Clang, compilation will fail if compiling against future version of libstdcxx (which uses __ibm128 in headers).

Although all operations in backend for __ibm128 is done by software, only PowerPC enables support for it.

There's something not implemented in this patch and can be done in future ones:

1. Literal suffix for __ibm128 type. w/W is suitable as GCC documented (https://gcc.gnu.org/onlinedocs/gcc/Floating-Types.html) but I believe they haven't implemented it yet.
2. __attribute__((mode(IF))) should be for __ibm128.

[steven.zhang]

clang/lib/AST/ItaniumMangle.cpp

2668

This is a bit confusing as the 'g' is for both float128 and ibm128. I know that PowerPC will mangle the float128 as "u9ieee128", and "g" for ibm128. But c++filt demangle the "g" as float128 which seems not right.

[hubert.reinterpretcast]

clang/lib/AST/ASTContext.cpp

6230

I think this function should vocally fail when presented with "unordered" cases.

clang/lib/CodeGen/CGDebugInfo.cpp

803

Update the comment for __ibm128.

clang/lib/Parse/ParseExprCXX.cpp

2245

Not sure what the best method is to implement this, but long double and __ibm128 are the same type for GCC when -mabi=ibmlongdouble is in effect.

clang/lib/Sema/SemaExpr.cpp

1188–1190

Comment needs update.

1229

Same comment about possible blocking of double to __ibm128 conversions.

1546–1547

Comment needs update.

clang/lib/Sema/SemaOverload.cpp

1887

This seems to disable conversion from double to __ibm128?

clang/lib/Sema/SemaType.cpp

1562–1563

Do the SYCL and OpenMP device exceptions to the error really apply for __ibm128?

clang/test/CodeGenCXX/ibm128-declarations.cpp

7

What does the debug info look like?

25

Add a function that reads an __ibm128 from varargs.

26

There's a lot of missing testing, especially around implicit conversions, narrowing conversions, and the usual arithmetic conversions.

26

Make this a constexpr function and call it from the initializer of a global declared with consteval.

30

Add a case where __ibm128 is used as the type of a non-type template parameter.

[hubert.reinterpretcast]

clang/test/CodeGenCXX/ibm128-declarations.cpp

26

Make this a constexpr function and call it from the initializer of a global declared with consteval.

Sorry, I meant constinit and not consteval.

[nemanjai]

Seems that conversion diagnostic test cases are completely missing.

clang/include/clang/Basic/TargetInfo.h

680

The same mangling for both of these types seems incorrect as Steven pointed out. Why not do something similar to what was done for bfloat16 (i.e. an llvm_unreachable) and override it for PowerPC?

clang/lib/AST/ASTContext.cpp

6204

Why? Is this coming in an upcoming patch or is this something that will never be available?

6230

But is it possible to emit errors here or should there be code explicitly added to Sema to disallow conversions between __ibm128 and __float128 (and long double to/from either of those to which it is not equivalent)?

clang/lib/Sema/SemaExpr.cpp

1229

I am not sure what "same comment" refers to, but I agree that this seems very wrong - doesn't this mean that we can't convert between __ibm128 and any other floating point type?
In any case, I think this can be represented quite concisely as something like:
if (<types have same size> && <types do not have same fltSemantics>)

clang/lib/Sema/SemaOverload.cpp

1887

Oh, now I understand the "same comment" comment above. Yes, this appears to also be a case where we don't want to allow types of the same width but different representation.

[hubert.reinterpretcast]

clang/lib/AST/ASTContext.cpp

6230

I did not mean a user-facing error message. I meant that there should be some form of assertion or internal diagnostic here. I believe assert is appropriate.

I will note that this is a public member function of ASTContext. Regardless of explicit code in Sema that does what you describe, I think this function should not present an interface where it does not report "unordered" cases as unordered.

[qiucf]

Address comments and add tests

clang/lib/AST/ASTContext.cpp

6204

Sure, I plan to add it in next patch

6230

Adding assertion here makes unsupportedTypeConversion always fail in such cases.

clang/lib/Parse/ParseExprCXX.cpp

2245

Seems clang is also different from GCC under -mabi=ieeelongdouble? I saw __float128 and long double are the same for GCC but not for clang.

clang/lib/Sema/SemaExpr.cpp

1229

I found this would break existing tests of x86_64: x86_fp80 is 96 bits long on x86_32, 128 bits long on x86_64. However tests expect x86_fp80 can be fpexted into fp128.

clang/lib/Sema/SemaType.cpp

1562–1563

If host supports __ibm128 but device does not?

[hubert.reinterpretcast]

clang/lib/AST/ASTContext.cpp

6230

Yes, I know. I think unsupportedTypeConversion should avoid calling this function when it is possibly dealing with an "unordered" case unless if this function has a way of indicating "unordered" as a result. If there is a helper function for testing the unordered case in this class, then I think unsupportedTypeConversion can simply say that all ordered cases are supported (before doing more to figure out the unordered cases that are safe).

clang/lib/Parse/ParseExprCXX.cpp

2245

Have you checked whether the new libstdc++ for which this support is being added needs the GCC behaviour to work properly?

The GCC behaviour allows the following to be compiled without introducing novel overload resolution tiebreakers:

void f(__float128);
void f(__ibm128);
void f(int);

long double ld;

int main() { f(ld); }

clang/lib/Sema/SemaType.cpp

1562–1563

Can you add a test that makes use of this? Also, there should be a case that triggers err_device_unsupported_type.

[rjmccall]

Are you committed to the name __ibm128? I think a name that says something about floating point would be better than just a company name and a number. "double double" is the common name for this format pretty much everywhere, and while I certainly would *not* suggest actually spelling it double double (i.e. with repeated type specifiers0), you could certainly use something like __doubledouble.

[hubert.reinterpretcast]

In D93377#2481312, @rjmccall wrote:

Are you committed to the name __ibm128?

Insofar as that's what GCC on Power (for example, gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0 from 2017) has shipped with for several years, yes.

[rjmccall]

In D93377#2481957, @hubert.reinterpretcast wrote:

In D93377#2481312, @rjmccall wrote:

Are you committed to the name __ibm128?

Insofar as that's what GCC on Power (for example, gcc (Ubuntu 7.5.0-3ubuntu1~18.04) 7.5.0 from 2017) has shipped with for several years, yes.

Okay, it wasn't clear from the description that this was an already-shipping type. In that case, it's regrettable but obviously just something we have to match.

[qiucf]

• Add helper method to count 'unordered' cases
• Add missing tests (in last update)
• Add test for openmp device-host case

[qiucf]

clang/lib/Parse/ParseExprCXX.cpp

2245

As I saw both GCC and clang have error for ambiguous operator<< for:

std::cout << "long double:\n";
std::cout << std::numeric_limits<long double>::max() << std::endl;
std::cout << std::numeric_limits<long double>::min() << std::endl;

std::cout << "__float128:\n";
std::cout << std::numeric_limits<__float128>::max() << std::endl;
std::cout << std::numeric_limits<__float128>::min() << std::endl;

std::cout << "__ibm128:\n";
std::cout << std::numeric_limits<__ibm128>::max() << std::endl;
std::cout << std::numeric_limits<__ibm128>::min() << std::endl;

[hubert.reinterpretcast]

clang/lib/Parse/ParseExprCXX.cpp

2245

@jwakely, are the overload resolution errors expected? @qiucf, are you sure you have a sufficiently new libstdc++?

[jwakely]

clang/lib/Parse/ParseExprCXX.cpp

2245

@jwakely, are the overload resolution errors expected?

Yes. Iostreams support long double but not __float128, unless that happens to be the same type as long double (due to a -mabi=ieeelongdouble option).

[hubert.reinterpretcast]

clang/lib/Parse/ParseExprCXX.cpp

2245

Meaning that Clang's __float128 iosteams support (with libstdc++) would diverge from GCC.

For example, Clang reports the call below as ambiguous even with -mabi=ieeelongdouble:

void f(double);
void f(long double);

void g(__float128 f128) { f(f128); }

https://godbolt.org/z/dhYEKa

Insofar as the user experience goes, is this lack of iostreams support for __float128 (even with -mabi=ieeelongdouble) within the realm of the intended design of libstdc++?

[jwakely]

clang/lib/Parse/ParseExprCXX.cpp

2245

The lack of iostreams support for __float128 is the intended design.

On power we support float, double and three types of long double. If __float128 is a distinct type from all those long double types it won't work.

GCC on power defines __float128 as a macro expanding to __ieee128, so it is the same as one of the long double types.

[hubert.reinterpretcast]

clang/lib/Parse/ParseExprCXX.cpp

2245

Okay, it sounds like the different treatment Clang has does not really interfere with recommended usage insofar as libstdc++ iostreams (and hopefully this extends to the rest of the library).

[hubert.reinterpretcast]

clang/bindings/python/clang/cindex.py

2061–2062

This looks suspiciously like the result of this file having not been maintained for the additions of:

CXType_Float16 = 32,
CXType_ShortAccum = 33,
CXType_Accum = 34,
CXType_LongAccum = 35,
CXType_UShortAccum = 36,
CXType_UAccum = 37,
CXType_ULongAccum = 38,
CXType_BFloat16 = 39,

What test coverage fails if the addition of TypeKind.IBM128 is omitted from this patch?

clang/include/clang-c/Index.h

3283

Looks like CXType_Ibm128 is the "last" built-in type now?

[qiucf]

Update cindex

clang/bindings/python/clang/cindex.py

2061–2062

Change this to 40 for consistency.

Actually I did not get any failure of check-clang even when removing all these floating point types assignment. Test coverage may miss here.

[jwakely]

clang/lib/AST/ItaniumMangle.cpp

2668

The (de)mangling is very confusing, but that's consistent with gcc.
See comment 3 and 4 at https://gcc.gnu.org/bugzilla/show_bug.cgi?id=98389#c3

I think double-double should never have used g it should have been something else (e.g. u8__ibm128), and then we could have g for the __ieee128 (aka __float128) type. But it is many years too late to change that now.

[rjmccall]

clang/lib/AST/ItaniumMangle.cpp

2668

Yeah, I think that's an unfortunate but ultimately understandable platform decision.

[qiucf]

Ping.. Any further comments?

[rjmccall]

clang/include/clang/Basic/TargetInfo.h

131

This is necessary because it's possible to derive this type from a mode attribute?

680

Why are these manglings abstracted into TargetInfo in the first place? Are there targets that are going to use a different mangling for __ibm128?

clang/lib/AST/ASTContext.cpp

6274

Is it language semantics that these are unordered or just an implementation limitation? I know WG14 is working on a draft for extended types that allows pairs to not be ordered, but IIRC that's supposed to be based on whether types have a subset relationship. I believe the only FP formats that pairwise don't have subset relationships are bfloat/half and ibm128/fp80, and we don't support ibm128 on any x86 targets so the latter is impossible in practice. The reason we have this restriction on converting between ibm128 and float128 is just that we haven't implemented the conversion in the backend / compiler-rt. I don't think we should lock that limitation in as an actual unordered-type relationship.

clang/lib/CodeGen/TargetInfo.cpp

5159

I hesitate to ask this, but does __ibm128 form homogeneous aggregates with doubles?

clang/lib/Index/USRGeneration.cpp

708

@akyrtzi @benlangmuir We can just add new USR codes for new types, right?

clang/lib/Sema/Sema.cpp

1849

I think this needs a comment explaining what you're checking for.

[akyrtzi]

clang/lib/Index/USRGeneration.cpp

708

Yes, it would be good to do that.

[qiucf]

clang/include/clang/Basic/TargetInfo.h

131

Yes, __attribute__((mode(IF)))

clang/lib/CodeGen/TargetInfo.cpp

5159

Homogeneous floating-point aggregates can have up to four IBM EXTENDED PRECISION members, four IEEE BINARY 128 QUADRUPLE PRECISION members, four _Decimal128 members, or eight members of other floating-point types. (Unions are treated as their largest member. For homogeneous unions, different union alternatives may have different sizes, provided that all union members are homogeneous with respect to each other.) They are passed in floating-point registers if parameters of that type would be passed in floating-point registers. They are passed in vector registers if parameters of that type would be passed in vector registers. They are passed as if each member was specified as a separate parameter.

Yes.

[rjmccall]

clang/include/clang/Basic/TargetInfo.h

131

Okay. I guess I agree that it makes sense to do that in a follow-up patch since it requires threading some extra state around.

clang/lib/CodeGen/TargetInfo.cpp

5159

No, I mean, would an __ibm128 in a struct with a pair of doubles be treated as if it were 4 doubles, or is it considered non-homogeneous the same way that a struct with e.g. 4 floats and 2 doubles would be non-homogeneous?

[qiucf]

clang/lib/CodeGen/TargetInfo.cpp

5159

Ah, I think not. __ibm128 (PowerPC long double also produces ppc_fp128) is distinct type in determining homogeneous aggregates.

[rjmccall]

Okay, thanks. LGTM, then.

clang/bindings/python/clang/cindex.py

 TypeKind.LONGDOUBLE = TypeKind(23)
 TypeKind.NULLPTR = TypeKind(24)
 TypeKind.OVERLOAD = TypeKind(25)
 TypeKind.DEPENDENT = TypeKind(26)
 TypeKind.OBJCID = TypeKind(27)
 TypeKind.OBJCCLASS = TypeKind(28)
 TypeKind.OBJCSEL = TypeKind(29)
 TypeKind.FLOAT128 = TypeKind(30)
 TypeKind.HALF = TypeKind(31)
+TypeKind.IBM128 = TypeKind(32)
 TypeKind.COMPLEX = TypeKind(100)
 TypeKind.POINTER = TypeKind(101)
 TypeKind.BLOCKPOINTER = TypeKind(102)
 TypeKind.LVALUEREFERENCE = TypeKind(103)
 TypeKind.RVALUEREFERENCE = TypeKind(104)
 TypeKind.RECORD = TypeKind(105)
 TypeKind.ENUM = TypeKind(106)
 TypeKind.TYPEDEF = TypeKind(107)

clang/include/clang-c/Index.h

   CXType_Float16 = 32,
   CXType_ShortAccum = 33,
   CXType_Accum = 34,
   CXType_LongAccum = 35,
   CXType_UShortAccum = 36,
   CXType_UAccum = 37,
   CXType_ULongAccum = 38,
   CXType_BFloat16 = 39,
+  CXType_Ibm128 = 40,
   CXType_FirstBuiltin = CXType_Void,
   CXType_LastBuiltin = CXType_BFloat16,
 
   CXType_Complex = 100,
   CXType_Pointer = 101,
   CXType_BlockPointer = 102,
   CXType_LValueReference = 103,
   CXType_RValueReference = 104,
   CXType_Record = 105,
   CXType_Enum = 106,

clang/include/clang/AST/ASTContext.h

   CanQualType WideCharTy; // Same as WCharTy in C++, integer type in C99.
   CanQualType WIntTy;   // [C99 7.24.1], integer type unchanged by default promotions.
   CanQualType Char8Ty;  // [C++20 proposal]
   CanQualType Char16Ty; // [C++0x 3.9.1p5], integer type in C99.
   CanQualType Char32Ty; // [C++0x 3.9.1p5], integer type in C99.
   CanQualType SignedCharTy, ShortTy, IntTy, LongTy, LongLongTy, Int128Ty;
   CanQualType UnsignedCharTy, UnsignedShortTy, UnsignedIntTy, UnsignedLongTy;
   CanQualType UnsignedLongLongTy, UnsignedInt128Ty;
-  CanQualType FloatTy, DoubleTy, LongDoubleTy, Float128Ty;
+  CanQualType FloatTy, DoubleTy, LongDoubleTy, Float128Ty, Ibm128Ty;
   CanQualType ShortAccumTy, AccumTy,
       LongAccumTy;  // ISO/IEC JTC1 SC22 WG14 N1169 Extension
   CanQualType UnsignedShortAccumTy, UnsignedAccumTy, UnsignedLongAccumTy;
   CanQualType ShortFractTy, FractTy, LongFractTy;
   CanQualType UnsignedShortFractTy, UnsignedFractTy, UnsignedLongFractTy;
   CanQualType SatShortAccumTy, SatAccumTy, SatLongAccumTy;
   CanQualType SatUnsignedShortAccumTy, SatUnsignedAccumTy,
       SatUnsignedLongAccumTy;

   /// \p LHS < \p RHS, return -1.
   int getFloatingTypeOrder(QualType LHS, QualType RHS) const;
 
   /// Compare the rank of two floating point types as above, but compare equal
   /// if both types have the same floating-point semantics on the target (i.e.
   /// long double and double on AArch64 will return 0).
   int getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const;
 
+  /// Return true if the two types actually don't have a rank to compare.
+  bool areUnorderedFloatingTypes(QualType LHS, QualType RHS) const;
+
   /// Return a real floating point or a complex type (based on
   /// \p typeDomain/\p typeSize).
   ///
   /// \param typeDomain a real floating point or complex type.
   /// \param typeSize a real floating point or complex type.
   QualType getFloatingTypeOfSizeWithinDomain(QualType typeSize,
                                              QualType typeDomain) const;
 

clang/include/clang/AST/BuiltinTypes.def

 FLOATING_TYPE(Float16, HalfTy)
 
 // '__bf16'
 FLOATING_TYPE(BFloat16, BFloat16Ty)
 
 // '__float128'
 FLOATING_TYPE(Float128, Float128Ty)
 
+// '__ibm128'
+FLOATING_TYPE(Ibm128, Ibm128Ty)
+
 //===- Language-specific types --------------------------------------------===//
 
 // This is the type of C++0x 'nullptr'.
 BUILTIN_TYPE(NullPtr, NullPtrTy)
 
 // The primitive Objective C 'id' type.  The user-visible 'id'
 // type is a typedef of an ObjCObjectPointerType to an
 // ObjCObjectType with this as its base.  In fact, this only ever

clang/include/clang/AST/Type.h

   /// isComplexIntegerType() can be used to test for complex integers.
   bool isComplexType() const;      // C99 6.2.5p11 (complex)
   bool isAnyComplexType() const;   // C99 6.2.5p11 (complex) + Complex Int.
   bool isFloatingType() const;     // C99 6.2.5p11 (real floating + complex)
   bool isHalfType() const;         // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
   bool isFloat16Type() const;      // C11 extension ISO/IEC TS 18661
   bool isBFloat16Type() const;
   bool isFloat128Type() const;
+  bool isIbm128Type() const;
   bool isRealType() const;         // C99 6.2.5p17 (real floating + integer)
   bool isArithmeticType() const;   // C99 6.2.5p18 (integer + floating)
   bool isVoidType() const;         // C99 6.2.5p19
   bool isScalarType() const;       // C99 6.2.5p21 (arithmetic + pointers)
   bool isAggregateType() const;
   bool isFundamentalType() const;
   bool isCompoundType() const;
 

     return getKind() >= Char_S && getKind() <= Int128;
   }
 
   bool isUnsignedInteger() const {
     return getKind() >= Bool && getKind() <= UInt128;
   }
 
   bool isFloatingPoint() const {
-    return getKind() >= Half && getKind() <= Float128;
+    return getKind() >= Half && getKind() <= Ibm128;
   }
 
   /// Determines whether the given kind corresponds to a placeholder type.
   static bool isPlaceholderTypeKind(Kind K) {
     return K >= Overload;
   }
 
   /// Determines whether this type is a placeholder type, i.e. a type

 inline bool Type::isBFloat16Type() const {
   return isSpecificBuiltinType(BuiltinType::BFloat16);
 }
 
 inline bool Type::isFloat128Type() const {
   return isSpecificBuiltinType(BuiltinType::Float128);
 }
 
+inline bool Type::isIbm128Type() const {
+  return isSpecificBuiltinType(BuiltinType::Ibm128);
+}
+
 inline bool Type::isNullPtrType() const {
   return isSpecificBuiltinType(BuiltinType::NullPtr);
 }
 
 bool IsEnumDeclComplete(EnumDecl *);
 bool IsEnumDeclScoped(EnumDecl *);
 
 inline bool Type::isIntegerType() const {

clang/include/clang/AST/TypeLoc.h

     return *(static_cast<WrittenBuiltinSpecs*>(getExtraLocalData()));
   }
   const WrittenBuiltinSpecs& getWrittenBuiltinSpecs() const {
     return *(static_cast<WrittenBuiltinSpecs*>(getExtraLocalData()));
   }
 
   bool needsExtraLocalData() const {
     BuiltinType::Kind bk = getTypePtr()->getKind();
-    return (bk >= BuiltinType::UShort && bk <= BuiltinType::UInt128)
-      || (bk >= BuiltinType::Short && bk <= BuiltinType::Float128)
-      || bk == BuiltinType::UChar
-      || bk == BuiltinType::SChar;
+    return (bk >= BuiltinType::UShort && bk <= BuiltinType::UInt128) ||
+           (bk >= BuiltinType::Short && bk <= BuiltinType::Ibm128) ||
+           bk == BuiltinType::UChar || bk == BuiltinType::SChar;
   }
 
   unsigned getExtraLocalDataSize() const {
     return needsExtraLocalData() ? sizeof(WrittenBuiltinSpecs) : 0;
   }
 
   unsigned getExtraLocalDataAlignment() const {
     return needsExtraLocalData() ? alignof(WrittenBuiltinSpecs) : 1;

clang/include/clang/Basic/Specifiers.h

namespace clang {
 
   enum class TypeSpecifiersPipe { Unspecified, Pipe };
 
   /// Specifies the kind of type.
   enum TypeSpecifierType {
     TST_unspecified,
     TST_void,
     TST_char,
     TST_wchar,        // C++ wchar_t
     TST_char8,        // C++20 char8_t (proposed)
     TST_char16,       // C++11 char16_t
     TST_char32,       // C++11 char32_t
     TST_int,
     TST_int128,
     TST_extint,       // Extended Int types.
     TST_half,         // OpenCL half, ARM NEON __fp16
     TST_Float16,      // C11 extension ISO/IEC TS 18661-3
     TST_Accum,        // ISO/IEC JTC1 SC22 WG14 N1169 Extension
     TST_Fract,
     TST_BFloat16,
     TST_float,
     TST_double,
     TST_float128,
+    TST_ibm128,
     TST_bool,         // _Bool
     TST_decimal32,    // _Decimal32
     TST_decimal64,    // _Decimal64
     TST_decimal128,   // _Decimal128
     TST_enum,
     TST_union,
     TST_struct,
     TST_class,        // C++ class type
     TST_interface,    // C++ (Microsoft-specific) __interface type
     TST_typename,     // Typedef, C++ class-name or enum name, etc.
     TST_typeofType,
     TST_typeofExpr,
     TST_decltype,         // C++11 decltype
     TST_underlyingType,   // __underlying_type for C++11
     TST_auto,             // C++11 auto
     TST_decltype_auto,    // C++1y decltype(auto)
     TST_auto_type,        // __auto_type extension
     TST_unknown_anytype,  // __unknown_anytype extension
     TST_atomic,           // C11 _Atomic
 #define GENERIC_IMAGE_TYPE(ImgType, Id) TST_##ImgType##_t, // OpenCL image types
 #include "clang/Basic/OpenCLImageTypes.def"

clang/include/clang/Basic/TargetInfo.h

 struct TransferrableTargetInfo {
   unsigned char PointerWidth, PointerAlign;
   unsigned char BoolWidth, BoolAlign;
   unsigned char IntWidth, IntAlign;
   unsigned char HalfWidth, HalfAlign;
   unsigned char BFloat16Width, BFloat16Align;
   unsigned char FloatWidth, FloatAlign;
   unsigned char DoubleWidth, DoubleAlign;
-  unsigned char LongDoubleWidth, LongDoubleAlign, Float128Align;
+  unsigned char LongDoubleWidth, LongDoubleAlign, Float128Align, Ibm128Align;
   unsigned char LargeArrayMinWidth, LargeArrayAlign;
   unsigned char LongWidth, LongAlign;
   unsigned char LongLongWidth, LongLongAlign;
 
   // Fixed point bit widths
   unsigned char ShortAccumWidth, ShortAccumAlign;
   unsigned char AccumWidth, AccumAlign;
   unsigned char LongAccumWidth, LongAccumAlign;

   unsigned char DefaultAlignForAttributeAligned;
   unsigned char MinGlobalAlign;
 
   unsigned short NewAlign;
   unsigned MaxVectorAlign;
   unsigned MaxTLSAlign;
 
   const llvm::fltSemantics *HalfFormat, *BFloat16Format, *FloatFormat,
-    *DoubleFormat, *LongDoubleFormat, *Float128Format;
+      *DoubleFormat, *LongDoubleFormat, *Float128Format, *Ibm128Format;
 
   ///===---- Target Data Type Query Methods -------------------------------===//
   enum IntType {
     NoInt = 0,
     SignedChar,
     UnsignedChar,
     SignedShort,
     UnsignedShort,
     SignedInt,
     UnsignedInt,
     SignedLong,
     UnsignedLong,
     SignedLongLong,
     UnsignedLongLong
   };
 
   enum RealType {
     NoFloat = 255,
     Float = 0,
     Double,
     LongDouble,
-    Float128
+    Float128,
+    Ibm128
   };
+
 protected:
   IntType SizeType, IntMaxType, PtrDiffType, IntPtrType, WCharType,
           WIntType, Char16Type, Char32Type, Int64Type, SigAtomicType,
           ProcessIDType;
 
   /// Whether Objective-C's built-in boolean type should be signed char.
   ///
   /// Otherwise, when this flag is not set, the normal built-in boolean type is

   bool TLSSupported;
   bool VLASupported;
   bool NoAsmVariants;  // True if {|} are normal characters.
   bool HasLegalHalfType; // True if the backend supports operations on the half
                          // LLVM IR type.
   bool HasFloat128;
   bool HasFloat16;
   bool HasBFloat16;
+  bool HasIbm128;
   bool HasStrictFP;
 
   unsigned char MaxAtomicPromoteWidth, MaxAtomicInlineWidth;
   unsigned short SimdDefaultAlign;
   std::unique_ptr<llvm::DataLayout> DataLayout;
   const char *MCountName;
   unsigned char RegParmMax, SSERegParmMax;
   TargetCXXABI TheCXXABI;

   virtual bool hasFloat128Type() const { return HasFloat128; }
 
   /// Determine whether the _Float16 type is supported on this target.
   virtual bool hasFloat16Type() const { return HasFloat16; }
 
   /// Determine whether the _BFloat16 type is supported on this target.
   virtual bool hasBFloat16Type() const { return HasBFloat16; }
 
+  /// Determine whether the __ibm128 type is supported on this target.
+  virtual bool hasIbm128Type() const { return HasIbm128; }
+
   /// Determine whether constrained floating point is supported on this target.
   virtual bool hasStrictFP() const { return HasStrictFP; }
 
   /// Return the alignment that is the largest alignment ever used for any
   /// scalar/SIMD data type on the target machine you are compiling for
   /// (including types with an extended alignment requirement).
   unsigned getSuitableAlign() const { return SuitableAlign; }
 

   /// getFloat128Width/Align/Format - Return the size/align/format of
   /// '__float128'.
   unsigned getFloat128Width() const { return 128; }
   unsigned getFloat128Align() const { return Float128Align; }
   const llvm::fltSemantics &getFloat128Format() const {
     return *Float128Format;
   }
 
+  /// getIbm128Width/Align/Format - Return the size/align/format of
+  /// '__ibm128'.
+  unsigned getIbm128Width() const { return 128; }
+  unsigned getIbm128Align() const { return Ibm128Align; }
+  const llvm::fltSemantics &getIbm128Format() const { return *Ibm128Format; }
+
   /// Return the mangled code of long double.
   virtual const char *getLongDoubleMangling() const { return "e"; }
 
   /// Return the mangled code of __float128.
   virtual const char *getFloat128Mangling() const { return "g"; }
 
+  /// Return the mangled code of __ibm128.
+  virtual const char *getIbm128Mangling() const {
+    llvm_unreachable("ibm128 not implemented on this target");
+  }
+
   /// Return the mangled code of bfloat.
   virtual const char *getBFloat16Mangling() const {
     llvm_unreachable("bfloat not implemented on this target");
   }
 
   /// Return the value for the C99 FLT_EVAL_METHOD macro.
   virtual unsigned getFloatEvalMethod() const { return 0; }
 

clang/include/clang/Basic/TokenKinds.def

 KEYWORD(__builtin_COLUMN            , KEYALL)
 
 // __builtin_types_compatible_p is a GNU C extension that we handle like a C++
 // type trait.
 TYPE_TRAIT_2(__builtin_types_compatible_p, TypeCompatible, KEYNOCXX)
 KEYWORD(__builtin_va_arg            , KEYALL)
 KEYWORD(__extension__               , KEYALL)
 KEYWORD(__float128                  , KEYALL)
+KEYWORD(__ibm128                    , KEYALL)
 KEYWORD(__imag                      , KEYALL)
 KEYWORD(__int128                    , KEYALL)
 KEYWORD(__label__                   , KEYALL)
 KEYWORD(__real                      , KEYALL)
 KEYWORD(__thread                    , KEYALL)
 KEYWORD(__FUNCTION__                , KEYALL)
 KEYWORD(__PRETTY_FUNCTION__         , KEYALL)
 KEYWORD(__auto_type                 , KEYALL)

clang/include/clang/Sema/DeclSpec.h

   static const TST TST_half = clang::TST_half;
   static const TST TST_BFloat16 = clang::TST_BFloat16;
   static const TST TST_float = clang::TST_float;
   static const TST TST_double = clang::TST_double;
   static const TST TST_float16 = clang::TST_Float16;
   static const TST TST_accum = clang::TST_Accum;
   static const TST TST_fract = clang::TST_Fract;
   static const TST TST_float128 = clang::TST_float128;
+  static const TST TST_ibm128 = clang::TST_ibm128;
   static const TST TST_bool = clang::TST_bool;
   static const TST TST_decimal32 = clang::TST_decimal32;
   static const TST TST_decimal64 = clang::TST_decimal64;
   static const TST TST_decimal128 = clang::TST_decimal128;
   static const TST TST_enum = clang::TST_enum;
   static const TST TST_union = clang::TST_union;
   static const TST TST_struct = clang::TST_struct;
   static const TST TST_interface = clang::TST_interface;

clang/include/clang/Serialization/ASTBitCodes.h

       /// OpenCL reserve_id type.
       PREDEF_TYPE_RESERVE_ID_ID = 41,
 
       /// The placeholder type for OpenMP array section.
       PREDEF_TYPE_OMP_ARRAY_SECTION = 42,
 
       /// The '__float128' type
       PREDEF_TYPE_FLOAT128_ID = 43,
 
       /// The '_Float16' type
       PREDEF_TYPE_FLOAT16_ID = 44,
 
       /// The C++ 'char8_t' type.
       PREDEF_TYPE_CHAR8_ID = 45,
 
       /// \brief The 'short _Accum' type
       PREDEF_TYPE_SHORT_ACCUM_ID    = 46,
 
       /// \brief The '_Accum' type
       PREDEF_TYPE_ACCUM_ID      = 47,
 
       /// \brief The 'long _Accum' type
       PREDEF_TYPE_LONG_ACCUM_ID = 48,
 
       /// \brief The 'unsigned short _Accum' type
       PREDEF_TYPE_USHORT_ACCUM_ID   = 49,
 
       /// \brief The 'unsigned _Accum' type
       PREDEF_TYPE_UACCUM_ID     = 50,
 
       /// \brief The 'unsigned long _Accum' type
       PREDEF_TYPE_ULONG_ACCUM_ID    = 51,
 
       /// \brief The 'short _Fract' type
       PREDEF_TYPE_SHORT_FRACT_ID = 52,
 
       /// \brief The '_Fract' type
       PREDEF_TYPE_FRACT_ID = 53,
 
       /// \brief The 'long _Fract' type

       PREDEF_TYPE_OMP_ITERATOR = 71,
 
       /// A placeholder type for incomplete matrix index operations.
       PREDEF_TYPE_INCOMPLETE_MATRIX_IDX = 72,
 
       /// \brief The '__bf16' type
       PREDEF_TYPE_BFLOAT16_ID = 73,
 
+      /// \brief The '__ibm128' type
+      PREDEF_TYPE_IBM128_ID = 74,
+
       /// OpenCL image types with auto numeration
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
       PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/OpenCLImageTypes.def"
       /// \brief OpenCL extension types with auto numeration
 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
       PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/OpenCLExtensionTypes.def"
       // \brief SVE types with auto numeration

clang/lib/AST/ASTContext.cpp

 #include <memory>
 #include <string>
 #include <tuple>
 #include <utility>
 
 using namespace clang;
 
 enum FloatingRank {
-  BFloat16Rank, Float16Rank, HalfRank, FloatRank, DoubleRank, LongDoubleRank, Float128Rank
+  BFloat16Rank, Float16Rank, HalfRank, FloatRank, DoubleRank, LongDoubleRank,
+  Float128Rank, Ibm128Rank
 };
 
 /// \returns location that is relevant when searching for Doc comments related
 /// to \p D.
 static SourceLocation getDeclLocForCommentSearch(const Decl *D,
                                                  SourceManager &SourceMgr) {
   assert(D);
 

   // C99 6.2.5p10.
   InitBuiltinType(FloatTy,             BuiltinType::Float);
   InitBuiltinType(DoubleTy,            BuiltinType::Double);
   InitBuiltinType(LongDoubleTy,        BuiltinType::LongDouble);
 
   // GNU extension, __float128 for IEEE quadruple precision
   InitBuiltinType(Float128Ty,          BuiltinType::Float128);
 
+  // __ibm128 for IBM extended precision
+  InitBuiltinType(Ibm128Ty, BuiltinType::Ibm128);
+
   // C11 extension ISO/IEC TS 18661-3
   InitBuiltinType(Float16Ty,           BuiltinType::Float16);
 
   // ISO/IEC JTC1 SC22 WG14 N1169 Extension
   InitBuiltinType(ShortAccumTy,            BuiltinType::ShortAccum);
   InitBuiltinType(AccumTy,                 BuiltinType::Accum);
   InitBuiltinType(LongAccumTy,             BuiltinType::LongAccum);
   InitBuiltinType(UnsignedShortAccumTy,    BuiltinType::UShortAccum);

     llvm_unreachable("Not a floating point type!");
   case BuiltinType::BFloat16:
     return Target->getBFloat16Format();
   case BuiltinType::Float16:
   case BuiltinType::Half:
     return Target->getHalfFormat();
   case BuiltinType::Float:      return Target->getFloatFormat();
   case BuiltinType::Double:     return Target->getDoubleFormat();
+  case BuiltinType::Ibm128:     return Target->getIbm128Format();
   case BuiltinType::LongDouble:
     if (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice)
       return AuxTarget->getLongDoubleFormat();
     return Target->getLongDoubleFormat();
   case BuiltinType::Float128:
     if (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice)
       return AuxTarget->getFloat128Format();
     return Target->getFloat128Format();

     case BuiltinType::Float:
       Width = Target->getFloatWidth();
       Align = Target->getFloatAlign();
       break;
     case BuiltinType::Double:
       Width = Target->getDoubleWidth();
       Align = Target->getDoubleAlign();
       break;
+    case BuiltinType::Ibm128:
+      Width = Target->getIbm128Width();
+      Align = Target->getIbm128Align();
+      break;
     case BuiltinType::LongDouble:
       if (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice &&
           (Target->getLongDoubleWidth() != AuxTarget->getLongDoubleWidth() ||
            Target->getLongDoubleAlign() != AuxTarget->getLongDoubleAlign())) {
         Width = AuxTarget->getLongDoubleWidth();
         Align = AuxTarget->getLongDoubleAlign();
       } else {
         Width = Target->getLongDoubleWidth();

     const ArrayType *array = split.Ty->getAsArrayTypeUnsafe();
     if (!array) break;
 
     type = array->getElementType();
     qs.addConsistentQualifiers(split.Quals);
   }
 
   return getQualifiedType(type, qs);
 }
 
 /// getConstantArrayElementCount - Returns number of constant array elements.
 uint64_t
 ASTContext::getConstantArrayElementCount(const ConstantArrayType *CA)  const {
   uint64_t ElementCount = 1;
   do {
     ElementCount *= CA->getSize().getZExtValue();
     CA = dyn_cast_or_null<ConstantArrayType>(

     return getFloatingRank(CT->getElementType());
 
   switch (T->castAs<BuiltinType>()->getKind()) {
   default: llvm_unreachable("getFloatingRank(): not a floating type");
   case BuiltinType::Float16:    return Float16Rank;
   case BuiltinType::Half:       return HalfRank;
   case BuiltinType::Float:      return FloatRank;
   case BuiltinType::Double:     return DoubleRank;
   case BuiltinType::LongDouble: return LongDoubleRank;
   case BuiltinType::Float128:   return Float128Rank;
   case BuiltinType::BFloat16:   return BFloat16Rank;
+  case BuiltinType::Ibm128:     return Ibm128Rank;
   }
 }
 
 /// getFloatingTypeOfSizeWithinDomain - Returns a real floating
 /// point or a complex type (based on typeDomain/typeSize).
 /// 'typeDomain' is a real floating point or complex type.
 /// 'typeSize' is a real floating point or complex type.
 QualType ASTContext::getFloatingTypeOfSizeWithinDomain(QualType Size,
                                                        QualType Domain) const {
   FloatingRank EltRank = getFloatingRank(Size);
   if (Domain->isComplexType()) {
     switch (EltRank) {
     case BFloat16Rank: llvm_unreachable("Complex bfloat16 is not supported");
     case Float16Rank:
     case HalfRank: llvm_unreachable("Complex half is not supported");
+    case Ibm128Rank: llvm_unreachable("Complex __ibm128 is not supported");
     case FloatRank:      return FloatComplexTy;
     case DoubleRank:     return DoubleComplexTy;
     case LongDoubleRank: return LongDoubleComplexTy;
     case Float128Rank:   return Float128ComplexTy;
     }
   }
 
   assert(Domain->isRealFloatingType() && "Unknown domain!");
   switch (EltRank) {
   case Float16Rank:    return HalfTy;
   case BFloat16Rank:   return BFloat16Ty;
   case HalfRank:       return HalfTy;
   case FloatRank:      return FloatTy;
   case DoubleRank:     return DoubleTy;
   case LongDoubleRank: return LongDoubleTy;
   case Float128Rank:   return Float128Ty;
+  case Ibm128Rank:     return Ibm128Ty;
   }
   llvm_unreachable("getFloatingRank(): illegal value for rank");
 }
 
+/// areUnorderedFloatingTypes - Compare if the two floating point types are in
+/// special cases so that they are 'unordered' and not convertable. (such as
+/// __float128 and __ibm128)
+bool ASTContext::areUnorderedFloatingTypes(QualType LHS, QualType RHS) const {
+  auto *LHSComplex = LHS->getAs<ComplexType>();
+  auto *RHSComplex = RHS->getAs<ComplexType>();
+
+  QualType LHSElem = LHSComplex ? LHSComplex->getElementType() : LHS;
+  QualType RHSElem = RHSComplex ? RHSComplex->getElementType() : RHS;
+
+  const llvm::fltSemantics &LHSSem = getFloatTypeSemantics(LHSElem);
+  const llvm::fltSemantics &RHSSem = getFloatTypeSemantics(RHSElem);
+
+  if ((&LHSSem == &llvm::APFloat::PPCDoubleDouble() &&
+      &RHSSem == &llvm::APFloat::IEEEquad()) ||
+      (&LHSSem == &llvm::APFloat::IEEEquad() &&
+      &RHSSem == &llvm::APFloat::PPCDoubleDouble()))
+    return true;
+
+  return false;
+}
+
 /// getFloatingTypeOrder - Compare the rank of the two specified floating
 /// point types, ignoring the domain of the type (i.e. 'double' ==
 /// '_Complex double').  If LHS > RHS, return 1.  If LHS == RHS, return 0. If
 /// LHS < RHS, return -1.
 int ASTContext::getFloatingTypeOrder(QualType LHS, QualType RHS) const {
+  assert(!areUnorderedFloatingTypes(LHS, RHS) &&
+         "No rank between unordered floating types!");
+
   FloatingRank LHSR = getFloatingRank(LHS);
   FloatingRank RHSR = getFloatingRank(RHS);
 
   if (LHSR == RHSR)
     return 0;
   if (LHSR > RHSR)
     return 1;
   return -1;

     case BuiltinType::Float:      return 'f';
     case BuiltinType::Double:     return 'd';
     case BuiltinType::LongDouble: return 'D';
     case BuiltinType::NullPtr:    return '*'; // like char*
 
     case BuiltinType::BFloat16:
     case BuiltinType::Float16:
     case BuiltinType::Float128:
+    case BuiltinType::Ibm128:
     case BuiltinType::Half:
     case BuiltinType::ShortAccum:
     case BuiltinType::Accum:
     case BuiltinType::LongAccum:
     case BuiltinType::UShortAccum:
     case BuiltinType::UAccum:
     case BuiltinType::ULongAccum:
     case BuiltinType::ShortFract:

   case TargetInfo::Float:
     return FloatTy;
   case TargetInfo::Double:
     return DoubleTy;
   case TargetInfo::LongDouble:
     return LongDoubleTy;
   case TargetInfo::Float128:
     return Float128Ty;
+  case TargetInfo::Ibm128:
+    return Ibm128Ty;
   case TargetInfo::NoFloat:
     return {};
   }
 
   llvm_unreachable("Unhandled TargetInfo::RealType value");
 }
 
 void ASTContext::setManglingNumber(const NamedDecl *ND, unsigned Number) {

clang/lib/AST/ItaniumMangle.cpp

 
     // Note that we don't update T: we want to add the
     // substitution at the original type.
   }
 
   if (quals || ty->isDependentAddressSpaceType()) {
     if (const DependentAddressSpaceType *DAST =
         dyn_cast<DependentAddressSpaceType>(ty)) {
       SplitQualType splitDAST = DAST->getPointeeType().split();
       mangleQualifiers(splitDAST.Quals, DAST);
       mangleType(QualType(splitDAST.Ty, 0));
     } else {
       mangleQualifiers(quals);
 
       // Recurse:  even if the qualified type isn't yet substitutable,
       // the unqualified type might be.
       mangleType(QualType(ty, 0));

   //                 ::= x  # long long, __int64
   //                 ::= y  # unsigned long long, __int64
   //                 ::= n  # __int128
   //                 ::= o  # unsigned __int128
   //                 ::= f  # float
   //                 ::= d  # double
   //                 ::= e  # long double, __float80
   //                 ::= g  # __float128
+  //                 ::= g  # __ibm128
   // UNSUPPORTED:    ::= Dd # IEEE 754r decimal floating point (64 bits)
   // UNSUPPORTED:    ::= De # IEEE 754r decimal floating point (128 bits)
   // UNSUPPORTED:    ::= Df # IEEE 754r decimal floating point (32 bits)
   //                 ::= Dh # IEEE 754r half-precision floating point (16 bits)
   //                 ::= DF <number> _ # ISO/IEC TS 18661 binary floating point type _FloatN (N bits);
   //                 ::= Di # char32_t
   //                 ::= Ds # char16_t
   //                 ::= Dn # std::nullptr_t (i.e., decltype(nullptr))
   //                 ::= u <source-name>    # vendor extended type
   std::string type_name;
   switch (T->getKind()) {
   case BuiltinType::Void:
     Out << 'v';

     Out << TI->getFloat128Mangling();
     break;
   }
   case BuiltinType::BFloat16: {
     const TargetInfo *TI = &getASTContext().getTargetInfo();
     Out << TI->getBFloat16Mangling();
     break;
   }
+  case BuiltinType::Ibm128: {
+    const TargetInfo *TI = &getASTContext().getTargetInfo();
+    Out << TI->getIbm128Mangling();
+    break;
+  }
   case BuiltinType::NullPtr:
     Out << "Dn";
     break;
 
 #define BUILTIN_TYPE(Id, SingletonId)
 #define PLACEHOLDER_TYPE(Id, SingletonId) \
   case BuiltinType::Id:
 #include "clang/AST/BuiltinTypes.def"

clang/lib/AST/MicrosoftMangle.cpp

   case BuiltinType::SatULongAccum:
   case BuiltinType::SatShortFract:
   case BuiltinType::SatFract:
   case BuiltinType::SatLongFract:
   case BuiltinType::SatUShortFract:
   case BuiltinType::SatUFract:
   case BuiltinType::SatULongFract:
   case BuiltinType::BFloat16:
+  case BuiltinType::Ibm128:
   case BuiltinType::Float128: {
     DiagnosticsEngine &Diags = Context.getDiags();
     unsigned DiagID = Diags.getCustomDiagID(
         DiagnosticsEngine::Error, "cannot mangle this built-in %0 type yet");
     Diags.Report(Range.getBegin(), DiagID)
         << T->getName(Context.getASTContext().getPrintingPolicy()) << Range;
     break;
   }

clang/lib/AST/NSAPI.cpp

   case BuiltinType::SatFract:
   case BuiltinType::SatLongFract:
   case BuiltinType::SatUShortFract:
   case BuiltinType::SatUFract:
   case BuiltinType::SatULongFract:
   case BuiltinType::UInt128:
   case BuiltinType::Float16:
   case BuiltinType::Float128:
+  case BuiltinType::Ibm128:
   case BuiltinType::NullPtr:
   case BuiltinType::ObjCClass:
   case BuiltinType::ObjCId:
   case BuiltinType::ObjCSel:
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
   case BuiltinType::Id:
 #include "clang/Basic/OpenCLImageTypes.def"
 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \

clang/lib/AST/PrintfFormatString.cpp

   case BuiltinType::Char16:
   case BuiltinType::Char32:
   case BuiltinType::UInt128:
   case BuiltinType::Int128:
   case BuiltinType::Half:
   case BuiltinType::BFloat16:
   case BuiltinType::Float16:
   case BuiltinType::Float128:
+  case BuiltinType::Ibm128:
   case BuiltinType::ShortAccum:
   case BuiltinType::Accum:
   case BuiltinType::LongAccum:
   case BuiltinType::UShortAccum:
   case BuiltinType::UAccum:
   case BuiltinType::ULongAccum:
   case BuiltinType::ShortFract:
   case BuiltinType::Fract:

clang/lib/AST/StmtPrinter.cpp

 
   if (!PrintSuffix)
     return;
 
   // Emit suffixes.  Float literals are always a builtin float type.
   switch (Node->getType()->castAs<BuiltinType>()->getKind()) {
   default: llvm_unreachable("Unexpected type for float literal!");
   case BuiltinType::Half:       break; // FIXME: suffix?
+  case BuiltinType::Ibm128:     break; // FIXME: No suffix for ibm128 literal
   case BuiltinType::Double:     break; // no suffix.
   case BuiltinType::Float16:    OS << "F16"; break;
   case BuiltinType::Float:      OS << 'F'; break;
   case BuiltinType::LongDouble: OS << 'L'; break;
   case BuiltinType::Float128:   OS << 'Q'; break;
   }
 }
 

clang/lib/AST/Type.cpp

     return VT->getElementType()->isUnsignedIntegerOrEnumerationType();
   else
     return isUnsignedIntegerOrEnumerationType();
 }
 
 bool Type::isFloatingType() const {
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() >= BuiltinType::Half &&
-           BT->getKind() <= BuiltinType::Float128;
+           BT->getKind() <= BuiltinType::Ibm128;
   if (const auto *CT = dyn_cast<ComplexType>(CanonicalType))
     return CT->getElementType()->isFloatingType();
   return false;
 }
 
 bool Type::hasFloatingRepresentation() const {
   if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
     return VT->getElementType()->isFloatingType();
   else
     return isFloatingType();
 }
 
 bool Type::isRealFloatingType() const {
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->isFloatingPoint();
   return false;
 }
 
 bool Type::isRealType() const {
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() >= BuiltinType::Bool &&
-           BT->getKind() <= BuiltinType::Float128;
+           BT->getKind() <= BuiltinType::Ibm128;
   if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
       return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
   return isExtIntType();
 }
 
 bool Type::isArithmeticType() const {
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() >= BuiltinType::Bool &&
-           BT->getKind() <= BuiltinType::Float128 &&
+           BT->getKind() <= BuiltinType::Ibm128 &&
            BT->getKind() != BuiltinType::BFloat16;
   if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
     // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2).
     // If a body isn't seen by the time we get here, return false.
     //
     // C++0x: Enumerations are not arithmetic types. For now, just return
     // false for scoped enumerations since that will disable any
     // unwanted implicit conversions.

   case BuiltinType::SatUFract:
     return "_Sat unsigned _Fract";
   case BuiltinType::SatULongFract:
     return "_Sat unsigned long _Fract";
   case Float16:
     return "_Float16";
   case Float128:
     return "__float128";
+  case Ibm128:
+    return "__ibm128";
   case WChar_S:
   case WChar_U:
     return Policy.MSWChar ? "__wchar_t" : "wchar_t";
   case Char8:
     return "char8_t";
   case Char16:
     return "char16_t";
   case Char32:

clang/lib/AST/TypeLoc.cpp

   case BuiltinType::LongLong:
   case BuiltinType::Int128:
   case BuiltinType::Half:
   case BuiltinType::Float:
   case BuiltinType::Double:
   case BuiltinType::LongDouble:
   case BuiltinType::Float16:
   case BuiltinType::Float128:
+  case BuiltinType::Ibm128:
   case BuiltinType::ShortAccum:
   case BuiltinType::Accum:
   case BuiltinType::LongAccum:
   case BuiltinType::UShortAccum:
   case BuiltinType::UAccum:
   case BuiltinType::ULongAccum:
   case BuiltinType::ShortFract:
   case BuiltinType::Fract:

clang/lib/Basic/TargetInfo.cpp

TargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), Triple(T) {
   // Set defaults.  Defaults are set for a 32-bit RISC platform, like PPC or
   // SPARC.  These should be overridden by concrete targets as needed.
   BigEndian = !T.isLittleEndian();
   TLSSupported = true;
   VLASupported = true;
   NoAsmVariants = false;
   HasLegalHalfType = false;
   HasFloat128 = false;
+  HasIbm128 = false;
   HasFloat16 = false;
   HasBFloat16 = false;
   HasStrictFP = false;
   PointerWidth = PointerAlign = 32;
   BoolWidth = BoolAlign = 8;
   IntWidth = IntAlign = 32;
   LongWidth = LongAlign = 32;
   LongLongWidth = LongLongAlign = 64;
TargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), Triple(T) {
   HalfAlign = 16;
   FloatWidth = 32;
   FloatAlign = 32;
   DoubleWidth = 64;
   DoubleAlign = 64;
   LongDoubleWidth = 64;
   LongDoubleAlign = 64;
   Float128Align = 128;
+  Ibm128Align = 128;
   LargeArrayMinWidth = 0;
   LargeArrayAlign = 0;
   MaxAtomicPromoteWidth = MaxAtomicInlineWidth = 0;
   MaxVectorAlign = 0;
   MaxTLSAlign = 0;
   SimdDefaultAlign = 0;
   SizeType = UnsignedLong;
   PtrDiffType = SignedLong;
TargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), Triple(T) {
   UseZeroLengthBitfieldAlignment = false;
   UseExplicitBitFieldAlignment = true;
   ZeroLengthBitfieldBoundary = 0;
   HalfFormat = &llvm::APFloat::IEEEhalf();
   FloatFormat = &llvm::APFloat::IEEEsingle();
   DoubleFormat = &llvm::APFloat::IEEEdouble();
   LongDoubleFormat = &llvm::APFloat::IEEEdouble();
   Float128Format = &llvm::APFloat::IEEEquad();
+  Ibm128Format = &llvm::APFloat::PPCDoubleDouble();
   MCountName = "mcount";
   RegParmMax = 0;
   SSERegParmMax = 0;
   HasAlignMac68kSupport = false;
   HasBuiltinMSVaList = false;
   IsRenderScriptTarget = false;
   HasAArch64SVETypes = false;
   HasRISCVVTypes = false;

clang/lib/Basic/Targets/PPC.h

 public:
   PPCTargetInfo(const llvm::Triple &Triple, const TargetOptions &)
       : TargetInfo(Triple) {
     SuitableAlign = 128;
     SimdDefaultAlign = 128;
     LongDoubleWidth = LongDoubleAlign = 128;
     LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble();
     HasStrictFP = true;
+    HasIbm128 = true;
   }
 
   // Set the language option for altivec based on our value.
   void adjust(LangOptions &Opts) override;
 
   // Note: GCC recognizes the following additional cpus:
   //  401, 403, 405, 405fp, 440fp, 464, 464fp, 476, 476fp, 505, 740, 801,
   //  821, 823, 8540, e300c2, e300c3, e500mc64, e6500, 860, cell, titan, rs64.

   const char *getLongDoubleMangling() const override {
     if (LongDoubleWidth == 64)
       return "e";
     return LongDoubleFormat == &llvm::APFloat::PPCDoubleDouble()
                ? "g"
                : "u9__ieee128";
   }
   const char *getFloat128Mangling() const override { return "u9__ieee128"; }
+  const char *getIbm128Mangling() const override { return "g"; }
 
   bool hasExtIntType() const override { return true; }
 
   bool isSPRegName(StringRef RegName) const override {
     return RegName.equals("r1") || RegName.equals("x1");
   }
 };
 

clang/lib/CodeGen/CGDebugInfo.cpp

            llvm::dwarf::DW_OP_div, llvm::dwarf::DW_OP_constu, LMUL});
       if (Fractional)
         Expr.push_back(llvm::dwarf::DW_OP_div);
       else
         Expr.push_back(llvm::dwarf::DW_OP_mul);
 
       auto *LowerBound =
           llvm::ConstantAsMetadata::get(llvm::ConstantInt::getSigned(
               llvm::Type::getInt64Ty(CGM.getLLVMContext()), 0));
       auto *UpperBound = DBuilder.createExpression(Expr);
       llvm::Metadata *Subscript = DBuilder.getOrCreateSubrange(
           /*count*/ nullptr, LowerBound, UpperBound, /*stride*/ nullptr);
       llvm::DINodeArray SubscriptArray = DBuilder.getOrCreateArray(Subscript);
       llvm::DIType *ElemTy =
           getOrCreateType(Info.ElementType, TheCU->getFile());
 
       auto Align = getTypeAlignIfRequired(BT, CGM.getContext());

     break;
   case BuiltinType::Half:
   case BuiltinType::Float:
   case BuiltinType::LongDouble:
   case BuiltinType::Float16:
   case BuiltinType::BFloat16:
   case BuiltinType::Float128:
   case BuiltinType::Double:
-    // FIXME: For targets where long double and __float128 have the same size,
-    // they are currently indistinguishable in the debugger without some
-    // special treatment. However, there is currently no consensus on encoding
-    // and this should be updated once a DWARF encoding exists for distinct
-    // floating point types of the same size.
+  case BuiltinType::Ibm128:
+    // FIXME: For targets where long double, __ibm128 and __float128 have the
+    // same size, they are currently indistinguishable in the debugger without
+    // some special treatment. However, there is currently no consensus on
+    // encoding and this should be updated once a DWARF encoding exists for
+    // distinct floating point types of the same size.
     Encoding = llvm::dwarf::DW_ATE_float;
     break;
   case BuiltinType::ShortAccum:
   case BuiltinType::Accum:
   case BuiltinType::LongAccum:
   case BuiltinType::ShortFract:
   case BuiltinType::Fract:
   case BuiltinType::LongFract:

clang/lib/CodeGen/CGExprScalar.cpp

 
     if (value->getType()->isFloatTy())
       amt = llvm::ConstantFP::get(VMContext,
                                   llvm::APFloat(static_cast<float>(amount)));
     else if (value->getType()->isDoubleTy())
       amt = llvm::ConstantFP::get(VMContext,
                                   llvm::APFloat(static_cast<double>(amount)));
     else {
-      // Remaining types are Half, LongDouble or __float128. Convert from float.
+      // Remaining types are Half, LongDouble, __ibm128 or __float128. Convert
+      // from float.
       llvm::APFloat F(static_cast<float>(amount));
       bool ignored;
       const llvm::fltSemantics *FS;
       // Don't use getFloatTypeSemantics because Half isn't
       // necessarily represented using the "half" LLVM type.
       if (value->getType()->isFP128Ty())
         FS = &CGF.getTarget().getFloat128Format();
       else if (value->getType()->isHalfTy())
         FS = &CGF.getTarget().getHalfFormat();
+      else if (value->getType()->isPPC_FP128Ty())
+        FS = &CGF.getTarget().getIbm128Format();
       else
         FS = &CGF.getTarget().getLongDoubleFormat();
       F.convert(*FS, llvm::APFloat::rmTowardZero, &ignored);
       amt = llvm::ConstantFP::get(VMContext, F);
     }
     value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec");
 
     if (type->isHalfType() && !CGF.getContext().getLangOpts().NativeHalfType) {

clang/lib/CodeGen/CodeGenTypes.cpp

           Context.getLangOpts().NativeHalfType ||
               !Context.getTargetInfo().useFP16ConversionIntrinsics());
       break;
     case BuiltinType::BFloat16:
     case BuiltinType::Float:
     case BuiltinType::Double:
     case BuiltinType::LongDouble:
     case BuiltinType::Float128:
+    case BuiltinType::Ibm128:
       ResultType = getTypeForFormat(getLLVMContext(),
                                     Context.getFloatTypeSemantics(T),
                                     /* UseNativeHalf = */ false);
       break;
 
     case BuiltinType::NullPtr:
       // Model std::nullptr_t as i8*
       ResultType = llvm::Type::getInt8PtrTy(getLLVMContext());

clang/lib/CodeGen/ItaniumCXXABI.cpp

     case BuiltinType::LongLong:
     case BuiltinType::ULongLong:
     case BuiltinType::Half:
     case BuiltinType::Float:
     case BuiltinType::Double:
     case BuiltinType::LongDouble:
     case BuiltinType::Float16:
     case BuiltinType::Float128:
+    case BuiltinType::Ibm128:
     case BuiltinType::Char8:
     case BuiltinType::Char16:
     case BuiltinType::Char32:
     case BuiltinType::Int128:
     case BuiltinType::UInt128:
       return true;
 
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \

clang/lib/CodeGen/TargetInfo.cpp

       return false;
   }
   return Members > 0 && isHomogeneousAggregateSmallEnough(Base, Members);
 }
 
 bool PPC64_SVR4_ABIInfo::isHomogeneousAggregateBaseType(QualType Ty) const {
   // Homogeneous aggregates for ELFv2 must have base types of float,
   // double, long double, or 128-bit vectors.
   if (const BuiltinType *BT = Ty->getAs<BuiltinType>()) {
     if (BT->getKind() == BuiltinType::Float ||
         BT->getKind() == BuiltinType::Double ||
         BT->getKind() == BuiltinType::LongDouble ||
+        BT->getKind() == BuiltinType::Ibm128 ||
         (getContext().getTargetInfo().hasFloat128Type() &&
           (BT->getKind() == BuiltinType::Float128))) {
       if (IsSoftFloatABI)
         return false;
       return true;
     }
   }
   if (const VectorType *VT = Ty->getAs<VectorType>()) {

clang/lib/Format/FormatToken.cpp

bool FormatToken::isSimpleTypeSpecifier() const {
   case tok::kw_char:
   case tok::kw_int:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
   case tok::kw___bf16:
   case tok::kw__Float16:
   case tok::kw___float128:
+  case tok::kw___ibm128:
   case tok::kw_wchar_t:
   case tok::kw_bool:
   case tok::kw___underlying_type:
   case tok::annot_typename:
   case tok::kw_char8_t:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
   case tok::kw_typeof:

clang/lib/Index/USRGeneration.cpp

           c = 'J'; break;
         case BuiltinType::Float16:
         case BuiltinType::Half:
           c = 'h'; break;
         case BuiltinType::Float:
           c = 'f'; break;
         case BuiltinType::Double:
           c = 'd'; break;
+        case BuiltinType::Ibm128: // FIXME: Need separate tag
         case BuiltinType::LongDouble:
           c = 'D'; break;
         case BuiltinType::Float128:
           c = 'Q'; break;
         case BuiltinType::NullPtr:
           c = 'n'; break;
 #define BUILTIN_TYPE(Id, SingletonId)
 #define PLACEHOLDER_TYPE(Id, SingletonId) case BuiltinType::Id:

clang/lib/Parse/ParseDecl.cpp

       } else {
         isInvalid = DS.SetTypeSpecSat(Loc, PrevSpec, DiagID);
       }
       break;
     case tok::kw___float128:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec,
                                      DiagID, Policy);
       break;
+    case tok::kw___ibm128:
+      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_ibm128, Loc, PrevSpec,
+                                     DiagID, Policy);
+      break;
     case tok::kw_wchar_t:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec,
                                      DiagID, Policy);
       break;
     case tok::kw_char8_t:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char8, Loc, PrevSpec,
                                      DiagID, Policy);
       break;

   case tok::kw___bf16:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
   case tok::kw__Accum:
   case tok::kw__Fract:
   case tok::kw__Float16:
   case tok::kw___float128:
+  case tok::kw___ibm128:
   case tok::kw_bool:
   case tok::kw__Bool:
   case tok::kw__Decimal32:
   case tok::kw__Decimal64:
   case tok::kw__Decimal128:
   case tok::kw___vector:
 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
 #include "clang/Basic/OpenCLImageTypes.def"

   case tok::kw_half:
   case tok::kw___bf16:
   case tok::kw_float:
   case tok::kw_double:
   case tok::kw__Accum:
   case tok::kw__Fract:
   case tok::kw__Float16:
   case tok::kw___float128:
+  case tok::kw___ibm128:
   case tok::kw_bool:
   case tok::kw__Bool:
   case tok::kw__Decimal32:
   case tok::kw__Decimal64:
   case tok::kw__Decimal128:
   case tok::kw___vector:
 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
 #include "clang/Basic/OpenCLImageTypes.def"

   case tok::kw_half:
   case tok::kw___bf16:
   case tok::kw_float:
   case tok::kw_double:
   case tok::kw__Accum:
   case tok::kw__Fract:
   case tok::kw__Float16:
   case tok::kw___float128:
+  case tok::kw___ibm128:
   case tok::kw_bool:
   case tok::kw__Bool:
   case tok::kw__Decimal32:
   case tok::kw__Decimal64:
   case tok::kw__Decimal128:
   case tok::kw___vector:
 
     // struct-or-union-specifier (C99) or class-specifier (C++)

clang/lib/Parse/ParseExpr.cpp

   case tok::kw_signed:
   case tok::kw_unsigned:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
   case tok::kw___bf16:
   case tok::kw__Float16:
   case tok::kw___float128:
+  case tok::kw___ibm128:
   case tok::kw_void:
   case tok::kw_typename:
   case tok::kw_typeof:
   case tok::kw___vector:
 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
 #include "clang/Basic/OpenCLImageTypes.def"
   {
     if (!getLangOpts().CPlusPlus) {

clang/lib/Parse/ParseExprCXX.cpp

     DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw__Float16:
     DS.SetTypeSpecType(DeclSpec::TST_float16, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw___float128:
     DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec, DiagID, Policy);
     break;
+  case tok::kw___ibm128:
+    DS.SetTypeSpecType(DeclSpec::TST_ibm128, Loc, PrevSpec, DiagID, Policy);
+    break;
   case tok::kw_wchar_t:
     DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw_char8_t:
     DS.SetTypeSpecType(DeclSpec::TST_char8, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw_char16_t:
     DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw_char32_t:

clang/lib/Parse/ParseTentative.cpp

   case tok::kw_signed:
   case tok::kw_unsigned:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
   case tok::kw___bf16:
   case tok::kw__Float16:
   case tok::kw___float128:
+  case tok::kw___ibm128:
   case tok::kw_void:
   case tok::annot_decltype:
 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
 #include "clang/Basic/OpenCLImageTypes.def"
     if (NextToken().is(tok::l_paren))
       return TPResult::Ambiguous;
 
     // This is a function-style cast in all cases we disambiguate other than

   case tok::kw_signed:
   case tok::kw_unsigned:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
   case tok::kw___bf16:
   case tok::kw__Float16:
   case tok::kw___float128:
+  case tok::kw___ibm128:
   case tok::kw_void:
   case tok::kw___unknown_anytype:
   case tok::kw___auto_type:
 #define GENERIC_IMAGE_TYPE(ImgType, Id) case tok::kw_##ImgType##_t:
 #include "clang/Basic/OpenCLImageTypes.def"
     return true;
 
   case tok::kw_auto:

clang/lib/Sema/DeclSpec.cpp

     case TST_decimal128:
     case TST_decimal32:
     case TST_decimal64:
     case TST_double:
     case TST_Accum:
     case TST_Fract:
     case TST_Float16:
     case TST_float128:
+    case TST_ibm128:
     case TST_enum:
     case TST_error:
     case TST_float:
     case TST_half:
     case TST_int:
     case TST_int128:
     case TST_extint:
     case TST_struct:

   case DeclSpec::TST_extint:      return "_ExtInt";
   case DeclSpec::TST_half:        return "half";
   case DeclSpec::TST_float:       return "float";
   case DeclSpec::TST_double:      return "double";
   case DeclSpec::TST_accum:       return "_Accum";
   case DeclSpec::TST_fract:       return "_Fract";
   case DeclSpec::TST_float16:     return "_Float16";
   case DeclSpec::TST_float128:    return "__float128";
+  case DeclSpec::TST_ibm128:      return "__ibm128";
   case DeclSpec::TST_bool:        return Policy.Bool ? "bool" : "_Bool";
   case DeclSpec::TST_decimal32:   return "_Decimal32";
   case DeclSpec::TST_decimal64:   return "_Decimal64";
   case DeclSpec::TST_decimal128:  return "_Decimal128";
   case DeclSpec::TST_enum:        return "enum";
   case DeclSpec::TST_class:       return "class";
   case DeclSpec::TST_union:       return "union";
   case DeclSpec::TST_struct:      return "struct";

clang/lib/Sema/Sema.cpp

       if (!Context.getTargetInfo().hasExtIntType()) {
         targetDiag(Loc, diag::err_device_unsupported_type, FD)
             << D << false /*show bit size*/ << 0 /*bitsize*/
             << Ty << Context.getTargetInfo().getTriple().str();
       }
       return;
     }
 
+    bool LongDoubleMismatched = false;
+    if (Ty->isRealFloatingType() && Context.getTypeSize(Ty) == 128) {
+      const llvm::fltSemantics &Sem = Context.getFloatTypeSemantics(Ty);
+      if (!Ty->isIbm128Type() && !Ty->isFloat128Type() &&
+          &Sem != &Context.getTargetInfo().getLongDoubleFormat())
+        LongDoubleMismatched = true;
+    }
+
     if ((Ty->isFloat16Type() && !Context.getTargetInfo().hasFloat16Type()) ||
-        ((Ty->isFloat128Type() ||
-          (Ty->isRealFloatingType() && Context.getTypeSize(Ty) == 128)) &&
-         !Context.getTargetInfo().hasFloat128Type()) ||
+        (Ty->isFloat128Type() && !Context.getTargetInfo().hasFloat128Type()) ||
+        (Ty->isIbm128Type() && !Context.getTargetInfo().hasIbm128Type()) ||
         (Ty->isIntegerType() && Context.getTypeSize(Ty) == 128 &&
-         !Context.getTargetInfo().hasInt128Type())) {
+         !Context.getTargetInfo().hasInt128Type()) || LongDoubleMismatched) {
       if (targetDiag(Loc, diag::err_device_unsupported_type, FD)
           << D << true /*show bit size*/
           << static_cast<unsigned>(Context.getTypeSize(Ty)) << Ty
           << Context.getTargetInfo().getTriple().str())
         D->setInvalidDecl();
       targetDiag(D->getLocation(), diag::note_defined_here, FD) << D;
     }
   };
 
   QualType Ty = D->getType();
   CheckType(Ty);
 
   if (const auto *FPTy = dyn_cast<FunctionProtoType>(Ty)) {
     for (const auto &ParamTy : FPTy->param_types())
       CheckType(ParamTy);
     CheckType(FPTy->getReturnType());
   }
   if (const auto *FNPTy = dyn_cast<FunctionNoProtoType>(Ty))
     CheckType(FNPTy->getReturnType());
 }

clang/lib/Sema/SemaDecl.cpp

   case tok::kw_char:
   case tok::kw_int:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
   case tok::kw___bf16:
   case tok::kw__Float16:
   case tok::kw___float128:
+  case tok::kw___ibm128:
   case tok::kw_wchar_t:
   case tok::kw_bool:
   case tok::kw___underlying_type:
   case tok::kw___auto_type:
     return true;
 
   case tok::annot_typename:
   case tok::kw_char16_t:

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 and long double if
-/// there is no support for such conversion. Helper function of
-/// UsualArithmeticConversions().
+/// 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 converting if at least one of the types is not a floating point
-      type or the two types have the same rank.
-  */
-  if (!LHSType->isFloatingType() || !RHSType->isFloatingType() ||
-      S.Context.getFloatingTypeOrder(LHSType, RHSType) == 0)
+  // No issue if either is not a floating point type.
+  if (!LHSType->isFloatingType() || !RHSType->isFloatingType())
     return false;
 
-  assert(LHSType->isFloatingType() && RHSType->isFloatingType() &&
-         "The remaining types must be floating point types.");
-
-  auto *LHSComplex = LHSType->getAs<ComplexType>();
-  auto *RHSComplex = RHSType->getAs<ComplexType>();
-
-  QualType LHSElemType = LHSComplex ?
-    LHSComplex->getElementType() : LHSType;
-  QualType RHSElemType = RHSComplex ?
-    RHSComplex->getElementType() : RHSType;
-
-  // No issue if the two types have the same representation
-  if (&S.Context.getFloatTypeSemantics(LHSElemType) ==
-      &S.Context.getFloatTypeSemantics(RHSElemType))
+  // No issue if the types are ordered.
+  if (!S.Context.areUnorderedFloatingTypes(LHSType, RHSType))
     return false;
 
-  bool Float128AndLongDouble = (LHSElemType == S.Context.Float128Ty &&
-                                RHSElemType == S.Context.LongDoubleTy);
-  Float128AndLongDouble |= (LHSElemType == S.Context.LongDoubleTy &&
-                            RHSElemType == S.Context.Float128Ty);
-
-  // We've handled the situation where __float128 and long double have the same
-  // representation. We allow all conversions for all possible long double types
-  // except PPC's double double.
-  return Float128AndLongDouble &&
-    (&S.Context.getFloatTypeSemantics(S.Context.LongDoubleTy) ==
-     &llvm::APFloat::PPCDoubleDouble());
+  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) {

 template <PerformCastFn doLHSCast, PerformCastFn doRHSCast>
 static QualType handleIntegerConversion(Sema &S, ExprResult &LHS,
                                         ExprResult &RHS, QualType LHSType,
                                         QualType RHSType, bool IsCompAssign) {
   // The rules for this case are in C99 6.3.1.8
   int order = S.Context.getIntegerTypeOrder(LHSType, RHSType);
   bool LHSSigned = LHSType->hasSignedIntegerRepresentation();
   bool RHSSigned = RHSType->hasSignedIntegerRepresentation();
   if (LHSSigned == RHSSigned) {
     // Same signedness; use the higher-ranked type
     if (order >= 0) {
       RHS = (*doRHSCast)(S, RHS.get(), LHSType);
       return LHSType;
     } else if (!IsCompAssign)
       LHS = (*doLHSCast)(S, LHS.get(), RHSType);
     return RHSType;
   } else if (order != (LHSSigned ? 1 : -1)) {

 
   // ExtInt types aren't subject to conversions between them or normal integers,
   // so this fails.
   if(LHSType->isExtIntType() || RHSType->isExtIntType())
     return QualType();
 
   // At this point, we have two different arithmetic types.
 
-  // Diagnose attempts to convert between __float128 and long double where
-  // such conversions currently can't be handled.
+  // 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);
 

   if (LHSType->isFixedPointType() || RHSType->isFixedPointType())
     return handleFixedPointConversion(*this, LHSType, RHSType);
 
   // Finally, we have two differing integer types.
   return handleIntegerConversion<doIntegralCast, doIntegralCast>
            (*this, LHS, RHS, LHSType, RHSType, ACK == ACK_CompAssign);
 }
 
 //===----------------------------------------------------------------------===//
 //  Semantic Analysis for various Expression Types
 //===----------------------------------------------------------------------===//
 
 
 ExprResult
 Sema::ActOnGenericSelectionExpr(SourceLocation KeyLoc,
                                 SourceLocation DefaultLoc,
                                 SourceLocation RParenLoc,
                                 Expr *ControllingExpr,

   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 __float128 and long double where
-  // such conversions currently can't be handled.
+  // 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

           Context.areLaxCompatibleSveTypes(LHSType, RHSType)) {
         Kind = CK_BitCast;
         return Compatible;
       }
 
     return Incompatible;
   }
 
-  // Diagnose attempts to convert between __float128 and long double where
-  // such conversions currently can't be handled.
+  // 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;

clang/lib/Sema/SemaOverload.cpp

     SCS.Second = ICK_Complex_Conversion;
     FromType = ToType.getUnqualifiedType();
   } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
              (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
     // Complex-real conversions (C99 6.3.1.7)
     SCS.Second = ICK_Complex_Real;
     FromType = ToType.getUnqualifiedType();
   } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
-    // FIXME: disable conversions between long double and __float128 if
-    // their representation is different until there is back end support
+    // FIXME: disable conversions between long double, __ibm128 and __float128
+    // if their representation is different until there is back end support
     // We of course allow this conversion if long double is really double.
 
     // Conversions between bfloat and other floats are not permitted.
     if (FromType == S.Context.BFloat16Ty || ToType == S.Context.BFloat16Ty)
       return false;
-    if (&S.Context.getFloatTypeSemantics(FromType) !=
-        &S.Context.getFloatTypeSemantics(ToType)) {
-      bool Float128AndLongDouble = ((FromType == S.Context.Float128Ty &&
-                                    ToType == S.Context.LongDoubleTy) ||
-                                   (FromType == S.Context.LongDoubleTy &&
-                                    ToType == S.Context.Float128Ty));
-      if (Float128AndLongDouble &&
-          (&S.Context.getFloatTypeSemantics(S.Context.LongDoubleTy) ==
-           &llvm::APFloat::PPCDoubleDouble()))
-        return false;
-    }
+
+    // Conversions between IEEE-quad and IBM-extended semantics are not
+    // permitted.
+    const llvm::fltSemantics &FromSem =
+        S.Context.getFloatTypeSemantics(FromType);
+    const llvm::fltSemantics &ToSem = S.Context.getFloatTypeSemantics(ToType);
+    if ((&FromSem == &llvm::APFloat::PPCDoubleDouble() &&
+         &ToSem == &llvm::APFloat::IEEEquad()) ||
+        (&FromSem == &llvm::APFloat::IEEEquad() &&
+         &ToSem == &llvm::APFloat::PPCDoubleDouble()))
+      return false;
+
     // Floating point conversions (C++ 4.8).
     SCS.Second = ICK_Floating_Conversion;
     FromType = ToType.getUnqualifiedType();
   } else if ((FromType->isRealFloatingType() &&
               ToType->isIntegralType(S.Context)) ||
              (FromType->isIntegralOrUnscopedEnumerationType() &&
               ToType->isRealFloatingType())) {
     // Conversions between bfloat and int are not permitted.

 
       // C99 6.3.1.5p1:
       //   When a float is promoted to double or long double, or a
       //   double is promoted to long double [...].
       if (!getLangOpts().CPlusPlus &&
           (FromBuiltin->getKind() == BuiltinType::Float ||
            FromBuiltin->getKind() == BuiltinType::Double) &&
           (ToBuiltin->getKind() == BuiltinType::LongDouble ||
-           ToBuiltin->getKind() == BuiltinType::Float128))
+           ToBuiltin->getKind() == BuiltinType::Float128 ||
+           ToBuiltin->getKind() == BuiltinType::Ibm128))
         return true;
 
       // Half can be promoted to float.
       if (!getLangOpts().NativeHalfType &&
            FromBuiltin->getKind() == BuiltinType::Half &&
           ToBuiltin->getKind() == BuiltinType::Float)
         return true;
     }

   void InitArithmeticTypes() {
     // Start of promoted types.
     FirstPromotedArithmeticType = 0;
     ArithmeticTypes.push_back(S.Context.FloatTy);
     ArithmeticTypes.push_back(S.Context.DoubleTy);
     ArithmeticTypes.push_back(S.Context.LongDoubleTy);
     if (S.Context.getTargetInfo().hasFloat128Type())
       ArithmeticTypes.push_back(S.Context.Float128Ty);
+    if (S.Context.getTargetInfo().hasIbm128Type())
+      ArithmeticTypes.push_back(S.Context.Ibm128Ty);
 
     // Start of integral types.
     FirstIntegralType = ArithmeticTypes.size();
     FirstPromotedIntegralType = ArithmeticTypes.size();
     ArithmeticTypes.push_back(S.Context.IntTy);
     ArithmeticTypes.push_back(S.Context.LongTy);
     ArithmeticTypes.push_back(S.Context.LongLongTy);
     if (S.Context.getTargetInfo().hasInt128Type() ||

clang/lib/Sema/SemaTemplateVariadic.cpp

   case TST_int128:
   case TST_half:
   case TST_float:
   case TST_double:
   case TST_Accum:
   case TST_Fract:
   case TST_Float16:
   case TST_float128:
+  case TST_ibm128:
   case TST_bool:
   case TST_decimal32:
   case TST_decimal64:
   case TST_decimal128:
   case TST_enum:
   case TST_union:
   case TST_struct:
   case TST_interface:

clang/lib/Sema/SemaType.cpp

   case DeclSpec::TST_float128:
     if (!S.Context.getTargetInfo().hasFloat128Type() &&
         !S.getLangOpts().SYCLIsDevice &&
         !(S.getLangOpts().OpenMP && S.getLangOpts().OpenMPIsDevice))
       S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
         << "__float128";
     Result = Context.Float128Ty;
     break;
+  case DeclSpec::TST_ibm128:
+    if (!S.Context.getTargetInfo().hasIbm128Type() &&
+        !S.getLangOpts().SYCLIsDevice &&
+        !(S.getLangOpts().OpenMP && S.getLangOpts().OpenMPIsDevice))
+      S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported) << "__ibm128";
+    Result = Context.Ibm128Ty;
+    break;
   case DeclSpec::TST_bool:
     Result = Context.BoolTy; // _Bool or bool
     break;
   case DeclSpec::TST_decimal32:    // _Decimal32
   case DeclSpec::TST_decimal64:    // _Decimal64
   case DeclSpec::TST_decimal128:   // _Decimal128
     S.Diag(DS.getTypeSpecTypeLoc(), diag::err_decimal_unsupported);
     Result = Context.IntTy;

clang/lib/Serialization/ASTCommon.cpp

     ID = PREDEF_TYPE_SAT_ULONG_FRACT_ID;
     break;
   case BuiltinType::Float16:
     ID = PREDEF_TYPE_FLOAT16_ID;
     break;
   case BuiltinType::Float128:
     ID = PREDEF_TYPE_FLOAT128_ID;
     break;
+  case BuiltinType::Ibm128:
+    ID = PREDEF_TYPE_IBM128_ID;
+    break;
   case BuiltinType::NullPtr:
     ID = PREDEF_TYPE_NULLPTR_ID;
     break;
   case BuiltinType::Char8:
     ID = PREDEF_TYPE_CHAR8_ID;
     break;
   case BuiltinType::Char16:
     ID = PREDEF_TYPE_CHAR16_ID;

clang/lib/Serialization/ASTReader.cpp

       T = Context.SatUnsignedLongFractTy;
       break;
     case PREDEF_TYPE_FLOAT16_ID:
       T = Context.Float16Ty;
       break;
     case PREDEF_TYPE_FLOAT128_ID:
       T = Context.Float128Ty;
       break;
+    case PREDEF_TYPE_IBM128_ID:
+      T = Context.Ibm128Ty;
+      break;
     case PREDEF_TYPE_OVERLOAD_ID:
       T = Context.OverloadTy;
       break;
     case PREDEF_TYPE_BOUND_MEMBER:
       T = Context.BoundMemberTy;
       break;
     case PREDEF_TYPE_PSEUDO_OBJECT:
       T = Context.PseudoObjectTy;

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'}}
+
+__ibm128 gf;
+
+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')}}
+}
+#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'}}
+
+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')}}
+}
+#endif

clang/test/CodeGen/ibm128-unsupported.c

+// RUN: %clang_cc1 -triple powerpc64le -emit-llvm-bc -fopenmp %s \
+// RUN:   -fopenmp-targets=powerpc64le,x86_64 -o %t-ppc-host.bc
+// RUN: %clang_cc1 -verify -triple x86_64 -aux-triple powerpc64le -fopenmp \
+// RUN:   -fopenmp-is-device -fopenmp-host-ir-file-path %t-ppc-host.bc %s \
+// RUN:   -fsyntax-only
+
+void foo(__ibm128 x); // expected-note {{'foo' defined here}}
+
+void loop(int n, __ibm128 *arr) {
+  #pragma omp target parallel
+  for (int i = 0; i < n; ++i) {
+     // expected-error@+1 {{'foo' requires 128 bit size '__ibm128' type support, but device 'x86_64' does not support it}}
+    foo(arr[i]);
+  }
+}

clang/test/CodeGenCXX/ibm128-declarations.cpp

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// RUN: %clang_cc1 -emit-llvm -triple powerpc64-unknown-unknown \
+// RUN:   -std=c++20 %s -o - -debug-info-kind=limited | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm -triple powerpc64le-unknown-unknown \
+// RUN:   -std=c++20 %s -o - -debug-info-kind=limited | FileCheck %s
+
+#include <stdarg.h>
+
+static __ibm128 sgf;
+__ibm128 arrgf[10];
+__ibm128 func1(__ibm128 arg);
+
+class CTest {
+  __ibm128 pf;
+  static const __ibm128 scf;
+  volatile __ibm128 vf;
+public:
+  CTest(__ibm128 arg) : pf(arg), vf(arg) {}
+  __ibm128 func2(__ibm128 arg) {
+    return pf + arg;
+  }
+  static __ibm128 func3(__ibm128 arg) {
+    return arg * CTest::scf;
+  }
+};
+
+constexpr __ibm128 func_add(__ibm128 a, __ibm128 b) {
+  return a + b;
+}
+
+constinit const __ibm128 ci = func_add(1.0, 2.0);
+__ibm128 gf = ci;
+
+__ibm128 func_arith(__ibm128 a, __ibm128 b, __ibm128 c) {
+  __ibm128 v1 = a + b;
+  __ibm128 v2 = a - c;
+  __ibm128 v3 = v1 * c;
+  __ibm128 v4 = v2 / v3;
+  return v4;
+}
+
+__ibm128 func_vaarg(int n, ...) {
+  va_list ap;
+  va_start(ap, n);
+  __ibm128 r = va_arg(ap, __ibm128);
+  va_end(ap);
+  return r;
+}
+
+template <typename T> struct T1 {
+  T mem1;
+};
+template <> struct T1<__ibm128> {
+  __ibm128 mem2;
+};
+
+template <__ibm128 Q> struct T2 {
+  constexpr static __ibm128 mem = Q;
+};
+
+int main(void) {
+  __ibm128 lf;
+  CTest ct(lf);
+  T1<__ibm128> tf;
+  __ibm128 lfi = tf.mem2 + func1(lf) - CTest::func3(lf);
+}
+
+// CHECK: %class.CTest = type { ppc_fp128, ppc_fp128 }
+// CHECK: %struct.T1 = type { ppc_fp128 }
+
+// CHECK: @arrgf = dso_local global [10 x ppc_fp128] zeroinitializer, align 16
+// CHECK: @gf = dso_local global ppc_fp128 0xM40080000000000000000000000000000, align 16
+// CHECK: @_ZN5CTest3scfE = external constant ppc_fp128, align 16
+
+// CHECK: define dso_local ppc_fp128 @_Z10func_arithggg(ppc_fp128 %a, ppc_fp128 %b, ppc_fp128 %c)
+// CHECK: entry:
+// CHECK:   store ppc_fp128 %a, ppc_fp128* %a.addr, align 16
+// CHECK:   store ppc_fp128 %b, ppc_fp128* %b.addr, align 16
+// CHECK:   store ppc_fp128 %c, ppc_fp128* %c.addr, align 16
+// CHECK:   %0 = load ppc_fp128, ppc_fp128* %a.addr, align 16
+// CHECK:   %1 = load ppc_fp128, ppc_fp128* %b.addr, align 16
+// CHECK:   %add = fadd ppc_fp128 %0, %1
+// CHECK:   store ppc_fp128 %add, ppc_fp128* %v1, align 16
+// CHECK:   %2 = load ppc_fp128, ppc_fp128* %a.addr, align 16
+// CHECK:   %3 = load ppc_fp128, ppc_fp128* %c.addr, align 16
+// CHECK:   %sub = fsub ppc_fp128 %2, %3
+// CHECK:   store ppc_fp128 %sub, ppc_fp128* %v2, align 16
+// CHECK:   %4 = load ppc_fp128, ppc_fp128* %v1, align 16
+// CHECK:   %5 = load ppc_fp128, ppc_fp128* %c.addr, align 16
+// CHECK:   %mul = fmul ppc_fp128 %4, %5
+// CHECK:   store ppc_fp128 %mul, ppc_fp128* %v3, align 16
+// CHECK:   %6 = load ppc_fp128, ppc_fp128* %v2, align 16
+// CHECK:   %7 = load ppc_fp128, ppc_fp128* %v3, align 16
+// CHECK:   %div = fdiv ppc_fp128 %6, %7
+// CHECK:   store ppc_fp128 %div, ppc_fp128* %v4, align 16
+// CHECK:   %8 = load ppc_fp128, ppc_fp128* %v4, align 16
+// CHECK:   ret ppc_fp128 %8
+// CHECK: }
+
+// CHECK: define dso_local ppc_fp128 @_Z10func_vaargiz(i32 signext %n, ...)
+// CHECK: entry:
+// CHECK:   store i32 %n, i32* %n.addr, align 4
+// CHECK:   %ap1 = bitcast i8** %ap to i8*
+// CHECK:   call void @llvm.va_start(i8* %ap1)
+// CHECK:   %argp.cur = load i8*, i8** %ap, align 8
+// CHECK:   %argp.next = getelementptr inbounds i8, i8* %argp.cur, i64 16
+// CHECK:   store i8* %argp.next, i8** %ap, align 8
+// CHECK:   %0 = bitcast i8* %argp.cur to ppc_fp128*
+// CHECK:   %1 = load ppc_fp128, ppc_fp128* %0, align 8
+// CHECK:   store ppc_fp128 %1, ppc_fp128* %r, align 16
+// CHECK:   %ap2 = bitcast i8** %ap to i8*
+// CHECK:   call void @llvm.va_end(i8* %ap2)
+// CHECK:   %2 = load ppc_fp128, ppc_fp128* %r, align 16
+// CHECK:   ret ppc_fp128 %2
+// CHECK: }
+
+// CHECK: define dso_local signext i32 @main()
+// CHECK: entry:
+// CHECK:   %0 = load ppc_fp128, ppc_fp128* %lf, align 16
+// CHECK:   call void @_ZN5CTestC1Eg(%class.CTest* nonnull dereferenceable(32) %ct, ppc_fp128 %0)
+// CHECK:   %mem2 = getelementptr inbounds %struct.T1, %struct.T1* %tf, i32 0, i32 0
+// CHECK:   %1 = load ppc_fp128, ppc_fp128* %mem2, align 16
+// CHECK:   %2 = load ppc_fp128, ppc_fp128* %lf, align 16
+// CHECK:   %call = call ppc_fp128 @_Z5func1g(ppc_fp128 %2)
+// CHECK:   %add = fadd ppc_fp128 %1, %call
+// CHECK:   %3 = load ppc_fp128, ppc_fp128* %lf, align 16
+// CHECK:   %call1 = call ppc_fp128 @_ZN5CTest5func3Eg(ppc_fp128 %3)
+// CHECK:   %sub = fsub ppc_fp128 %add, %call1
+// CHECK:   store ppc_fp128 %sub, ppc_fp128* %lfi, align 16
+// CHECK:   ret i32 0
+// CHECK: }
+
+// CHECK: define linkonce_odr void @_ZN5CTestC1Eg(%class.CTest* nonnull dereferenceable(32) %this, ppc_fp128 %arg)
+// CHECK: entry:
+// CHECK:   store %class.CTest* %this, %class.CTest** %this.addr, align 8
+// CHECK:   store ppc_fp128 %arg, ppc_fp128* %arg.addr, align 16
+// CHECK:   %this1 = load %class.CTest*, %class.CTest** %this.addr, align 8
+// CHECK:   %0 = load ppc_fp128, ppc_fp128* %arg.addr, align 16
+// CHECK:   call void @_ZN5CTestC2Eg(%class.CTest* nonnull dereferenceable(32) %this1, ppc_fp128 %0)
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: define linkonce_odr ppc_fp128 @_ZN5CTest5func3Eg(ppc_fp128 %arg)
+// CHECK: entry:
+// CHECK:   %arg.addr = alloca ppc_fp128, align 16
+// CHECK:   store ppc_fp128 %arg, ppc_fp128* %arg.addr, align 16
+// CHECK:   %0 = load ppc_fp128, ppc_fp128* %arg.addr, align 16
+// CHECK:   %1 = load ppc_fp128, ppc_fp128* @_ZN5CTest3scfE, align 16
+// CHECK:   %mul = fmul ppc_fp128 %0, %1
+// CHECK:   ret ppc_fp128 %mul
+// CHECK: }
+
+// CHECK: define linkonce_odr void @_ZN5CTestC2Eg(%class.CTest* nonnull dereferenceable(32) %this, ppc_fp128 %arg)
+// CHECK: entry:
+// CHECK:   store %class.CTest* %this, %class.CTest** %this.addr, align 8
+// CHECK:   store ppc_fp128 %arg, ppc_fp128* %arg.addr, align 16
+// CHECK:   %this1 = load %class.CTest*, %class.CTest** %this.addr, align 8
+// CHECK:   %pf = getelementptr inbounds %class.CTest, %class.CTest* %this1, i32 0, i32 0
+// CHECK:   %0 = load ppc_fp128, ppc_fp128* %arg.addr, align 16
+// CHECK:   store ppc_fp128 %0, ppc_fp128* %pf, align 16
+// CHECK:   %vf = getelementptr inbounds %class.CTest, %class.CTest* %this1, i32 0, i32 1
+// CHECK:   %1 = load ppc_fp128, ppc_fp128* %arg.addr, align 16
+// CHECK:   store volatile ppc_fp128 %1, ppc_fp128* %vf, align 16
+// CHECK:   ret void
+// CHECK: }
+
+// CHECK: !7 = distinct !DIGlobalVariable(name: "gf", scope: !2, file: !8, line: {{[0-9]+}}, type: !9, isLocal: false, isDefinition: true)
+// CHECK: !9 = !DIBasicType(name: "__ibm128", size: 128, encoding: DW_ATE_float)

clang/test/Sema/128bitfloat.cpp

 // RUN: %clang_cc1 -verify -std=gnu++11 %s
 // RUN: %clang_cc1 -verify -std=c++11 %s
 // RUN: %clang_cc1 -triple powerpc64-linux -verify -std=c++11 %s
 // RUN: %clang_cc1 -triple i686-windows-gnu -verify -std=c++11 %s
 // RUN: %clang_cc1 -triple x86_64-windows-gnu -verify -std=c++11 %s
 // RUN: %clang_cc1 -triple x86_64-windows-msvc -verify -std=c++11 %s
 
 #if defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)
 __float128 f;
 template<typename> struct __is_floating_point_helper {};
 template<> struct __is_floating_point_helper<__float128> {};
 int g(int x, __float128 *y) {
   return x + *y;
 }
 
-// expected-no-diagnostics
+// expected-no-error {{__float128 is not supported on this target}}
 #else
 #if !defined(__STRICT_ANSI__)
 __float128 f;  // expected-error {{__float128 is not supported on this target}}
 // But this should work:
 template<typename> struct __is_floating_point_helper {};
 template<> struct __is_floating_point_helper<__float128> {};  // expected-error {{__float128 is not supported on this target}}
 
 // FIXME: This could have a better diag.
 int g(int x, __float128 *y) {  // expected-error {{__float128 is not supported on this target}}
   return x + *y;
 }
 
 #else
 __float128 f;  // expected-error {{__float128 is not supported on this target}}
 template<typename> struct __is_floating_point_helper {};
 template<> struct __is_floating_point_helper<__float128> {};  // expected-error {{__float128 is not supported on this target}}
 
 int g(int x, __float128 *y) {  // expected-error {{__float128 is not supported on this target}}
   return x + *y;
 }
 
 #endif
 #endif
+
+#ifdef __ppc__
+__ibm128 i;
+template<> struct __is_floating_point_helper<__ibm128> {};
+int w(int x, __ibm128 *y) {
+  return x + *y;
+}
+// expected-no-error {{__ibm128 is not supported on this target}}
+#else
+__ibm128 i; // expected-error {{__ibm128 is not supported on this target}}
+template<> struct __is_floating_point_helper<__ibm128> {}; // expected-error {{__ibm128 is not supported on this target}}
+int w(int x, __ibm128 *y) { // expected-error {{__ibm128 is not supported on this target}}
+  return x + *y;
+}
+#endif

clang/tools/libclang/CXType.cpp

     BTCASE(ShortAccum);
     BTCASE(Accum);
     BTCASE(LongAccum);
     BTCASE(UShortAccum);
     BTCASE(UAccum);
     BTCASE(ULongAccum);
     BTCASE(Float16);
     BTCASE(Float128);
+    BTCASE(Ibm128);
     BTCASE(NullPtr);
     BTCASE(Overload);
     BTCASE(Dependent);
     BTCASE(ObjCId);
     BTCASE(ObjCClass);
     BTCASE(ObjCSel);
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) BTCASE(Id);
 #include "clang/Basic/OpenCLImageTypes.def"

     TKIND(ShortAccum);
     TKIND(Accum);
     TKIND(LongAccum);
     TKIND(UShortAccum);
     TKIND(UAccum);
     TKIND(ULongAccum);
     TKIND(Float16);
     TKIND(Float128);
+    TKIND(Ibm128);
     TKIND(NullPtr);
     TKIND(Overload);
     TKIND(Dependent);
     TKIND(ObjCId);
     TKIND(ObjCClass);
     TKIND(ObjCSel);
     TKIND(Complex);
     TKIND(Pointer);