Add support for __float128 type to be used by targets that support it

[nemanjai]

Summary

This patch adds support for the __float128 keyword and literals for IEEE Quad Precision.

[nemanjai]

Just a friendly reminder to the reviewers that this patch has been up for almost a week with no review comments. Please take some time to review.

[rsmith]

+rjmccall for @encode and USR mangling.

include/clang-c/Index.h

2885–2887

Do not renumber these, the libclang ABI has stability guarantees. Add your new enumerator with value 30 instead.

include/clang/Analysis/Analyses/ThreadSafetyTIL.h

244–245 ↗

(On Diff #41524)

I don't know, and this template looks suspicious already. We likely shouldn't be assuming that long double's size is 128 in the previous function.

include/clang/Basic/TokenKinds.def

260

Please keep the list in alphabetical order, and in any case add this to the GNU extensions list below, not here.

include/clang/Serialization/ASTBitCodes.h

813

I would say "The '__float128' type." here -- we don't need to assume that it's *this* 128-bit floating point type on any particular platform (except in the setup for that particular target).

lib/AST/ASTContext.cpp

971

This function only existed to allow us to parse libstdc++'s numeric_limits specialization for __float128. We won't need it any more once we have real support for __float128.

8021

We can defer that until we want to add a builtin that takes a __float128.

lib/AST/ItaniumMangle.cpp

2062

We should test a platform that uses useFloat128ManglingForLongDouble. Presumably they must either not support __float128 or use a different mangling here. (IIRC, they can't make long double and __float128 the same type because that would break libstdc++.)

lib/AST/MicrosoftMangle.cpp

1708

Yes, that seems like the best thing to do for now; you can just drop this FIXME.

lib/AST/NSAPI.cpp

444–445

This looks appropriate.

lib/AST/StmtPrinter.cpp

1234–1235

Does GCC support a suffix for __int128? If not, just add a FIXME like we do for Half. This case -- presumably -- should never happen if there are no literals of this type.

lib/Basic/TargetInfo.cpp

225–228

Return long double. We should prefer the standard type over the GNU extension here.

lib/Basic/Targets.cpp

1037–1045

Should we really support both __float128 and using the __float128 mangling for long double simultaneously? That seems likely to be broken unless there's another mangling for __float128 that we can use.

lib/CodeGen/CGExprScalar.cpp

1799

Yes. You should be able to test this by incrementing / decrementing a __float128.

lib/Frontend/InitPreprocessor.cpp

717–718

What macros does GCC define for __float128?

lib/Sema/SemaLookup.cpp

664–665

Delete this entire if block.

lib/Sema/SemaOverload.cpp

1921–1922

This should also allow promoting long double to __float128.

lib/Sema/SemaType.cpp

6699–6705

This isn't necessary any more; remove it.

[rjmccall]

lib/AST/ASTContext.cpp

5415

Please add this as a case to the block below for Half. I'll ping internally for a decision on what @encoding to use.

lib/Index/USRGeneration.cpp

604

I'm pretty sure you can just choose something here that doesn't collide, but the right person to ask is Argyrios.

[nemanjai]

Updated to address review comments. Rather than listing responses and justification for some of the changes, I'll provide comments inline for better readability.

[nemanjai]

lib/AST/ItaniumMangle.cpp

2064

Please refer to https://gcc.gnu.org/ml/gcc-patches/2015-10/txt5mF4d1XnFb.txt.
GCC recently added this for PowerPC and the new mangling was provided for the __float128 type when it coexists with long double.

lib/AST/StmtPrinter.cpp

1234

As in GCC, __float128 literals in source code have a suffix 'q'/'Q'. I'll be perfectly honest - I don't know when this function is called, but it seems that for consistency, we should use the same suffix here.

lib/Basic/TargetInfo.cpp

228

Left this condition in but moved it down. This way if a target exists that has 'long double' that is narrower than 128 bits, but it supports __float128, we can still return a 128-bit floating point type here.

lib/Basic/Targets.cpp

1043

Now that we have different mangling for float128 and long double, it should be safe to support float128 and leave the mangling of long double unchanged.

1236

GCC defines this macro when -mfloat128 is specified.

lib/CodeGen/CGExprScalar.cpp

1799

An expression incrementing a variable of __float128 type was added to the test case.

lib/Frontend/InitPreprocessor.cpp

718

GCC does not do this at this particular time, but it seems logical to actually provide this macro on targets that support it. For PPC, the macros are defined (and tested) to match IEEE quad precision values (when -mfloat128 is specified).

lib/Index/USRGeneration.cpp

603

As far as I can tell, this does not collide and it is consistent with the literal suffix for this type. However, I'd be happy to change it if there is a better suffix to use. Do you have a different suggestion @akyrtzi?

[hubert.reinterpretcast]

I would like to see a test:

__float128 qf();
long double ldf();

long double ld{qf()}; // error: narrowing
__float128 q{ldf()}; // passes

include/clang/Basic/TargetInfo.h

384

This should probably not be hard-coded. On s390x-ibm-linux-gnu, the IEEE 128-bit binary format type has 8 byte alignment (not 16).

lib/CodeGen/CGDebugInfo.cpp

539

Is a PPCDoubleDouble "long double" and "__float128" distinguishable on PPC given this DWARF treatment?

lib/Lex/LiteralSupport.cpp

604

minor: should the comment have FL instead of LF?

lib/Sema/SemaOverload.cpp

1921–1922

In C99 6.3.1.5p1:

[...] its value is unchanged.

Allowing long double to promote to __float128 violates that on at least one target platform.
For example, PPCDoubleDouble can represent (2^512) - 1 exactly.

[nemanjai]

include/clang/Basic/TargetInfo.h

384

OK, I probably shouldn't have assumed anything about the alignment. I'll add fields to the target info that can be set as needed.

lib/CodeGen/CGDebugInfo.cpp

539

Unless there's something put into the debugger to figure out which type something actually is, I don't think so. However, there isn't a consensus on what encoding will be used, so I'll just leave it as-is and put a FIXME in the code to note this.

lib/Lex/LiteralSupport.cpp

604

I agree that it probably should, but it was already there so I didn't change it. I'll change it on the next review.

[hubert.reinterpretcast]

I would also like to see a test case based on the following from ISO/IEC TS 18661-3:2015:

If both operands have floating types and neither of the sets of values of their corresponding real types is a subset of (or equivalent to) the other, the behavior is undefined.

auto f(__float128 q, long double ld) {
  return q + ld; // error: no common type
}

[nemanjai]

I think the correct course of action would be to allow/disallow promotion based on a condition that the two types are the same/different (respectively). I think a comparison of the float semantics is a valid way to check this. Also, should operations between long double and __float128 be diagnosed as warnings or errors if the two types are distinct?

[hubert.reinterpretcast]

In D15120#310992, @nemanjai wrote:

I think the correct course of action would be to allow/disallow promotion based on a condition that the two types are the same/different (respectively). I think a comparison of the float semantics is a valid way to check this. Also, should operations between long double and __float128 be diagnosed as warnings or errors if the two types are distinct?

When the "two" types have the same float semantics, an additional consideration is whether there are indeed two types, or if there is just one (with different ways to name it). On x86_64 Linux systems, I believe that the latter case is true for __float80 and long double with GCC; however, with -mlong-double-128, GCC treats __float128 and long double as distinct (but uses the same mangling for both). That is to say, GCC is inconsistent.
With regards to the usual arithmetic conversions, I believe that an error is the safest course of action when the two types are distinct (between PPCDoubleDouble and IEEEquad). It appears that the use of IsFloatingPointPromotion for C is sketchy (see inline comments).

lib/Sema/SemaOverload.cpp

1921–1922

The only "promotions" in C as of C11 are the integer promotions and the default argument promotions. The (now removed) use of "promoted" to describe a conversion between double to long double appears to have been an unintentional overloading of the term. If the purpose of this function is as described (to implement conv.fpprom), then the use of it for C appears to be erroneous. At the very least, the comments are not sufficient and the naming of the function (given its current implementation) no longer has a basis in the C Standard.

[nemanjai]

Addressed the review comments:

• Added the requested test cases
• Disabled promotion of long double to __float128
• Disabled operations between long double and __float128 if they have different representations

[hubert.reinterpretcast]

lib/CodeGen/CGDebugInfo.cpp

541

There are various typos in this comment.

lib/CodeGen/CGExprScalar.cpp

1808

It might make sense to move the call to getLongDoubleFormat() to the if/else block and perhaps to order it as long double/__float128/half.

lib/Sema/SemaExpr.cpp

1116

Are we all comfortable that if long double and __float128 have the same representation, but are considered distinct types, then the LHS type is used? Is this consistent with GCC?

1147

There's no actual need for the .getTypePtr() part; the overloaded operator-> does the same thing.

1154

LHSComplexType is only used here. It could be replaced with cast<ComplexType>(LHSType.getTypePtr()) (and similarly for the RHS).

Indeed, since we are checking against specific real element types anyway, dyn_cast<ComplexType>(LHSType.getTypePtr()) (and checking for null) would suffice (no need to use isComplexType()).

test/Sema/float128-ld-incompatibility.cpp

32 ↗

(On Diff #44459)

I believe a test for the conditional operator would be appropriate.

[rjmccall]

include/clang/Basic/TargetInfo.h

384

I think you can safely have this method hard-code the size, though. :)

lib/AST/ASTContext.cpp

4587

Follow the same code styling as above, please.

4603

Indentation.

4627

This is a really bad language rule with nasty implications for a lot of code. Is there a really urgent need to emulate some other compiler bug-for-bug here?

It's okay for there to a formal rank difference even when types have the same representation — that's basically always true for the integer types — so unless there's a very specific and very good reason not to, let's just use the rule that float128 has higher rank than long double.

[hubert.reinterpretcast]

lib/AST/ASTContext.cpp

4627

I am not very keen on the implications of having the equal rank either.

I believe the case where neither type represents the full set of values of the other should be considered "unordered" though (currently that is handled by typesNotCompatible(), which is in need of a better name since the function does not deal with "compatible types" as defined by C11 subclause 6.2.7).

[nemanjai]

Addressed review comments.
The key differences are:

• No assignments or operations between entities of long double and __float128 allowed if the two types have a different representation
• Each type has a distinct rank

This isn't the same behaviour as GCC currently has. For example, GCC allows assignments between the two types on PowerPC. The conversion is achieved through a library routine. However, there is no compelling reason at this point to allow such behaviour and this work is deferred until such a need arises.

[rjmccall]

In D15120#336282, @nemanjai wrote:

Addressed review comments.
The key differences are:

• No assignments or operations between entities of long double and __float128 allowed if the two types have a different representation
• Each type has a distinct rank

This isn't the same behaviour as GCC currently has. For example, GCC allows assignments between the two types on PowerPC. The conversion is achieved through a library routine. However, there is no compelling reason at this point to allow such behaviour and this work is deferred until such a need arises.

As I understand it, PPC's long-double (~103 bits of precision) is still strictly less precise than float128_t (113 bits of precision), so it ought to be have lower rank. Is there actually a supported platform where this is not true? If not, we should just add this as another type with higher rank.

[hubert.reinterpretcast]

In D15120#336430, @rjmccall wrote:

As I understand it, PPC's long-double (~103 bits of precision) is still strictly less precise than float128_t (113 bits of precision), so it ought to be have lower rank. Is there actually a supported platform where this is not true? If not, we should just add this as another type with higher rank.

PPC's long-double has variable precision. It is not strictly less precise than float128_t.

[rjmccall]

In D15120#336776, @hubert.reinterpretcast wrote:

In D15120#336430, @rjmccall wrote:

As I understand it, PPC's long-double (~103 bits of precision) is still strictly less precise than float128_t (113 bits of precision), so it ought to be have lower rank. Is there actually a supported platform where this is not true? If not, we should just add this as another type with higher rank.

PPC's long-double has variable precision. It is not strictly less precise than float128_t.

Ah, right. I was thinking of it as if the lower double were pegged to 1/2 an ulp of the higher double, but it isn't; it can be variably lower.

Here's the thing, though: I don't think there's a reasonable language solution here besides saying that float128_t has higher rank. You can't make the types incompatible, because it's clearly reasonable to simply convert one to the other. What you're trying to say is that they don't have a common type, but it's a novel concept in C/C++ to have two arithmetic types that don't have a common type and therefore cannot be added / compared / ternary'd together. In contrast, it is not a novel concept to have a type that implicitly promotes to another type but potentially loses precision, because all the integer types will happily convert to float/double.

This patch will be much simpler, and you will get a better language design, if you simply make float128_t a new FP type with a higher rank than long double.

[hubert.reinterpretcast]

In D15120#336827, @rjmccall wrote:

Here's the thing, though: I don't think there's a reasonable language solution here besides saying that float128_t has higher rank. You can't make the types incompatible, because it's clearly reasonable to simply convert one to the other. What you're trying to say is that they don't have a common type, but it's a novel concept in C/C++ to have two arithmetic types that don't have a common type and therefore cannot be added / compared / ternary'd together. In contrast, it is not a novel concept to have a type that implicitly promotes to another type but potentially loses precision, because all the integer types will happily convert to float/double.

I believe that decimal floating point types introduced the situation of having two arithmetic types that don't have a common type into "C".

This patch will be much simpler, and you will get a better language design, if you simply make float128_t a new FP type with a higher rank than long double.

The C committee decided that "undefined behavior" was what they could agree on for this sort of case. I suppose that on most platforms float128_t logically has the higher rank and it would be a shame to have source portability issues because the expression would need more casts on PPC. Even the narrowing conversion semantics in C++ is fine with losing precision.

[rjmccall]

In D15120#336855, @hubert.reinterpretcast wrote:

In D15120#336827, @rjmccall wrote:

Here's the thing, though: I don't think there's a reasonable language solution here besides saying that float128_t has higher rank. You can't make the types incompatible, because it's clearly reasonable to simply convert one to the other. What you're trying to say is that they don't have a common type, but it's a novel concept in C/C++ to have two arithmetic types that don't have a common type and therefore cannot be added / compared / ternary'd together. In contrast, it is not a novel concept to have a type that implicitly promotes to another type but potentially loses precision, because all the integer types will happily convert to float/double.

I believe that decimal floating point types introduced the situation of having two arithmetic types that don't have a common type into "C".

Perhaps; I don't know those rules at all.

This patch will be much simpler, and you will get a better language design, if you simply make float128_t a new FP type with a higher rank than long double.

The C committee decided that "undefined behavior" was what they could agree on for this sort of case.

That's only when the operand value is actually outside of the range of the type, which for implementations claiming IEEE 754 compatibility means "never" because of the infinities. Even if it weren't specified, every implementation I know of in practice does give this defined behavior using the active FP rounding rules.

Anyway, I think we're agreed that we should just give make float128_t higher rank on all platforms.

[hubert.reinterpretcast]

In D15120#336891, @rjmccall wrote:

The C committee decided that "undefined behavior" was what they could agree on for this sort of case.

That's only when the operand value is actually outside of the range of the type, which for implementations claiming IEEE 754 compatibility means "never" because of the infinities. Even if it weren't specified, every implementation I know of in practice does give this defined behavior using the active FP rounding rules.

The applicable wording is quoted here: D15120#310972, but I guess that's unimportant for the purposes this discussion now.

Anyway, I think we're agreed that we should just give make float128_t higher rank on all platforms.

Agreed.

[rjmccall]

In D15120#336996, @hubert.reinterpretcast wrote:

In D15120#336891, @rjmccall wrote:

The C committee decided that "undefined behavior" was what they could agree on for this sort of case.

That's only when the operand value is actually outside of the range of the type, which for implementations claiming IEEE 754 compatibility means "never" because of the infinities. Even if it weren't specified, every implementation I know of in practice does give this defined behavior using the active FP rounding rules.

The applicable wording is quoted here: D15120#310972, but I guess that's unimportant for the purposes this discussion now.

Oh, I see, you were referring to an FP->FP conversion rule, whereas I was still talking about the int->FP conversion rule as an example where C accepts converting to a common FP type even when it loses precision.

That TS rule is extremely strange; I wonder whether they really mean "undefined", or if they just mean "implementation-defined", or if they just meant to say that it's UB if the original value isn't a member of the result type. I really don't know why you would intentionally give an entire statically-determined operation dynamically undefined behavior instead of simply making it ill-formed. Sometimes TSes aren't drafted very carefully.

Oh well, a question for another day.

[nemanjai]

Thank you for the discussion on rank. I'm glad we have an agreement on the rank of the two types.
However, considering __float128 already has a higher rank in this patch, is there anything else that you would like me to change here before the patch is approved?

Do you suggest that we need to allow operations (or at least assignments) between the two types and take away the diagnostics that are part of this patch?

[hubert.reinterpretcast]

This comment was removed by hubert.reinterpretcast.

[hubert.reinterpretcast]

In D15120#337144, @nemanjai wrote:

Do you suggest that we need to allow operations (or at least assignments) between the two types and take away the diagnostics that are part of this patch?

My overriding concern at this time is to allow (or not) the operations consistently (that is, not making it platform-specific). The net result is that we will allow operations between the two types; however, we will encounter a further issue to discuss (@rjmccall @rsmith; your input requested) regarding what the common type should be when the representations are the same (the TS prefers the standard floating type, which is long double here).

As for the diagnostics, the IEEEquad to PPCDoubleDouble conversion still requires checks for narrowing.

[rjmccall]

I think it's not unlikely that float128_t will see future standardization (as an optional extension, of course), and it would be strange for an operation between two types to not consistently yield the type of higher rank.

I could see an argument that we should not treat float128_t as a distinct type from long double on targets where they have the same implementation. That might avoid the need for special-case manglings.

[hubert.reinterpretcast]

This comment was removed by hubert.reinterpretcast.

[hubert.reinterpretcast]

In D15120#337384, @rjmccall wrote:

I think it's not unlikely that float128_t will see future standardization (as an optional extension, of course), and it would be strange for an operation between two types to not consistently yield the type of higher rank.

It remains that the present standardization effort (as _Float128) does not imbue the "interchange" type with inherently higher rank than long double. In a parallel to the treatment of extended integer types, the "standard" type has higher rank when the set of values are equivalent between the two. This is consistent with the GCC implementation (online compiler: http://melpon.org/wandbox/permlink/tM3PyGWC5WTWIdKP).

I could see an argument that we should not treat float128_t as a distinct type from long double on targets where they have the same implementation. That might avoid the need for special-case manglings.

I would prefer this as well (insofar as it saves us from the common type issue). As I have mentioned before, for __float128 and -mlong-double-128 on x86-64, GCC ends up with an undesirable situation of treating the types as distinct, but mangling them the same. In the TS, _Float128 is always distinct from long double, which is helpful for portability of _Generic expressions with both types. In the end, it seems to come down to what sort of code people will write. If overloads for both __float128 and long double are the norm, then we will need to consider the types distinct.

[rjmccall]

In D15120#337552, @hubert.reinterpretcast wrote:

In D15120#337384, @rjmccall wrote:

I think it's not unlikely that float128_t will see future standardization (as an optional extension, of course), and it would be strange for an operation between two types to not consistently yield the type of higher rank.

It remains that the present standardization effort (as _Float128) does not imbue the "interchange" type with inherently higher rank than long double. In a parallel to the treatment of extended integer types, the "standard" type has higher rank when the set of values are equivalent between the two. This is consistent with the GCC implementation (online compiler: http://melpon.org/wandbox/permlink/tM3PyGWC5WTWIdKP).

Do we have anyone involved in this standardization effort? It seems like a really poor idea to having type ranking be target-dependent.

I could see an argument that we should not treat float128_t as a distinct type from long double on targets where they have the same implementation. That might avoid the need for special-case manglings.

I would prefer this as well (insofar as it saves us from the common type issue). As I have mentioned before, for __float128 and -mlong-double-128 on x86-64, GCC ends up with an undesirable situation of treating the types as distinct, but mangling them the same.

Does Clang currently support that option?

In the TS, _Float128 is always distinct from long double, which is helpful for portability of _Generic expressions with both types. In the end, it seems to come down to what sort of code people will write. If overloads for both __float128 and long double are the norm, then we will need to consider the types distinct.

Makes sense.

[hubert.reinterpretcast]

In D15120#337654, @rjmccall wrote:

In D15120#337552, @hubert.reinterpretcast wrote:

It remains that the present standardization effort (as _Float128) does not imbue the "interchange" type with inherently higher rank than long double. In a parallel to the treatment of extended integer types, the "standard" type has higher rank when the set of values are equivalent between the two. This is consistent with the GCC implementation (online compiler: http://melpon.org/wandbox/permlink/tM3PyGWC5WTWIdKP).

Do we have anyone involved in this standardization effort? It seems like a really poor idea to having type ranking be target-dependent.

I can reach out to someone who is involved.

As I have mentioned before, for __float128 and -mlong-double-128 on x86-64, GCC ends up with an undesirable situation of treating the types as distinct, but mangling them the same.

Does Clang currently support that option?

It appears that Clang does not currently support that option; however, there are platforms where long double is already IEEE quad, e.g., s390x-ibm-linux-gnu (where I have not found a GCC providing __float128). It appears that we can defer the issue as long as we do not provide __float128 when long double is already IEEE quad.

[rjmccall]

In D15120#337975, @hubert.reinterpretcast wrote:

In D15120#337654, @rjmccall wrote:

In D15120#337552, @hubert.reinterpretcast wrote:

It remains that the present standardization effort (as _Float128) does not imbue the "interchange" type with inherently higher rank than long double. In a parallel to the treatment of extended integer types, the "standard" type has higher rank when the set of values are equivalent between the two. This is consistent with the GCC implementation (online compiler: http://melpon.org/wandbox/permlink/tM3PyGWC5WTWIdKP).

Do we have anyone involved in this standardization effort? It seems like a really poor idea to having type ranking be target-dependent.

I can reach out to someone who is involved.

Thank you. If they have a strong motivation here, that's fine, but this feels like it would block and complicate future standardization efforts, as well as impair portability.

As I have mentioned before, for __float128 and -mlong-double-128 on x86-64, GCC ends up with an undesirable situation of treating the types as distinct, but mangling them the same.

Does Clang currently support that option?

It appears that Clang does not currently support that option

Ok. It would be better if we can avoid that, I think.

; however, there are platforms where long double is already IEEE quad, e.g., s390x-ibm-linux-gnu (where I have not found a GCC providing __float128).

Sure, that's a legitimate platform ABI choice.

It appears that we can defer the issue as long as we do not provide __float128 when long double is already IEEE quad.

Sounds good.

[hubert.reinterpretcast]

In D15120#337144, @nemanjai wrote:

Do you suggest that we need to allow operations (or at least assignments) between the two types and take away the diagnostics that are part of this patch?

It appears that the conclusion is that operations between the two types will be allowed. The common type between __float128 and long double will be __float128 at this time, based on the observation that __float128 is not yet available in cases where the choice of common type is still unclear.
It appears that at some point, interoperability issues with GCC will change that, and the choice of common type may need to be a target-based property (which may be implemented by the rank being target-based). For the purposes of this patch, I think we are deferring that issue.

[nemanjai]

If the reviewers don't mind, I would like to keep this patch with diagnostics for interoperability between the two types for now. This is simply because enabling such interoperability requires changes to some of the conversion infrastructure (i.e. allowing FPTrunc/FPExt for types of the same width, etc.). This is to prevent crashes on code such as:

__float128 foo(long double d) {
  return d;
}

A test case like that will trip asserts when attempting to generate code. Of course, this is easy to fix (3 minor changes in 2 files) but even if we emit that IR, the back end will fail when trying to compile it.
What I meant to do with this patch is to just get the Clang support in and emit diagnostics for things that the target isn't able to do yet. I will follow this up with a patch that will:

1. Remove the diagnostics
2. Allow the conversions
3. Provide libcalls for the necessary operations (similarly to what GCC does)

[hubert.reinterpretcast]

In D15120#340515, @nemanjai wrote:

If the reviewers don't mind, I would like to keep this patch with diagnostics for interoperability between the two types for now. This is simply because enabling such interoperability requires changes to some of the conversion infrastructure (i.e. allowing FPTrunc/FPExt for types of the same width, etc.). This is to prevent crashes on code such as:

__float128 foo(long double d) {
  return d;
}

A test case like that will trip asserts when attempting to generate code. Of course, this is easy to fix (3 minor changes in 2 files) but even if we emit that IR, the back end will fail when trying to compile it.
What I meant to do with this patch is to just get the Clang support in and emit diagnostics for things that the target isn't able to do yet. I will follow this up with a patch that will:

1. Remove the diagnostics
2. Allow the conversions
3. Provide libcalls for the necessary operations (similarly to what GCC does)

This sounds good to me. @rjmccall @rsmith, are we good to move forward with this first patch?

lib/Sema/SemaExpr.cpp

1157

The result of the dyn_cast can be saved instead of using cast after the dyn_cast.

[rsmith]

include/clang/Driver/Options.td

1425

Per the mangling rules at the top of this file, this should be named mno_float128.

lib/CodeGen/ItaniumCXXABI.cpp

3327–3328

Please keep this in the same order as TypeInfoIsInStandardLibrary (put Float128Ty after LongDoubleTy).

lib/Sema/SemaExpr.cpp

1157–1160

Do not use dyn_cast / cast on types, use LHSType->getAs<...>() / LHSType->castAs<...>() instead. This will do the wrong thing on sugared types (eg, a typedef for a complex type).

1305

Please indicate why you're diagnosing these here.

1307

Too much indentation.

lib/Sema/SemaOverload.cpp

1623–1632

This is over-indented.

[hubert.reinterpretcast]

lib/Sema/SemaExpr.cpp

1157–1160

Are there contexts in Clang where sugared types don't occur? Is the general guidance to use getAs or castAs even if the types are known to be canonical (which I agree isn't the case here)?

[nemanjai]

Fixed the naming, indentation and removed the use of dyn_cast for types.

[hubert.reinterpretcast]

lib/Basic/TargetInfo.cpp

229

Is it necessary to check that __float128 is IEEE quad here? Unlike the long double cases, __float128 really better be 128 bits.

lib/Sema/SemaExpr.cpp

1170

I do not believe that the width of long double is sufficiently established to be the same as that of __float128 in this context.

1306

s/such type/such types;

lib/Sema/SemaOverload.cpp

1623

Is conversion between long double and __float128 the correct characterization of the missing back-end support? (as opposed to conversion between PPCDoubleDouble and IEEEquad)

[nemanjai]

lib/Basic/TargetInfo.cpp

229

It would indeed be weird if it wasn't so. I can remove the second condition in that if.

lib/Sema/SemaExpr.cpp

1170

This would certainly cause any attempts to convert between some different implementation of long double (i.e. the Intel 80-bit type). I believe that this behaviour is desired in all cases where long double and double have a different representation. Namely, we do not currently have any support for converting between fp128 and anything that has precision >= double that is not actually double.

What I propose to do here and in other locations where we diagnose conversions between the two types is that the check is:

• One type is __float128
• The other is long double
• The representation of long double is not llvm::APFloat::IEEEdouble

Basically in this function, the early exit path would be:

• representations are the same or
• representation of long double is llvm::APFloat::IEEEdouble

1306

Oops, I dropped the s. I'll fix it.

lib/Sema/SemaOverload.cpp

1623

Well, the same issue exists with x86_fp80. We don't have libcalls set up for handling that either. Of course the intended semantics and the comment are still not quite correct here. Really, what I think we should be after is catching attempts to convert between __float128 and long double on targets where long double is not actually just double.

[hubert.reinterpretcast]

lib/Sema/SemaExpr.cpp

1170

This really sounds like a property of the target. The situation described in D15120#inline-141210 is similar.

I would not want to do a virtual function call without early exits here. So, perhaps the TargetInfo should be queried only at the point where we would otherwise return true.

I can't say that I like the name of this function now. Perhaps unsupportedTypeConversion?

[hubert.reinterpretcast]

lib/Frontend/InitPreprocessor.cpp

718

I am concerned that setting these macros are premature. We still do not know if the _Float128 type from the C Technical Specification (which has claim to FLT128_*, although not necessarily the double-underscore versions) will be the same type as __float128. The latter may be considered typedef-equivalent to long double; the former shall not be.

[nemanjai]

Removed questionable macro definitions.
Renamed the test function for invalid conversions and changed the semantics so that it allows float128 <-> long double conversions only if the two types have the same representation or the latter has the same representation as double.
Removed unnecessary check for the representation of float128 when returning a float type of width 128.

[hubert.reinterpretcast]

lib/Sema/SemaOverload.cpp

1623

The update to check the case where the representation of long double is the same as that of double is missing.

1921–1922

@rsmith; this is the discussion on floating-point "promotions" in "C" that I was asking you about.

[nemanjai]

lib/Sema/SemaOverload.cpp

1623

Yes, I missed this. Thanks for noticing. I'll update the comment and change the body of the if to:

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::IEEEdouble))
    return false;
}

1921–1922

I can certainly remove this if the agreement is that I should do so.

[hubert.reinterpretcast]

lib/Sema/SemaOverload.cpp

1623

I'm not a fan of redundant parentheses, but that looks okay.

1921–1922

Richard had requested to allow "promoting" long double to __float128, and at the time, implicitly converting from long double to __float128 was something I was not convinced we should do at the time. At this time, I believe that adding this "promotion" is consistent with the rest of the patch; however, I am still not sure what this code is meant to implement (again, C11 does not have floating-point promotions).

[rsmith]

LGTM

lib/Sema/SemaOverload.cpp

1921–1922

I think our justification for allowing this promotion in C doesn't make any sense. The C wording is just trying to give slightly different rules for the "type gets bigger" and "type gets smaller" case and "promotion" here is an unfortunate choice of words. C99 didn't have floating point promotions.

I'm inclined to think we should remove this special case entirely. Does that cause any test failures?

[nemanjai]

Committed revision 266186.

bindings/python/clang/cindex.py

 TypeKind.DOUBLE = TypeKind(22)
 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.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)

include/clang-c/Index.h

enum CXTypeKind {
   CXType_Float = 21,
   CXType_Double = 22,
   CXType_LongDouble = 23,
   CXType_NullPtr = 24,
   CXType_Overload = 25,
   CXType_Dependent = 26,
   CXType_ObjCId = 27,
   CXType_ObjCClass = 28,
   CXType_ObjCSel = 29,
+  CXType_Float128 = 30,
   CXType_FirstBuiltin = CXType_Void,
   CXType_LastBuiltin  = CXType_ObjCSel,
 
   CXType_Complex = 100,
   CXType_Pointer = 101,
   CXType_BlockPointer = 102,
   CXType_LValueReference = 103,
   CXType_RValueReference = 104,
   CXType_Record = 105,

include/clang/AST/ASTContext.h

public:
   CanQualType WCharTy;  // [C++ 3.9.1p5].
   CanQualType WideCharTy; // Same as WCharTy in C++, integer type in C99.
   CanQualType WIntTy;   // [C99 7.24.1], integer type unchanged by default promotions.
   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;
+  CanQualType FloatTy, DoubleTy, LongDoubleTy, Float128Ty;
   CanQualType HalfTy; // [OpenCL 6.1.1.1], ARM NEON
   CanQualType FloatComplexTy, DoubleComplexTy, LongDoubleComplexTy;
+  CanQualType Float128ComplexTy;
   CanQualType VoidPtrTy, NullPtrTy;
   CanQualType DependentTy, OverloadTy, BoundMemberTy, UnknownAnyTy;
   CanQualType BuiltinFnTy;
   CanQualType PseudoObjectTy, ARCUnbridgedCastTy;
   CanQualType ObjCBuiltinIdTy, ObjCBuiltinClassTy, ObjCBuiltinSelTy;
   CanQualType ObjCBuiltinBoolTy;
   CanQualType OCLImage1dTy, OCLImage1dArrayTy, OCLImage1dBufferTy;
   CanQualType OCLImage2dTy, OCLImage2dArrayTy, OCLImage2dDepthTy;
public:
   TypedefDecl *buildImplicitTypedef(QualType T, StringRef Name) const;
 
   /// \brief Retrieve the declaration for the 128-bit signed integer type.
   TypedefDecl *getInt128Decl() const;
 
   /// \brief Retrieve the declaration for the 128-bit unsigned integer type.
   TypedefDecl *getUInt128Decl() const;
 
-  /// \brief Retrieve the declaration for a 128-bit float stub type.
-  TypeDecl *getFloat128StubType() const;
-
   //===--------------------------------------------------------------------===//
   //                           Type Constructors
   //===--------------------------------------------------------------------===//
 
 private:
   /// \brief Return a type with extended qualifiers.
   QualType getExtQualType(const Type *Base, Qualifiers Quals) const;
 

include/clang/AST/BuiltinTypes.def

 FLOATING_TYPE(Float, FloatTy)
 
 // 'double'
 FLOATING_TYPE(Double, DoubleTy)
 
 // 'long double'
 FLOATING_TYPE(LongDouble, LongDoubleTy)
 
+// '__float128'
+FLOATING_TYPE(Float128, Float128Ty)
+
 //===- 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

include/clang/AST/Type.h

bool isSignedInteger() const {
     return getKind() >= Char_S && getKind() <= Int128;
   }
 
   bool isUnsignedInteger() const {
     return getKind() >= Bool && getKind() <= UInt128;
   }
 
   bool isFloatingPoint() const {
-    return getKind() >= Half && getKind() <= LongDouble;
+    return getKind() >= Half && getKind() <= Float128;
   }
 
   /// 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

include/clang/AST/TypeLoc.h

public:
   }
   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::LongDouble)
+      || (bk >= BuiltinType::Short && bk <= BuiltinType::Float128)
       || bk == BuiltinType::UChar
       || bk == BuiltinType::SChar;
   }
 
   unsigned getExtraLocalDataSize() const {
     return needsExtraLocalData() ? sizeof(WrittenBuiltinSpecs) : 0;
   }
 

include/clang/Basic/DiagnosticSemaKinds.td

def err_typecheck_arithmetic_incomplete_type : Error<
   "arithmetic on a pointer to an incomplete type %0">;
 def err_typecheck_pointer_arith_function_type : Error<
   "arithmetic on%select{ a|}0 pointer%select{|s}0 to%select{ the|}2 "
   "function type%select{|s}2 %1%select{| and %3}2">;
 def err_typecheck_pointer_arith_void_type : Error<
   "arithmetic on%select{ a|}0 pointer%select{|s}0 to void">;
 def err_typecheck_decl_incomplete_type : Error<
   "variable has incomplete type %0">;
-def err_typecheck_decl_incomplete_type___float128 : Error<
-  "support for type '__float128' is not yet implemented">;
 def ext_typecheck_decl_incomplete_type : ExtWarn<
   "tentative definition of variable with internal linkage has incomplete non-array type %0">,
   InGroup<DiagGroup<"tentative-definition-incomplete-type">>;
 def err_tentative_def_incomplete_type : Error<
   "tentative definition has type %0 that is never completed">;
 def warn_tentative_incomplete_array : Warning<
   "tentative array definition assumed to have one element">;
 def err_typecheck_incomplete_array_needs_initializer : Error<

 def ext_c99_array_usage : Extension<
   "%select{qualifier in |static |}0array size %select{||'[*] '}0is a C99 "
   "feature">, InGroup<C99>;
 def err_c99_array_usage_cxx : Error<
   "%select{qualifier in |static |}0array size %select{||'[*] '}0is a C99 "
   "feature, not permitted in C++">;
  def err_type_requires_extension : Error<
   "use of type %0 requires %1 extension to be enabled">;
-def err_int128_unsupported : Error<
-  "__int128 is not supported on this target">;
+def err_type_unsupported : Error<
+  "%0 is not supported on this target">;
 def err_nsconsumed_attribute_mismatch : Error<
   "overriding method has mismatched ns_consumed attribute on its"
   " parameter">;
 def err_nsreturns_retained_attribute_mismatch : Error<
   "overriding method has mismatched ns_returns_%select{not_retained|retained}0"
   " attributes">;
   
 def note_getter_unavailable : Note<

include/clang/Basic/Specifiers.h

enum TypeSpecifierType {
     TST_wchar,        // C++ wchar_t
     TST_char16,       // C++11 char16_t
     TST_char32,       // C++11 char32_t
     TST_int,
     TST_int128,
     TST_half,         // OpenCL half, ARM NEON __fp16
     TST_float,
     TST_double,
+    TST_float128,
     TST_bool,         // _Bool
     TST_decimal32,    // _Decimal32
     TST_decimal64,    // _Decimal64
     TST_decimal128,   // _Decimal128
     TST_enum,
     TST_union,
     TST_struct,
     TST_class,        // C++ class type

include/clang/Basic/TargetInfo.h

protected:
   unsigned char MaxAtomicPromoteWidth, MaxAtomicInlineWidth;
   unsigned short MaxVectorAlign;
   unsigned short MaxTLSAlign;
   unsigned short SimdDefaultAlign;
   const char *DataLayoutString;
   const char *UserLabelPrefix;
   const char *MCountName;
   const llvm::fltSemantics *HalfFormat, *FloatFormat, *DoubleFormat,
-    *LongDoubleFormat;
+    *LongDoubleFormat, *Float128Format;
   unsigned char RegParmMax, SSERegParmMax;
   TargetCXXABI TheCXXABI;
   const LangAS::Map *AddrSpaceMap;
 
   mutable StringRef PlatformName;
   mutable VersionTuple PlatformMinVersion;
 
   unsigned HasAlignMac68kSupport : 1;
enum IntType {
     SignedLongLong,
     UnsignedLongLong
   };
 
   enum RealType {
     NoFloat = 255,
     Float = 0,
     Double,
-    LongDouble
+    LongDouble,
+    Float128
   };
 
   /// \brief The different kinds of __builtin_va_list types defined by
   /// the target implementation.
   enum BuiltinVaListKind {
     /// typedef char* __builtin_va_list;
     CharPtrBuiltinVaList = 0,
 
public:
   unsigned getLongLongWidth() const { return LongLongWidth; }
   unsigned getLongLongAlign() const { return LongLongAlign; }
 
   /// \brief Determine whether the __int128 type is supported on this target.
   virtual bool hasInt128Type() const {
     return getPointerWidth(0) >= 64;
   } // FIXME
 
+  /// \brief Determine whether the __float128 type is supported on this target.
+  virtual bool hasFloat128Type() const {
+    return false;
+  }
+
   /// \brief Return the alignment that is suitable for storing any
   /// object with a fundamental alignment requirement.
   unsigned getSuitableAlign() const { return SuitableAlign; }
 
   /// \brief Return the default alignment for __attribute__((aligned)) on
   /// this target, to be used if no alignment value is specified.
   unsigned getDefaultAlignForAttributeAligned() const {
     return DefaultAlignForAttributeAligned;
public:
   /// getLongDoubleWidth/Align/Format - Return the size/align/format of 'long
   /// double'.
   unsigned getLongDoubleWidth() const { return LongDoubleWidth; }
   unsigned getLongDoubleAlign() const { return LongDoubleAlign; }
   const llvm::fltSemantics &getLongDoubleFormat() const {
     return *LongDoubleFormat;
   }
 
+  /// getFloat128Width/Align/Format - Return the size/align/format of
+  /// '__float128'.
+  unsigned getFloat128Width() const { return 128; }
+  unsigned getFloat128Align() const { return 128; }
+  const llvm::fltSemantics &getFloat128Format() const {
+    return *Float128Format;
+  }
+
   /// \brief Return true if the 'long double' type should be mangled like
   /// __float128.
   virtual bool useFloat128ManglingForLongDouble() const { return false; }
 
   /// \brief Return the value for the C99 FLT_EVAL_METHOD macro.
   virtual unsigned getFloatEvalMethod() const { return 0; }
 
   // getLargeArrayMinWidth/Align - Return the minimum array size that is

include/clang/Basic/TokenKinds.def

 KEYWORD(break                       , KEYALL)
 KEYWORD(case                        , KEYALL)
 KEYWORD(char                        , KEYALL)
 KEYWORD(const                       , KEYALL)
 KEYWORD(continue                    , KEYALL)
 KEYWORD(default                     , KEYALL)
 KEYWORD(do                          , KEYALL)
 KEYWORD(double                      , KEYALL)
 KEYWORD(else                        , KEYALL)
 KEYWORD(enum                        , KEYALL)
 KEYWORD(extern                      , KEYALL)
 KEYWORD(float                       , KEYALL)
 KEYWORD(for                         , KEYALL)
 KEYWORD(goto                        , KEYALL)
 KEYWORD(if                          , KEYALL)
 KEYWORD(inline                      , KEYC99|KEYCXX|KEYGNU)
 KEYWORD(int                         , KEYALL)

 KEYWORD(__attribute                 , KEYALL)
 KEYWORD(__builtin_choose_expr       , KEYALL)
 KEYWORD(__builtin_offsetof          , 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(__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)

include/clang/Driver/Options.td

 def mno_qpx : Flag<["-"], "mno-qpx">, Group<m_ppc_Features_Group>;
 def mcrbits : Flag<["-"], "mcrbits">, Group<m_ppc_Features_Group>;
 def mno_crbits : Flag<["-"], "mno-crbits">, Group<m_ppc_Features_Group>;
 def minvariant_function_descriptors :
   Flag<["-"], "minvariant-function-descriptors">, Group<m_ppc_Features_Group>;
 def mno_invariant_function_descriptors :
   Flag<["-"], "mno-invariant-function-descriptors">,
   Group<m_ppc_Features_Group>;
+def mfloat128: Flag<["-"], "mfloat128">,
+    Group<m_ppc_Features_Group>;
+def mnofloat128 : Flag<["-"], "mno-float128">,
+    Group<m_ppc_Features_Group>;
 
 def faltivec : Flag<["-"], "faltivec">, Group<f_Group>, Flags<[CC1Option]>,
   HelpText<"Enable AltiVec vector initializer syntax">;
 def fno_altivec : Flag<["-"], "fno-altivec">, Group<f_Group>, Flags<[CC1Option]>;
 def maltivec : Flag<["-"], "maltivec">, Alias<faltivec>;
 def mno_altivec : Flag<["-"], "mno-altivec">, Alias<fno_altivec>;
 
 def mvx : Flag<["-"], "mvx">, Group<m_Group>;

include/clang/Lex/LiteralSupport.h

NumericLiteralParser(StringRef TokSpelling,
                        SourceLocation TokLoc,
                        Preprocessor &PP);
   bool hadError : 1;
   bool isUnsigned : 1;
   bool isLong : 1;          // This is *not* set for long long.
   bool isLongLong : 1;
   bool isFloat : 1;         // 1.0f
   bool isImaginary : 1;     // 1.0i
+  bool isFloat128 : 1;      // 1.0q
   uint8_t MicrosoftInteger; // Microsoft suffix extension i8, i16, i32, or i64.
 
   bool isIntegerLiteral() const {
     return !saw_period && !saw_exponent;
   }
   bool isFloatingLiteral() const {
     return saw_period || saw_exponent;
   }

include/clang/Sema/DeclSpec.h

public:
   static const TST TST_wchar = clang::TST_wchar;
   static const TST TST_char16 = clang::TST_char16;
   static const TST TST_char32 = clang::TST_char32;
   static const TST TST_int = clang::TST_int;
   static const TST TST_int128 = clang::TST_int128;
   static const TST TST_half = clang::TST_half;
   static const TST TST_float = clang::TST_float;
   static const TST TST_double = clang::TST_double;
+  static const TST TST_float128 = clang::TST_float128;
   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;

include/clang/Serialization/ASTBitCodes.h

enum PredefinedTypeIDs {
       PREDEF_TYPE_SAMPLER_ID    = 51,
       /// \brief OpenCL queue type.
       PREDEF_TYPE_QUEUE_ID      = 52,
       /// \brief OpenCL ndrange type.
       PREDEF_TYPE_NDRANGE_ID    = 53,
       /// \brief OpenCL reserve_id type.
       PREDEF_TYPE_RESERVE_ID_ID = 54,
       /// \brief The placeholder type for OpenMP array section.
-      PREDEF_TYPE_OMP_ARRAY_SECTION = 55
+      PREDEF_TYPE_OMP_ARRAY_SECTION = 55,
+      /// \brief The '__float128' type
+      PREDEF_TYPE_FLOAT128_ID = 56
     };
 
     /// \brief The number of predefined type IDs that are reserved for
     /// the PREDEF_TYPE_* constants.
     ///
     /// Type IDs for non-predefined types will start at
     /// NUM_PREDEF_TYPE_IDs.
     const unsigned NUM_PREDEF_TYPE_IDS = 100;

lib/AST/ASTContext.cpp

 unsigned ASTContext::NumImplicitCopyAssignmentOperators;
 unsigned ASTContext::NumImplicitCopyAssignmentOperatorsDeclared;
 unsigned ASTContext::NumImplicitMoveAssignmentOperators;
 unsigned ASTContext::NumImplicitMoveAssignmentOperatorsDeclared;
 unsigned ASTContext::NumImplicitDestructors;
 unsigned ASTContext::NumImplicitDestructorsDeclared;
 
 enum FloatingRank {
-  HalfRank, FloatRank, DoubleRank, LongDoubleRank
+  HalfRank, FloatRank, DoubleRank, LongDoubleRank, Float128Rank
 };
 
 RawComment *ASTContext::getRawCommentForDeclNoCache(const Decl *D) const {
   if (!CommentsLoaded && ExternalSource) {
     ExternalSource->ReadComments();
 
 #ifndef NDEBUG
     ArrayRef<RawComment *> RawComments = Comments.getComments();

 }
 
 TypedefDecl *ASTContext::getUInt128Decl() const {
   if (!UInt128Decl)
     UInt128Decl = buildImplicitTypedef(UnsignedInt128Ty, "__uint128_t");
   return UInt128Decl;
 }
 
-TypeDecl *ASTContext::getFloat128StubType() const {
-  assert(LangOpts.CPlusPlus && "should only be called for c++");
-  if (!Float128StubDecl)
-    Float128StubDecl = buildImplicitRecord("__float128");
-
-  return Float128StubDecl;
-}
-
 void ASTContext::InitBuiltinType(CanQualType &R, BuiltinType::Kind K) {
   BuiltinType *Ty = new (*this, TypeAlignment) BuiltinType(K);
   R = CanQualType::CreateUnsafe(QualType(Ty, 0));
   Types.push_back(Ty);
 }
 
 void ASTContext::InitBuiltinTypes(const TargetInfo &Target,
                                   const TargetInfo *AuxTarget) {
   assert((!this->Target || this->Target == &Target) &&
void ASTContext::InitBuiltinTypes(const TargetInfo &Target,
   InitBuiltinType(UnsignedLongTy,      BuiltinType::ULong);
   InitBuiltinType(UnsignedLongLongTy,  BuiltinType::ULongLong);
 
   // 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);
+
   // GNU extension, 128-bit integers.
   InitBuiltinType(Int128Ty,            BuiltinType::Int128);
   InitBuiltinType(UnsignedInt128Ty,    BuiltinType::UInt128);
 
   // C++ 3.9.1p5
   if (TargetInfo::isTypeSigned(Target.getWCharType()))
     InitBuiltinType(WCharTy,           BuiltinType::WChar_S);
   else  // -fshort-wchar makes wchar_t be unsigned.
void ASTContext::InitBuiltinTypes(const TargetInfo &Target,
   // Placeholder type for OMP array sections.
   if (LangOpts.OpenMP)
     InitBuiltinType(OMPArraySectionTy, BuiltinType::OMPArraySection);
 
   // C99 6.2.5p11.
   FloatComplexTy      = getComplexType(FloatTy);
   DoubleComplexTy     = getComplexType(DoubleTy);
   LongDoubleComplexTy = getComplexType(LongDoubleTy);
+  Float128ComplexTy   = getComplexType(Float128Ty);
 
   // Builtin types for 'id', 'Class', and 'SEL'.
   InitBuiltinType(ObjCBuiltinIdTy, BuiltinType::ObjCId);
   InitBuiltinType(ObjCBuiltinClassTy, BuiltinType::ObjCClass);
   InitBuiltinType(ObjCBuiltinSelTy, BuiltinType::ObjCSel);
 
   if (LangOpts.OpenCL) { 
     InitBuiltinType(OCLImage1dTy, BuiltinType::OCLImage1d);
const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
   const BuiltinType *BT = T->getAs<BuiltinType>();
   assert(BT && "Not a floating point type!");
   switch (BT->getKind()) {
   default: llvm_unreachable("Not a floating point type!");
   case BuiltinType::Half:       return Target->getHalfFormat();
   case BuiltinType::Float:      return Target->getFloatFormat();
   case BuiltinType::Double:     return Target->getDoubleFormat();
   case BuiltinType::LongDouble: return Target->getLongDoubleFormat();
+  case BuiltinType::Float128:   return Target->getFloat128Format();
   }
 }
 
 CharUnits ASTContext::getDeclAlign(const Decl *D, bool ForAlignof) const {
   unsigned Align = Target->getCharWidth();
 
   bool UseAlignAttrOnly = false;
   if (unsigned AlignFromAttr = D->getMaxAlignment()) {
case Type::Builtin:
     case BuiltinType::Double:
       Width = Target->getDoubleWidth();
       Align = Target->getDoubleAlign();
       break;
     case BuiltinType::LongDouble:
       Width = Target->getLongDoubleWidth();
       Align = Target->getLongDoubleAlign();
       break;
+    case BuiltinType::Float128:
+      Width = Target->getFloat128Width();
+      Align = Target->getFloat128Align();
+      break;
     case BuiltinType::NullPtr:
       Width = Target->getPointerWidth(0); // C++ 3.9.1p11: sizeof(nullptr_t)
       Align = Target->getPointerAlign(0); //   == sizeof(void*)
       break;
     case BuiltinType::ObjCId:
     case BuiltinType::ObjCClass:
     case BuiltinType::ObjCSel:
       Width = Target->getPointerWidth(0); 
static FloatingRank getFloatingRank(QualType T) {
 
   assert(T->getAs<BuiltinType>() && "getFloatingRank(): not a floating type");
   switch (T->getAs<BuiltinType>()->getKind()) {
   default: llvm_unreachable("getFloatingRank(): not a floating type");
   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;
   }
 }
 
 /// 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 HalfRank: llvm_unreachable("Complex half 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 HalfRank:       return HalfTy;
   case FloatRank:      return FloatTy;
   case DoubleRank:     return DoubleTy;
   case LongDoubleRank: return LongDoubleTy;
+  case Float128Rank:   return Float128Ty;
   }
   llvm_unreachable("getFloatingRank(): illegal value for rank");
 }
 
 /// 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 {
   FloatingRank LHSR = getFloatingRank(LHS);
   FloatingRank RHSR = getFloatingRank(RHS);
 
   if (LHSR == RHSR)
     return 0;
   if (LHSR > RHSR)
     return 1;
   return -1;
 }
 
 /// getIntegerRank - Return an integer conversion rank (C99 6.3.1.1p1). This
 /// routine will assert if passed a built-in type that isn't an integer or enum,
 /// or if it is not canonicalized.
static char getObjCEncodingForPrimitiveKind(const ASTContext *C,
     case BuiltinType::Long:
       return C->getTargetInfo().getLongWidth() == 32 ? 'l' : 'q';
     case BuiltinType::LongLong:   return 'q';
     case BuiltinType::Int128:     return 't';
     case BuiltinType::Float:      return 'f';
     case BuiltinType::Double:     return 'd';
     case BuiltinType::LongDouble: return 'D';
     case BuiltinType::NullPtr:    return '*'; // like char*
 
+    case BuiltinType::Float128:
     case BuiltinType::Half:
       // FIXME: potentially need @encodes for these!
       return ' ';
 
     case BuiltinType::ObjCId:
     case BuiltinType::ObjCClass:
     case BuiltinType::ObjCSel:
       llvm_unreachable("@encoding ObjC primitive type");
assert(HowLong == 0 && !Signed && !Unsigned &&
            "Bad modifiers used with 'h'!");
     Type = Context.HalfTy;
     break;
   case 'f':
     assert(HowLong == 0 && !Signed && !Unsigned &&
            "Bad modifiers used with 'f'!");
     Type = Context.FloatTy;
     break;
   case 'd':
     assert(HowLong < 2 && !Signed && !Unsigned &&
            "Bad modifiers used with 'd'!");
     if (HowLong)
       Type = Context.LongDoubleTy;
     else
       Type = Context.DoubleTy;
     break;
   case 's':
QualType ASTContext::getRealTypeForBitwidth(unsigned DestWidth) const {
   TargetInfo::RealType Ty = getTargetInfo().getRealTypeByWidth(DestWidth);
   switch (Ty) {
   case TargetInfo::Float:
     return FloatTy;
   case TargetInfo::Double:
     return DoubleTy;
   case TargetInfo::LongDouble:
     return LongDoubleTy;
+  case TargetInfo::Float128:
+    return Float128Ty;
   case TargetInfo::NoFloat:
     return QualType();
   }
 
   llvm_unreachable("Unhandled TargetInfo::RealType value");
 }
 
 void ASTContext::setManglingNumber(const NamedDecl *ND, unsigned Number) {

lib/AST/ItaniumMangle.cpp

void CXXNameMangler::mangleType(const BuiltinType *T) {
   //                 ::= m  # unsigned long
   //                 ::= x  # long long, __int64
   //                 ::= y  # unsigned long long, __int64
   //                 ::= n  # __int128
   //                 ::= o  # unsigned __int128
   //                 ::= f  # float
   //                 ::= d  # double
   //                 ::= e  # long double, __float80
-  // UNSUPPORTED:    ::= g  # __float128
+  //                 ::= g  # __float128
   // 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)
   //                 ::= Di # char32_t
   //                 ::= Ds # char16_t
   //                 ::= Dn # std::nullptr_t (i.e., decltype(nullptr))
   //                 ::= u <source-name>    # vendor extended type
void CXXNameMangler::mangleType(const BuiltinType *T) {
   case BuiltinType::Double:
     Out << 'd';
     break;
   case BuiltinType::LongDouble:
     Out << (getASTContext().getTargetInfo().useFloat128ManglingForLongDouble()
                 ? 'g'
                 : 'e');
     break;
+  case BuiltinType::Float128:
+    if (getASTContext().getTargetInfo().useFloat128ManglingForLongDouble())
+      Out << "U10__float128"; // Match the GCC mangling
+    else
+      Out << 'g';
+    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"

lib/AST/MicrosoftMangle.cpp

#include "clang/AST/BuiltinTypes.def"
   case BuiltinType::OCLReserveID:
     Out << "PAUocl_reserveid@@";
     break;
 
   case BuiltinType::NullPtr:
     Out << "$$T";
     break;
 
+  case BuiltinType::Float128:
   case BuiltinType::Half: {
     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;
   }

lib/AST/NSAPI.cpp

NSAPI::getNSNumberFactoryMethodKind(QualType T) const {
   case BuiltinType::Void:
   case BuiltinType::WChar_U:
   case BuiltinType::WChar_S:
   case BuiltinType::Char16:
   case BuiltinType::Char32:
   case BuiltinType::Int128:
   case BuiltinType::LongDouble:
   case BuiltinType::UInt128:
+  case BuiltinType::Float128:
   case BuiltinType::NullPtr:
   case BuiltinType::ObjCClass:
   case BuiltinType::ObjCId:
   case BuiltinType::ObjCSel:
   case BuiltinType::OCLImage1d:
   case BuiltinType::OCLImage1dArray:
   case BuiltinType::OCLImage1dBuffer:
   case BuiltinType::OCLImage2d:
   case BuiltinType::OCLImage2dArray:

lib/AST/StmtPrinter.cpp

static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node,
 
   // Emit suffixes.  Float literals are always a builtin float type.
   switch (Node->getType()->getAs<BuiltinType>()->getKind()) {
   default: llvm_unreachable("Unexpected type for float literal!");
   case BuiltinType::Half:       break; // FIXME: suffix?
   case BuiltinType::Double:     break; // no suffix.
   case BuiltinType::Float:      OS << 'F'; break;
   case BuiltinType::LongDouble: OS << 'L'; break;
+  case BuiltinType::Float128:   OS << 'Q'; break;
   }
 }
 
 void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) {
   PrintFloatingLiteral(OS, Node, /*PrintSuffix=*/true);
 }
 
 void StmtPrinter::VisitImaginaryLiteral(ImaginaryLiteral *Node) {
   PrintExpr(Node->getSubExpr());

lib/AST/Type.cpp

if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
     return VT->getElementType()->isUnsignedIntegerOrEnumerationType();
   else
     return isUnsignedIntegerOrEnumerationType();
 }
 
 bool Type::isFloatingType() const {
   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() >= BuiltinType::Half &&
-           BT->getKind() <= BuiltinType::LongDouble;
+           BT->getKind() <= BuiltinType::Float128;
   if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType))
     return CT->getElementType()->isFloatingType();
   return false;
 }
 
 bool Type::hasFloatingRepresentation() const {
   if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType))
     return VT->getElementType()->isFloatingType();
   else
     return isFloatingType();
 }
 
 bool Type::isRealFloatingType() const {
   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->isFloatingPoint();
   return false;
 }
 
 bool Type::isRealType() const {
   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() >= BuiltinType::Bool &&
-           BT->getKind() <= BuiltinType::LongDouble;
+           BT->getKind() <= BuiltinType::Float128;
   if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType))
       return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
   return false;
 }
 
 bool Type::isArithmeticType() const {
   if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() >= BuiltinType::Bool &&
-           BT->getKind() <= BuiltinType::LongDouble;
+           BT->getKind() <= BuiltinType::Float128;
   if (const EnumType *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.
     return !ET->getDecl()->isScoped() && ET->getDecl()->isComplete();
StringRef BuiltinType::getName(const PrintingPolicy &Policy) const {
   case Half:
     return Policy.Half ? "half" : "__fp16";
   case Float:
     return "float";
   case Double:
     return "double";
   case LongDouble:
     return "long double";
+  case Float128:
+    return "__float128";
   case WChar_S:
   case WChar_U:
     return Policy.MSWChar ? "__wchar_t" : "wchar_t";
   case Char16:
     return "char16_t";
   case Char32:
     return "char32_t";
   case NullPtr:

lib/AST/TypeLoc.cpp

TypeSpecifierType BuiltinTypeLoc::getWrittenTypeSpec() const {
   case BuiltinType::Int:
   case BuiltinType::Long:
   case BuiltinType::LongLong:
   case BuiltinType::Int128:
   case BuiltinType::Half:
   case BuiltinType::Float:
   case BuiltinType::Double:
   case BuiltinType::LongDouble:
+  case BuiltinType::Float128:
     llvm_unreachable("Builtin type needs extra local data!");
     // Fall through, if the impossible happens.
       
   case BuiltinType::NullPtr:
   case BuiltinType::Overload:
   case BuiltinType::Dependent:
   case BuiltinType::BoundMember:
   case BuiltinType::UnknownAny:

lib/Analysis/PrintfFormatString.cpp

bool PrintfSpecifier::fixType(QualType QT, const LangOptions &LangOpt,
   case BuiltinType::Bool:
   case BuiltinType::WChar_U:
   case BuiltinType::WChar_S:
   case BuiltinType::Char16:
   case BuiltinType::Char32:
   case BuiltinType::UInt128:
   case BuiltinType::Int128:
   case BuiltinType::Half:
+  case BuiltinType::Float128:
     // Various types which are non-trivial to correct.
     return false;
 
 #define SIGNED_TYPE(Id, SingletonId)
 #define UNSIGNED_TYPE(Id, SingletonId)
 #define FLOATING_TYPE(Id, SingletonId)
 #define BUILTIN_TYPE(Id, SingletonId) \
   case BuiltinType::Id:

lib/Basic/TargetInfo.cpp

TargetInfo::TargetInfo(const llvm::Triple &T) : TargetOpts(), Triple(T) {
   UseSignedCharForObjCBool = true;
   UseBitFieldTypeAlignment = true;
   UseZeroLengthBitfieldAlignment = false;
   ZeroLengthBitfieldBoundary = 0;
   HalfFormat = &llvm::APFloat::IEEEhalf;
   FloatFormat = &llvm::APFloat::IEEEsingle;
   DoubleFormat = &llvm::APFloat::IEEEdouble;
   LongDoubleFormat = &llvm::APFloat::IEEEdouble;
+  Float128Format = &llvm::APFloat::IEEEquad;
   DataLayoutString = nullptr;
   UserLabelPrefix = "_";
   MCountName = "mcount";
   RegParmMax = 0;
   SSERegParmMax = 0;
   HasAlignMac68kSupport = false;
   HasBuiltinMSVaList = false;
 
if (getDoubleWidth() == BitWidth)
     return Double;
 
   switch (BitWidth) {
   case 96:
     if (&getLongDoubleFormat() == &llvm::APFloat::x87DoubleExtended)
       return LongDouble;
     break;
   case 128:
     if (&getLongDoubleFormat() == &llvm::APFloat::PPCDoubleDouble ||
         &getLongDoubleFormat() == &llvm::APFloat::IEEEquad)
       return LongDouble;
+    if (hasFloat128Type())
+      return Float128;
     break;
   }
 
   return NoFloat;
 }
 
 /// getTypeAlign - Return the alignment (in bits) of the specified integer type
 /// enum. For example, SignedInt -> getIntAlign().

lib/Basic/Targets.cpp

class PPCTargetInfo : public TargetInfo {
   bool HasVSX;
   bool HasP8Vector;
   bool HasP8Crypto;
   bool HasDirectMove;
   bool HasQPX;
   bool HasHTM;
   bool HasBPERMD;
   bool HasExtDiv;
+  bool HasFloat128;
 
 protected:
   std::string ABI;
 
 public:
   PPCTargetInfo(const llvm::Triple &Triple)
     : TargetInfo(Triple), HasVSX(false), HasP8Vector(false),
       HasP8Crypto(false), HasDirectMove(false), HasQPX(false), HasHTM(false),
-      HasBPERMD(false), HasExtDiv(false) {
+      HasBPERMD(false), HasExtDiv(false), HasFloat128(false) {
     BigEndian = (Triple.getArch() != llvm::Triple::ppc64le);
     SimdDefaultAlign = 128;
     LongDoubleWidth = LongDoubleAlign = 128;
     LongDoubleFormat = &llvm::APFloat::PPCDoubleDouble;
   }
 
   /// \brief Flags for architecture specific defines.
   typedef enum {
int getEHDataRegisterNumber(unsigned RegNo) const override {
     if (RegNo == 1) return 4;
     return -1;
   }
 
   bool hasSjLjLowering() const override {
     return true;
   }
 
   bool useFloat128ManglingForLongDouble() const override {
     return LongDoubleWidth == 128 &&
            LongDoubleFormat == &llvm::APFloat::PPCDoubleDouble &&
            getTriple().isOSBinFormatELF();
   }
+  bool hasFloat128Type() const override {
+    return HasFloat128;
+  }
 };
 
 const Builtin::Info PPCTargetInfo::BuiltinInfo[] = {
 #define BUILTIN(ID, TYPE, ATTRS) \
   { #ID, TYPE, ATTRS, nullptr, ALL_LANGUAGES, nullptr },
 #define LIBBUILTIN(ID, TYPE, ATTRS, HEADER) \
   { #ID, TYPE, ATTRS, HEADER, ALL_LANGUAGES, nullptr },
 #include "clang/Basic/BuiltinsPPC.def"
 };
for (const auto &Feature : Features) {
     } else if (Feature == "+crypto") {
       HasP8Crypto = true;
     } else if (Feature == "+direct-move") {
       HasDirectMove = true;
     } else if (Feature == "+qpx") {
       HasQPX = true;
     } else if (Feature == "+htm") {
       HasHTM = true;
+    } else if (Feature == "+float128") {
+      HasFloat128 = true;
     }
     // TODO: Finish this list and add an assert that we've handled them
     // all.
   }
 
   return true;
 }
 
void PPCTargetInfo::getTargetDefines(const LangOptions &Opts,
   if (HasVSX)
     Builder.defineMacro("__VSX__");
   if (HasP8Vector)
     Builder.defineMacro("__POWER8_VECTOR__");
   if (HasP8Crypto)
     Builder.defineMacro("__CRYPTO__");
   if (HasHTM)
     Builder.defineMacro("__HTM__");
+  if (HasFloat128)
+    Builder.defineMacro("__FLOAT128__");
 
   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
   Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
   if (PointerWidth == 64)
     Builder.defineMacro("__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
 
   // FIXME: The following are not yet generated here by Clang, but are
if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "-vsx") !=
     }
 
     if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "+direct-move") !=
         FeaturesVec.end()) {
       Diags.Report(diag::err_opt_not_valid_with_opt) << "-mdirect-move"
                                                      << "-mno-vsx";
       return false;
     }
+
+    if (std::find(FeaturesVec.begin(), FeaturesVec.end(), "+float128") !=
+        FeaturesVec.end()) {
+      Diags.Report(diag::err_opt_not_valid_with_opt) << "-mfloat128"
+                                                     << "-mno-vsx";
+      return false;
+    }
   }
 
   return true;
 }
 
 bool PPCTargetInfo::initFeatureMap(
     llvm::StringMap<bool> &Features, DiagnosticsEngine &Diags, StringRef CPU,
     const std::vector<std::string> &FeaturesVec) const {
return llvm::StringSwitch<bool>(Feature)
     .Case("vsx", HasVSX)
     .Case("power8-vector", HasP8Vector)
     .Case("crypto", HasP8Crypto)
     .Case("direct-move", HasDirectMove)
     .Case("qpx", HasQPX)
     .Case("htm", HasHTM)
     .Case("bpermd", HasBPERMD)
     .Case("extdiv", HasExtDiv)
+    .Case("float128", HasFloat128)
     .Default(false);
 }
 
 void PPCTargetInfo::setFeatureEnabled(llvm::StringMap<bool> &Features,
                                       StringRef Name, bool Enabled) const {
   // If we're enabling direct-move or power8-vector go ahead and enable vsx
   // as well. Do the inverse if we're disabling vsx. We'll diagnose any user
   // incompatible options.
   if (Enabled) {
-    if (Name == "vsx") {
-     Features[Name] = true;
-    } else if (Name == "direct-move") {
+    if (Name == "direct-move") {
       Features[Name] = Features["vsx"] = true;
     } else if (Name == "power8-vector") {
       Features[Name] = Features["vsx"] = true;
+    } else if (Name == "float128") {
+      Features[Name] = Features["vsx"] = true;
     } else {
       Features[Name] = true;
     }
   } else {
     if (Name == "vsx") {
       Features[Name] = Features["direct-move"] = Features["power8-vector"] =
-          false;
+          Features["float128"] = false;
     } else {
       Features[Name] = false;
     }
   }
 }
 
 const char * const PPCTargetInfo::GCCRegNames[] = {
   "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7",

lib/CodeGen/CGDebugInfo.cpp

case BuiltinType::LongLong:
     Encoding = llvm::dwarf::DW_ATE_signed;
     break;
   case BuiltinType::Bool:
     Encoding = llvm::dwarf::DW_ATE_boolean;
     break;
   case BuiltinType::Half:
   case BuiltinType::Float:
   case BuiltinType::LongDouble:
+  case BuiltinType::Float128:
   case BuiltinType::Double:
     Encoding = llvm::dwarf::DW_ATE_float;
     break;
   }
 
   switch (BT->getKind()) {
   case BuiltinType::Long:
     BTName = "long int";
     break;
   case BuiltinType::LongLong:

lib/CodeGen/CGExprScalar.cpp

// Floating point.
 
     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 either Half or LongDouble.  Convert from float.
+      // Remaining types are Half, LongDouble or __float128. Convert from float.
       llvm::APFloat F(static_cast<float>(amount));
       bool ignored;
+      const llvm::fltSemantics *FS = &CGF.getTarget().getLongDoubleFormat();
       // Don't use getFloatTypeSemantics because Half isn't
       // necessarily represented using the "half" LLVM type.
-      F.convert(value->getType()->isHalfTy()
-                    ? CGF.getTarget().getHalfFormat()
-                    : CGF.getTarget().getLongDoubleFormat(),
-                llvm::APFloat::rmTowardZero, &ignored);
+      if (value->getType()->isFP128Ty())
+        FS = &CGF.getTarget().getFloat128Format();
+      else if (value->getType()->isHalfTy())
+        FS = &CGF.getTarget().getHalfFormat();
+      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) {
       if (!CGF.getContext().getLangOpts().HalfArgsAndReturns) {
         value = Builder.CreateCall(
             CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16,

lib/CodeGen/CodeGenTypes.cpp

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

lib/CodeGen/ItaniumCXXABI.cpp

switch (Ty->getKind()) {
     case BuiltinType::Long:
     case BuiltinType::ULong:
     case BuiltinType::LongLong:
     case BuiltinType::ULongLong:
     case BuiltinType::Half:
     case BuiltinType::Float:
     case BuiltinType::Double:
     case BuiltinType::LongDouble:
+    case BuiltinType::Float128:
     case BuiltinType::Char16:
     case BuiltinType::Char32:
     case BuiltinType::Int128:
     case BuiltinType::UInt128:
     case BuiltinType::OCLImage1d:
     case BuiltinType::OCLImage1dArray:
     case BuiltinType::OCLImage1dBuffer:
     case BuiltinType::OCLImage2d:
QualType FundamentalTypes[] = {
       getContext().BoolTy,             getContext().WCharTy,
       getContext().CharTy,             getContext().UnsignedCharTy,
       getContext().SignedCharTy,       getContext().ShortTy,
       getContext().UnsignedShortTy,    getContext().IntTy,
       getContext().UnsignedIntTy,      getContext().LongTy,
       getContext().UnsignedLongTy,     getContext().LongLongTy,
       getContext().UnsignedLongLongTy, getContext().HalfTy,
       getContext().FloatTy,            getContext().DoubleTy,
       getContext().LongDoubleTy,       getContext().Char16Ty,
-      getContext().Char32Ty,
+      getContext().Char32Ty,           getContext().Float128Ty
   };
   for (const QualType &FundamentalType : FundamentalTypes)
     EmitFundamentalRTTIDescriptor(FundamentalType);
 }
 
 /// What sort of uniqueness rules should we use for the RTTI for the
 /// given type?
 ItaniumCXXABI::RTTIUniquenessKind ItaniumCXXABI::classifyRTTIUniqueness(

lib/Format/FormatToken.cpp

bool FormatToken::isSimpleTypeSpecifier() const {
   case tok::kw_signed:
   case tok::kw_unsigned:
   case tok::kw_void:
   case tok::kw_char:
   case tok::kw_int:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw___float128:
   case tok::kw_wchar_t:
   case tok::kw_bool:
   case tok::kw___underlying_type:
   case tok::annot_typename:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
   case tok::kw_typeof:
   case tok::kw_decltype:

lib/Frontend/InitPreprocessor.cpp

#undef TOSTR2
   DefineTypeWidth("__UINTMAX_WIDTH__",  TI.getUIntMaxType(), TI, Builder);
   DefineType("__UINTPTR_TYPE__", TI.getUIntPtrType(), Builder);
   DefineFmt("__UINTPTR", TI.getUIntPtrType(), TI, Builder);
   DefineTypeWidth("__UINTPTR_WIDTH__", TI.getUIntPtrType(), TI, Builder);
 
   DefineFloatMacros(Builder, "FLT", &TI.getFloatFormat(), "F");
   DefineFloatMacros(Builder, "DBL", &TI.getDoubleFormat(), "");
   DefineFloatMacros(Builder, "LDBL", &TI.getLongDoubleFormat(), "L");
+  if (TI.hasFloat128Type())
+    DefineFloatMacros(Builder, "FLT128", &TI.getFloat128Format(), "Q");
 
   // Define a __POINTER_WIDTH__ macro for stdint.h.
   Builder.defineMacro("__POINTER_WIDTH__",
                       Twine((int)TI.getPointerWidth(0)));
 
   // Define __BIGGEST_ALIGNMENT__ to be compatible with gcc.
   Builder.defineMacro("__BIGGEST_ALIGNMENT__",
                       Twine(TI.getSuitableAlign() / TI.getCharWidth()) );

lib/Index/USRGeneration.cpp

if (const BuiltinType *BT = T->getAs<BuiltinType>()) {
         case BuiltinType::Half:
           c = 'h'; break;
         case BuiltinType::Float:
           c = 'f'; break;
         case BuiltinType::Double:
           c = 'd'; break;
         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:
 #include "clang/AST/BuiltinTypes.def"
         case BuiltinType::Dependent:
         case BuiltinType::OCLImage1d:
         case BuiltinType::OCLImage1dArray:
         case BuiltinType::OCLImage1dBuffer:

lib/Lex/LiteralSupport.cpp

NumericLiteralParser::NumericLiteralParser(StringRef TokSpelling,
   saw_exponent = false;
   saw_period = false;
   saw_ud_suffix = false;
   isLong = false;
   isUnsigned = false;
   isLongLong = false;
   isFloat = false;
   isImaginary = false;
+  isFloat128 = false;
   MicrosoftInteger = 0;
   hadError = false;
 
   if (*s == '0') { // parse radix
     ParseNumberStartingWithZero(TokLoc);
     if (hadError)
       return;
   } else { // the first digit is non-zero
NumericLiteralParser::NumericLiteralParser(StringRef TokSpelling,
 
   // Loop over all of the characters of the suffix.  If we see something bad,
   // we break out of the loop.
   for (; s != ThisTokEnd; ++s) {
     switch (*s) {
     case 'f':      // FP Suffix for "float"
     case 'F':
       if (!isFPConstant) break;  // Error for integer constant.
-      if (isFloat || isLong) break; // FF, LF invalid.
+      if (isFloat || isLong || isFloat128) break; // FF, LF, QF invalid.
       isFloat = true;
       continue;  // Success.
+    case 'q':     // FP Suffix for "__float128"
+    case 'Q':
+      if (!isFPConstant) break;  // Error for integer constant.
+      if (isFloat || isLong || isFloat128) break; // FQ, LQ, QQ invalid.
+      isFloat128 = true;
+      continue;  // Success.
     case 'u':
     case 'U':
       if (isFPConstant) break;  // Error for floating constant.
       if (isUnsigned) break;    // Cannot be repeated.
       isUnsigned = true;
       continue;  // Success.
     case 'l':
     case 'L':
       if (isLong || isLongLong) break;  // Cannot be repeated.
-      if (isFloat) break;               // LF invalid.
+      if (isFloat || isFloat128) break; // LF, QL invalid.
 
       // Check for long long.  The L's need to be adjacent and the same case.
       if (s[1] == s[0]) {
         assert(s + 1 < ThisTokEnd && "didn't maximally munch?");
         if (isFPConstant) break;        // long long invalid for floats.
         isLongLong = true;
         ++s;  // Eat both of them.
       } else {

lib/Parse/ParseDecl.cpp

while (1) {
     case tok::kw_float:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec,
                                      DiagID, Policy);
       break;
     case tok::kw_double:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec,
                                      DiagID, Policy);
       break;
+    case tok::kw___float128:
+      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec,
+                                     DiagID, Policy);
+      break;
     case tok::kw_wchar_t:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_wchar, Loc, PrevSpec,
                                      DiagID, Policy);
       break;
     case tok::kw_char16_t:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_char16, Loc, PrevSpec,
                                      DiagID, Policy);
       break;
bool Parser::isKnownToBeTypeSpecifier(const Token &Tok) const {
   case tok::kw_char:
   case tok::kw_wchar_t:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
   case tok::kw_int:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw___float128:
   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++)
bool Parser::isTypeSpecifierQualifier() {
   case tok::kw_char:
   case tok::kw_wchar_t:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
   case tok::kw_int:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw___float128:
   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++)
bool Parser::isDeclarationSpecifier(bool DisambiguatingWithExpression) {
   case tok::kw_wchar_t:
   case tok::kw_char16_t:
   case tok::kw_char32_t:
 
   case tok::kw_int:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw___float128:
   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++)

lib/Parse/ParseExpr.cpp

#undef RTT_JOIN
   case tok::kw_long:
   case tok::kw___int64:
   case tok::kw___int128:
   case tok::kw_signed:
   case tok::kw_unsigned:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw___float128:
   case tok::kw_void:
   case tok::kw_typename:
   case tok::kw_typeof:
   case tok::kw___vector: {
     if (!getLangOpts().CPlusPlus) {
       Diag(Tok, diag::err_expected_expression);
       return ExprError();
     }

lib/Parse/ParseExprCXX.cpp

case tok::kw_half:
     DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw_float:
     DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw_double:
     DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec, DiagID, Policy);
     break;
+  case tok::kw___float128:
+    DS.SetTypeSpecType(DeclSpec::TST_float128, Loc, PrevSpec, DiagID, Policy);
+    break;
   case tok::kw_wchar_t:
     DS.SetTypeSpecType(DeclSpec::TST_wchar, 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:
     DS.SetTypeSpecType(DeclSpec::TST_char32, Loc, PrevSpec, DiagID, Policy);

lib/Parse/ParseTentative.cpp

#define TYPE_TRAIT(N,Spelling,K) \
   case tok::kw_##Spelling:
 #include "clang/Basic/TokenKinds.def"
     return TPResult::True;
       
   // Obviously starts a type-specifier-seq:
   case tok::kw_char:
   case tok::kw_const:
   case tok::kw_double:
+  case tok::kw___float128:
   case tok::kw_enum:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_int:
   case tok::kw_long:
   case tok::kw___int64:
   case tok::kw___int128:
   case tok::kw_restrict:
Parser::isCXXDeclarationSpecifier(Parser::TPResult BracedCastResult,
   case tok::kw_long:
   case tok::kw___int64:
   case tok::kw___int128:
   case tok::kw_signed:
   case tok::kw_unsigned:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw___float128:
   case tok::kw_void:
   case tok::annot_decltype:
     if (NextToken().is(tok::l_paren))
       return TPResult::Ambiguous;
 
     // This is a function-style cast in all cases we disambiguate other than
     // one:
     //   struct S {
bool Parser::isCXXDeclarationSpecifierAType() {
   case tok::kw_long:
   case tok::kw___int64:
   case tok::kw___int128:
   case tok::kw_signed:
   case tok::kw_unsigned:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw___float128:
   case tok::kw_void:
   case tok::kw___unknown_anytype:
   case tok::kw___auto_type:
     return true;
 
   case tok::kw_auto:
     return getLangOpts().CPlusPlus11;
 

lib/Sema/DeclSpec.cpp

switch (DS.getTypeSpecType()) {
     case TST_char:
     case TST_char16:
     case TST_char32:
     case TST_class:
     case TST_decimal128:
     case TST_decimal32:
     case TST_decimal64:
     case TST_double:
+    case TST_float128:
     case TST_enum:
     case TST_error:
     case TST_float:
     case TST_half:
     case TST_int:
     case TST_int128:
     case TST_struct:
     case TST_interface:
const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
   case DeclSpec::TST_wchar:       return Policy.MSWChar ? "__wchar_t" : "wchar_t";
   case DeclSpec::TST_char16:      return "char16_t";
   case DeclSpec::TST_char32:      return "char32_t";
   case DeclSpec::TST_int:         return "int";
   case DeclSpec::TST_int128:      return "__int128";
   case DeclSpec::TST_half:        return "half";
   case DeclSpec::TST_float:       return "float";
   case DeclSpec::TST_double:      return "double";
+  case DeclSpec::TST_float128:    return "__float128";
   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";

lib/Sema/SemaDecl.cpp

bool Sema::isSimpleTypeSpecifier(tok::TokenKind Kind) const {
   case tok::kw_signed:
   case tok::kw_unsigned:
   case tok::kw_void:
   case tok::kw_char:
   case tok::kw_int:
   case tok::kw_half:
   case tok::kw_float:
   case tok::kw_double:
+  case tok::kw___float128:
   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:

lib/Sema/SemaExpr.cpp

static QualType handleFloatConversion(Sema &S, ExprResult &LHS,
                                       QualType RHSType, bool IsCompAssign) {
   bool LHSFloat = LHSType->isRealFloatingType();
   bool RHSFloat = RHSType->isRealFloatingType();
 
   // If we have two real floating types, convert the smaller operand
   // to the bigger result.
   if (LHSFloat && RHSFloat) {
     int order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
     if (order > 0) {
       RHS = S.ImpCastExprToType(RHS.get(), LHSType, CK_FloatingCast);
       return LHSType;
     }
 
     assert(order < 0 && "illegal float comparison");
     if (!IsCompAssign)
       LHS = S.ImpCastExprToType(LHS.get(), RHSType, CK_FloatingCast);
     return RHSType;
return handleIntToFloatConversion(S, RHS, LHS, RHSType, LHSType,
                                     /*convertFloat=*/!IsCompAssign);
 }
 
 typedef ExprResult PerformCastFn(Sema &S, Expr *operand, QualType toType);
 
 namespace {
 /// These helper callbacks are placed in an anonymous namespace to
 /// permit their use as function template parameters.
 ExprResult doIntegralCast(Sema &S, Expr *op, QualType toType) {
   return S.ImpCastExprToType(op, toType, CK_IntegralCast);
 }
 
 ExprResult doComplexIntegralCast(Sema &S, Expr *op, QualType toType) {
   return S.ImpCastExprToType(op, S.Context.getComplexType(toType),
                              CK_IntegralComplexCast);
 }
 }
 
 /// \brief Handle integer arithmetic conversions.  Helper function of
 /// UsualArithmeticConversions()
 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)) {
     // The unsigned type has greater than or equal rank to the
     // signed type, so use the unsigned type
     if (RHSSigned) {
if (LHSType != LHSUnpromotedType && !IsCompAssign)
     LHS = ImpCastExprToType(LHS.get(), LHSType, CK_IntegralCast);
 
   // If both types are identical, no conversion is needed.
   if (LHSType == RHSType)
     return LHSType;
 
   // At this point, we have two different arithmetic types.
 
   // Handle complex types first (C99 6.3.1.8p1).
   if (LHSType->isComplexType() || RHSType->isComplexType())
     return handleComplexFloatConversion(*this, LHS, RHS, LHSType, RHSType,
                                         IsCompAssign);
 
   // Now handle "real" floating types (i.e. float, double, long double).
   if (LHSType->isRealFloatingType() || RHSType->isRealFloatingType())
     return handleFloatConversion(*this, LHS, RHS, LHSType, RHSType,
                                  IsCompAssign);
 
   // Handle GCC complex int extension.
ExprResult Sema::ActOnNumericConstant(const Token &Tok, Scope *UDLScope) {
   }
 
   Expr *Res;
 
   if (Literal.isFloatingLiteral()) {
     QualType Ty;
     if (Literal.isFloat)
       Ty = Context.FloatTy;
-    else if (!Literal.isLong)
-      Ty = Context.DoubleTy;
-    else
+    else if (Literal.isLong)
       Ty = Context.LongDoubleTy;
+    else if (Literal.isFloat128)
+      Ty = Context.Float128Ty;
+    else
+      Ty = Context.DoubleTy;
 
     Res = BuildFloatingLiteral(*this, Literal, Ty, Tok.getLocation());
 
     if (Ty == Context.DoubleTy) {
       if (getLangOpts().SinglePrecisionConstants) {
         Res = ImpCastExprToType(Res, Context.FloatTy, CK_FloatingCast).get();
       } else if (getLangOpts().OpenCL &&
                  !((getLangOpts().OpenCLVersion >= 120) ||

lib/Sema/SemaLookup.cpp

static bool LookupBuiltin(Sema &S, LookupResult &R) {
   Sema::LookupNameKind NameKind = R.getLookupKind();
 
   // If we didn't find a use of this identifier, and if the identifier
   // corresponds to a compiler builtin, create the decl object for the builtin
   // now, injecting it into translation unit scope, and return it.
   if (NameKind == Sema::LookupOrdinaryName ||
       NameKind == Sema::LookupRedeclarationWithLinkage) {
     IdentifierInfo *II = R.getLookupName().getAsIdentifierInfo();
     if (II) {
-      if (S.getLangOpts().CPlusPlus11 && S.getLangOpts().GNUMode &&
-          II == S.getFloat128Identifier()) {
-        // libstdc++4.7's type_traits expects type __float128 to exist, so
-        // insert a dummy type to make that header build in gnu++11 mode.
-        R.addDecl(S.getASTContext().getFloat128StubType());
-        return true;
-      }
       if (S.getLangOpts().CPlusPlus && NameKind == Sema::LookupOrdinaryName &&
           II == S.getASTContext().getMakeIntegerSeqName()) {
         R.addDecl(S.getASTContext().getMakeIntegerSeqDecl());
         return true;
       }
 
       // If this is a builtin on this (or all) targets, create the decl.
       if (unsigned BuiltinID = II->getBuiltinID()) {
         // In C++, we don't have any predefined library functions like

lib/Sema/SemaOverload.cpp

if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
     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()) {
     // 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())) {
     // Floating-integral conversions (C++ 4.9).
     SCS.Second = ICK_Floating_Integral;
     FromType = ToType.getUnqualifiedType();
   } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
     SCS.Second = ICK_Block_Pointer_Conversion;
   } else if (AllowObjCWritebackConversion &&
              S.isObjCWritebackConversion(FromType, ToType, FromType)) {
     SCS.Second = ICK_Writeback_Conversion;
   } else if (S.IsPointerConversion(From, FromType, ToType, InOverloadResolution,
                                    FromType, IncompatibleObjC)) {
     // Pointer conversions (C++ 4.10).
if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>())
     if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
       /// An rvalue of type float can be converted to an rvalue of type
       /// double. (C++ 4.6p1).
       if (FromBuiltin->getKind() == BuiltinType::Float &&
           ToBuiltin->getKind() == BuiltinType::Double)
         return true;
 
       // 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::LongDouble ||
+           ToBuiltin->getKind() == BuiltinType::Float128))
+        return true;
+
+      // A long double can be promoted to __float128
+      if (!getLangOpts().CPlusPlus &&
+          FromBuiltin->getKind() == BuiltinType::LongDouble &&
+          ToBuiltin->getKind() == BuiltinType::Float128)
         return true;
 
       // Half can be promoted to float.
       if (!getLangOpts().NativeHalfType &&
            FromBuiltin->getKind() == BuiltinType::Half &&
           ToBuiltin->getKind() == BuiltinType::Float)
         return true;
     }
class BuiltinOperatorOverloadBuilder {
   bool HasArithmeticOrEnumeralCandidateType;
   SmallVectorImpl<BuiltinCandidateTypeSet> &CandidateTypes;
   OverloadCandidateSet &CandidateSet;
 
   // Define some constants used to index and iterate over the arithemetic types
   // provided via the getArithmeticType() method below.
   // The "promoted arithmetic types" are the arithmetic
   // types are that preserved by promotion (C++ [over.built]p2).
-  static const unsigned FirstIntegralType = 3;
-  static const unsigned LastIntegralType = 20;
-  static const unsigned FirstPromotedIntegralType = 3,
-                        LastPromotedIntegralType = 11;
+  static const unsigned FirstIntegralType = 4;
+  static const unsigned LastIntegralType = 21;
+  static const unsigned FirstPromotedIntegralType = 4,
+                        LastPromotedIntegralType = 12;
   static const unsigned FirstPromotedArithmeticType = 0,
-                        LastPromotedArithmeticType = 11;
-  static const unsigned NumArithmeticTypes = 20;
+                        LastPromotedArithmeticType = 12;
+  static const unsigned NumArithmeticTypes = 21;
 
   /// \brief Get the canonical type for a given arithmetic type index.
   CanQualType getArithmeticType(unsigned index) {
     assert(index < NumArithmeticTypes);
     static CanQualType ASTContext::* const
       ArithmeticTypes[NumArithmeticTypes] = {
       // Start of promoted types.
       &ASTContext::FloatTy,
       &ASTContext::DoubleTy,
       &ASTContext::LongDoubleTy,
+      &ASTContext::Float128Ty,
 
       // Start of integral types.
       &ASTContext::IntTy,
       &ASTContext::LongTy,
       &ASTContext::LongLongTy,
       &ASTContext::Int128Ty,
       &ASTContext::UnsignedIntTy,
       &ASTContext::UnsignedLongTy,

lib/Sema/SemaTemplateVariadic.cpp

bool Sema::containsUnexpandedParameterPacks(Declarator &D) {
   case TST_wchar:
   case TST_char16:
   case TST_char32:
   case TST_int:
   case TST_int128:
   case TST_half:
   case TST_float:
   case TST_double:
+  case TST_float128:
   case TST_bool:
   case TST_decimal32:
   case TST_decimal64:
   case TST_decimal128:
   case TST_enum:
   case TST_union:
   case TST_struct:
   case TST_interface:

lib/Sema/SemaType.cpp

if (DS.getTypeSpecSign() != DeclSpec::TSS_unsigned) {
         }
         break;
       }
     }
     break;
   }
   case DeclSpec::TST_int128:
     if (!S.Context.getTargetInfo().hasInt128Type())
-      S.Diag(DS.getTypeSpecTypeLoc(), diag::err_int128_unsupported);
+      S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
+        << "__int128";
     if (DS.getTypeSpecSign() == DeclSpec::TSS_unsigned)
       Result = Context.UnsignedInt128Ty;
     else
       Result = Context.Int128Ty;
     break;
   case DeclSpec::TST_half: Result = Context.HalfTy; break;
   case DeclSpec::TST_float: Result = Context.FloatTy; break;
   case DeclSpec::TST_double:
     if (DS.getTypeSpecWidth() == DeclSpec::TSW_long)
       Result = Context.LongDoubleTy;
     else
       Result = Context.DoubleTy;
 
     if (S.getLangOpts().OpenCL &&
         !((S.getLangOpts().OpenCLVersion >= 120) ||
           S.getOpenCLOptions().cl_khr_fp64)) {
       S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_requires_extension)
           << Result << "cl_khr_fp64";
       declarator.setInvalidType(true);
     }
     break;
+  case DeclSpec::TST_float128:
+    if (!S.Context.getTargetInfo().hasFloat128Type())
+      S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
+        << "__float128";
+    Result = Context.Float128Ty;
+    break;
   case DeclSpec::TST_bool: Result = Context.BoolTy; break; // _Bool or bool
   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;
     declarator.setInvalidType(true);
     break;
if (ClassTemplateSpecializationDecl *ClassTemplateSpec
                                   /*Complain=*/!Diagnoser.Suppressed);
       }
     }
   }
 
   if (Diagnoser.Suppressed)
     return true;
 
-  // We have an incomplete type. Produce a diagnostic.
-  if (Ident___float128 &&
-      T == Context.getTypeDeclType(Context.getFloat128StubType())) {
-    Diag(Loc, diag::err_typecheck_decl_incomplete_type___float128);
-    return true;
-  }
-
   Diagnoser.diagnose(*this, Loc, T);
 
   // If the type was a forward declaration of a class/struct/union
   // type, produce a note.
   if (Tag && !Tag->getDecl()->isInvalidDecl())
     Diag(Tag->getDecl()->getLocation(),
          Tag->isBeingDefined() ? diag::note_type_being_defined
                                : diag::note_forward_declaration)
       << QualType(Tag, 0);
 
   // If the Objective-C class was a forward declaration, produce a note.
   if (IFace && !IFace->getDecl()->isInvalidDecl())
     Diag(IFace->getDecl()->getLocation(), diag::note_forward_class);
 
   // If we have external information that we can use to suggest a fix,

lib/Serialization/ASTCommon.cpp

case BuiltinType::Float:
     ID = PREDEF_TYPE_FLOAT_ID;
     break;
   case BuiltinType::Double:
     ID = PREDEF_TYPE_DOUBLE_ID;
     break;
   case BuiltinType::LongDouble:
     ID = PREDEF_TYPE_LONGDOUBLE_ID;
     break;
+  case BuiltinType::Float128:
+    ID = PREDEF_TYPE_FLOAT128_ID;
+    break;
   case BuiltinType::NullPtr:
     ID = PREDEF_TYPE_NULLPTR_ID;
     break;
   case BuiltinType::Char16:
     ID = PREDEF_TYPE_CHAR16_ID;
     break;
   case BuiltinType::Char32:
     ID = PREDEF_TYPE_CHAR32_ID;

lib/Serialization/ASTReader.cpp

case PREDEF_TYPE_FLOAT_ID:
       T = Context.FloatTy;
       break;
     case PREDEF_TYPE_DOUBLE_ID:
       T = Context.DoubleTy;
       break;
     case PREDEF_TYPE_LONGDOUBLE_ID:
       T = Context.LongDoubleTy;
       break;
+    case PREDEF_TYPE_FLOAT128_ID:
+      T = Context.Float128Ty;
+      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;

test/CodeGenCXX/float128-declarations.cpp

+// RUN: %clang_cc1 -emit-llvm -triple powerpc64-unknown-unknown \
+// RUN:   -target-feature +float128 -std=c++11 %s -o - | FileCheck %s
+// RUN: %clang_cc1 -emit-llvm -triple powerpc64le-unknown-unknown \
+// RUN:   -target-feature +float128 -std=c++11 %s -o - | FileCheck %s
+//
+/*  Various contexts where type __float128 can appear. */
+
+/*  Namespace */
+namespace {
+  __float128 f1n;
+  __float128 f2n = 33.q;
+  __float128 arr1n[10];
+  __float128 arr2n[] = { 1.2q, 3.0q, 3.e11q };
+  const volatile __float128 func1n(const __float128 &arg) {
+    return arg + f2n + arr1n[4] - arr2n[1];
+  }
+}
+
+/* File */
+__float128 f1f;
+__float128 f2f = 32.4q;
+static __float128 f3f = f2f;
+__float128 arr1f[10];
+__float128 arr2f[] = { -1.2q, -3.0q, -3.e11q };
+__float128 func1f(__float128 arg);
+
+/* Class */
+class C1 {
+  __float128 f1c;
+  static const __float128 f2c;
+  volatile __float128 f3c;
+public:
+  C1(__float128 arg) : f1c(arg), f3c(arg) { }
+  __float128 func1c(__float128 arg ) {
+    return f1c + arg;
+  }
+  static __float128 func2c(__float128 arg) {
+    return arg * C1::f2c;
+  }
+};
+
+/*  Template */
+template <class C> C func1t(C arg) { return arg * 2.q; }
+template <class C> struct S1 {
+  C mem1;
+};
+template <> struct S1<__float128> {
+  __float128 mem2;
+};
+
+/* Local */
+int main(void) {
+  __float128 f1l = 123e220q;
+  __float128 f2l = -0.q;
+  __float128 f3l = 1.189731495357231765085759326628007e4932q;
+  C1 c1(f1l);
+  S1<__float128> s1 = { 132.q };
+  __float128 f4l = func1n(f1l) + func1f(f2l) + c1.func1c(f3l) + c1.func2c(f1l) +
+    func1t(f1l) + s1.mem2 - f1n + f2n;
+#if (__cplusplus >= 201103L)
+  auto f5l = -1.q, *f6l = &f2l, f7l = func1t(f3l);
+#endif
+  __float128 f8l = f4l++;
+  __float128 arr1l[] = { -1.q, -0.q, -11.q };
+}
+// CHECK-DAG: @_ZN12_GLOBAL__N_13f1nE = internal global fp128 0xL00000000000000000000000000000000
+// CHECK-DAG: @_ZN12_GLOBAL__N_13f2nE = internal global fp128 0xL00000000000000004004080000000000
+// CHECK-DAG: @_ZN12_GLOBAL__N_15arr1nE = internal global [10 x fp128]
+// CHECK-DAG: @_ZN12_GLOBAL__N_15arr2nE = internal global [3 x fp128] [fp128 0xL33333333333333333FFF333333333333, fp128 0xL00000000000000004000800000000000, fp128 0xL00000000000000004025176592E00000]
+// CHECK-DAG: define internal fp128 @_ZN12_GLOBAL__N_16func1nERKU10__float128(fp128*
+// CHECK-DAG: @f1f = global fp128 0xL00000000000000000000000000000000
+// CHECK-DAG: @f2f = global fp128 0xL33333333333333334004033333333333
+// CHECK-DAG: @arr1f = global [10 x fp128]
+// CHECK-DAG: @arr2f = global [3 x fp128] [fp128 0xL3333333333333333BFFF333333333333, fp128 0xL0000000000000000C000800000000000, fp128 0xL0000000000000000C025176592E00000]
+// CHECK-DAG: declare fp128 @_Z6func1fU10__float128(fp128)
+// CHECK-DAG: define linkonce_odr void @_ZN2C1C2EU10__float128(%class.C1* %this, fp128 %arg)
+// CHECK-DAG: define linkonce_odr fp128 @_ZN2C16func2cEU10__float128(fp128 %arg)
+// CHECK-DAG: define linkonce_odr fp128 @_Z6func1tIU10__float128ET_S0_(fp128 %arg)
+// CHECK-DAG: @_ZZ4mainE2s1 = private unnamed_addr constant %struct.S1 { fp128 0xL00000000000000004006080000000000 }
+// CHECK-DAG: store fp128 0xLF0AFD0EBFF292DCE42E0B38CDD83F26F, fp128* %f1l, align 16
+// CHECK-DAG: store fp128 0xL00000000000000008000000000000000, fp128* %f2l, align 16
+// CHECK-DAG: store fp128 0xLFFFFFFFFFFFFFFFF7FFEFFFFFFFFFFFF, fp128* %f3l, align 16
+// CHECK-DAG: store fp128 0xL0000000000000000BFFF000000000000, fp128* %f5l, align 16
+// CHECK-DAG: [[F4L:%[a-z0-9]+]] = load fp128, fp128* %f4l
+// CHECK-DAG: [[INC:%[a-z0-9]+]] = fadd fp128 [[F4L]], 0xL00000000000000003FFF000000000000
+// CHECK-DAG: store fp128 [[INC]], fp128* %f4l

test/Preprocessor/init.c

 // PPCPOWER8:#define _ARCH_PWR4 1
 // PPCPOWER8:#define _ARCH_PWR5 1
 // PPCPOWER8:#define _ARCH_PWR5X 1
 // PPCPOWER8:#define _ARCH_PWR6 1
 // PPCPOWER8:#define _ARCH_PWR6X 1
 // PPCPOWER8:#define _ARCH_PWR7 1
 // PPCPOWER8:#define _ARCH_PWR8 1
 //
+// RUN: %clang_cc1 -E -dM -ffreestanding -triple=powerpc64-none-none -target-feature +float128 -target-cpu power8 -fno-signed-char < /dev/null | FileCheck -check-prefix PPC-FLOAT128 %s
+// PPC-FLOAT128:#define __FLOAT128__ 1
+// PPC-FLOAT128:#define __FLT128_DECIMAL_DIG__ 36
+// PPC-FLOAT128:#define __FLT128_DENORM_MIN__ 6.47517511943802511092443895822764655e-4966Q
+// PPC-FLOAT128:#define __FLT128_DIG__ 33
+// PPC-FLOAT128:#define __FLT128_EPSILON__ 1.92592994438723585305597794258492732e-34Q
+// PPC-FLOAT128:#define __FLT128_HAS_DENORM__ 1
+// PPC-FLOAT128:#define __FLT128_HAS_INFINITY__ 1
+// PPC-FLOAT128:#define __FLT128_HAS_QUIET_NAN__ 1
+// PPC-FLOAT128:#define __FLT128_MANT_DIG__ 113
+// PPC-FLOAT128:#define __FLT128_MAX_10_EXP__ 4932
+// PPC-FLOAT128:#define __FLT128_MAX_EXP__ 16384
+// PPC-FLOAT128:#define __FLT128_MAX__ 1.18973149535723176508575932662800702e+4932Q
+// PPC-FLOAT128:#define __FLT128_MIN_10_EXP__ (-4931)
+// PPC-FLOAT128:#define __FLT128_MIN_EXP__ (-16381)
+// PPC-FLOAT128:#define __FLT128_MIN__ 3.36210314311209350626267781732175260e-4932Q
+//
 // RUN: %clang_cc1 -E -dM -ffreestanding -triple=powerpc64-unknown-linux-gnu -fno-signed-char < /dev/null | FileCheck -check-prefix PPC64-LINUX %s
 //
 // PPC64-LINUX:#define _ARCH_PPC 1
 // PPC64-LINUX:#define _ARCH_PPC64 1
 // PPC64-LINUX:#define _BIG_ENDIAN 1
 // PPC64-LINUX:#define _LP64 1
 // PPC64-LINUX:#define __BIGGEST_ALIGNMENT__ 8
 // PPC64-LINUX:#define __BIG_ENDIAN__ 1

test/Sema/128bitfloat.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=gnu++11 %s
 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 #if !defined(__STRICT_ANSI__)
-__float128 f;  // expected-error {{support for type '__float128' is not yet implemented}}
+__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> {};
+template<> struct __is_floating_point_helper<__float128> {};  // expected-error {{__float128 is not supported on this target}}
 
 // FIXME: This could have a better diag.
-void g(int x, __float128 *y) {
-  x + *y;  // expected-error {{invalid operands to binary expression ('int' and '__float128')}}
+int g(int x, __float128 *y) {  // expected-error {{__float128 is not supported on this target}}
+  return x + *y;
 }
 
 #else
-__float128 f;  // expected-error {{unknown type name '__float128'}}
+__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 {{use of undeclared identifier '__float128'}}
+template<> struct __is_floating_point_helper<__float128> {};  // expected-error {{__float128 is not supported on this target}}
 
-void g(int x, __float128 *y) {  // expected-error {{unknown type name '__float128'}}
-  x + *y;
+int g(int x, __float128 *y) {  // expected-error {{__float128 is not supported on this target}}
+  return x + *y;
 }
 
 #endif

test/SemaCXX/deleted-operator.cpp

 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
 
 struct PR10757 {
   bool operator~() = delete; // expected-note {{explicitly deleted}}
   bool operator==(const PR10757&) = delete; // expected-note {{explicitly deleted}}
   operator float();
 };
 int PR10757f() {
   PR10757 a1;
   // FIXME: We get a ridiculous number of "built-in candidate" notes here...
   if(~a1) {} // expected-error {{overload resolution selected deleted operator}} expected-note 8 {{built-in candidate}}
-  if(a1==a1) {} // expected-error {{overload resolution selected deleted operator}} expected-note 121 {{built-in candidate}}
+  if(a1==a1) {} // expected-error {{overload resolution selected deleted operator}} expected-note 144 {{built-in candidate}}
 }
 
 struct DelOpDel {
   // FIXME: In MS ABI, we error twice below.
   virtual ~DelOpDel() {} // expected-error 1-2 {{attempt to use a deleted function}}
   void operator delete(void*) = delete; // expected-note 1-2 {{deleted here}}
 };

test/SemaCXX/overloaded-builtin-operators.cpp

 struct A {
   template< typename T > operator T() const;
 };
 
 void test_dr425(A a) {
   // FIXME: lots of candidates here!
   (void)(1.0f * a); // expected-error{{ambiguous}} \
                     // expected-note 4{{candidate}} \
-                    // expected-note {{remaining 117 candidates omitted; pass -fshow-overloads=all to show them}}
+                    // expected-note {{remaining 140 candidates omitted; pass -fshow-overloads=all to show them}}
 }
 
 // pr5432
 enum e {X};
 
 const int a[][2] = {{1}};
 
 int test_pr5432() {

tools/libclang/CXType.cpp

switch (BT->getKind()) {
     BTCASE(Short);
     BTCASE(Int);
     BTCASE(Long);
     BTCASE(LongLong);
     BTCASE(Int128);
     BTCASE(Float);
     BTCASE(Double);
     BTCASE(LongDouble);
+    BTCASE(Float128);
     BTCASE(NullPtr);
     BTCASE(Overload);
     BTCASE(Dependent);
     BTCASE(ObjCId);
     BTCASE(ObjCClass);
     BTCASE(ObjCSel);
   default:
     return CXType_Unexposed;
switch (K) {
     TKIND(Short);
     TKIND(Int);
     TKIND(Long);
     TKIND(LongLong);
     TKIND(Int128);
     TKIND(Float);
     TKIND(Double);
     TKIND(LongDouble);
+    TKIND(Float128);
     TKIND(NullPtr);
     TKIND(Overload);
     TKIND(Dependent);
     TKIND(ObjCId);
     TKIND(ObjCClass);
     TKIND(ObjCSel);
     TKIND(Complex);
     TKIND(Pointer);