[Clang][C++23] Implement core language changes from P1467R9 extended floating-point types and standard names

[codemzs]

Summary

This commit implements Core language changes based on P1467R9 Extended floating-point types and standard names

As per the proposal's definition the following two types are marked as extended floating point: Float16 (aka _Float16) and Bfloat16 (aka decltype (0.0bf16) or __bf16). Future work can extend this to support other floating-point types such as Float32, Float64, and Float128. Please refer to the RFC for more details.

[tschuett]

I don't believe that there is NativeBFloat16Type. AArch64 learned bf16 with ARMv8.6-A, but very limited operations and only in SIMD. X86 supports bf16 since Cooperlake, but very limited operations and only in SIMD.

Maybe GPUs?

[codemzs]

In D149573#4309378, @tschuett wrote:

I don't believe that there is NativeBFloat16Type. AArch64 learned bf16 with ARMv8.6-A, but very limited operations and only in SIMD. X86 supports bf16 since Cooperlake, but very limited operations and only in SIMD.

Maybe GPUs?

Dear @tschuett,

Thank you for your input. It seems that NativeBFloat16Type is indeed limited in availability. As you mentioned, AArch64 and X86 offer some bf16 support, but only in SIMD and with limited operations. This flag is intended to guard changes for targets with full bf16 support, as discussed in this RFC: https://discourse.llvm.org/t/rfc-c-23-p1467r9-extended-floating-point-types-and-standard-names/70033/12.

[tschuett]

Agreed.

[codemzs]

libcxxabi/test/test_demangle.pass.cpp

10921

Forgot to update the mangled name as these tests don't seem to run locally with cmake check-all

[codemzs]

Updated test_demangle.pass.cpp with mangled name for clang::Type::isArithmeticType(clang::ASTContext&) const, didn't catch this while testing locally using cmake check-all.

[codemzs]

Fix Clang format failures.

[codemzs]

My change to libcxxabi/test/test_demangle.pass.cpp (last file in the change) is only one line i.e {"_ZNK5clang4Type16isArithmeticTypeERNS_10ASTContextE", "clang::Type::isArithmeticType(clang::ASTContext&) const"}, but running clang-format on it changes bunch of lines.

[philnik]

In D149573#4310009, @codemzs wrote:

My change to libcxxabi/test/test_demangle.pass.cpp (last file in the change) is only one line i.e {"_ZNK5clang4Type16isArithmeticTypeERNS_10ASTContextE", "clang::Type::isArithmeticType(clang::ASTContext&) const"}, but running clang-format on it changes bunch of lines.

Please don't clang-format the test then. There is no need to do it, and the changes look rather confusing. I don't really understand why you add it at all TBH. This doesn't look like it tests anything from this patch.

[codemzs]

Revert the changes to /llvm-project/libcxxabi/test/test_demangle.pass.cpp. Updating the function prototype for clang::Type::isArithmeticType() const causes clang-format issues and leads to numerous unnecessary line changes. As this specific test file isn't crucial for testing the current patch, it's acceptable to leave it unchanged.

[codemzs]

In D149573#4310601, @philnik wrote:

In D149573#4310009, @codemzs wrote:

My change to libcxxabi/test/test_demangle.pass.cpp (last file in the change) is only one line i.e {"_ZNK5clang4Type16isArithmeticTypeERNS_10ASTContextE", "clang::Type::isArithmeticType(clang::ASTContext&) const"}, but running clang-format on it changes bunch of lines.

Please don't clang-format the test then. There is no need to do it, and the changes look rather confusing. I don't really understand why you add it at all TBH. This doesn't look like it tests anything from this patch.

@philnik Thank you for your feedback on the changes to libcxxabi/test/test_demangle.pass.cpp. I apologize for any confusion my initial approach may have caused. I intended to keep the test file consistent with the updated function prototype, but I understand your concern about clang-format's impact on readability.

I will revert the changes to the test file as you suggested, ensuring it does not affect the current patch's functionality. I appreciate your guidance and will consider these aspects in future updates.

[philnik]

In D149573#4311113, @codemzs wrote:

In D149573#4310601, @philnik wrote:

In D149573#4310009, @codemzs wrote:

My change to libcxxabi/test/test_demangle.pass.cpp (last file in the change) is only one line i.e {"_ZNK5clang4Type16isArithmeticTypeERNS_10ASTContextE", "clang::Type::isArithmeticType(clang::ASTContext&) const"}, but running clang-format on it changes bunch of lines.

Please don't clang-format the test then. There is no need to do it, and the changes look rather confusing. I don't really understand why you add it at all TBH. This doesn't look like it tests anything from this patch.

@philnik Thank you for your feedback on the changes to libcxxabi/test/test_demangle.pass.cpp. I apologize for any confusion my initial approach may have caused. I intended to keep the test file consistent with the updated function prototype, but I understand your concern about clang-format's impact on readability.

I will revert the changes to the test file as you suggested, ensuring it does not affect the current patch's functionality. I appreciate your guidance and will consider these aspects in future updates.

No worries :D. The clang-format guidelines are a bit confusing, and there is nothing wrong with not knowing all the conventions of the different subprojects.

[erichkeane]

I

clang/include/clang/AST/ASTContext.h

28

What is this needed for?

2808

2809

2811

clang/include/clang/Basic/DiagnosticSemaKinds.td

8745

clang/include/clang/Basic/LangOptions.def

468

I'm not sure I like the implications or maintainability of this. This is something that is likely to get out of hand too quickly. We probably need to just figure out what the itanium mangling is GOING to be (perhaps @rjmccall has some insight?), and just implement that.

Also, this isn't really a 'Language Option', so much as a codegen option.

clang/lib/AST/ASTContext.cpp

116

I don't quite see what this is used for yet, but nested unordered-maps for what is all compile-time constants seems like a waste of compile-time. I wonder if there is a good way to use a table for this comparison (perhaps with some level of adjustment on the type-kinds to make them non-sparse).

7152

by coding standard, you can't use 'auto' here. Also, variables are capital. I probably just would return it without the intermediary variable.

That said, this is exactly what I feared the unordered-map table above was for. We need to come up with a better storage medium for that.

My thought is to introduce something like:

constexpr unsigned FloatRankToIndex(clang::BuiltinType::Kind) {
  switch(Kind) {
    case clang::BuiltinType::Float16: return 0;  
    case clang::BuiltinType::BF16: return 1;
    case clang::BuiltinType::Float: return 2;
    case clang::BuiltinType::Double: return 3;
    case clang::BuiltinType::LongDouble: return 4;
    default: llvm_unreachable("Not a floating builtin type");
 }

And just run that on LHSKind and RHSKind here. Then, the CXX23FloatingPointConversionRankMap can be just a 2d pair of arrays:

std::array<std::array<FloatingRankCompareResult, 5>, 5> CXX23FloatingPointConversionRankMap =

We get the same results with very small runtime cost (for the 2 switches per operation), but save two unordered_map lookups, AND save the runtime construction of the unordered_maps.

clang/test/CodeGenCXX/cxx2b-fp-ext-std-names-p1467r9.cpp

6

entry isn't a stable name here, so you shouldn't use this label.

102

I'd vastly prefer these check-next commands be interlaced in teh code, so it is easy to see which line is supposed to associate with which.

clang/test/Sema/cxx2b-fp-ext-std-names-p1467r9.cpp

10

How we emit the result of the floats is inconsistent, at least in IR, so I'm not sure how stable it'll be here.

Also, don't use the |- and | \-`` in the check-lines, those get messy when something changes.

466

Definitely need the newline here.

[codemzs]

Addressing @erichkeane 's review comments and pushing out the updated patch.

clang/include/clang/Basic/LangOptions.def

468

Thank you for your valuable feedback. Based on your suggestion and considering that GCC has already implemented the mangling as DF16b, I agree that if we have reasonable confidence in the direction the mangling will take, it would be better to implement it directly instead of guarding it with an experimental flag. Therefore, I will be removing the flag. I initially added the flag since @tahonermann was on board with implementing the bf16 arithmetic type, assuming the mangling was finalized.

However, I understand your concerns and would appreciate further input from both @tahonermann and @rjmccall on this matter. My intention is to avoid stalling the progress of this change due to mangling finalization.

I'm open to further discussion and collaboration to ensure we make the right decision for our project while maintaining the momentum of the review process.

clang/lib/AST/ASTContext.cpp

7152

Thank you for your insightful suggestion! I agree that using a 2D array along with the FloatRankToIndex function is a more efficient and cleaner approach. I've updated the implementation accordingly. I appreciate your guidance on this.

clang/test/CodeGenCXX/cxx2b-fp-ext-std-names-p1467r9.cpp

6

I have removed the "entry" label as you suggested.

Just to let you know, this label was automatically generated by the script utils/update_cc_test_checks.py, which is used to update the expected output of the test cases. I noticed that this label is present in other tests in the codebase as well.

Out of curiosity, why is this label not considered stable?

102

I understand your preference for interlacing CHECK-NEXT commands with the code to improve readability. Unfortunately, the update_cc_test_checks.py script doesn't seem have an option to interlace CHECK-NEXT statements, and it can be challenging to achieve this in certain scenarios, such as when we have multiple loads followed by stores.

To address your concern, I've refactored the test code into smaller functions, which should make it easier to read and understand the relationship between the code and the corresponding CHECK statements. I hope this improves the readability and addresses your concerns. If you have any further suggestions or improvements, please don't hesitate to let me know. I'm open to making any necessary changes to ensure the code is clear and maintainable.

clang/test/Sema/cxx2b-fp-ext-std-names-p1467r9.cpp

10

I've observed similar floating-point representations in other tests, but I acknowledge your concerns about potential inconsistencies and stability. To address this, would replacing them with {{.*}} be a suitable solution? I'm also considering dividing the test into two parts: one for error checks in the current location and another for AST checks under test/AST. Would this resolve your concerns about the use of |- and | characters? Furthermore, I'd like to clarify whether your comment about avoiding |- applies specifically to tests in the test/Sema directory or more generally. My intention is to seek clarification and ensure the test code adheres to best practices.

[codemzs]

Addressing @erichkeane 's code review comments.

[erichkeane]

Others definitely need to review this, but i'm about happy with it.

clang/include/clang/Basic/LangOptions.def

468

Thanks, I think this is a good direction for this patch to take.

clang/lib/AST/ASTContext.cpp

135

Just a suggestion here, feel free to toss it, but I suspect some comments to explain the 'grid' a bit are helpful.

Basically, split it up into the 5 groups, and comment which is which.

clang/test/CodeGenCXX/cxx2b-fp-ext-std-names-p1467r9.cpp

6

Urgh, I kinda hate that script, it always gives such difficult to read tests...

My understanding is that when compiled with 'strip symbol names', no names are included that aren't required for ABI purposes. So labels all switch to %0, param names are removed entirely/etc.

Though, I guess I haven't seen that bot complain in a while, so perhaps it disappeared...

clang/test/Sema/cxx2b-fp-ext-std-names-p1467r9.cpp

10

I looked it up too, and I don't see this being a problem in our AST output as it is with our LLVM output, so perhaps I'm incorrect here. Feel free to leave them alone as is...

As far as the |- characters: I'd suggest just removing them entirely. Just left-align so it'd be :

VarDecl {{.*}} f16_val_6 '_Float16' cinit
FloatingLiteral {{.*}} '_Float16' 1.000000e+00

It'll still pass, and not be sensitive to the AST-dump's way of outputting.

[codemzs]

Addressing @erichkeane 's code review feedback.

[codemzs]

Thank you @erichkeane for your insightful review. I have addressed the feedback from your previous review.

[codemzs]

Rebase to the latest from upstream as LangOpt flag for C++23 has been updated to C++23 (instead of C++2b).

[codemzs]

clang/include/clang/Basic/LangOptions.def

468

@erichkeane @tahonermann Itanium mangling is now finalized as DF16band [[ https://github.com/itanium-cxx-abi/cxx-abi/pull/147#issuecomment-1540692344 | merged ]]into the github repository.

[codemzs]

This comment was removed by codemzs.

[codemzs]

Hi @rjmccall and @erichkeane,

I would like to inquire about the necessity of implementing excess precision support for std::bfloat16_t in this patch. In reference to the discussion on https://reviews.llvm.org/D136919, it was mentioned that introducing std::bfloat16_t in Clang requires proper mangling, semantics, and excess precision support.

However, this change includes a front-end flag that enables bfloat16 arithmetic only when the target natively supports bfloat16 operations. Given this restriction, is it still essential to provide excess precision support for std::bfloat16_t in this patch?

Thank you for your guidance.

[tahonermann]

I reviewed about a third of this, but then stopped due to the __bf16 vs std::bfloat16_t naming issues. I think the existing names that use "bfloat16" to support the __bf16 type should be renamed, in a separate patch, and this patch rebased on top of it. We are sure to make mistakes if this confusing situation is not resolved.

clang/include/clang/AST/ASTContext.h

1114–1116

This seems wrong. C++23 introduces std​::​bfloat16_t and Clang already supports __bf16. It seems to me that the BFloat16Ty name should be used for the former and BF16Ty used for the latter. I get that the inconsistency is preexisting, but I think we should fix that (in another patch before landing this one; there aren't very many references).

clang/include/clang/AST/BuiltinTypes.def

215–219

Here again, the type names are the exact opposite of what one would intuitively expect (I do appreciate that the comment makes the intent clear, but it still looks like a copy/paste error or similar).

clang/include/clang/AST/Type.h

2152–2162

Precedent elsewhere in this file is to place multi-line comments ahead of the function they appertain to.

7259–7267

This is a great example of BFloat16 vs BF16 confusion; here the names are *not* reversed. It is really hard to know if this code is wrong or for callers to know which one they should use.

clang/include/clang/Driver/Options.td

6420–6422

Since this message is specific to C++ for now (pending the addition of a _BFloat16 type in some future C standard, I think the message should reference std::bfloat16_t and skip explicit mention of C++23. I know it is kind of awkward to refer to the standard library name for the type, but since WG21 decided not to provide a keyword name (I wish they would just use the C names for these and get over it; they can still provide pretty library names!), there isn't another more explicit name to use. Alternatively, we could say something like "Enable the underlying type of std::bfloat16_t in C++ ...".

clang/include/clang/Lex/LiteralSupport.h

75

Is this for __bf16 or for std::bfloat16_t?

[codemzs]

In D149573#4332549, @tahonermann wrote:

I reviewed about a third of this, but then stopped due to the __bf16 vs std::bfloat16_t naming issues. I think the existing names that use "bfloat16" to support the __bf16 type should be renamed, in a separate patch, and this patch rebased on top of it. We are sure to make mistakes if this confusing situation is not resolved.

@tahonermann, thank you for your review and highlighting the naming issues with __bf16 and std::bfloat16_t. I agree that reversing the type names will improve readability and maintainability. I considered this while working on the code and appreciate your suggestion to address it in a separate patch before rebasing this one. I have the made change as a new patch here: https://reviews.llvm.org/D150291

clang/include/clang/Lex/LiteralSupport.h

75

Its for std::bfloat16_t, I don't believe __bf16 has a literal suffix.

[stuij]

I made a comment on the RFC to understand if we really need/want a new bfloat16 type.

[codemzs]

In D149573#4337480, @stuij wrote:

I made a comment on the RFC to understand if we really need/want a new bfloat16 type.

Thank you, @stuij, for your input. I will continue to follow the consensus on the RFC regarding the introduction of a new bfloat16 type. For context, my initial implementation transitioned the existing storage-only __bf16 type into an arithmetic type. If the decision leans towards not introducing a new bfloat16 type, I'm prepared to revert my changes to utilize the __bf16 type. To ensure our collective efforts are effectively streamlined and avoid any potential duplication, I am committed to aligning my work with the community consensus and ongoing discussions.

@tahonermann, when you have a moment, your guidance would be greatly appreciated.

[codemzs]

Following the RFC discussion, __bf16 has been adapted to function as an arithmetic type where hardware natively supports bfloat16 arithmetic. @stuij, as you initially introduced __bf16 as a storage-type, your review on this adjustment would be greatly appreciated.

[codemzs]

Addresses code style feedback from @tahonermann

[codemzs]

I have created a separate change to upgrade existing __bf16 to arithmetic type at D150913

clang/lib/AST/Type.cpp

2216

Remove

clang/lib/Basic/Targets/AMDGPU.h

120

Remove

[stuij]

In D149573#4341323, @codemzs wrote:

@stuij, as you initially introduced __bf16 as a storage-type, your review on this adjustment would be greatly appreciated.

Sorry for the late reaction, was on holiday. Yes, I'll have a look. I've put it on my todo.

[codemzs]

Hi @tahonermann / @erichkeane ,

This change has been simplified and rebased onto D150913, which is now in LLVM main. I hope this makes the review process more straightforward.

CC: @rjmccall / @pengfei

[codemzs]

Remove unused header file.

[stuij]

This is going to be a very unhelpful comment. After looking through the changes, I don't have any comments to make, but I also don't feel comfortable to accept this revision as I don't feel to know enough about the front-end.

[codemzs]

In D149573#4390863, @stuij wrote:

This is going to be a very unhelpful comment. After looking through the changes, I don't have any comments to make, but I also don't feel comfortable to accept this revision as I don't feel to know enough about the front-end.

@stuij, I sincerely appreciate you taking the time to review the changes. Your hesitation due to unfamiliarity with the front-end elements is completely understandable, and I respect your candid feedback.

@erichkeane, given your extensive contributions to the core Sema* files, I believe your expertise and experience would be particularly valuable in reviewing the changes I've made. I recall your initial informal approval for the change, and since then, I've further refined it after incorporating the outcomes of D150913. I'd be most appreciative if you could please review this revision once again.

My intention is to ensure this revision aligns with our shared vision for LLVM/Clang, and your reviews will greatly contribute to this goal. If there are any other changes or improvements required for the successful landing of this revision, please feel free to let me know.

[erichkeane]

In D149573#4390895, @codemzs wrote:

In D149573#4390863, @stuij wrote:

This is going to be a very unhelpful comment. After looking through the changes, I don't have any comments to make, but I also don't feel comfortable to accept this revision as I don't feel to know enough about the front-end.

@stuij, I sincerely appreciate you taking the time to review the changes. Your hesitation due to unfamiliarity with the front-end elements is completely understandable, and I respect your candid feedback.

@erichkeane, given your extensive contributions to the core Sema* files, I believe your expertise and experience would be particularly valuable in reviewing the changes I've made. I recall your initial informal approval for the change, and since then, I've further refined it after incorporating the outcomes of D150913. I'd be most appreciative if you could please review this revision once again.

My intention is to ensure this revision aligns with our shared vision for LLVM/Clang, and your reviews will greatly contribute to this goal. If there are any other changes or improvements required for the successful landing of this revision, please feel free to let me know.

I'll put you on my list to re-review for early next week, though Aaron probably needs to do a look through this as well.

[codemzs]

In D149573#4391013, @erichkeane wrote:

In D149573#4390895, @codemzs wrote:

In D149573#4390863, @stuij wrote:

This is going to be a very unhelpful comment. After looking through the changes, I don't have any comments to make, but I also don't feel comfortable to accept this revision as I don't feel to know enough about the front-end.

@stuij, I sincerely appreciate you taking the time to review the changes. Your hesitation due to unfamiliarity with the front-end elements is completely understandable, and I respect your candid feedback.

@erichkeane, given your extensive contributions to the core Sema* files, I believe your expertise and experience would be particularly valuable in reviewing the changes I've made. I recall your initial informal approval for the change, and since then, I've further refined it after incorporating the outcomes of D150913. I'd be most appreciative if you could please review this revision once again.

My intention is to ensure this revision aligns with our shared vision for LLVM/Clang, and your reviews will greatly contribute to this goal. If there are any other changes or improvements required for the successful landing of this revision, please feel free to let me know.

I'll put you on my list to re-review for early next week, though Aaron probably needs to do a look through this as well.

Thank you, @erichkeane that would be great, are you referring to @aaron.ballman ?

[erichkeane]

In D149573#4391083, @codemzs wrote:

In D149573#4391013, @erichkeane wrote:

In D149573#4390895, @codemzs wrote:

In D149573#4390863, @stuij wrote:

This is going to be a very unhelpful comment. After looking through the changes, I don't have any comments to make, but I also don't feel comfortable to accept this revision as I don't feel to know enough about the front-end.

@stuij, I sincerely appreciate you taking the time to review the changes. Your hesitation due to unfamiliarity with the front-end elements is completely understandable, and I respect your candid feedback.

@erichkeane, given your extensive contributions to the core Sema* files, I believe your expertise and experience would be particularly valuable in reviewing the changes I've made. I recall your initial informal approval for the change, and since then, I've further refined it after incorporating the outcomes of D150913. I'd be most appreciative if you could please review this revision once again.

My intention is to ensure this revision aligns with our shared vision for LLVM/Clang, and your reviews will greatly contribute to this goal. If there are any other changes or improvements required for the successful landing of this revision, please feel free to let me know.

I'll put you on my list to re-review for early next week, though Aaron probably needs to do a look through this as well.

Thank you, @erichkeane that would be great, are you referring to @aaron.ballman ?

Yes.

[erichkeane]

This all LGTM, but I want @tahonermann to do a pass as well, he knows more about FP than I do, so I don't want to accept without his run-through.

[codemzs]

In D149573#4395968, @erichkeane wrote:

This all LGTM, but I want @tahonermann to do a pass as well, he knows more about FP than I do, so I don't want to accept without his run-through.

Thank you, @erichkeane for the review. @aaron.ballman if you can please also have a look when you get a chance it would be great!

@tahonermann Just a quick note - I've made the changes you initially suggested in the RFC. When you get a chance, could you have another look?

[tahonermann]

@tahonermann Just a quick note - I've made the changes you initially suggested in the RFC. When you get a chance, could you have another look?

Yes, I hope to today. If not, I'll make it a priority for tomorrow.

[tahonermann]

This is looking good to me. I added a few comments seeking clarification.

I'm concerned about the changes to the existing calls to getFloatingTypeOrder(). The changes look like they will preserve prior behavior for standard types just fine, but I'm not sure whether they implement the right behavior for the extended types. Defining comparison functions that are explicit in their handling of FRCR_Unordered and subrank comparisons would help me feel more confident about the changes, the intent, and my ability to audit for the desired behavior.

clang/include/clang/Lex/LiteralSupport.h

75

I guess it does now! :)

clang/lib/AST/ASTContext.cpp

127–128

Assuming there is no need to handle __float128 and __ibm128 here, how about a comment to state why they don't require support here?

clang/lib/Sema/Sema.cpp

705

This comparison depends on the order of the enumerators in FloatingRankCompareResult and that seems brittle. I suggest either encompassing such comparisons in a function or, at least, adding a comment to the enumeration definition that explains the ordering requirements.

clang/lib/Sema/SemaCast.cpp

1367

Should this be a FIXME comment? What happens in this case? Should we perhaps assert on such attempted conversions?

clang/lib/Sema/SemaExpr.cpp

1235–1237

Return of an invalid type is a new behavior for this function and it isn't clear to me that callers will handle it (or be expected to handle it) such that a diagnostic will be generated. Perhaps a diagnostic should be issued here? Or perhaps this should be an assertion?

clang/lib/Sema/SemaOverload.cpp

4201

This comparison includes FRCR_Unordered, is that intended? (another case at line 4225 below)

[codemzs]

Hi @tahonermann,

Thank you for your insights on the patch. I concur with your perspective about the potential brittleness of comparison operations on the FloatingRankCompareResult enum type. As a remedy, I have incorporated a helper routine to handle such operations.

Regarding the getFloatingTypeOrder()method, it employs a 2-D grid to evaluate the conversion rank between two types. The grid index for a type is firmly established in the CXX23FloatRankToIndex, offering a stable indexing mechanism. Hence, it appears that this approach mitigates the brittleness concern associated with the comparison of FloatingRankCompareResult enum values.

I'm open to further insights if there are aspects I may have overlooked.

[codemzs]

clang/lib/Sema/SemaCast.cpp

1367

I have added the FIXME. There is a test case for this scenario:

_Float16 f16_val_7 = static_cast<_Float16>(1.0bf16); // expected-error {{static_cast from '__bf16' to '_Float16' is not allowed}}

If you still believe it might be better to add an assert I can do that, please let me know.

clang/lib/Sema/SemaExpr.cpp

1235–1237

It results in an error, please see the below test case:

auto f16_bf16 = 1.0f16 + 1.0bf16; // expected-error {{invalid operands to binary expression ('_Float16' and '__bf16')}}

This function is only called by UsualArithmeticConversions which returns invalid type in several places, hence returning invalid type should be ok? If you still prefer an assertion or diagnostic, I will happily add one.

clang/lib/Sema/SemaOverload.cpp

4201

Yes, my understanding is we are checking if the second sequence's type's (T3) conversion rank is not equal to the conversion rank of FP2. Is that not correct?

[codemzs]

@tahonermann Gentle ping, please let me know if you have any questions.

[aaron.ballman]

In D149573#4418001, @codemzs wrote:

@tahonermann Gentle ping, please let me know if you have any questions.

FWIW, there are C++ standards meetings all week this week, and C standards meetings all next week (and into the following week), so @tahonermann (and other reviewers) might be slower to respond as a result.

[tahonermann]

Sorry for the long delay reviewing again. I noted some mostly minor issues. I'm on vacation next week, but I'll try to watch for updates.

I'm still concerned that the changes to the code that was already performing rank comparisons don't explicitly do anything for unordered cases. I think I would feel better if we at least asserted that the comparisons are not unordered.

I'd like to see tests added to exercise va_arg and passing the extended types through ...; this will exercise the promotion related changes.

clang/lib/AST/ASTContext.cpp

192

I just realized that none of these comparisons results in FRCR_Equal_Lesser_Subrank or FRCR_Equal_Greater_Subrank. I guess those won't actually be used until support for std::float32_t and std::float64_t are added. That means that we don't have a way to test code that performs subrank checks though.

7133–7137

clang/lib/Frontend/InitPreprocessor.cpp

457

Should the definition of __STDCPP_BFLOAT16_T__ be conditional on something like Ctx.getTargetInfo().hasFullBFloat16Type()?

clang/lib/Sema/SemaCast.cpp

1367

If the condition can be legitimately hit, then we definitely want error handling rather than an assert. Thanks, this looks good.

clang/lib/Sema/SemaChecking.cpp

10412

I'm not sure this is right. If I understand correctly, the C++23 extended FP types don't participate in argument promotions. Perhaps they should be excluded here.

14132–14157

Should FRCR_Unordered be handled in some way here? It seems like we should at least assert that the types are not unordered.

clang/lib/Sema/SemaExpr.cpp

1235–1237

Ah, thank you. This looks good then.

1244–1247

Since the assertion requires order to be one of FRCR_Lesser or FRCE_Equal_Lesser_Subrank, there is no need to check for FRCR_Equal.

clang/lib/Sema/SemaOverload.cpp

4201

I definitely trust you more than myself to know if it is correct! I haven't really internalized the unordered and sub-rank concerns yet.

clang/test/Sema/cxx23-fp-ext-std-names-p1467r9.cpp

3–6 ↗

(On Diff #529171)

Are these errors correct? Since the source is a constant expression that specifies a value that is within the representable range of the type, I think these initializations are expected to be allowed.

[codemzs]

Updated with feedback from @tahonermann

[codemzs]

@tahonermann I would like to understand your concern better on unordered floating point types as the callers of getFloatingTypeOrder handle this result as per the C++23 proposal, for example there is a test case that exercises this scenario: _Float16 f16_val_1 = 1.0bf16; // expected-error {{cannot initialize a variable of type '_Float16' with an rvalue of type '__bf16'}}

Perhaps if you can please give me an example that further illustrates your concerns it would help me understand and assuage your concerns. Thank you.

clang/lib/AST/ASTContext.cpp

192

That is correct, my plan was to add support for these types after this change is committed.

clang/lib/Frontend/InitPreprocessor.cpp

457

Based on our discussion on the RFC it was determined that representing bfloat16 using fp32 is ok as per the author of the proposal, in that case do you believe we should be making this macro conditional on the target natively supporting bfloat16?

clang/lib/Sema/SemaChecking.cpp

10412

Rules for promotion are unchanged as per the proposal. This is just using the new enumeration to represent a smaller conversion rank.

clang/test/Sema/cxx23-fp-ext-std-names-p1467r9.cpp

3–6 ↗

(On Diff #529171)

I believe this should be an error unless my understanding is incorrect, below is what the proposal says for constant expressions:

"A drawback of this part of the proposal is that constant values don’t get any special treatment. As a result, this code:

std::float16_t x = 1.0;

would be ill-formed. The constant 1.0 has type double, which cannot be implicitly converted to type std::float16_t, even though the value 1.0 can be represented exactly in both types. To compile, the code must have an explicit cast, or, preferably, use a literal suffix:
std::float16_t x = 1.0f16;
...."

[tahonermann]

@codemzs, I'm sorry for the very long delay following up on this review. I've been struggling to keep up, but expect to be able to devote some time to this next week. I'm committed to helping to ensure we land this before Phabricator stops accepting new diffs (proposed for November 15th).

[codemzs]

Synced to the main and resolved merge conflicts, updated tests.

[codemzs]

Hi @tahonermann,

I've just pushed a new diff with tests for va_arg and ..., ensuring promotion rules are intact.

Also, I've made sure getFloatingTypeOrder returns FRCR_Unordered only when we're dealing with both operands as C++23 extended floating point types and they are unordered. I've added tests like _Float16 f16_val_1 = 1.0bf16; // expected-error {{cannot initialize a variable of type '_Float16' with an rvalue of type '__bf16'}} to cover these cases. If you see any potential issues here, I'm all ears and ready to make adjustments.

Thanks a lot for reviewing this, especially with your busy schedule.

[tahonermann]

Apologies once again for the delayed response. I reviewed some today and will resume reviewing on Monday.

In addition to the inline suggestions:

clang/docs/ReleaseNotes.rst will need to be updated to reflect that the core language changes for P1467R9 have been implemented for std::float16_t and std::bfloat16_t.

Given the confusing array of 16-bit floating-point types, how about modifying clang/include/clang/AST/BuiltinTypes.def to be more explicit regarding which is which?

// 'half' in OpenCL, '__fp16' in ARM NEON.
FLOATING_TYPE(Half, HalfTy)
...
// '_Float16', 'std::float16_t'
FLOATING_TYPE(Float16, HalfTy)

// '__bf16', 'std::bfloat16_t'
FLOATING_TYPE(BFloat16, BFloat16Ty)

Hmm, having pasted the above, I now noticed that the Half and Float16 types share the HalfTy singleton. Unless I'm mistaken, the changes being made will cause divergent behavior. Do these now need to be split?

clang/include/clang/AST/ASTContext.h

63

Naming suggestion: FloatConvRankCompareResult.

1117

I think the comment should reference http://eel.is/c++draft/basic.extended.fp#1 for std::float16_t. p5 is for std::bfloat16_t.

clang/include/clang/Basic/DiagnosticSemaKinds.td

8743

The diagnostic text here looks more like the text of a warning. Since this is an error, I think it makes more sense to model the text on other similar errors and use "narrowing" or "implicit cast" terminology. For examples, see err_spaceship_argument_narrowing and err_impcast_complex_scalar

Additionally, it would be helpful to include the relevant types in the message.

Finally, line length should be kept to 80 characters or less per https://llvm.org/docs/CodingStandards.html#source-code-width.

clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConv.h

779–788

This looks like a pre-existing bug since, for standard floating-point types, narrowing implicit conversions are allowed. I think the intent was to add a cast on which ever side is needed, but the existing code instead adds a cast on the RHS when the LHS has a higher rank, adds a cast on the LHS when the LHS and RHS have the same rank, and wanders into UB when the RHS has a higher rank.

The incorrect comparison goes back to when the code was introduced in commit 08f943c5630d8ee31d6a93227171d2f05db59e62.

The introduction of unordered conversion ranks suggests additional changes are needed here, but it isn't clear to me what the right changes are. I added a suggested edit that adds an arbitrary cast (which probably suffices for the purposes of static analysis). Alternatively, an assert could be added for the unordered and equal cases.

clang/lib/Sema/SemaChecking.cpp

10412

I think this still produces an incorrect result in some cases though. According to http://eel.is/c++draft/conv.fpprom, the only floating-point promotion is from float to double.

Ah, I think the prior code was incorrect, but non-symptomatic because it is only currently used in one place (in CheckPrintfHandler::checkFormatExpr()) and that code only cares about the integer cases. I would prefer that we fix this rather than extend the issue into extended FP types. One way to fix it would be to introduce isPromotableFloatingType() and getPromotedFloatingType() functions to match the existing ones integers used above.

[zahiraam]

Just starting to look at this. Don't we need a RN for this?

[jcranmer-intel]

So while trying to review this patch, I've discovered there's an annoying incompatibility between C and C++ here, in that C and C++ specify different rules on how to choose between _Float64, double, and long double if all are binary64 (C says _Float64 > long double > double, C++ says long double > _Float64 > double), and I don't have enough knowledge of clang internal implementation to know if the changes being done can capture the different semantics there. (It's also not entirely clear to me that the incompatibility between C and C++ was intentional in the first place; it looks like the paper author intentionally chose the ordering for C++ and argued for the change to C, but the CFP working group soundly rejected the change, and personally I agree with the CFP decision here over C++).

clang/lib/AST/ASTContext.cpp

136–138

I don't like having a large table here of results. It just doesn't scale; if you take into account all of the putative types that might be supported, you've got 3 basic types + 4 interchange formats + 3 decimal types + 1 IEEE extended type + bfloat + 3 IBM hex floats, and that's just things already supported by LLVM or that I know someone's working on.

I think after special casing float/double/long double, you can handle all the other types by simply using a mixture of fltSemantics::isRepresentableBy and a subrank preference list.

In the event that support for _Float32 and _Float64 are added, this table will no longer be target-independent. We have a few targets where double is binary32 and several targets where long double is either binary32 or binary64 (and others where it's neither). I think it's better to start writing this method in a way that can handle this mapping be target-dependent.

clang-tools-extra/clang-tidy/modernize/LoopConvertCheck.cpp

if (E->getType().isConstQualified())
     return false;
   auto Parents = Context->getParents(*E);
   if (Parents.size() != 1)
     return true;
   if (const auto *Cast = Parents[0].get<ImplicitCastExpr>()) {
     if ((Cast->getCastKind() == CK_NoOp &&
          Context->hasSameType(Cast->getType(), E->getType().withConst())) ||
         (Cast->getCastKind() == CK_LValueToRValue &&
-         !Cast->getType().isNull() && Cast->getType()->isFundamentalType()))
+         !Cast->getType().isNull() &&
+         Cast->getType()->isFundamentalType(*Context)))
       return false;
   }
   // FIXME: Make this function more generic.
   return true;
 }
 
 /// Returns true when it can be guaranteed that the elements of the
 /// container are not being modified.
for (const auto &Usage : Usages) {
           CharSourceRange::getTokenRange(Range), ReplaceText));
     }
   }
 
   // Now, we need to construct the new range expression.
   SourceRange ParenRange(Loop->getLParenLoc(), Loop->getRParenLoc());
 
   QualType Type = Context->getAutoDeductType();
-  if (!Descriptor.ElemType.isNull() && Descriptor.ElemType->isFundamentalType())
+  if (!Descriptor.ElemType.isNull() &&
+      Descriptor.ElemType->isFundamentalType(*Context))
     Type = Descriptor.ElemType.getUnqualifiedType();
   Type = Type.getDesugaredType(*Context);
 
   // If the new variable name is from the aliased variable, then the reference
   // type for the new variable should only be used if the aliased variable was
   // declared as a reference.
   bool IsCheapToCopy =
       !Descriptor.ElemType.isNull() &&

clang-tools-extra/clang-tidy/readability/SuspiciousCallArgumentCheck.cpp

static bool areTypesCompatible(QualType ArgType, QualType ParamType,
   // before further checking.
   ArgType = ArgType.getNonReferenceType();
   ParamType = ParamType.getNonReferenceType();
 
   if (ParamType.getUnqualifiedType() == ArgType.getUnqualifiedType())
     return true;
 
   // Arithmetic types are interconvertible, except scoped enums.
-  if (ParamType->isArithmeticType() && ArgType->isArithmeticType()) {
+  if (ParamType->isArithmeticType(Ctx) && ArgType->isArithmeticType(Ctx)) {
     if ((ParamType->isEnumeralType() &&
          ParamType->castAs<EnumType>()->getDecl()->isScoped()) ||
         (ArgType->isEnumeralType() &&
          ArgType->castAs<EnumType>()->getDecl()->isScoped()))
       return false;
 
     return true;
   }

clang/include/clang/AST/ASTContext.h

 #include "clang/AST/ComparisonCategories.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/ExternalASTSource.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/RawCommentList.h"
 #include "clang/AST/TemplateName.h"
+#include "clang/AST/Type.h"
 #include "clang/Basic/IdentifierTable.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/NoSanitizeList.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/ProfileList.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/XRayLists.h"

 class FixedPointSemantics;
 struct fltSemantics;
 template <typename T, unsigned N> class SmallPtrSet;
 
 } // namespace llvm
 
 namespace clang {
 
+// Conversion ranks introduced in C++23 6.8.6p2 [conv.rank]
+enum FloatingRankCompareResult {
+  FRCR_Unordered,
+  FRCR_Lesser,
+  FRCR_Greater,
+  FRCR_Equal,
+  FRCR_Equal_Lesser_Subrank,
+  FRCR_Equal_Greater_Subrank,
+};
+
 class APValue;
 class ASTMutationListener;
 class ASTRecordLayout;
 class AtomicExpr;
 class BlockExpr;
 class BuiltinTemplateDecl;
 class CharUnits;
 class ConceptDecl;
public:
   CanQualType UnsignedShortFractTy, UnsignedFractTy, UnsignedLongFractTy;
   CanQualType SatShortAccumTy, SatAccumTy, SatLongAccumTy;
   CanQualType SatUnsignedShortAccumTy, SatUnsignedAccumTy,
       SatUnsignedLongAccumTy;
   CanQualType SatShortFractTy, SatFractTy, SatLongFractTy;
   CanQualType SatUnsignedShortFractTy, SatUnsignedFractTy,
       SatUnsignedLongFractTy;
   CanQualType HalfTy; // [OpenCL 6.1.1.1], ARM NEON
   CanQualType BFloat16Ty;
+  CanQualType BF16Ty;    // [C++23 6.8.3p5], ISO/IEC/IEEE 60559.
   CanQualType Float16Ty; // C11 extension ISO/IEC TS 18661-3
   CanQualType VoidPtrTy, NullPtrTy;
   CanQualType DependentTy, OverloadTy, BoundMemberTy, UnknownAnyTy;
   CanQualType BuiltinFnTy;
   CanQualType PseudoObjectTy, ARCUnbridgedCastTy;
   CanQualType ObjCBuiltinIdTy, ObjCBuiltinClassTy, ObjCBuiltinSelTy;
   CanQualType ObjCBuiltinBoolTy;
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \
   CanQualType SingletonId;
 #include "clang/Basic/OpenCLImageTypes.def"
public:
   ///
   /// If \p LHS > \p RHS, returns 1.  If \p LHS == \p RHS, returns 0.  If
   /// \p LHS < \p RHS, return -1.
   int getIntegerTypeOrder(QualType LHS, QualType RHS) const;
 
   /// Compare the rank of the two specified floating point types,
   /// ignoring the domain of the type (i.e. 'double' == '_Complex double').
   ///
-  /// If \p LHS > \p RHS, returns 1.  If \p LHS == \p RHS, returns 0.  If
-  /// \p LHS < \p RHS, return -1.
-  int getFloatingTypeOrder(QualType LHS, QualType RHS) const;
+  /// If \p LHS > \p RHS, returns FRCR_Greater. If \p LHS == \p RHS, returns
+  /// FRCR_Equal.  If \p LHS < \p RHS, return FRCR_Lesser. If \p LHS and \p RHS
+  /// are unordered, return FRCR_Unordered. If \p LHS and \p RHS are equal but
+  /// subrank of \p LHS is greater than \p RHS, return FRCR_Equal_Greater_Subrank. If \p
+  /// LHS and \p RHS are equal but subrank of \p LHS is less than \p RHS, return
+  /// FRCR_Equal_Lesser_Subrank. Subrank and Unordered comparision was
+  /// introduced in C++23.
+  FloatingRankCompareResult getFloatingTypeOrder(QualType LHS,
+                                                 QualType RHS) const;
 
   /// Compare the rank of two floating point types as above, but compare equal
   /// if both types have the same floating-point semantics on the target (i.e.
-  /// long double and double on AArch64 will return 0).
-  int getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const;
+  /// long double and double on AArch64 will return FRCR_Equal).
+  FloatingRankCompareResult getFloatingTypeSemanticOrder(QualType LHS,
+                                                         QualType RHS) const;
 
   unsigned getTargetAddressSpace(LangAS AS) const;
 
   LangAS getLangASForBuiltinAddressSpace(unsigned AS) const;
 
   /// Get target-dependent integer value for null pointer which is used for
   /// constant folding.
   uint64_t getTargetNullPointerValue(QualType QT) const;

clang/include/clang/AST/BuiltinTypes.def

 FLOATING_TYPE(Double, DoubleTy)
 
 // 'long double'
 FLOATING_TYPE(LongDouble, LongDoubleTy)
 
 // '_Float16'
 FLOATING_TYPE(Float16, HalfTy)
 
+// 'Bfloat16' arithmetic type to represent std::bfloat16_t.
+FLOATING_TYPE(BF16, BFloat16Ty)
+
 // '__bf16'
 FLOATING_TYPE(BFloat16, BFloat16Ty)
 
 // '__float128'
 FLOATING_TYPE(Float128, Float128Ty)
 
 // '__ibm128'
 FLOATING_TYPE(Ibm128, Ibm128Ty)
 
 //===- Language-specific types --------------------------------------------===//

clang/include/clang/AST/Type.h

public:
 
   /// Floating point categories.
   bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
   /// isComplexType() does *not* include complex integers (a GCC extension).
   /// isComplexIntegerType() can be used to test for complex integers.
   bool isComplexType() const;      // C99 6.2.5p11 (complex)
   bool isAnyComplexType() const;   // C99 6.2.5p11 (complex) + Complex Int.
   bool isFloatingType() const;     // C99 6.2.5p11 (real floating + complex)
+  bool isCXX23FloatingPointType()
+      const; // C++23 6.8.2p12 [basic.fundamental] (standard floating point +
+             // extended floating point)
+  bool isCXX23StandardFloatingPointType()
+      const; // C++23 6.8.2p12 [basic.fundamental] (standard floating point)
+  bool isCXX23ExtendedFloatingPointType()
+      const; // C++23 6.8.2p12 [basic.fundamental] (extended floating point)
+  bool isCXX23StandardAndExtendedFpOp(const ASTContext &Ctx, QualType &Type)
+      const; // C++23 6.8.2p12 [basic.fundamental] (Used to determine if at
+             // least one of the types is a standard floating-point type and the
+             // other is an extended floating-point type)
   bool isHalfType() const;         // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
   bool isFloat16Type() const;      // C11 extension ISO/IEC TS 18661
   bool isBFloat16Type() const;
+  bool isBF16Type() const; // [C++23 6.8.3p5], ISO/IEC/IEEE 60559.
   bool isFloat128Type() const;
   bool isIbm128Type() const;
   bool isRealType() const;         // C99 6.2.5p17 (real floating + integer)
-  bool isArithmeticType() const;   // C99 6.2.5p18 (integer + floating)
+  bool isArithmeticType(
+      const ASTContext &Ctx) const; // C99 6.2.5p18 (integer + floating)
   bool isVoidType() const;         // C99 6.2.5p19
   bool isScalarType() const;       // C99 6.2.5p21 (arithmetic + pointers)
   bool isAggregateType() const;
-  bool isFundamentalType() const;
+  bool isFundamentalType(const ASTContext &Ctx) const;
   bool isCompoundType() const;
 
   // Type Predicates: Check to see if this type is structurally the specified
   // type, ignoring typedefs and qualifiers.
   bool isFunctionType() const;
   bool isFunctionNoProtoType() const { return getAs<FunctionNoProtoType>(); }
   bool isFunctionProtoType() const { return getAs<FunctionProtoType>(); }
   bool isPointerType() const;

 inline bool QualType::isCForbiddenLValueType() const {
   return ((getTypePtr()->isVoidType() && !hasQualifiers()) ||
           getTypePtr()->isFunctionType());
 }
 
 /// Tests whether the type is categorized as a fundamental type.
 ///
 /// \returns True for types specified in C++0x [basic.fundamental].
-inline bool Type::isFundamentalType() const {
-  return isVoidType() ||
-         isNullPtrType() ||
+inline bool Type::isFundamentalType(const ASTContext &Ctx) const {
+  return isVoidType() || isNullPtrType() ||
          // FIXME: It's really annoying that we don't have an
          // 'isArithmeticType()' which agrees with the standard definition.
-         (isArithmeticType() && !isEnumeralType());
+         (isArithmeticType(Ctx) && !isEnumeralType());
 }
 
 /// Tests whether the type is categorized as a compound type.
 ///
 /// \returns True for types specified in C++0x [basic.compound].
 inline bool Type::isCompoundType() const {
   // C++0x [basic.compound]p1:
   //   Compound types can be constructed in the following ways:
inline bool Type::isHalfType() const {
   // FIXME: Should we allow complex __fp16? Probably not.
   return isSpecificBuiltinType(BuiltinType::Half);
 }
 
 inline bool Type::isFloat16Type() const {
   return isSpecificBuiltinType(BuiltinType::Float16);
 }
 
 inline bool Type::isBFloat16Type() const {
   return isSpecificBuiltinType(BuiltinType::BFloat16);
 }
 
+inline bool Type::isBF16Type() const {
+  return isSpecificBuiltinType(BuiltinType::BF16);
+}
+
 inline bool Type::isFloat128Type() const {
   return isSpecificBuiltinType(BuiltinType::Float128);
 }
 
 inline bool Type::isIbm128Type() const {
   return isSpecificBuiltinType(BuiltinType::Ibm128);
 }
 
 inline bool Type::isNullPtrType() const {

clang/include/clang/Basic/DiagnosticSemaKinds.td

def warn_cast_function_type : Warning<
   InGroup<CastFunctionType>, DefaultIgnore;
 def warn_cast_function_type_strict : Warning<warn_cast_function_type.Summary>,
   InGroup<CastFunctionTypeStrict>, DefaultIgnore;
 def err_cast_pointer_to_non_pointer_int : Error<
   "pointer cannot be cast to type %0">;
 def err_nullptr_cast : Error<
   "cannot cast an object of type %select{'nullptr_t' to %1|%1 to 'nullptr_t'}0"
 >;
 def err_cast_to_bfloat16 : Error<"cannot type-cast to __bf16">;
 def err_cast_from_bfloat16 : Error<"cannot type-cast from __bf16">;
+def err_cxx2b_invalid_implicit_floating_point_cast : Error<"floating point cast results in loss of precision.">;
 def err_typecheck_expect_scalar_operand : Error<
   "operand of type %0 where arithmetic or pointer type is required">;
 def err_typecheck_cond_incompatible_operands : Error<
   "incompatible operand types%diff{ ($ and $)|}0,1">;
 def err_typecheck_expect_flt_or_vector : Error<
   "invalid operand of type %0 where floating, complex or "
   "a vector of such types is required">;
 def err_cast_selector_expr : Error<

clang/include/clang/Basic/LangOptions.def

 
 LANGOPT(OpenCL            , 1, 0, "OpenCL")
 LANGOPT(OpenCLVersion     , 32, 0, "OpenCL C version")
 LANGOPT(OpenCLCPlusPlus   , 1, 0, "C++ for OpenCL")
 LANGOPT(OpenCLCPlusPlusVersion     , 32, 0, "C++ for OpenCL version")
 LANGOPT(OpenCLGenericAddressSpace, 1, 0, "OpenCL generic keyword")
 LANGOPT(OpenCLPipes              , 1, 0, "OpenCL pipes language constructs and built-ins")
 LANGOPT(NativeHalfType    , 1, 0, "Native half type support")
+LANGOPT(NativeBFloat16Type    , 1, 0, "Native BFloat16 type support")
 LANGOPT(NativeHalfArgsAndReturns, 1, 0, "Native half args and returns")
 LANGOPT(CUDA              , 1, 0, "CUDA")
 LANGOPT(HIP               , 1, 0, "HIP")
 LANGOPT(OpenMP            , 32, 0, "OpenMP support and version of OpenMP (31, 40 or 45)")
 LANGOPT(OpenMPExtensions  , 1, 1, "Enable all Clang extensions for OpenMP directives and clauses")
 LANGOPT(OpenMPSimd        , 1, 0, "Use SIMD only OpenMP support.")
 LANGOPT(OpenMPUseTLS      , 1, 0, "Use TLS for threadprivates or runtime calls")
 LANGOPT(OpenMPIsDevice    , 1, 0, "Generate code only for OpenMP target device")

 // on large _BitInts.
 BENIGN_VALUE_LANGOPT(MaxBitIntWidth, 32, 128, "Maximum width of a _BitInt")
 
 LANGOPT(IncrementalExtensions, 1, 0, " True if we want to process statements"
         "on the global scope, ignore EOF token and continue later on (thus "
         "avoid tearing the Lexer and etc. down). Controlled by "
         "-fincremental-extensions.")
 
+LANGOPT(ExperimentalNewItaniumMangling, 1, 0, "experimental new Itanium mangling")
+
 #undef LANGOPT
 #undef COMPATIBLE_LANGOPT
 #undef BENIGN_LANGOPT
 #undef ENUM_LANGOPT
 #undef COMPATIBLE_ENUM_LANGOPT
 #undef BENIGN_ENUM_LANGOPT
 #undef VALUE_LANGOPT
 #undef COMPATIBLE_VALUE_LANGOPT
 #undef BENIGN_VALUE_LANGOPT

clang/include/clang/Basic/TargetInfo.h

virtual const char *getIbm128Mangling() const {
     llvm_unreachable("ibm128 not implemented on this target");
   }
 
   /// Return the mangled code of bfloat.
   virtual const char *getBFloat16Mangling() const {
     llvm_unreachable("bfloat not implemented on this target");
   }
 
+  /// Return the mangled code of native/arithemetic bfloat16.
+  virtual const char *getBF16Mangling() const {
+    llvm_unreachable(
+        "Arithmetic/Native bfloat16 not implemented on this target");
+  }
+
   /// Return the value for the C99 FLT_EVAL_METHOD macro.
   virtual LangOptions::FPEvalMethodKind getFPEvalMethod() const {
     return LangOptions::FPEvalMethodKind::FEM_Source;
   }
 
   virtual bool supportSourceEvalMethod() const { return true; }
 
   // getLargeArrayMinWidth/Align - Return the minimum array size that is

clang/include/clang/Driver/Options.td

defm experimental_library : BoolFOption<"experimental-library",
   LangOpts<"ExperimentalLibrary">, DefaultFalse,
   PosFlag<SetTrue, [CC1Option, CoreOption], "Control whether unstable and experimental library features are enabled. "
           "This option enables various library features that are either experimental (also known as TSes), or have been "
           "but are not stable yet in the selected Standard Library implementation. It is not recommended to use this option "
           "in production code, since neither ABI nor API stability are guaranteed. This is intended to provide a preview "
           "of features that will ship in the future for experimentation purposes">,
   NegFlag<SetFalse>>;
 
+defm fexperimental_new_itanium_mangling : BoolFOption<"experimental-new-itanium-mangling",
+  LangOpts<"ExperimentalNewItaniumMangling">, DefaultFalse,
+  PosFlag<SetTrue, [CC1Option, CoreOption], "Enable experimental Itanium name mangling">,
+  NegFlag<SetFalse>>;
+
 def fembed_offload_object_EQ : Joined<["-"], "fembed-offload-object=">,
   Group<f_Group>, Flags<[NoXarchOption, CC1Option, FC1Option]>,
   HelpText<"Embed Offloading device-side binary into host object file as a section.">,
   MarshallingInfoStringVector<CodeGenOpts<"OffloadObjects">>;
 def fembed_bitcode_EQ : Joined<["-"], "fembed-bitcode=">,
     Group<f_Group>, Flags<[NoXarchOption, CC1Option, CC1AsOption]>, MetaVarName<"<option>">,
     HelpText<"Embed LLVM bitcode">,
     Values<"off,all,bitcode,marker">, NormalizedValuesScope<"CodeGenOptions">,

 // TODO: Enforce values valid for MSVtorDispMode.
 def vtordisp_mode_EQ : Joined<["-"], "vtordisp-mode=">,
   HelpText<"Control vtordisp placement on win32 targets">,
   MarshallingInfoInt<LangOpts<"VtorDispMode">, "1">;
 def fnative_half_type: Flag<["-"], "fnative-half-type">,
   HelpText<"Use the native half type for __fp16 instead of promoting to float">,
   MarshallingInfoFlag<LangOpts<"NativeHalfType">>,
   ImpliedByAnyOf<[open_cl.KeyPath, render_script.KeyPath]>;
+def fnative_bfloat16_type: Flag<["-"], "fnative-bfloat16-type">,
+  HelpText<"Enable bfloat16 arithmetic type in C++23 for targets with native support.">,
+  MarshallingInfoFlag<LangOpts<"NativeBFloat16Type">>;
 def fnative_half_arguments_and_returns : Flag<["-"], "fnative-half-arguments-and-returns">,
   HelpText<"Use the native __fp16 type for arguments and returns (and skip ABI-specific lowering)">,
   MarshallingInfoFlag<LangOpts<"NativeHalfArgsAndReturns">>,
   ImpliedByAnyOf<[open_cl.KeyPath, render_script.KeyPath, hlsl.KeyPath]>;
 def fdefault_calling_conv_EQ : Joined<["-"], "fdefault-calling-conv=">,
   HelpText<"Set default calling convention">,
   Values<"cdecl,fastcall,stdcall,vectorcall,regcall">,
   NormalizedValuesScope<"LangOptions">,

clang/include/clang/Lex/LiteralSupport.h

public:
   bool isHalf : 1;          // 1.0h
   bool isFloat : 1;         // 1.0f
   bool isImaginary : 1;     // 1.0i
   bool isFloat16 : 1;       // 1.0f16
   bool isFloat128 : 1;      // 1.0q
   bool isFract : 1;         // 1.0hr/r/lr/uhr/ur/ulr
   bool isAccum : 1;         // 1.0hk/k/lk/uhk/uk/ulk
   bool isBitInt : 1;        // 1wb, 1uwb (C2x)
+  bool isBF16 : 1;          // 1.0bf
   uint8_t MicrosoftInteger; // Microsoft suffix extension i8, i16, i32, or i64.
 
 
   bool isFixedPointLiteral() const {
     return (saw_period || saw_exponent) && saw_fixed_point_suffix;
   }
 
   bool isIntegerLiteral() const {

clang/include/clang/Serialization/ASTBitCodes.h

enum PredefinedTypeIDs {
   PREDEF_TYPE_INCOMPLETE_MATRIX_IDX = 72,
 
   /// \brief The '__bf16' type
   PREDEF_TYPE_BFLOAT16_ID = 73,
 
   /// \brief The '__ibm128' type
   PREDEF_TYPE_IBM128_ID = 74,
 
+  /// \brief The 'bf16' arithmetic type.
+  PREDEF_TYPE_BF16_ID = 75,
+
 /// OpenCL image types with auto numeration
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
   PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/OpenCLImageTypes.def"
 /// \brief OpenCL extension types with auto numeration
 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/OpenCLExtensionTypes.def"
 // \brief SVE types with auto numeration

clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConv.h

 //== SMTConv.h --------------------------------------------------*- C++ -*--==//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines a set of functions to create SMT expressions
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SMTCONV_H
 #define LLVM_CLANG_STATICANALYZER_CORE_PATHSENSITIVE_SMTCONV_H
 
+#include "clang/AST/ASTContext.h"
 #include "clang/AST/Expr.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/APSIntType.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"
 #include "llvm/Support/SMTAPI.h"
 
 namespace clang {
 namespace ento {
 
static inline void doTypeConversion(llvm::SMTSolverRef &Solver,
                                       ASTContext &Ctx, llvm::SMTExprRef &LHS,
                                       llvm::SMTExprRef &RHS, QualType &LTy,
                                       QualType &RTy) {
     assert(!LTy.isNull() && !RTy.isNull() && "Input type is null!");
 
     // Perform type conversion
     if ((LTy->isIntegralOrEnumerationType() &&
          RTy->isIntegralOrEnumerationType()) &&
-        (LTy->isArithmeticType() && RTy->isArithmeticType())) {
+        (LTy->isArithmeticType(Ctx) && RTy->isArithmeticType(Ctx))) {
       SMTConv::doIntTypeConversion<llvm::SMTExprRef, &fromCast>(
           Solver, Ctx, LHS, LTy, RHS, RTy);
       return;
     }
 
     if (LTy->isRealFloatingType() || RTy->isRealFloatingType()) {
       SMTConv::doFloatTypeConversion<llvm::SMTExprRef, &fromCast>(
           Solver, Ctx, LHS, LTy, RHS, RTy);
doFloatTypeConversion(llvm::SMTSolverRef &Solver, ASTContext &Ctx, T &LHS,
     }
 
     if (LTy == RTy)
       return;
 
     // If we have two real floating types, convert the smaller operand to the
     // bigger result
     // Note: Safe to skip updating bitwidth because this must terminate
-    int order = Ctx.getFloatingTypeOrder(LTy, RTy);
-    if (order > 0) {
+    FloatingRankCompareResult order = Ctx.getFloatingTypeOrder(LTy, RTy);
+    if ((order == FRCR_Greater) || (order == FRCR_Equal_Greater_Subrank)) {
       RHS = (*doCast)(Solver, RHS, LTy, LBitWidth, RTy, RBitWidth);
       RTy = LTy;
-    } else if (order == 0) {
+    } else if ((order == FRCR_Equal) || (order == FRCR_Equal_Lesser_Subrank)) {
       LHS = (*doCast)(Solver, LHS, RTy, RBitWidth, LTy, LBitWidth);
       LTy = RTy;
     } else {
       llvm_unreachable("Unsupported floating-point type cast!");
     }
   }
 };
 } // namespace ento
 } // namespace clang
 
 #endif

clang/lib/AST/ASTContext.cpp

enum FloatingRank {
   HalfRank,
   FloatRank,
   DoubleRank,
   LongDoubleRank,
   Float128Rank,
   Ibm128Rank
 };
 
+// C++23 6.8.6p2 [conv.rank]
+using RankMap =
+    std::unordered_map<clang::BuiltinType::Kind, FloatingRankCompareResult>;
+std::unordered_map<clang::BuiltinType::Kind, RankMap>
+    CXX23FloatingPointConversionRankMap = {
+        {clang::BuiltinType::Float16,
+         {{clang::BuiltinType::Float16, FloatingRankCompareResult::FRCR_Equal},
+          {clang::BuiltinType::BF16, FloatingRankCompareResult::FRCR_Unordered},
+          {clang::BuiltinType::Float, FloatingRankCompareResult::FRCR_Lesser},
+          {clang::BuiltinType::Double, FloatingRankCompareResult::FRCR_Lesser},
+          {clang::BuiltinType::LongDouble,
+           FloatingRankCompareResult::FRCR_Lesser}}},
+        {clang::BuiltinType::BF16,
+         {{clang::BuiltinType::Float16,
+           FloatingRankCompareResult::FRCR_Unordered},
+          {clang::BuiltinType::BF16, FloatingRankCompareResult::FRCR_Equal},
+          {clang::BuiltinType::Float, FloatingRankCompareResult::FRCR_Lesser},
+          {clang::BuiltinType::Double, FloatingRankCompareResult::FRCR_Lesser},
+          {clang::BuiltinType::LongDouble,
+           FloatingRankCompareResult::FRCR_Lesser}}},
+        {clang::BuiltinType::Float,
+         {{clang::BuiltinType::Float16,
+           FloatingRankCompareResult::FRCR_Greater},
+          {clang::BuiltinType::BF16, FloatingRankCompareResult::FRCR_Greater},
+          {clang::BuiltinType::Float, FloatingRankCompareResult::FRCR_Equal},
+          {clang::BuiltinType::Double, FloatingRankCompareResult::FRCR_Lesser},
+          {clang::BuiltinType::LongDouble,
+           FloatingRankCompareResult::FRCR_Lesser}}},
+        {clang::BuiltinType::Double,
+         {{clang::BuiltinType::Float16,
+           FloatingRankCompareResult::FRCR_Greater},
+          {clang::BuiltinType::BF16, FloatingRankCompareResult::FRCR_Greater},
+          {clang::BuiltinType::Float, FloatingRankCompareResult::FRCR_Greater},
+          {clang::BuiltinType::Double, FloatingRankCompareResult::FRCR_Equal},
+          {clang::BuiltinType::LongDouble,
+           FloatingRankCompareResult::FRCR_Lesser}}},
+        {clang::BuiltinType::LongDouble,
+         {{clang::BuiltinType::Float16,
+           FloatingRankCompareResult::FRCR_Greater},
+          {clang::BuiltinType::BF16, FloatingRankCompareResult::FRCR_Greater},
+          {clang::BuiltinType::Float, FloatingRankCompareResult::FRCR_Greater},
+          {clang::BuiltinType::Double, FloatingRankCompareResult::FRCR_Greater},
+          {clang::BuiltinType::LongDouble,
+           FloatingRankCompareResult::FRCR_Equal}}}};
+
 /// \returns location that is relevant when searching for Doc comments related
 /// to \p D.
 static SourceLocation getDeclLocForCommentSearch(const Decl *D,
                                                  SourceManager &SourceMgr) {
   assert(D);
 
   // User can not attach documentation to implicit declarations.
   if (D->isImplicit())
if (CRD->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
       return {};
   }
 
   if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
     TemplateSpecializationKind TSK = CTSD->getSpecializationKind();
     if (TSK == TSK_ImplicitInstantiation ||
         TSK == TSK_Undeclared)
       return {};
   }
 
   if (const auto *ED = dyn_cast<EnumDecl>(D)) {
     if (ED->getTemplateSpecializationKind() == TSK_ImplicitInstantiation)
       return {};
   }
   if (const auto *TD = dyn_cast<TagDecl>(D)) {
     // When tag declaration (but not definition!) is part of the
     // decl-specifier-seq of some other declaration, it doesn't get comment
#include "clang/Basic/WebAssemblyReferenceTypes.def"
   // nullptr type (C++0x 2.14.7)
   InitBuiltinType(NullPtrTy,           BuiltinType::NullPtr);
 
   // half type (OpenCL 6.1.1.1) / ARM NEON __fp16
   InitBuiltinType(HalfTy, BuiltinType::Half);
 
   InitBuiltinType(BFloat16Ty, BuiltinType::BFloat16);
 
+  InitBuiltinType(BF16Ty, BuiltinType::BF16);
+
   // Builtin type used to help define __builtin_va_list.
   VaListTagDecl = nullptr;
 
   // MSVC predeclares struct _GUID, and we need it to create MSGuidDecls.
   if (LangOpts.MicrosoftExt || LangOpts.Borland) {
     MSGuidTagDecl = buildImplicitRecord("_GUID");
     getTranslationUnitDecl()->addDecl(MSGuidTagDecl);
   }

 
 /// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified
 /// scalar floating point type.
 const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
   switch (T->castAs<BuiltinType>()->getKind()) {
   default:
     llvm_unreachable("Not a floating point type!");
   case BuiltinType::BFloat16:
+  case BuiltinType::BF16:
     return Target->getBFloat16Format();
   case BuiltinType::Float16:
     return Target->getHalfFormat();
   case BuiltinType::Half:
     // For HLSL, when the native half type is disabled, half will be treat as
     // float.
     if (getLangOpts().HLSL)
       if (getLangOpts().NativeHalfType)
case BuiltinType::BFloat16:
         Align = Target->getBFloat16Align();
       } else if ((getLangOpts().SYCLIsDevice ||
                   (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice)) &&
                  AuxTarget->hasBFloat16Type()) {
         Width = AuxTarget->getBFloat16Width();
         Align = AuxTarget->getBFloat16Align();
       }
       break;
+    case BuiltinType::BF16:
+      Width = Target->getBFloat16Width();
+      Align = Target->getBFloat16Align();
+      break;
     case BuiltinType::Float16:
     case BuiltinType::Half:
       if (Target->hasFloat16Type() || !getLangOpts().OpenMP ||
           !getLangOpts().OpenMPIsDevice) {
         Width = Target->getHalfWidth();
         Align = Target->getHalfAlign();
       } else {
         assert(getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice &&
static FloatingRank getFloatingRank(QualType T) {
   default: llvm_unreachable("getFloatingRank(): not a floating type");
   case BuiltinType::Float16:    return Float16Rank;
   case BuiltinType::Half:       return HalfRank;
   case BuiltinType::Float:      return FloatRank;
   case BuiltinType::Double:     return DoubleRank;
   case BuiltinType::LongDouble: return LongDoubleRank;
   case BuiltinType::Float128:   return Float128Rank;
   case BuiltinType::BFloat16:   return BFloat16Rank;
+  case BuiltinType::BF16:
+    return BFloat16Rank;
   case BuiltinType::Ibm128:     return Ibm128Rank;
   }
 }
 
+/// C++23 6.8.5 [conv.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 {
+/// '_Complex double').
+/// If LHS > RHS, return FRCR_Greater.  If LHS == RHS, return FRCR_Equal. If
+/// LHS < RHS, return FRCR_Lesser. If the values representedable by the two
+/// are not subset of each other, return FRCR_Unordered. If LHS == RHS but
+/// LHS has a higher subrank than RHS return FRCR_Equal_Greater_Subrank else
+/// return FRCR_Equal_Lesser_Subrank.
+FloatingRankCompareResult ASTContext::getFloatingTypeOrder(QualType LHS,
+                                                           QualType RHS) const {
+  if (this->LangOpts.CPlusPlus2b && LHS->isCXX23FloatingPointType() &&
+      RHS->isCXX23FloatingPointType()) {
+    BuiltinType::Kind LHSKind;
+    BuiltinType::Kind RHSKind;
+    if (const auto *CT = LHS->getAs<ComplexType>())
+      LHSKind = CT->getElementType()->castAs<BuiltinType>()->getKind();
+    else
+      LHSKind = LHS->castAs<BuiltinType>()->getKind();
+    if (const auto *CT = RHS->getAs<ComplexType>())
+      RHSKind = CT->getElementType()->castAs<BuiltinType>()->getKind();
+    else
+      RHSKind = RHS->castAs<BuiltinType>()->getKind();
+    auto comp = CXX23FloatingPointConversionRankMap[LHSKind][RHSKind];
+    return comp;
+  }
+
   FloatingRank LHSR = getFloatingRank(LHS);
   FloatingRank RHSR = getFloatingRank(RHS);
 
   if (LHSR == RHSR)
-    return 0;
+    return FRCR_Equal;
   if (LHSR > RHSR)
-    return 1;
-  return -1;
+    return FRCR_Greater;
+  return FRCR_Lesser;
 }
 
-int ASTContext::getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const {
+FloatingRankCompareResult
+ASTContext::getFloatingTypeSemanticOrder(QualType LHS, QualType RHS) const {
   if (&getFloatTypeSemantics(LHS) == &getFloatTypeSemantics(RHS))
-    return 0;
+    return FRCR_Equal;
   return getFloatingTypeOrder(LHS, RHS);
 }
 
 /// 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.
 unsigned ASTContext::getIntegerRank(const Type *T) const {
   assert(T->isCanonicalUnqualified() && "T should be canonicalized");
static char getObjCEncodingForPrimitiveType(const ASTContext *C,
     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::BFloat16:
+    case BuiltinType::BF16:
     case BuiltinType::Float16:
     case BuiltinType::Float128:
     case BuiltinType::Ibm128:
     case BuiltinType::Half:
     case BuiltinType::ShortAccum:
     case BuiltinType::Accum:
     case BuiltinType::LongAccum:
     case BuiltinType::UShortAccum:

clang/lib/AST/Interp/ByteCodeExprGen.cpp

bool ByteCodeExprGen<Emitter>::dereferenceVar(
   }
 
   // If the declaration is a constant value, emit it here even
   // though the declaration was not evaluated in the current scope.
   // The access mode can only be read in this case.
   if (!DiscardResult && AK == DerefKind::Read) {
     if (VD->hasLocalStorage() && VD->hasInit() && !VD->isConstexpr()) {
       QualType VT = VD->getType();
-      if (VT.isConstQualified() && VT->isFundamentalType())
+      if (VT.isConstQualified() && VT->isFundamentalType(VD->getASTContext()))
         return this->visit(VD->getInit());
     }
   }
 
   // Value cannot be produced - try to emit pointer.
   return visit(LV) && Indirect(T);
 }
 

clang/lib/AST/ItaniumMangle.cpp

case BuiltinType::BFloat16: {
     const TargetInfo *TI = ((getASTContext().getLangOpts().OpenMP &&
                              getASTContext().getLangOpts().OpenMPIsDevice) ||
                             getASTContext().getLangOpts().SYCLIsDevice)
                                ? getASTContext().getAuxTargetInfo()
                                : &getASTContext().getTargetInfo();
     Out << TI->getBFloat16Mangling();
     break;
   }
+  case BuiltinType::BF16: {
+    if (getASTContext().getLangOpts().ExperimentalNewItaniumMangling)
+      Out << getASTContext().getTargetInfo().getBF16Mangling();
+    else
+      llvm_unreachable(
+          "BF16 with arithmetic support mangling is not finalized for Itanium "
+          "ABI, please consider using -fexperimental-new-itanium-mangling");
+    break;
+  }
   case BuiltinType::Ibm128: {
     const TargetInfo *TI = &getASTContext().getTargetInfo();
     Out << TI->getIbm128Mangling();
     break;
   }
   case BuiltinType::NullPtr:
     Out << "Dn";
     break;

clang/lib/AST/MicrosoftMangle.cpp

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

clang/lib/AST/NSAPI.cpp

#include "clang/Basic/WebAssemblyReferenceTypes.def"
   case BuiltinType::Half:
   case BuiltinType::PseudoObject:
   case BuiltinType::BuiltinFn:
   case BuiltinType::IncompleteMatrixIdx:
   case BuiltinType::OMPArraySection:
   case BuiltinType::OMPArrayShaping:
   case BuiltinType::OMPIterator:
   case BuiltinType::BFloat16:
+  case BuiltinType::BF16:
     break;
   }
 
   return std::nullopt;
 }
 
 /// Returns true if \param T is a typedef of "BOOL" in objective-c.
 bool NSAPI::isObjCBOOLType(QualType T) const {

clang/lib/AST/PrintfFormatString.cpp

bool PrintfSpecifier::fixType(QualType QT, const LangOptions &LangOpt,
   case BuiltinType::WChar_S:
   case BuiltinType::Char8: // FIXME: Treat like 'char'?
   case BuiltinType::Char16:
   case BuiltinType::Char32:
   case BuiltinType::UInt128:
   case BuiltinType::Int128:
   case BuiltinType::Half:
   case BuiltinType::BFloat16:
+  case BuiltinType::BF16:
   case BuiltinType::Float16:
   case BuiltinType::Float128:
   case BuiltinType::Ibm128:
   case BuiltinType::ShortAccum:
   case BuiltinType::Accum:
   case BuiltinType::LongAccum:
   case BuiltinType::UShortAccum:
   case BuiltinType::UAccum:

clang/lib/AST/StmtPrinter.cpp

static void PrintFloatingLiteral(raw_ostream &OS, FloatingLiteral *Node,
   default: llvm_unreachable("Unexpected type for float literal!");
   case BuiltinType::Half:       break; // FIXME: suffix?
   case BuiltinType::Ibm128:     break; // FIXME: No suffix for ibm128 literal
   case BuiltinType::Double:     break; // no suffix.
   case BuiltinType::Float16:    OS << "F16"; break;
   case BuiltinType::Float:      OS << 'F'; break;
   case BuiltinType::LongDouble: OS << 'L'; break;
   case BuiltinType::Float128:   OS << 'Q'; break;
+  case BuiltinType::BF16:
+    OS << "BF16";
+    break;
   }
 }
 
 void StmtPrinter::VisitFloatingLiteral(FloatingLiteral *Node) {
   if (Policy.ConstantsAsWritten && printExprAsWritten(OS, Node, Context))
     return;
   PrintFloatingLiteral(OS, Node, /*PrintSuffix=*/true);
 }

clang/lib/AST/Type.cpp

bool Type::isFloatingType() const {
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() >= BuiltinType::Half &&
            BT->getKind() <= BuiltinType::Ibm128;
   if (const auto *CT = dyn_cast<ComplexType>(CanonicalType))
     return CT->getElementType()->isFloatingType();
   return false;
 }
 
+bool Type::isCXX23FloatingPointType() const {
+  return isCXX23StandardFloatingPointType() ||
+         isCXX23ExtendedFloatingPointType();
+}
+
+bool Type::isCXX23StandardFloatingPointType() const {
+  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
+    return BT->getKind() >= BuiltinType::Float &&
+           BT->getKind() <= BuiltinType::LongDouble;
+  if (const auto *CT = dyn_cast<ComplexType>(CanonicalType))
+    return CT->getElementType()->isCXX23StandardFloatingPointType();
+  return false;
+}
+
+bool Type::isCXX23ExtendedFloatingPointType() const {
+  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
+    return BT->getKind() == BuiltinType::Float16 ||
+           BT->getKind() == BuiltinType::BF16;
+  if (const auto *CT = dyn_cast<ComplexType>(CanonicalType))
+    return CT->getElementType()->isCXX23ExtendedFloatingPointType();
+  return false;
+}
+bool Type::isCXX23StandardAndExtendedFpOp(const ASTContext &Ctx,
+                                          QualType &Type) const {
+  return (Ctx.getLangOpts().CPlusPlus2b &&
+          ((isCXX23FloatingPointType() && Type->isCXX23FloatingPointType())) &&
+          (isCXX23ExtendedFloatingPointType() ||
+           Type->isCXX23ExtendedFloatingPointType()));
+}
+
 bool Type::hasFloatingRepresentation() const {
   if (const auto *VT = dyn_cast<VectorType>(CanonicalType))
     return VT->getElementType()->isFloatingType();
   if (const auto *MT = dyn_cast<MatrixType>(CanonicalType))
     return MT->getElementType()->isFloatingType();
   return isFloatingType();
 }
 
 bool Type::isRealFloatingType() const {
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->isFloatingPoint();
   return false;
 }
 
 bool Type::isRealType() const {
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
     return BT->getKind() >= BuiltinType::Bool &&
            BT->getKind() <= BuiltinType::Ibm128;
   if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
       return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
   return isBitIntType();
 }
 
-bool Type::isArithmeticType() const {
+bool Type::isArithmeticType(const ASTContext &Ctx) const {
   if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
-    return BT->getKind() >= BuiltinType::Bool &&
+      return (BT->getKind() >= BuiltinType::Bool &&
               BT->getKind() <= BuiltinType::Ibm128 &&
-           BT->getKind() != BuiltinType::BFloat16;
+              BT->getKind() != BuiltinType::BFloat16 &&
+              BT->getKind() != BuiltinType::BF16) ||
+             (Ctx.getLangOpts().CPlusPlus2b &&
+              BT->getKind() == BuiltinType::BF16);
   if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
     // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2).
     // If a body isn't seen by the time we get here, return false.
     //
     // C++0x: Enumerations are not arithmetic types. For now, just return
     // false for scoped enumerations since that will disable any
     // unwanted implicit conversions.
     return !ET->getDecl()->isScoped() && ET->getDecl()->isComplete();
StringRef BuiltinType::getName(const PrintingPolicy &Policy) const {
   case ULongLong:
     return "unsigned long long";
   case UInt128:
     return "unsigned __int128";
   case Half:
     return Policy.Half ? "half" : "__fp16";
   case BFloat16:
     return "__bf16";
+  case BF16:
+    return "BF16";
   case Float:
     return "float";
   case Double:
     return "double";
   case LongDouble:
     return "long double";
   case ShortAccum:
     return "short _Accum";

clang/lib/AST/TypeLoc.cpp

TypeSpecifierType BuiltinTypeLoc::getWrittenTypeSpec() const {
   case BuiltinType::SatULongAccum:
   case BuiltinType::SatShortFract:
   case BuiltinType::SatFract:
   case BuiltinType::SatLongFract:
   case BuiltinType::SatUShortFract:
   case BuiltinType::SatUFract:
   case BuiltinType::SatULongFract:
   case BuiltinType::BFloat16:
+  case BuiltinType::BF16:
     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:

clang/lib/Basic/Targets/AArch64.h

public:
   StringRef getConstraintRegister(StringRef Constraint,
                                   StringRef Expression) const override {
     return Expression;
   }
 
   int getEHDataRegisterNumber(unsigned RegNo) const override;
 
   const char *getBFloat16Mangling() const override { return "u6__bf16"; };
+
+  const char *getBF16Mangling() const override { return "u6__bf16"; };
+
   bool hasInt128Type() const override;
 
   bool hasBitIntType() const override { return true; }
 };
 
 class LLVM_LIBRARY_VISIBILITY AArch64leTargetInfo : public AArch64TargetInfo {
 public:
   AArch64leTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);

clang/lib/Basic/Targets/AMDGPU.h

public:
   }
 
   uint64_t getMaxPointerWidth() const override {
     return getTriple().getArch() == llvm::Triple::amdgcn ? 64 : 32;
   }
 
   bool hasBFloat16Type() const override { return isAMDGCN(getTriple()); }
   const char *getBFloat16Mangling() const override { return "u6__bf16"; };
-
+  const char *getBF16Mangling() const override { return "DF16b"; };
   std::string_view getClobbers() const override { return ""; }
 
   ArrayRef<const char *> getGCCRegNames() const override;
 
   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
     return std::nullopt;
   }
 
   /// Accepted register names: (n, m is unsigned integer, n < m)

clang/lib/Basic/Targets/ARM.h

public:
 
   int getEHDataRegisterNumber(unsigned RegNo) const override;
 
   bool hasSjLjLowering() const override;
 
   bool hasBitIntType() const override { return true; }
 
   const char *getBFloat16Mangling() const override { return "u6__bf16"; };
+
+  const char *getBF16Mangling() const override { return "u6__bf16"; };
 };
 
 class LLVM_LIBRARY_VISIBILITY ARMleTargetInfo : public ARMTargetInfo {
 public:
   ARMleTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 };

clang/lib/Basic/Targets/NVPTX.h

CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
     if (HostTarget)
       return HostTarget->checkCallingConvention(CC);
     return CCCR_Warning;
   }
 
   bool hasBitIntType() const override { return true; }
   bool hasBFloat16Type() const override { return true; }
   const char *getBFloat16Mangling() const override { return "u6__bf16"; };
+  const char *getBF16Mangling() const override { return "DF16b"; };
 };
 } // namespace targets
 } // namespace clang
 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_NVPTX_H

clang/lib/Basic/Targets/X86.h

uint64_t getPointerWidthV(LangAS AS) const override {
     return PointerWidth;
   }
 
   uint64_t getPointerAlignV(LangAS AddrSpace) const override {
     return getPointerWidthV(AddrSpace);
   }
 
   const char *getBFloat16Mangling() const override { return "u6__bf16"; };
+
+  const char *getBF16Mangling() const override { return "DF16b"; };
 };
 
 // X86-32 generic target
 class LLVM_LIBRARY_VISIBILITY X86_32TargetInfo : public X86TargetInfo {
 public:
   X86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : X86TargetInfo(Triple, Opts) {
     DoubleAlign = LongLongAlign = 32;

clang/lib/CodeGen/CGDebugInfo.cpp

#include "clang/Basic/WebAssemblyReferenceTypes.def"
   case BuiltinType::Bool:
     Encoding = llvm::dwarf::DW_ATE_boolean;
     break;
   case BuiltinType::Half:
   case BuiltinType::Float:
   case BuiltinType::LongDouble:
   case BuiltinType::Float16:
   case BuiltinType::BFloat16:
+  case BuiltinType::BF16:
   case BuiltinType::Float128:
   case BuiltinType::Double:
   case BuiltinType::Ibm128:
     // FIXME: For targets where long double, __ibm128 and __float128 have the
     // same size, they are currently indistinguishable in the debugger without
     // some special treatment. However, there is currently no consensus on
     // encoding and this should be updated once a DWARF encoding exists for
     // distinct floating point types of the same size.

clang/lib/CodeGen/CGExpr.cpp

LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) {
   case UO_Imag: {
     LValue LV = EmitLValue(E->getSubExpr());
     assert(LV.isSimple() && "real/imag on non-ordinary l-value");
 
     // __real is valid on scalars.  This is a faster way of testing that.
     // __imag can only produce an rvalue on scalars.
     if (E->getOpcode() == UO_Real &&
         !LV.getAddress(*this).getElementType()->isStructTy()) {
-      assert(E->getSubExpr()->getType()->isArithmeticType());
+      assert(E->getSubExpr()->getType()->isArithmeticType(getContext()));
       return LV;
     }
 
     QualType T = ExprTy->castAs<ComplexType>()->getElementType();
 
     Address Component =
         (E->getOpcode() == UO_Real
              ? emitAddrOfRealComponent(LV.getAddress(*this), LV.getType())

clang/lib/CodeGen/CGExprScalar.cpp

if (Ops.Ty->isConstantMatrixType()) {
     llvm::MatrixBuilder MB(Builder);
     // We need to check the types of the operands of the operator to get the
     // correct matrix dimensions.
     auto *BO = cast<BinaryOperator>(Ops.E);
     (void)BO;
     assert(
         isa<ConstantMatrixType>(BO->getLHS()->getType().getCanonicalType()) &&
         "first operand must be a matrix");
-    assert(BO->getRHS()->getType().getCanonicalType()->isArithmeticType() &&
+    assert(BO->getRHS()->getType().getCanonicalType()->isArithmeticType(
+               CGF.getContext()) &&
            "second operand must be an arithmetic type");
     CodeGenFunction::CGFPOptionsRAII FPOptsRAII(CGF, Ops.FPFeatures);
     return MB.CreateScalarDiv(Ops.LHS, Ops.RHS,
                               Ops.Ty->hasUnsignedIntegerRepresentation());
   }
 
   if (Ops.LHS->getType()->isFPOrFPVectorTy()) {
     llvm::Value *Val;

clang/lib/CodeGen/CodeGenTypes.cpp

case Type::Builtin: {
     case BuiltinType::Half:
       // Half FP can either be storage-only (lowered to i16) or native.
       ResultType = getTypeForFormat(
           getLLVMContext(), Context.getFloatTypeSemantics(T),
           Context.getLangOpts().NativeHalfType ||
               !Context.getTargetInfo().useFP16ConversionIntrinsics());
       break;
     case BuiltinType::BFloat16:
+    case BuiltinType::BF16:
     case BuiltinType::Float:
     case BuiltinType::Double:
     case BuiltinType::LongDouble:
     case BuiltinType::Float128:
     case BuiltinType::Ibm128:
       ResultType = getTypeForFormat(getLLVMContext(),
                                     Context.getFloatTypeSemantics(T),
                                     /* UseNativeHalf = */ false);

clang/lib/CodeGen/ItaniumCXXABI.cpp

#include "clang/Basic/WebAssemblyReferenceTypes.def"
     case BuiltinType::SatULongAccum:
     case BuiltinType::SatShortFract:
     case BuiltinType::SatFract:
     case BuiltinType::SatLongFract:
     case BuiltinType::SatUShortFract:
     case BuiltinType::SatUFract:
     case BuiltinType::SatULongFract:
     case BuiltinType::BFloat16:
+    case BuiltinType::BF16:
       return false;
 
     case BuiltinType::Dependent:
 #define BUILTIN_TYPE(Id, SingletonId)
 #define PLACEHOLDER_TYPE(Id, SingletonId) \
     case BuiltinType::Id:
 #include "clang/AST/BuiltinTypes.def"
       llvm_unreachable("asking for RRTI for a placeholder type!");

clang/lib/Frontend/InitPreprocessor.cpp

else if (LangOpts.C11)
       Builder.defineMacro("__STDC_VERSION__", "201112L");
     else if (LangOpts.C99)
       Builder.defineMacro("__STDC_VERSION__", "199901L");
     else if (!LangOpts.GNUMode && LangOpts.Digraphs)
       Builder.defineMacro("__STDC_VERSION__", "199409L");
   } else {
     //   -- __cplusplus
     // FIXME: Use correct value for C++23.
-    if (LangOpts.CPlusPlus2b)
+    if (LangOpts.CPlusPlus2b) {
       Builder.defineMacro("__cplusplus", "202101L");
+      // [C++2b] 15.11p2 [cpp.predefined]
+      Builder.defineMacro("__STDCPP_FLOAT16_T__", "1");
+      if (LangOpts.NativeBFloat16Type)
+        Builder.defineMacro("__STDCPP_BFLOAT16_T__", "1");
+    }
     //      [C++20] The integer literal 202002L.
     else if (LangOpts.CPlusPlus20)
       Builder.defineMacro("__cplusplus", "202002L");
     //      [C++17] The integer literal 201703L.
     else if (LangOpts.CPlusPlus17)
       Builder.defineMacro("__cplusplus", "201703L");
     //      [C++14] The name __cplusplus is defined to the value 201402L when
     //      compiling a C++ translation unit.

clang/lib/Index/USRGeneration.cpp

#include "clang/Basic/WebAssemblyReferenceTypes.def"
           Out << "@BT@SatLongFract"; break;
         case BuiltinType::SatUShortFract:
           Out << "@BT@SatUShortFract"; break;
         case BuiltinType::SatUFract:
           Out << "@BT@SatUFract"; break;
         case BuiltinType::SatULongFract:
           Out << "@BT@SatULongFract"; break;
         case BuiltinType::BFloat16:
+        case BuiltinType::BF16:
           Out << "@BT@__bf16"; break;
         case BuiltinType::Ibm128:
           Out << "@BT@__ibm128"; break;
         case BuiltinType::ObjCId:
           Out << 'o'; break;
         case BuiltinType::ObjCClass:
           Out << 'O'; break;
         case BuiltinType::ObjCSel:

clang/lib/Lex/LiteralSupport.cpp

NumericLiteralParser::NumericLiteralParser(StringRef TokSpelling,
   isImaginary = false;
   isFloat16 = false;
   isFloat128 = false;
   MicrosoftInteger = 0;
   isFract = false;
   isAccum = false;
   hadError = false;
   isBitInt = false;
+  isBF16 = false;
 
   // This routine assumes that the range begin/end matches the regex for integer
   // and FP constants (specifically, the 'pp-number' regex), and assumes that
   // the byte at "*end" is both valid and not part of the regex.  Because of
   // this, it doesn't have to check for 'overscan' in various places.
   if (isPreprocessingNumberBody(*ThisTokEnd)) {
     Diags.Report(TokLoc, diag::err_lexing_numeric);
     hadError = true;
case 'F':
           s + 2 < ThisTokEnd && s[1] == '1' && s[2] == '6') {
         s += 2; // success, eat up 2 characters.
         isFloat16 = true;
         continue;
       }
 
       isFloat = true;
       continue;  // Success.
+    // C++23 5.13.4 [lex.fcon]
+    case 'b':
+    case 'B':
+      if (!isFPConstant)
+        break; // Error for integer constant.
+      if (s + 3 < ThisTokEnd && (s[1] == 'f' || s[1] == 'F') && s[2] == '1' &&
+          s[3] == '6') {
+        if (!LangOpts.CPlusPlus2b || !LangOpts.NativeBFloat16Type)
+          break;
+        if (HasSize)
+          break;
+        HasSize = true;
+        s += 3;
+        isBF16 = true;
+        continue;
+      }
+      break;
     case 'q':    // FP Suffix for "__float128"
     case 'Q':
       if (!isFPConstant) break;  // Error for integer constant.
       if (HasSize)
         break;
       HasSize = true;
       isFloat128 = true;
       continue;  // Success.
if (isValidUDSuffix(LangOpts, UDSuffixBuf)) {
         isFloat16 = false;
         isHalf = false;
         isImaginary = false;
         isBitInt = false;
         MicrosoftInteger = 0;
         saw_fixed_point_suffix = false;
         isFract = false;
         isAccum = false;
+        isBF16 = false;
       }
 
       saw_ud_suffix = true;
       return;
     }
 
     if (s != ThisTokEnd) {
       // Report an error if there are any.

clang/lib/Sema/Sema.cpp

if (VK == VK_PRValue && !getLangOpts().CPlusPlus && !E->isPRValue()) {
                 << /*register variable*/ 3 << E->getSourceRange();
             return ExprError();
           }
         }
       }
     }
   }
 
+  // C++23 7.3.10 [conv.double]
+  // A prvalue of floating-point type can be converted to a prvalue of another
+  // floating-point type with a greater or equal conversion rank ([conv.rank]).
+  // A prvalue of standard floating-point type can be converted to a prvalue of
+  // another standard floating-point type
+  if (ExprTy->isCXX23StandardAndExtendedFpOp(Context, TypeTy) &&
+      Kind == CK_FloatingCast && E->isPRValue() &&
+      (CCK == CCK_ImplicitConversion)) {
+    auto conversionRank = Context.getFloatingTypeOrder(TypeTy, ExprTy);
+    if (conversionRank < FRCR_Greater) {
+      Diag(E->getExprLoc(),
+           diag::err_cxx2b_invalid_implicit_floating_point_cast)
+          << E->getSourceRange();
+      return ExprError();
+    }
+  }
+
   if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
     if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
       ImpCast->setType(Ty);
       ImpCast->setValueKind(VK);
       return E;
     }
   }
 

clang/lib/Sema/SemaCast.cpp

if (Enum->getDecl()->isScoped()) {
         return TC_Success;
       } else if (DestType->isRealFloatingType()) {
         Kind = CK_IntegralToFloating;
         return TC_Success;
       }
     }
   }
 
+  // [expr.static.cast] 7.6.1.9p11, A prvalue of floating-point type can
+  // be explicitly converted to any other floating-point type.
+  // Conversion between fp16 and bf16 is not supported yet.
+  if (SrcExpr.get()->isPRValue() &&
+      DestType->isCXX23StandardAndExtendedFpOp(Self.Context, SrcType)) {
+    // Support to cast between fp16 and bf16 doesn't exist yet.
+    if (!((DestType->isBF16Type() || DestType->isFloat16Type()) &&
+          (SrcType->isBF16Type() || SrcType->isFloat16Type()))) {
+      Kind = CK_FloatingCast;
+      return TC_Success;
+    }
+  }
+
   // Reverse integral promotion/conversion. All such conversions are themselves
   // again integral promotions or conversions and are thus already handled by
   // p2 (TryDirectInitialization above).
   // (Note: any data loss warnings should be suppressed.)
   // The exception is the reverse of enum->integer, i.e. integer->enum (and
   // enum->enum). See also C++ 5.2.9p7.
   // The same goes for reverse floating point promotion/conversion and
   // floating-integral conversions. Again, only floating->enum is relevant.
if (SrcType->isBFloat16Type() && !DestType->isBFloat16Type()) {
     Self.Diag(SrcExpr.get()->getExprLoc(), diag::err_cast_from_bfloat16)
         << SrcExpr.get()->getSourceRange();
     SrcExpr = ExprError();
     return;
   }
 
   // If either type is a pointer, the other type has to be either an
   // integer or a pointer.
-  if (!DestType->isArithmeticType()) {
-    if (!SrcType->isIntegralType(Self.Context) && SrcType->isArithmeticType()) {
+  if (!DestType->isArithmeticType(Self.Context)) {
+    if (!SrcType->isIntegralType(Self.Context) &&
+        SrcType->isArithmeticType(Self.Context)) {
       Self.Diag(SrcExpr.get()->getExprLoc(),
                 diag::err_cast_pointer_from_non_pointer_int)
         << SrcType << SrcExpr.get()->getSourceRange();
       SrcExpr = ExprError();
       return;
     }
     checkIntToPointerCast(/* CStyle */ true, OpRange, SrcExpr.get(), DestType,
                           Self);
-  } else if (!SrcType->isArithmeticType()) {
+  } else if (!SrcType->isArithmeticType(Self.Context)) {
     if (!DestType->isIntegralType(Self.Context) &&
-        DestType->isArithmeticType()) {
+        DestType->isArithmeticType(Self.Context)) {
       Self.Diag(SrcExpr.get()->getBeginLoc(),
                 diag::err_cast_pointer_to_non_pointer_int)
           << DestType << SrcExpr.get()->getSourceRange();
       SrcExpr = ExprError();
       return;
     }
 
     if ((Self.Context.getTypeSize(SrcType) >

clang/lib/Sema/SemaChecking.cpp

isArithmeticArgumentPromotion(Sema &S, const ImplicitCastExpr *ICE) {
   // Look through vector types, since we do default argument promotion for
   // those in OpenCL.
   if (const auto *VecTy = From->getAs<ExtVectorType>())
     From = VecTy->getElementType();
   if (const auto *VecTy = To->getAs<ExtVectorType>())
     To = VecTy->getElementType();
   // It's a floating promotion if the source type is a lower rank.
   return ICE->getCastKind() == CK_FloatingCast &&
-         S.Context.getFloatingTypeOrder(From, To) < 0;
+         S.Context.getFloatingTypeOrder(From, To) == FRCR_Lesser;
 }
 
 bool
 CheckPrintfHandler::checkFormatExpr(const analyze_printf::PrintfSpecifier &FS,
                                     const char *StartSpecifier,
                                     unsigned SpecifierLen,
                                     const Expr *E) {
   using namespace analyze_format_string;
static void AnalyzeCompoundAssignment(Sema &S, BinaryOperator *E) {
   if (ResultBT->isInteger())
     return DiagnoseImpCast(S, E, E->getRHS()->getType(), E->getLHS()->getType(),
                            E->getExprLoc(), diag::warn_impcast_float_integer);
 
   if (!ResultBT->isFloatingPoint())
     return;
 
   // If both source and target are floating points, warn about losing precision.
-  int Order = S.getASTContext().getFloatingTypeSemanticOrder(
-      QualType(ResultBT, 0), QualType(RBT, 0));
-  if (Order < 0 && !S.SourceMgr.isInSystemMacro(E->getOperatorLoc()))
+  FloatingRankCompareResult Order =
+      S.getASTContext().getFloatingTypeSemanticOrder(QualType(ResultBT, 0),
+                                                     QualType(RBT, 0));
+
+  assert(Order != FRCR_Unordered && "Invalid floating point types");
+  if (Order == FRCR_Lesser &&
+      !S.SourceMgr.isInSystemMacro(E->getOperatorLoc()))
     // warn about dropping FP rank.
     DiagnoseImpCast(S, E->getRHS(), E->getLHS()->getType(), E->getOperatorLoc(),
                     diag::warn_impcast_float_result_precision);
 }
 
 static std::string PrettyPrintInRange(const llvm::APSInt &Value,
                                       IntRange Range) {
   if (!Range.Width) return "0";
if (TargetBT && TargetBT->isVLSTBuiltinType())
     Target = TargetBT->getSveEltType(S.Context).getTypePtr();
 
   // If the source is floating point...
   if (SourceBT && SourceBT->isFloatingPoint()) {
     // ...and the target is floating point...
     if (TargetBT && TargetBT->isFloatingPoint()) {
       // ...then warn if we're dropping FP rank.
 
       int Order = S.getASTContext().getFloatingTypeSemanticOrder(
           QualType(SourceBT, 0), QualType(TargetBT, 0));
-      if (Order > 0) {
+      if (Order == FRCR_Greater) {
         // Don't warn about float constants that are precisely
         // representable in the target type.
         Expr::EvalResult result;
         if (E->EvaluateAsRValue(result, S.Context)) {
           // Value might be a float, a float vector, or a float complex.
           if (IsSameFloatAfterCast(result.Val,
                    S.Context.getFloatTypeSemantics(QualType(TargetBT, 0)),
                    S.Context.getFloatTypeSemantics(QualType(SourceBT, 0))))
             return;
         }
 
         if (S.SourceMgr.isInSystemMacro(CC))
           return;
 
         DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_float_precision);
       }
       // ... or possibly if we're increasing rank, too
-      else if (Order < 0) {
+      else if (Order == FRCR_Lesser) {
         if (S.SourceMgr.isInSystemMacro(CC))
           return;
 
         DiagnoseImpCast(S, E, T, CC, diag::warn_impcast_double_promotion);
       }
       return;
     }
 
     // If the target is integral, always warn.
     if (TargetBT && TargetBT->isInteger()) {
       if (S.SourceMgr.isInSystemMacro(CC))
         return;
 

clang/lib/Sema/SemaExpr.cpp

if (EvalMethod != LangOptions::FEM_Source && Ty->isFloatingType() &&
     switch (EvalMethod) {
     default:
       llvm_unreachable("Unrecognized float evaluation method");
       break;
     case LangOptions::FEM_UnsetOnCommandLine:
       llvm_unreachable("Float evaluation method should be set by now");
       break;
     case LangOptions::FEM_Double:
-      if (Context.getFloatingTypeOrder(Context.DoubleTy, Ty) > 0)
+      if (Context.getFloatingTypeOrder(Context.DoubleTy, Ty) == FRCR_Greater)
         // Widen the expression to double.
         return Ty->isComplexType()
                    ? ImpCastExprToType(E,
                                        Context.getComplexType(Context.DoubleTy),
                                        CK_FloatingComplexCast)
                    : ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast);
       break;
     case LangOptions::FEM_Extended:
-      if (Context.getFloatingTypeOrder(Context.LongDoubleTy, Ty) > 0)
+      if (Context.getFloatingTypeOrder(Context.LongDoubleTy, Ty) == FRCR_Greater)
         // Widen the expression to long double.
         return Ty->isComplexType()
                    ? ImpCastExprToType(
                          E, Context.getComplexType(Context.LongDoubleTy),
                          CK_FloatingComplexCast)
                    : ImpCastExprToType(E, Context.LongDoubleTy,
                                        CK_FloatingCast);
       break;
static QualType handleComplexConversion(Sema &S, ExprResult &LHS,
   if (!handleIntegerToComplexFloatConversion(S, RHS, LHS, RHSType, LHSType,
                                              /*SkipCast=*/false))
     return LHSType;
   if (!handleIntegerToComplexFloatConversion(S, LHS, RHS, LHSType, RHSType,
                                              /*SkipCast=*/IsCompAssign))
     return RHSType;
 
   // Compute the rank of the two types, regardless of whether they are complex.
-  int Order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
-  if (Order < 0)
+  FloatingRankCompareResult Order =
+      S.Context.getFloatingTypeOrder(LHSType, RHSType);
+  if (Order == FRCR_Lesser)
     // Promote the precision of the LHS if not an assignment.
     return handleComplexFloatConversion(S, LHS, LHSType, RHSType,
                                         /*PromotePrecision=*/!IsCompAssign);
   // Promote the precision of the RHS unless it is already the same as the LHS.
   return handleComplexFloatConversion(S, RHS, RHSType, LHSType,
-                                      /*PromotePrecision=*/Order > 0);
+                                      /*PromotePrecision=*/Order ==
+                                          clang::FRCR_Greater);
 }
 
 /// Handle arithmetic conversion from integer to float.  Helper function
 /// of UsualArithmeticConversions()
 static QualType handleIntToFloatConversion(Sema &S, ExprResult &FloatExpr,
                                            ExprResult &IntExpr,
                                            QualType FloatTy, QualType IntTy,
                                            bool ConvertFloat, bool ConvertInt) {
static QualType handleFloatConversion(Sema &S, ExprResult &LHS,
   if (LHSType->isFixedPointType() || RHSType->isFixedPointType()) {
     if (LHSFloat)
       RHS = S.ImpCastExprToType(RHS.get(), LHSType, CK_FixedPointToFloating);
     else if (!IsCompAssign)
       LHS = S.ImpCastExprToType(LHS.get(), RHSType, CK_FixedPointToFloating);
     return LHSFloat ? LHSType : RHSType;
   }
 
-  // If we have two real floating types, convert the smaller operand
-  // to the bigger result.
+  // C++23 [expr.arith.conv] 7.4
+  // If the floating-point conversion ranks ([conv.rank]) of the types
+  // of the operands are ordered but not equal, then the operand of the type
+  // with the lesser floating-point conversion rank is converted to the type of
+  // the other operand.
+  //
+  // If the floating-point conversion ranks of the types of the operands are
+  // equal, then the operand with the lesser floating-point conversion subrank
+  // ([conv.rank]) is converted to the type of the other operand.
+  //
+  // Otherwise, the expression is ill-formed i.e unordered conversion rank
+  // between floating-point types.
   if (LHSFloat && RHSFloat) {
-    int order = S.Context.getFloatingTypeOrder(LHSType, RHSType);
-    if (order > 0) {
+    FloatingRankCompareResult order =
+        S.Context.getFloatingTypeOrder(LHSType, RHSType);
+
+    if (order == FRCR_Unordered) {
+      return QualType();
+    }
+
+    if (order == FRCR_Greater || order == FRCR_Equal_Greater_Subrank) {
       RHS = S.ImpCastExprToType(RHS.get(), LHSType, CK_FloatingCast);
       return LHSType;
     }
 
-    assert(order < 0 && "illegal float comparison");
+    assert(((order != FRCR_Equal) &&
+            (order == FRCR_Lesser || order == FRCR_Equal_Lesser_Subrank)) &&
+           "illegal float comparison");
     if (!IsCompAssign)
       LHS = S.ImpCastExprToType(LHS.get(), RHSType, CK_FloatingCast);
     return RHSType;
   }
 
   if (LHSFloat) {
     // Half FP has to be promoted to float unless it is natively supported
     if (LHSType->isHalfType() && !S.getLangOpts().NativeHalfType)
       LHSType = S.Context.FloatTy;
if (const AtomicType *AtomicLHS = LHSType->getAs<AtomicType>())
     LHSType = AtomicLHS->getValueType();
 
   // If both types are identical, no conversion is needed.
   if (Context.hasSameType(LHSType, RHSType))
     return Context.getCommonSugaredType(LHSType, RHSType);
 
   // If either side is a non-arithmetic type (e.g. a pointer), we are done.
   // The caller can deal with this (e.g. pointer + int).
-  if (!LHSType->isArithmeticType() || !RHSType->isArithmeticType())
+  if (!LHSType->isArithmeticType(Context) ||
+      !RHSType->isArithmeticType(Context))
     return QualType();
 
   // Apply unary and bitfield promotions to the LHS's type.
   QualType LHSUnpromotedType = LHSType;
   if (Context.isPromotableIntegerType(LHSType))
     LHSType = Context.getPromotedIntegerType(LHSType);
   QualType LHSBitfieldPromoteTy = Context.isPromotableBitField(LHS.get());
   if (!LHSBitfieldPromoteTy.isNull())
if (Literal.isFixedPointLiteral()) {
     } else if (Literal.isFloat)
       Ty = Context.FloatTy;
     else if (Literal.isLong)
       Ty = Context.LongDoubleTy;
     else if (Literal.isFloat16)
       Ty = Context.Float16Ty;
     else if (Literal.isFloat128)
       Ty = Context.Float128Ty;
+    else if (Literal.isBF16)
+      Ty = Context.BF16Ty;
     else
       Ty = Context.DoubleTy;
 
     Res = BuildFloatingLiteral(*this, Literal, Ty, Tok.getLocation());
 
     if (Ty == Context.DoubleTy) {
       if (getLangOpts().SinglePrecisionConstants) {
         if (Ty->castAs<BuiltinType>()->getKind() != BuiltinType::Float) {

 
 static bool CheckVecStepTraitOperandType(Sema &S, QualType T,
                                          SourceLocation Loc,
                                          SourceRange ArgRange) {
   // [OpenCL 1.1 6.11.12] "The vec_step built-in function takes a built-in
   // scalar or vector data type argument..."
   // Every built-in scalar type (OpenCL 1.1 6.1.1) is either an arithmetic
   // type (C99 6.2.5p18) or void.
-  if (!(T->isArithmeticType() || T->isVoidType() || T->isVectorType())) {
+  if (!(T->isArithmeticType(S.Context) || T->isVoidType() ||
+        T->isVectorType())) {
     S.Diag(Loc, diag::err_vecstep_non_scalar_vector_type)
       << T << ArgRange;
     return true;
   }
 
   assert((T->isVoidType() || !T->isIncompleteType()) &&
          "Scalar types should always be complete");
   return false;
if (V.isInvalid())
       return QualType();
   }
 
   // These operators return the element type of a complex type.
   if (const ComplexType *CT = V.get()->getType()->getAs<ComplexType>())
     return CT->getElementType();
 
   // Otherwise they pass through real integer and floating point types here.
-  if (V.get()->getType()->isArithmeticType())
+  if (V.get()->getType()->isArithmeticType(S.Context))
     return V.get()->getType();
 
   // Test for placeholders.
   ExprResult PR = S.CheckPlaceholderExpr(V.get());
   if (PR.isInvalid()) return QualType();
   if (PR.get() != V.get()) {
     V = PR;
     return CheckRealImagOperand(S, V, Loc, IsReal);
QualType Sema::CheckConditionalOperands(ExprResult &Cond, ExprResult &LHS,
   // selection operator (?:).
   if (getLangOpts().OpenCL &&
       ((int)checkBlockType(*this, LHS.get()) | (int)checkBlockType(*this, RHS.get()))) {
     return QualType();
   }
 
   // If both operands have arithmetic type, do the usual arithmetic conversions
   // to find a common type: C99 6.5.15p3,5.
-  if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) {
+  if (LHSTy->isArithmeticType(Context) && RHSTy->isArithmeticType(Context)) {
     // Disallow invalid arithmetic conversions, such as those between bit-
     // precise integers types of different sizes, or between a bit-precise
     // integer and another type.
     if (ResTy.isNull() && (LHSTy->isBitIntType() || RHSTy->isBitIntType())) {
       Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands)
           << LHSTy << RHSTy << LHS.get()->getSourceRange()
           << RHS.get()->getSourceRange();
       return QualType();
if (const ReferenceType *LHSTypeRef = LHSType->getAs<ReferenceType>()) {
     return Incompatible;
   }
 
   // Allow scalar to ExtVector assignments, and assignments of an ExtVector type
   // to the same ExtVector type.
   if (LHSType->isExtVectorType()) {
     if (RHSType->isExtVectorType())
       return Incompatible;
-    if (RHSType->isArithmeticType()) {
+    if (RHSType->isArithmeticType(Context)) {
       // CK_VectorSplat does T -> vector T, so first cast to the element type.
       if (ConvertRHS)
         RHS = prepareVectorSplat(LHSType, RHS.get());
       Kind = CK_VectorSplat;
       return Compatible;
     }
   }
 
Sema::CheckAssignmentConstraints(QualType LHSType, ExprResult &RHS,
 
   // Disallow assigning a _Complex to a real type in C++ mode since it simply
   // discards the imaginary part.
   if (getLangOpts().CPlusPlus && RHSType->getAs<ComplexType>() &&
       !LHSType->getAs<ComplexType>())
     return Incompatible;
 
   // Arithmetic conversions.
-  if (LHSType->isArithmeticType() && RHSType->isArithmeticType() &&
+  if (LHSType->isArithmeticType(Context) &&
+      RHSType->isArithmeticType(Context) &&
       !(getLangOpts().CPlusPlus && LHSType->isEnumeralType())) {
     if (ConvertRHS)
       Kind = PrepareScalarCast(RHS, LHSType);
     return Compatible;
   }
 
   // Conversions to normal pointers.
   if (const PointerType *LHSPointer = dyn_cast<PointerType>(LHSType)) {
if (S.getLangOpts().OpenCL && (scalarTy->isRealFloatingType() ||
       return true;
     }
     if (!scalarTy->isIntegralType(S.Context))
       return true;
     scalarCast = CK_IntegralCast;
   } else if (vectorEltTy->isRealFloatingType()) {
     if (scalarTy->isRealFloatingType()) {
       if (S.getLangOpts().OpenCL &&
-          S.Context.getFloatingTypeOrder(vectorEltTy, scalarTy) < 0) {
+          S.Context.getFloatingTypeOrder(vectorEltTy, scalarTy) ==
+              clang::FRCR_Lesser) {
         DiagID = diag::err_opencl_scalar_type_rank_greater_than_vector_type;
         return true;
       }
       scalarCast = CK_FloatingCast;
     }
     else if (scalarTy->isIntegralType(S.Context))
       scalarCast = CK_IntegralToFloating;
     else
if (const auto *VT = VectorTy->getAs<VectorType>()) {
     VectorEltTy =
         VectorTy->castAs<BuiltinType>()->getSveEltType(S.getASTContext());
   } else {
     llvm_unreachable("Only Fixed-Length and SVE Vector types are handled here");
   }
 
   // Reject cases where the vector element type or the scalar element type are
   // not integral or floating point types.
-  if (!VectorEltTy->isArithmeticType() || !ScalarTy->isArithmeticType())
+  if (!VectorEltTy->isArithmeticType(S.Context) ||
+      !ScalarTy->isArithmeticType(S.Context))
     return true;
 
   // The conversion to apply to the scalar before splatting it,
   // if necessary.
   CastKind ScalarCast = CK_NoOp;
 
   // Accept cases where the vector elements are integers and the scalar is
   // an integer.
if (ScalarTy->isRealFloatingType()) {
       llvm::APFloat Result(0.0);
 
       // Determine whether this is a constant scalar. In the event that the
       // value is dependent (and thus cannot be evaluated by the constant
       // evaluator), skip the evaluation. This will then diagnose once the
       // expression is instantiated.
       bool CstScalar = Scalar->get()->isValueDependent() ||
                        Scalar->get()->EvaluateAsFloat(Result, S.Context);
-      int Order = S.Context.getFloatingTypeOrder(VectorEltTy, ScalarTy);
-      if (!CstScalar && Order < 0)
+      FloatingRankCompareResult Order =
+          S.Context.getFloatingTypeOrder(VectorEltTy, ScalarTy);
+
+      // Although the GCC Vector Extensions are not part of the C++23 language
+      // standard, we are currently applying the C++23 extended floating point
+      // rules to them. This is in keeping with the spirit of this function and
+      // maintains consistency in handling floating point types
+      if (S.Context.getLangOpts().CPlusPlus2b &&
+          (ScalarTy->isCXX23StandardAndExtendedFpOp(S.Context, VectorEltTy)) &&
+          (Order <= FRCR_Lesser))
+        return true;
+
+      if (!CstScalar && (Order == FRCR_Lesser))
         return true;
 
       // If the scalar cannot be safely casted to the vector element type,
       // reject it.
       if (CstScalar) {
         bool Truncated = false;
         Result.convert(S.Context.getFloatTypeSemantics(VectorEltTy),
                        llvm::APFloat::rmNearestTiesToEven, &Truncated);
QualType Sema::CheckMultiplyDivideOperands(ExprResult &LHS, ExprResult &RHS,
   if (LHSTy->isVLSTBuiltinType() || RHSTy->isVLSTBuiltinType())
     return CheckSizelessVectorOperands(LHS, RHS, Loc, IsCompAssign,
                                        ACK_Arithmetic);
   if (!IsDiv &&
       (LHSTy->isConstantMatrixType() || RHSTy->isConstantMatrixType()))
     return CheckMatrixMultiplyOperands(LHS, RHS, Loc, IsCompAssign);
   // For division, only matrix-by-scalar is supported. Other combinations with
   // matrix types are invalid.
-  if (IsDiv && LHSTy->isConstantMatrixType() && RHSTy->isArithmeticType())
+  if (IsDiv && LHSTy->isConstantMatrixType() &&
+      RHSTy->isArithmeticType(Context))
     return CheckMatrixElementwiseOperands(LHS, RHS, Loc, IsCompAssign);
 
   QualType compType = UsualArithmeticConversions(
       LHS, RHS, Loc, IsCompAssign ? ACK_CompAssign : ACK_Arithmetic);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
 
-
-  if (compType.isNull() || !compType->isArithmeticType())
+  if (compType.isNull() || !compType->isArithmeticType(Context))
     return InvalidOperands(Loc, LHS, RHS);
   if (IsDiv) {
     DiagnoseBadDivideOrRemainderValues(*this, LHS, RHS, Loc, IsDiv);
     DiagnoseDivisionSizeofPointerOrArray(*this, LHS.get(), RHS.get(), Loc);
   }
   return compType;
 }
 
QualType Sema::CheckAdditionOperands(ExprResult &LHS, ExprResult &RHS,
 
   // Diagnose "string literal" '+' int and string '+' "char literal".
   if (Opc == BO_Add) {
     diagnoseStringPlusInt(*this, Loc, LHS.get(), RHS.get());
     diagnoseStringPlusChar(*this, Loc, LHS.get(), RHS.get());
   }
 
   // handle the common case first (both operands are arithmetic).
-  if (!compType.isNull() && compType->isArithmeticType()) {
+  if (!compType.isNull() && compType->isArithmeticType(Context)) {
     if (CompLHSTy) *CompLHSTy = compType;
     return compType;
   }
 
   // Type-checking.  Ultimately the pointer's going to be in PExp;
   // note that we bias towards the LHS being the pointer.
   Expr *PExp = LHS.get(), *IExp = RHS.get();
 
QualType Sema::CheckSubtractionOperands(ExprResult &LHS, ExprResult &RHS,
   QualType compType = UsualArithmeticConversions(
       LHS, RHS, Loc, CompLHSTy ? ACK_CompAssign : ACK_Arithmetic);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
 
   // Enforce type constraints: C99 6.5.6p3.
 
   // Handle the common case first (both operands are arithmetic).
-  if (!compType.isNull() && compType->isArithmeticType()) {
+  if (!compType.isNull() && compType->isArithmeticType(Context)) {
     if (CompLHSTy) *CompLHSTy = compType;
     return compType;
   }
 
   // Either ptr - int   or   ptr - ptr.
   if (LHS.get()->getType()->isAnyPointerType()) {
     QualType lpointee = LHS.get()->getType()->getPointeeType();
 
if (NumEnumArgs == 2) {
     // type E, the operator yields the result of converting the operands
     // to the underlying type of E and applying <=> to the converted operands.
     if (!S.Context.hasSameUnqualifiedType(LHSStrippedType, RHSStrippedType)) {
       S.InvalidOperands(Loc, LHS, RHS);
       return QualType();
     }
     QualType IntType =
         LHSStrippedType->castAs<EnumType>()->getDecl()->getIntegerType();
-    assert(IntType->isArithmeticType());
+    assert(IntType->isArithmeticType(S.Context));
 
     // We can't use `CK_IntegralCast` when the underlying type is 'bool', so we
     // promote the boolean type, and all other promotable integer types, to
     // avoid this.
     if (S.Context.isPromotableIntegerType(IntType))
       IntType = S.Context.getPromotedIntegerType(IntType);
 
     LHS = S.ImpCastExprToType(LHS.get(), IntType, CK_IntegralCast);
static QualType checkArithmeticOrEnumeralCompare(Sema &S, ExprResult &LHS,
 
   // C99 6.5.8p3 / C99 6.5.9p4
   QualType Type =
       S.UsualArithmeticConversions(LHS, RHS, Loc, Sema::ACK_Comparison);
   if (LHS.isInvalid() || RHS.isInvalid())
     return QualType();
   if (Type.isNull())
     return S.InvalidOperands(Loc, LHS, RHS);
-  assert(Type->isArithmeticType() || Type->isEnumeralType());
+  assert(Type->isArithmeticType(S.Context) || Type->isEnumeralType());
 
   if (Type->isAnyComplexType() && BinaryOperator::isRelationalOp(Opc))
     return S.InvalidOperands(Loc, LHS, RHS);
 
   // Check for comparisons of floating point operands using != and ==.
   if (Type->hasFloatingRepresentation())
     S.CheckFloatComparison(Loc, LHS.get(), RHS.get(), Opc);
 
if (LHS.get()->getType()->isVLSTBuiltinType() ||
       RHS.get()->getType()->isVLSTBuiltinType())
     return CheckSizelessVectorCompareOperands(LHS, RHS, Loc, Opc);
 
   diagnoseLogicalNotOnLHSofCheck(*this, LHS, RHS, Loc, Opc);
   diagnoseTautologicalComparison(*this, Loc, LHS.get(), RHS.get(), Opc);
 
   QualType LHSType = LHS.get()->getType();
   QualType RHSType = RHS.get()->getType();
-  if ((LHSType->isArithmeticType() || LHSType->isEnumeralType()) &&
-      (RHSType->isArithmeticType() || RHSType->isEnumeralType()))
+  if ((LHSType->isArithmeticType(Context) || LHSType->isEnumeralType()) &&
+      (RHSType->isArithmeticType(Context) || RHSType->isEnumeralType()))
     return checkArithmeticOrEnumeralCompare(*this, LHS, RHS, Loc, Opc);
 
   const Expr::NullPointerConstantKind LHSNullKind =
       LHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull);
   const Expr::NullPointerConstantKind RHSNullKind =
       RHS.get()->isNullPointerConstant(Context, Expr::NPC_ValueDependentIsNull);
   bool LHSIsNull = LHSNullKind != Expr::NPCK_NotNull;
   bool RHSIsNull = RHSNullKind != Expr::NPCK_NotNull;
case UO_Minus:
     ConvertHalfVec = needsConversionOfHalfVec(true, Context, Input.get());
 
     // If the operand is a half vector, promote it to a float vector.
     if (ConvertHalfVec)
       Input = convertVector(Input.get(), Context.FloatTy, *this);
     resultType = Input.get()->getType();
     if (resultType->isDependentType())
       break;
-    if (resultType->isArithmeticType()) // C99 6.5.3.3p1
+    if (resultType->isArithmeticType(Context)) // C99 6.5.3.3p1
       break;
     else if (resultType->isVectorType() &&
              // The z vector extensions don't allow + or - with bool vectors.
              (!Context.getLangOpts().ZVector ||
               resultType->castAs<VectorType>()->getVectorKind() !=
               VectorType::AltiVecBool))
       break;
     else if (resultType->isVLSTBuiltinType()) // SVE vectors allow + and -

clang/lib/Sema/SemaExprCXX.cpp

static bool EvaluateUnaryTypeTrait(Sema &Self, TypeTrait UTT,
   case UTT_IsFunction:
     return T->isFunctionType();
 
     // Type trait expressions which correspond to the convenient composition
     // predicates in C++0x [meta.unary.comp].
   case UTT_IsReference:
     return T->isReferenceType();
   case UTT_IsArithmetic:
-    return T->isArithmeticType() && !T->isEnumeralType();
+    return T->isArithmeticType(C) && !T->isEnumeralType();
   case UTT_IsFundamental:
-    return T->isFundamentalType();
+    return T->isFundamentalType(C);
   case UTT_IsObject:
     return T->isObjectType();
   case UTT_IsScalar:
     // Note: semantic analysis depends on Objective-C lifetime types to be
     // considered scalar types. However, such types do not actually behave
     // like scalar types at run time (since they may require retain/release
     // operations), so we report them as non-scalar.
     if (T->isObjCLifetimeType()) {
return CheckVectorOperands(LHS, RHS, QuestionLoc, /*isCompAssign*/ false,
                                /*AllowBothBool*/ true,
                                /*AllowBoolConversions*/ false,
                                /*AllowBoolOperation*/ false,
                                /*ReportInvalid*/ true);
 
   //   -- The second and third operands have arithmetic or enumeration type;
   //      the usual arithmetic conversions are performed to bring them to a
   //      common type, and the result is of that type.
-  if (LTy->isArithmeticType() && RTy->isArithmeticType()) {
+  if (LTy->isArithmeticType(Context) && RTy->isArithmeticType(Context)) {
     QualType ResTy =
         UsualArithmeticConversions(LHS, RHS, QuestionLoc, ACK_Conditional);
     if (LHS.isInvalid() || RHS.isInvalid())
       return QualType();
     if (ResTy.isNull()) {
       Diag(QuestionLoc,
            diag::err_typecheck_cond_incompatible_operands) << LTy << RTy
         << LHS.get()->getSourceRange() << RHS.get()->getSourceRange();

clang/lib/Sema/SemaObjCProperty.cpp

if (!Context.hasSameType(PropertyIvarType, IvarType)) {
         // a property implementation and to avoid future warnings.
       }
       else {
         // FIXME! Rules for properties are somewhat different that those
         // for assignments. Use a new routine to consolidate all cases;
         // specifically for property redeclarations as well as for ivars.
         QualType lhsType =Context.getCanonicalType(PropertyIvarType).getUnqualifiedType();
         QualType rhsType =Context.getCanonicalType(IvarType).getUnqualifiedType();
-        if (lhsType != rhsType &&
-            lhsType->isArithmeticType()) {
+        if (lhsType != rhsType && lhsType->isArithmeticType(Context)) {
           Diag(PropertyDiagLoc, diag::err_property_ivar_type)
             << property->getDeclName() << PropType
             << Ivar->getDeclName() << IvarType;
           Diag(Ivar->getLocation(), diag::note_ivar_decl);
           // Fall thru - see previous comment
         }
       }
       // __weak is explicit. So it works on Canonical type.
else if (CheckAssignmentConstraints(Loc, GetterType, PropertyRValueType)
             << property->getDeclName() << PropertyRValueType
             << GetterMethod->getSelector() << GetterType;
           Diag(GetterMethod->getLocation(), diag::note_declared_at);
           return true;
     } else {
       compat = true;
       QualType lhsType = Context.getCanonicalType(PropertyRValueType);
       QualType rhsType =Context.getCanonicalType(GetterType).getUnqualifiedType();
-      if (lhsType != rhsType && lhsType->isArithmeticType())
+      if (lhsType != rhsType && lhsType->isArithmeticType(Context))
         compat = false;
     }
   }
 
   if (!compat) {
     Diag(Loc, diag::warn_accessor_property_type_mismatch)
     << property->getDeclName()
     << GetterMethod->getSelector();

clang/lib/Sema/SemaOpenMP.cpp

for (Expr *RefExpr : VarList) {
     // of the list item must be an allowed arithmetic data type: char, int,
     // float, double, or _Bool, possibly modified with long, short, signed, or
     // unsigned. For a max or min reduction in C++, the type of the list item
     // must be an allowed arithmetic data type: char, wchar_t, int, float,
     // double, or bool, possibly modified with long, short, signed, or unsigned.
     if (DeclareReductionRef.isUnset()) {
       if ((BOK == BO_GT || BOK == BO_LT) &&
           !(Type->isScalarType() ||
-            (S.getLangOpts().CPlusPlus && Type->isArithmeticType()))) {
+            (S.getLangOpts().CPlusPlus && Type->isArithmeticType(Context)))) {
         S.Diag(ELoc, diag::err_omp_clause_not_arithmetic_type_arg)
             << getOpenMPClauseName(ClauseKind) << S.getLangOpts().CPlusPlus;
         if (!ASE && !OASE) {
           bool IsDecl = !VD || VD->isThisDeclarationADefinition(Context) ==
                                    VarDecl::DeclarationOnly;
           S.Diag(D->getLocation(),
                  IsDecl ? diag::note_previous_decl : diag::note_defined_here)
               << D;

clang/lib/Sema/SemaOverload.cpp

FloatingIntegralConversion:
     return NK_Not_Narrowing;
 
   // -- from long double to double or float, or from double to float, except
   //    where the source is a constant expression and the actual value after
   //    conversion is within the range of values that can be represented (even
   //    if it cannot be represented exactly), or
   case ICK_Floating_Conversion:
     if (FromType->isRealFloatingType() && ToType->isRealFloatingType() &&
-        Ctx.getFloatingTypeOrder(FromType, ToType) == 1) {
+        Ctx.getFloatingTypeOrder(FromType, ToType) == FRCR_Greater) {
       // FromType is larger than ToType.
       const Expr *Initializer = IgnoreNarrowingConversion(Ctx, Converted);
 
       // If it's value-dependent, we can't tell whether it's narrowing.
       if (Initializer->isValueDependent())
         return NK_Dependent_Narrowing;
 
       if (Initializer->isCXX11ConstantExpr(Ctx, &ConstantValue)) {
static bool IsVectorConversion(Sema &S, QualType FromType, QualType ToType,
   // There are no conversions between extended vector types, only identity.
   if (ToType->isExtVectorType()) {
     // There are no conversions between extended vector types other than the
     // identity conversion.
     if (FromType->isExtVectorType())
       return false;
 
     // Vector splat from any arithmetic type to a vector.
-    if (FromType->isArithmeticType()) {
+    if (FromType->isArithmeticType(S.Context)) {
       ICK = ICK_Vector_Splat;
       return true;
     }
   }
 
   if (ToType->isSVESizelessBuiltinType() ||
       FromType->isSVESizelessBuiltinType())
     if (S.Context.areCompatibleSveTypes(FromType, ToType) ||
if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
     // Floating point promotion (C++ 4.6).
     SCS.Second = ICK_Floating_Promotion;
     FromType = ToType.getUnqualifiedType();
   } else if (S.IsComplexPromotion(FromType, ToType)) {
     // Complex promotion (Clang extension)
     SCS.Second = ICK_Complex_Promotion;
     FromType = ToType.getUnqualifiedType();
   } else if (ToType->isBooleanType() &&
-             (FromType->isArithmeticType() ||
-              FromType->isAnyPointerType() ||
-              FromType->isBlockPointerType() ||
+             (FromType->isArithmeticType(S.Context) ||
+              FromType->isAnyPointerType() || FromType->isBlockPointerType() ||
               FromType->isMemberPointerType())) {
     // Boolean conversions (C++ 4.12).
     SCS.Second = ICK_Boolean_Conversion;
     FromType = S.Context.BoolTy;
   } else if (FromType->isIntegralOrUnscopedEnumerationType() &&
              ToType->isIntegralType(S.Context)) {
     // Integral conversions (C++ 4.7).
     SCS.Second = ICK_Integral_Conversion;
     FromType = ToType.getUnqualifiedType();
   } else if (FromType->isAnyComplexType() && ToType->isAnyComplexType()) {
     // Complex conversions (C99 6.3.1.6)
     SCS.Second = ICK_Complex_Conversion;
     FromType = ToType.getUnqualifiedType();
-  } else if ((FromType->isAnyComplexType() && ToType->isArithmeticType()) ||
-             (ToType->isAnyComplexType() && FromType->isArithmeticType())) {
+  } else if ((FromType->isAnyComplexType() &&
+              ToType->isArithmeticType(S.Context)) ||
+             (ToType->isAnyComplexType() &&
+              FromType->isArithmeticType(S.Context))) {
     // Complex-real conversions (C99 6.3.1.7)
     SCS.Second = ICK_Complex_Real;
     FromType = ToType.getUnqualifiedType();
   } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
     // FIXME: disable conversions between long double, __ibm128 and __float128
     // if their representation is different until there is back end support
     // We of course allow this conversion if long double is really double.
 
+    // C++23 7.3.10p1 [conv.double]
+    // A prvalue of floating-point type can be converted to a prvalue of another
+    // floating-point type with a greater or equal conversion rank
+    // ([conv.rank]). A prvalue of standard floating-point type can be converted
+    // to a prvalue of another standard floating-point type.
+    if ((FromType->isCXX23StandardAndExtendedFpOp(S.Context, ToType)) &&
+        (S.Context.getFloatingTypeOrder(ToType, FromType) <= FRCR_Lesser))
+      return false;
+
     // Conversions between bfloat and other floats are not permitted.
-    if (FromType == S.Context.BFloat16Ty || ToType == S.Context.BFloat16Ty)
+    if (FromType->isBFloat16Type() || ToType->isBFloat16Type())
       return false;
 
     // Conversions between IEEE-quad and IBM-extended semantics are not
     // permitted.
     const llvm::fltSemantics &FromSem =
         S.Context.getFloatTypeSemantics(FromType);
     const llvm::fltSemantics &ToSem = S.Context.getFloatTypeSemantics(ToType);
     if ((&FromSem == &llvm::APFloat::PPCDoubleDouble() &&
          &ToSem == &llvm::APFloat::IEEEquad()) ||
         (&FromSem == &llvm::APFloat::IEEEquad() &&
          &ToSem == &llvm::APFloat::PPCDoubleDouble()))
       return false;
 
     // Floating point conversions (C++ 4.8).
     SCS.Second = ICK_Floating_Conversion;
     FromType = ToType.getUnqualifiedType();
   } else if ((FromType->isRealFloatingType() &&
               ToType->isIntegralType(S.Context)) ||
              (FromType->isIntegralOrUnscopedEnumerationType() &&
               ToType->isRealFloatingType())) {
     // Conversions between bfloat and int are not permitted.
-    if (FromType->isBFloat16Type() || ToType->isBFloat16Type())
+    if ((FromType->isBFloat16Type() || ToType->isBFloat16Type()))
       return false;
 
     // 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 &&
SCS.Second = ICK_Pointer_Member;
                                 InOverloadResolution, CStyle)) {
     SCS.Second = SecondICK;
     FromType = ToType.getUnqualifiedType();
   } else if (!S.getLangOpts().CPlusPlus &&
              S.Context.typesAreCompatible(ToType, FromType)) {
     // Compatible conversions (Clang extension for C function overloading)
     SCS.Second = ICK_Compatible_Conversion;
     FromType = ToType.getUnqualifiedType();
-  } else if (IsTransparentUnionStandardConversion(S, From, ToType,
-                                             InOverloadResolution,
-                                             SCS, CStyle)) {
+  } else if (IsTransparentUnionStandardConversion(
+                 S, From, ToType, InOverloadResolution, SCS, CStyle)) {
     SCS.Second = ICK_TransparentUnionConversion;
     FromType = ToType;
   } else if (tryAtomicConversion(S, From, ToType, InOverloadResolution, SCS,
                                  CStyle)) {
     // tryAtomicConversion has updated the standard conversion sequence
     // appropriately.
     return true;
   } else if (ToType->isEventT() &&
CompareStandardConversionSequences(Sema &S, SourceLocation Loc,
   FixedEnumPromotion FEP1 = getFixedEnumPromtion(S, SCS1);
   FixedEnumPromotion FEP2 = getFixedEnumPromtion(S, SCS2);
   if (FEP1 != FixedEnumPromotion::None && FEP2 != FixedEnumPromotion::None &&
       FEP1 != FEP2)
     return FEP1 == FixedEnumPromotion::ToUnderlyingType
                ? ImplicitConversionSequence::Better
                : ImplicitConversionSequence::Worse;
 
+  // C++23 12.2.4.3p4:
+  // A conversion in either direction between floating-point type FP1 and
+  // floating-point type FP2 is better than a conversion in the same direction
+  // between FP1 and arithmetic type T3 if:
+  // 1) The floating-point conversion rank ([conv.rank]) of FP1 is equal to the
+  // rank of FP2, and 2) T3 is not a floating-point type, or T3 is a
+  // floating-point type whose rank is not equal to the rank of FP1, or the
+  // floating-point conversion subrank ([conv.rank]) of FP2 is greater than the
+  // subrank of T3.
+  if (S.Context.getLangOpts().CPlusPlus2b) {
+    if (S.Context.hasSameType(SCS1.getFromType(), SCS2.getFromType())) {
+
+      if ((SCS1.Second == ICK_Floating_Conversion) &&
+          (SCS1.getFromType()->isCXX23FloatingPointType() &&
+           SCS1.getToType(1)->isCXX23FloatingPointType()) &&
+          S.Context.getFloatingTypeOrder(SCS1.getToType(1),
+                                         SCS1.getFromType()) >= FRCR_Equal) {
+
+        if ((SCS2.getToType(1)->isArithmeticType(S.Context)) &&
+            SCS2.getFromType()->isCXX23FloatingPointType()) {
+
+          if (!SCS2.getToType(1)->isCXX23FloatingPointType()) {
+            return ImplicitConversionSequence::Better;
+          }
+
+          if (S.Context.getFloatingTypeOrder(SCS2.getToType(1),
+                                             SCS1.getFromType()) < FRCR_Equal) {
+            return ImplicitConversionSequence::Better;
+          }
+
+          if (S.Context.getFloatingTypeOrder(SCS1.getToType(1),
+                                             SCS2.getToType(1)) ==
+              FRCR_Equal_Greater_Subrank) {
+            return ImplicitConversionSequence::Better;
+          }
+          return ImplicitConversionSequence::Worse;
+        }
+      }
+
+      if ((SCS2.Second == ICK_Floating_Conversion) &&
+          (SCS2.getFromType()->isCXX23FloatingPointType() &&
+           SCS2.getToType(1)->isCXX23FloatingPointType()) &&
+          S.Context.getFloatingTypeOrder(SCS2.getToType(1),
+                                         SCS2.getFromType()) >= FRCR_Equal) {
+        if ((SCS1.getToType(1)->isArithmeticType(S.Context)) &&
+            SCS1.getFromType()->isCXX23FloatingPointType()) {
+
+          if (!SCS1.getToType(1)->isCXX23FloatingPointType()) {
+            return ImplicitConversionSequence::Worse;
+          }
+
+          if (S.Context.getFloatingTypeOrder(SCS1.getToType(1),
+                                             SCS2.getFromType()) < FRCR_Equal) {
+            return ImplicitConversionSequence::Worse;
+          }
+
+          if (S.Context.getFloatingTypeOrder(SCS2.getToType(1),
+                                             SCS1.getToType(1)) ==
+              FRCR_Equal_Greater_Subrank) {
+            return ImplicitConversionSequence::Worse;
+          }
+
+          assert(false && "Should not reach here");
+        }
+      }
+    }
+  }
+
   // C++ [over.ics.rank]p4b2:
   //
   //   If class B is derived directly or indirectly from class A,
   //   conversion of B* to A* is better than conversion of B* to
   //   void*, and conversion of A* to void* is better than conversion
   //   of B* to void*.
   bool SCS1ConvertsToVoid
     = SCS1.isPointerConversionToVoidPointer(S.Context);
BuiltinCandidateTypeSet::AddTypesConvertedFrom(QualType Ty,
   Ty = Ty.getLocalUnqualifiedType();
 
   // Flag if we ever add a non-record type.
   const RecordType *TyRec = Ty->getAs<RecordType>();
   HasNonRecordTypes = HasNonRecordTypes || !TyRec;
 
   // Flag if we encounter an arithmetic type.
   HasArithmeticOrEnumeralTypes =
-    HasArithmeticOrEnumeralTypes || Ty->isArithmeticType();
+      HasArithmeticOrEnumeralTypes || Ty->isArithmeticType(Context);
 
   if (Ty->isObjCIdType() || Ty->isObjCClassType())
     PointerTypes.insert(Ty);
   else if (Ty->getAs<PointerType>() || Ty->getAs<ObjCObjectPointerType>()) {
     // Insert our type, and its more-qualified variants, into the set
     // of types.
     if (!AddPointerWithMoreQualifiedTypeVariants(Ty, VisibleQuals))
       return;

clang/lib/Serialization/ASTCommon.cpp

case BuiltinType::OMPArrayShaping:
     ID = PREDEF_TYPE_OMP_ARRAY_SHAPING;
     break;
   case BuiltinType::OMPIterator:
     ID = PREDEF_TYPE_OMP_ITERATOR;
     break;
   case BuiltinType::BFloat16:
     ID = PREDEF_TYPE_BFLOAT16_ID;
     break;
+  case BuiltinType::BF16:
+    ID = PREDEF_TYPE_BF16_ID;
+    break;
   }
 
   return TypeIdx(ID);
 }
 
 unsigned serialization::ComputeHash(Selector Sel) {
   unsigned N = Sel.getNumArgs();
   if (N == 0)

clang/lib/Serialization/ASTReader.cpp

case PREDEF_TYPE_LONGLONG_ID:
       T = Context.LongLongTy;
       break;
     case PREDEF_TYPE_INT128_ID:
       T = Context.Int128Ty;
       break;
     case PREDEF_TYPE_BFLOAT16_ID:
       T = Context.BFloat16Ty;
       break;
+    case PREDEF_TYPE_BF16_ID:
+      T = Context.BF16Ty;
+      break;
     case PREDEF_TYPE_HALF_ID:
       T = Context.HalfTy;
       break;
     case PREDEF_TYPE_FLOAT_ID:
       T = Context.FloatTy;
       break;
     case PREDEF_TYPE_DOUBLE_ID:
       T = Context.DoubleTy;

clang/test/CodeGenCXX/cxx2b-fp-ext-std-names-p1467r9.cpp

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py
+// RUN: %clang_cc1 -std=c++2b -triple x86_64-unknown-linux-gnu -fnative-bfloat16-type -fexperimental-new-itanium-mangling -S -emit-llvm %s -o - | FileCheck %s  --check-prefix=CHECK
+
+// CHECK-LABEL: @_Z1fDF16b(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[V_ADDR:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    store bfloat [[V:%.*]], ptr [[V_ADDR]], align 2
+// CHECK-NEXT:    ret i32 1
+//
+int f(decltype(0.BF16) v) { return 1; }
+// CHECK-LABEL: @_Z1fDF16_(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[V_ADDR:%.*]] = alloca half, align 2
+// CHECK-NEXT:    store half [[V:%.*]], ptr [[V_ADDR]], align 2
+// CHECK-NEXT:    ret i32 1
+//
+int f(_Float16 v) { return 1; }
+// CHECK-LABEL: @_Z1ff(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[V_ADDR:%.*]] = alloca float, align 4
+// CHECK-NEXT:    store float [[V:%.*]], ptr [[V_ADDR]], align 4
+// CHECK-NEXT:    ret i32 1
+//
+int f(float v) { return 1; }
+// CHECK-LABEL: @_Z1fd(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[V_ADDR:%.*]] = alloca double, align 8
+// CHECK-NEXT:    store double [[V:%.*]], ptr [[V_ADDR]], align 8
+// CHECK-NEXT:    ret i32 1
+//
+int f(double v) { return 1; }
+// CHECK-LABEL: @_Z1fe(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[V_ADDR:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    store x86_fp80 [[V:%.*]], ptr [[V_ADDR]], align 16
+// CHECK-NEXT:    ret i32 1
+//
+int f(long double v) { return 1; }
+// CHECK-LABEL: @_Z1fi(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[V_ADDR:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    store i32 [[V:%.*]], ptr [[V_ADDR]], align 4
+// CHECK-NEXT:    ret i32 1
+//
+int f(int v) { return 1; }
+
+// CHECK-LABEL: @_Z3f_2e(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[V_ADDR:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    store x86_fp80 [[V:%.*]], ptr [[V_ADDR]], align 16
+// CHECK-NEXT:    ret i32 1
+//
+int f_2(long double v) { return 1; }
+
+struct S {
+
+    operator decltype(0.BF16)() const {
+        return 0.0bf16;
+    }
+
+    operator _Float16() const {
+        return 0.0f16;
+    }
+
+    operator float() const {
+        return 0.0f;
+    }
+
+    operator double() const {
+        return 0.0;
+    }
+
+    operator long double() const {
+        return 0.0L;
+    }
+
+    operator int() const {
+        return 0;
+    }
+};
+
+struct S1 {
+    operator _Float16() const {
+        return 0.0f16;
+    }
+    operator float() const {
+        return 0.0f;
+    }
+    operator double() const {
+        return 0.0;
+    }
+    operator long double() const {
+        return 0.0L;
+    }
+
+    operator int() const {
+        return 0;
+    }
+};
+
+// CHECK-LABEL: @_Z4testv(
+// CHECK-NEXT:  entry:
+// CHECK-NEXT:    [[F16_VAL_6:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[F16_VAL_8:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[F16_VAL_9:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[F16_VAL_10:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[F16_VAL_11:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[BF16_VAL_5:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[BF16_VAL_7:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[BF16_VAL_8:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[BF16_VAL_9:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[BF16_VAL_10:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[F_VAL_1:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[F_VAL_2:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[F_VAL_3:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[F_VAL_4:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[F_VAL_5:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[D_VAL_1:%.*]] = alloca double, align 8
+// CHECK-NEXT:    [[D_VAL_2:%.*]] = alloca double, align 8
+// CHECK-NEXT:    [[D_VAL_3:%.*]] = alloca double, align 8
+// CHECK-NEXT:    [[D_VAL_4:%.*]] = alloca double, align 8
+// CHECK-NEXT:    [[D_VAL_5:%.*]] = alloca double, align 8
+// CHECK-NEXT:    [[LD_VAL_1:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    [[LD_VAL_2:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    [[LD_VAL_3:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    [[LD_VAL_4:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    [[LD_VAL_5:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    [[F16_FLOAT:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[F16_DOUBLE:%.*]] = alloca double, align 8
+// CHECK-NEXT:    [[F16_LDOUBLE:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    [[F16_INT:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[F16_UINT:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[F16_LONG:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[F16_ULONG:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[F16_LLONG:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[F16_ULLONG:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[F16_BOOL:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[BF16_FLOAT:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[BF16_DOUBLE:%.*]] = alloca double, align 8
+// CHECK-NEXT:    [[BF16_LDOUBLE:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    [[BF16_INT:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[BF16_UINT:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[BF16_LONG:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[BF16_ULONG:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[BF16_LLONG:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[BF16_ULLONG:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[BF16_BOOL:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[BF16_VAL:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[FLOAT16_VAL:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[FLOAT_VAL:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[DOUBLE_VAL:%.*]] = alloca double, align 8
+// CHECK-NEXT:    [[LONG_DOUBLE_VAL:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    [[INT_VAL:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST1:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST2:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST3:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST4:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST5:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST6:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST_7:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST_8:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST_9:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST_10:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[USER_DEFINED_VAL:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-NEXT:    [[BFLOAT16_VAL:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[F16_VAL:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[F_VAL:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[D_VAL:%.*]] = alloca double, align 8
+// CHECK-NEXT:    [[LD_VAL:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    [[I_VAL:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[USER_DEFINED_VAL_2:%.*]] = alloca [[STRUCT_S1:%.*]], align 1
+// CHECK-NEXT:    [[BFLOAT16_VAL_2:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    store half 0xH3C00, ptr [[F16_VAL_6]], align 2
+// CHECK-NEXT:    store half 0xH3C00, ptr [[F16_VAL_8]], align 2
+// CHECK-NEXT:    store half 0xH3C00, ptr [[F16_VAL_9]], align 2
+// CHECK-NEXT:    store half 0xH3C00, ptr [[F16_VAL_10]], align 2
+// CHECK-NEXT:    store half 0xH3C00, ptr [[F16_VAL_11]], align 2
+// CHECK-NEXT:    store bfloat 0xR3F80, ptr [[BF16_VAL_5]], align 2
+// CHECK-NEXT:    store bfloat 0xR3F80, ptr [[BF16_VAL_7]], align 2
+// CHECK-NEXT:    store bfloat 0xR3F80, ptr [[BF16_VAL_8]], align 2
+// CHECK-NEXT:    store bfloat 0xR3F80, ptr [[BF16_VAL_9]], align 2
+// CHECK-NEXT:    store bfloat 0xR3F80, ptr [[BF16_VAL_10]], align 2
+// CHECK-NEXT:    store float 1.000000e+00, ptr [[F_VAL_1]], align 4
+// CHECK-NEXT:    store float 1.000000e+00, ptr [[F_VAL_2]], align 4
+// CHECK-NEXT:    store float 1.000000e+00, ptr [[F_VAL_3]], align 4
+// CHECK-NEXT:    store float 1.000000e+00, ptr [[F_VAL_4]], align 4
+// CHECK-NEXT:    store float 1.000000e+00, ptr [[F_VAL_5]], align 4
+// CHECK-NEXT:    store double 1.000000e+00, ptr [[D_VAL_1]], align 8
+// CHECK-NEXT:    store double 1.000000e+00, ptr [[D_VAL_2]], align 8
+// CHECK-NEXT:    store double 1.000000e+00, ptr [[D_VAL_3]], align 8
+// CHECK-NEXT:    store double 1.000000e+00, ptr [[D_VAL_4]], align 8
+// CHECK-NEXT:    store double 1.000000e+00, ptr [[D_VAL_5]], align 8
+// CHECK-NEXT:    store x86_fp80 0xK3FFF8000000000000000, ptr [[LD_VAL_1]], align 16
+// CHECK-NEXT:    store x86_fp80 0xK3FFF8000000000000000, ptr [[LD_VAL_2]], align 16
+// CHECK-NEXT:    store x86_fp80 0xK3FFF8000000000000000, ptr [[LD_VAL_3]], align 16
+// CHECK-NEXT:    store x86_fp80 0xK3FFF8000000000000000, ptr [[LD_VAL_4]], align 16
+// CHECK-NEXT:    store x86_fp80 0xK3FFF8000000000000000, ptr [[LD_VAL_5]], align 16
+// CHECK-NEXT:    store float 2.000000e+00, ptr [[F16_FLOAT]], align 4
+// CHECK-NEXT:    store double 2.000000e+00, ptr [[F16_DOUBLE]], align 8
+// CHECK-NEXT:    store x86_fp80 0xK40008000000000000000, ptr [[F16_LDOUBLE]], align 16
+// CHECK-NEXT:    store half 0xH4000, ptr [[F16_INT]], align 2
+// CHECK-NEXT:    store half 0xH4000, ptr [[F16_UINT]], align 2
+// CHECK-NEXT:    store half 0xH4000, ptr [[F16_LONG]], align 2
+// CHECK-NEXT:    store half 0xH4000, ptr [[F16_ULONG]], align 2
+// CHECK-NEXT:    store half 0xH4000, ptr [[F16_LLONG]], align 2
+// CHECK-NEXT:    store half 0xH4000, ptr [[F16_ULLONG]], align 2
+// CHECK-NEXT:    store half 0xH4000, ptr [[F16_BOOL]], align 2
+// CHECK-NEXT:    store float 2.000000e+00, ptr [[BF16_FLOAT]], align 4
+// CHECK-NEXT:    store double 2.000000e+00, ptr [[BF16_DOUBLE]], align 8
+// CHECK-NEXT:    store x86_fp80 0xK40008000000000000000, ptr [[BF16_LDOUBLE]], align 16
+// CHECK-NEXT:    store bfloat 0xR4000, ptr [[BF16_INT]], align 2
+// CHECK-NEXT:    store bfloat 0xR4000, ptr [[BF16_UINT]], align 2
+// CHECK-NEXT:    store bfloat 0xR4000, ptr [[BF16_LONG]], align 2
+// CHECK-NEXT:    store bfloat 0xR4000, ptr [[BF16_ULONG]], align 2
+// CHECK-NEXT:    store bfloat 0xR4000, ptr [[BF16_LLONG]], align 2
+// CHECK-NEXT:    store bfloat 0xR4000, ptr [[BF16_ULLONG]], align 2
+// CHECK-NEXT:    store bfloat 0xR4000, ptr [[BF16_BOOL]], align 2
+// CHECK-NEXT:    store bfloat 0xR3F80, ptr [[BF16_VAL]], align 2
+// CHECK-NEXT:    store half 0xH3C00, ptr [[FLOAT16_VAL]], align 2
+// CHECK-NEXT:    store float 1.000000e+00, ptr [[FLOAT_VAL]], align 4
+// CHECK-NEXT:    store double 1.000000e+00, ptr [[DOUBLE_VAL]], align 8
+// CHECK-NEXT:    store x86_fp80 0xK3FFF8000000000000000, ptr [[LONG_DOUBLE_VAL]], align 16
+// CHECK-NEXT:    store i32 1, ptr [[INT_VAL]], align 4
+// CHECK-NEXT:    [[TMP0:%.*]] = load bfloat, ptr [[BF16_VAL]], align 2
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef i32 @_Z1fDF16b(bfloat noundef [[TMP0]])
+// CHECK-NEXT:    store i32 [[CALL]], ptr [[TEST1]], align 4
+// CHECK-NEXT:    [[TMP1:%.*]] = load half, ptr [[FLOAT16_VAL]], align 2
+// CHECK-NEXT:    [[CALL1:%.*]] = call noundef i32 @_Z1fDF16_(half noundef [[TMP1]])
+// CHECK-NEXT:    store i32 [[CALL1]], ptr [[TEST2]], align 4
+// CHECK-NEXT:    [[TMP2:%.*]] = load float, ptr [[FLOAT_VAL]], align 4
+// CHECK-NEXT:    [[CALL2:%.*]] = call noundef i32 @_Z1ff(float noundef [[TMP2]])
+// CHECK-NEXT:    store i32 [[CALL2]], ptr [[TEST3]], align 4
+// CHECK-NEXT:    [[TMP3:%.*]] = load double, ptr [[DOUBLE_VAL]], align 8
+// CHECK-NEXT:    [[CALL3:%.*]] = call noundef i32 @_Z1fd(double noundef [[TMP3]])
+// CHECK-NEXT:    store i32 [[CALL3]], ptr [[TEST4]], align 4
+// CHECK-NEXT:    [[TMP4:%.*]] = load x86_fp80, ptr [[LONG_DOUBLE_VAL]], align 16
+// CHECK-NEXT:    [[CALL4:%.*]] = call noundef i32 @_Z1fe(x86_fp80 noundef [[TMP4]])
+// CHECK-NEXT:    store i32 [[CALL4]], ptr [[TEST5]], align 4
+// CHECK-NEXT:    [[TMP5:%.*]] = load i32, ptr [[INT_VAL]], align 4
+// CHECK-NEXT:    [[CALL5:%.*]] = call noundef i32 @_Z1fi(i32 noundef [[TMP5]])
+// CHECK-NEXT:    store i32 [[CALL5]], ptr [[TEST6]], align 4
+// CHECK-NEXT:    [[TMP6:%.*]] = load float, ptr [[FLOAT_VAL]], align 4
+// CHECK-NEXT:    [[CONV:%.*]] = fpext float [[TMP6]] to x86_fp80
+// CHECK-NEXT:    [[CALL6:%.*]] = call noundef i32 @_Z3f_2e(x86_fp80 noundef [[CONV]])
+// CHECK-NEXT:    store i32 [[CALL6]], ptr [[TEST_7]], align 4
+// CHECK-NEXT:    [[TMP7:%.*]] = load double, ptr [[DOUBLE_VAL]], align 8
+// CHECK-NEXT:    [[CONV7:%.*]] = fpext double [[TMP7]] to x86_fp80
+// CHECK-NEXT:    [[CALL8:%.*]] = call noundef i32 @_Z3f_2e(x86_fp80 noundef [[CONV7]])
+// CHECK-NEXT:    store i32 [[CALL8]], ptr [[TEST_8]], align 4
+// CHECK-NEXT:    [[TMP8:%.*]] = load bfloat, ptr [[BF16_VAL]], align 2
+// CHECK-NEXT:    [[CONV9:%.*]] = fpext bfloat [[TMP8]] to x86_fp80
+// CHECK-NEXT:    [[CALL10:%.*]] = call noundef i32 @_Z3f_2e(x86_fp80 noundef [[CONV9]])
+// CHECK-NEXT:    store i32 [[CALL10]], ptr [[TEST_9]], align 4
+// CHECK-NEXT:    [[TMP9:%.*]] = load half, ptr [[FLOAT16_VAL]], align 2
+// CHECK-NEXT:    [[CONV11:%.*]] = fpext half [[TMP9]] to x86_fp80
+// CHECK-NEXT:    [[CALL12:%.*]] = call noundef i32 @_Z3f_2e(x86_fp80 noundef [[CONV11]])
+// CHECK-NEXT:    store i32 [[CALL12]], ptr [[TEST_10]], align 4
+// CHECK-NEXT:    [[CALL13:%.*]] = call noundef bfloat @_ZNK1ScvDF16bEv(ptr noundef nonnull align 1 dereferenceable(1) [[USER_DEFINED_VAL]])
+// CHECK-NEXT:    store bfloat [[CALL13]], ptr [[BFLOAT16_VAL]], align 2
+// CHECK-NEXT:    [[CALL14:%.*]] = call noundef half @_ZNK1ScvDF16_Ev(ptr noundef nonnull align 1 dereferenceable(1) [[USER_DEFINED_VAL]])
+// CHECK-NEXT:    store half [[CALL14]], ptr [[F16_VAL]], align 2
+// CHECK-NEXT:    [[CALL15:%.*]] = call noundef float @_ZNK1ScvfEv(ptr noundef nonnull align 1 dereferenceable(1) [[USER_DEFINED_VAL]])
+// CHECK-NEXT:    store float [[CALL15]], ptr [[F_VAL]], align 4
+// CHECK-NEXT:    [[CALL16:%.*]] = call noundef double @_ZNK1ScvdEv(ptr noundef nonnull align 1 dereferenceable(1) [[USER_DEFINED_VAL]])
+// CHECK-NEXT:    store double [[CALL16]], ptr [[D_VAL]], align 8
+// CHECK-NEXT:    [[CALL17:%.*]] = call noundef x86_fp80 @_ZNK1ScveEv(ptr noundef nonnull align 1 dereferenceable(1) [[USER_DEFINED_VAL]])
+// CHECK-NEXT:    store x86_fp80 [[CALL17]], ptr [[LD_VAL]], align 16
+// CHECK-NEXT:    [[CALL18:%.*]] = call noundef i32 @_ZNK1ScviEv(ptr noundef nonnull align 1 dereferenceable(1) [[USER_DEFINED_VAL]])
+// CHECK-NEXT:    store i32 [[CALL18]], ptr [[I_VAL]], align 4
+// CHECK-NEXT:    [[CALL19:%.*]] = call noundef i32 @_ZNK2S1cviEv(ptr noundef nonnull align 1 dereferenceable(1) [[USER_DEFINED_VAL_2]])
+// CHECK-NEXT:    [[CONV20:%.*]] = sitofp i32 [[CALL19]] to bfloat
+// CHECK-NEXT:    store bfloat [[CONV20]], ptr [[BFLOAT16_VAL_2]], align 2
+// CHECK-NEXT:    ret void
+//
+void test() {
+    _Float16 f16_val_6 = 1.0f16;
+    _Float16 f16_val_8 = static_cast<_Float16>(1.0f);
+    _Float16 f16_val_9 = static_cast<_Float16>(1.0);
+    _Float16 f16_val_10 = static_cast<_Float16>(1.0l);
+    _Float16 f16_val_11 = static_cast<_Float16>(1.0f16);
+
+    decltype(0.BF16) bf16_val_5 = 1.0bf16;
+    decltype(0.BF16) bf16_val_7 = static_cast<decltype(0.BF16)>(1.0f);
+    decltype(0.BF16) bf16_val_8 = static_cast<decltype(0.BF16)>(1.0);
+    decltype(0.BF16) bf16_val_9 = static_cast<decltype(0.BF16)>(1.0l);
+    decltype(0.BF16) bf16_val_10 = static_cast<decltype(0.BF16)>(1.0bf16);
+
+    float f_val_1 = 1.0f16;
+    float f_val_2 = 1.0bf16;
+    float f_val_3 = 1.0;
+    float f_val_4 = 1.0l;
+    float f_val_5 = 1.0f;
+
+    double d_val_1 = 1.0f16;
+    double d_val_2 = 1.0bf16;
+    double d_val_3 = 1.0f;
+    double d_val_4 = 1.0l;
+    double d_val_5 = 1.0;
+
+    long double ld_val_1 = 1.0f16;
+    long double ld_val_2 = 1.0bf16;
+    long double ld_val_3 = 1.0f;
+    long double ld_val_4 = 1.0;
+    long double ld_val_5 = 1.0l;
+
+    auto f16_float = 1.0f16 + 1.0f;
+    auto f16_double = 1.0f16 + 1.0;
+    auto f16_ldouble = 1.0f16 + 1.0l;
+    auto f16_int = 1.0f16 + 1;
+    auto f16_uint = 1.0f16 + 1u;
+    auto f16_long = 1.0f16 + 1l;
+    auto f16_ulong = 1.0f16 + 1ul;
+    auto f16_llong = 1.0f16 + 1ll;
+    auto f16_ullong = 1.0f16 + 1ull;
+    auto f16_bool = 1.0f16 + true;
+
+    auto bf16_float = 1.0bf16 + 1.0f;
+    auto bf16_double = 1.0bf16 + 1.0;
+    auto bf16_ldouble = 1.0bf16 + 1.0l;
+    auto bf16_int = 1.0bf16 + 1;
+    auto bf16_uint = 1.0bf16 + 1u;
+    auto bf16_long = 1.0bf16 + 1l;
+    auto bf16_ulong = 1.0bf16 + 1ul;
+    auto bf16_llong = 1.0bf16 + 1ll;
+    auto bf16_ullong = 1.0bf16 + 1ull;
+    auto bf16_bool = 1.0bf16 + true;
+
+    decltype(0.BF16) bf16_val = 1.0bf16;
+    _Float16 float16_val = 1.0f16;
+    float float_val = 1.0f;
+    double double_val = 1.0;
+    long double long_double_val = 1.0l;
+    int int_val = 1;
+
+    int test1 = f(bf16_val); // calls f(decltype(0.BF16))
+    int test2 = f(float16_val); // calls f(_Float16)
+    int test3 = f(float_val); // calls f(float)
+    int test4 = f(double_val); // calls f(double)
+    int test5 = f(long_double_val); // calls f(long double)
+    int test6 = f(int_val); // calls f(int)
+    int test_7 = f_2(float_val);
+    int test_8 = f_2(double_val);
+    int test_9 = f_2(bf16_val);
+    int test_10 = f_2(float16_val);
+
+
+    S user_defined_val;
+    // User-defined overload cases
+    decltype(0.BF16) bfloat16_val(user_defined_val); // calls operator decltype(0.BF16)()
+    _Float16 f16_val(user_defined_val); // calls operator _Float16()
+    float f_val(user_defined_val); // calls operator float()
+    double d_val(user_defined_val); // calls operator double()
+    long double ld_val(user_defined_val); // calls operator long double()
+    int i_val(user_defined_val); // calls operator int()
+
+    S1 user_defined_val_2;
+    // User-defined overload cases
+    decltype(0.BF16) bfloat16_val_2(user_defined_val_2); // calls operator int()
+}

clang/test/Sema/cxx2b-fp-ext-std-names-p1467r9.cpp

+// RUN: %clang_cc1 -fsyntax-only -std=c++2b -fnative-bfloat16-type -verify -ast-dump %s | FileCheck %s
+
+_Float16 f16_val_1 = 1.0bf16; // expected-error {{cannot initialize a variable of type '_Float16' with an rvalue of type 'BF16'}}
+_Float16 f16_val_2 = 1.0f; // expected-error {{cannot initialize a variable of type '_Float16' with an rvalue of type 'float'}}
+_Float16 f16_val_3 = 1.0; // expected-error {{cannot initialize a variable of type '_Float16' with an rvalue of type 'double'}}
+_Float16 f16_val_4 = 1.0l; // expected-error {{cannot initialize a variable of type '_Float16' with an rvalue of type 'long double'}}
+_Float16 f16_val_6 = 1.0f16;
+//CHECK:      |-VarDecl {{.*}} f16_val_6 '_Float16' cinit
+//CHECK-NEXT: | `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+_Float16 f16_val_7 = static_cast<_Float16>(1.0bf16); // expected-error {{static_cast from 'BF16' to '_Float16' is not allowed}}
+_Float16 f16_val_8 = static_cast<_Float16>(1.0f);
+//CHECK:      |-VarDecl {{.*}} f16_val_8 '_Float16' cinit
+//CHECK-NEXT: | `-CXXStaticCastExpr {{.*}} '_Float16' static_cast<_Float16> <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'float' 1.000000e+00
+_Float16 f16_val_9 = static_cast<_Float16>(1.0);
+//CHECK:      |-VarDecl {{.*}} f16_val_9 '_Float16' cinit
+//CHECK-NEXT: | `-CXXStaticCastExpr {{.*}} '_Float16' static_cast<_Float16> <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'double' 1.000000e+00
+_Float16 f16_val_10 = static_cast<_Float16>(1.0l);
+//CHECK:      |-VarDecl {{.*}} f16_val_10 '_Float16' cinit
+//CHECK-NEXT: | `-CXXStaticCastExpr {{.*}} '_Float16' static_cast<_Float16> <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'long double' 1.000000e+00
+_Float16 f16_val_11 = static_cast<_Float16>(1.0f16);
+//CHECK:      |-VarDecl {{.*}} f16_val_11 '_Float16' cinit
+//CHECK-NEXT: | `-CXXStaticCastExpr {{.*}} '_Float16' static_cast<_Float16> <NoOp>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+
+decltype(0.0BF16) bf16_val_1 = 1.0f16; // expected-error {{cannot initialize a variable of type 'decltype(0.BF16)' (aka 'BF16') with an rvalue of type '_Float16'}}
+decltype(0.0BF16) bf16_val_2 = 1.0f; // expected-error {{cannot initialize a variable of type 'decltype(0.BF16)' (aka 'BF16') with an rvalue of type 'float'}}
+decltype(0.0BF16) bf16_val_3 = 1.0; // expected-error {{cannot initialize a variable of type 'decltype(0.BF16)' (aka 'BF16') with an rvalue of type 'double'}}
+decltype(0.0BF16) bf16_val_4 = 1.0l; // expected-error {{cannot initialize a variable of type 'decltype(0.BF16)' (aka 'BF16') with an rvalue of type 'long double'}}
+decltype(0.0BF16) bf16_val_5 = 1.0bf16;
+//CHECK:      |-VarDecl {{.*}} bf16_val_5 'decltype(0.BF16)':'BF16' cinit
+//CHECK-NEXT: | `-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+
+decltype(0.0BF16) bf16_val_6 = static_cast<decltype(0.0BF16)>(1.0f16); // expected-error {{static_cast from '_Float16' to 'decltype(0.BF16)' (aka 'BF16') is not allowed}}
+decltype(0.0BF16) bf16_val_7 = static_cast<decltype(0.0BF16)>(1.0f);
+//CHECK:      |-VarDecl {{.*}} bf16_val_7 'decltype(0.BF16)':'BF16' cinit
+//CHECK-NEXT: | `-CXXStaticCastExpr {{.*}} 'decltype(0.BF16)':'BF16' static_cast<decltype(0.BF16)> <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'float' 1.000000e+00
+decltype(0.0BF16) bf16_val_8 = static_cast<decltype(0.0BF16)>(1.0);
+//CHECK:      |-VarDecl {{.*}} bf16_val_8 'decltype(0.BF16)':'BF16' cinit
+//CHECK-NEXT: | `-CXXStaticCastExpr {{.*}} 'decltype(0.BF16)':'BF16' static_cast<decltype(0.BF16)> <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'double' 1.000000e+00
+decltype(0.0BF16) bf16_val_9 = static_cast<decltype(0.0BF16)>(1.0l);
+//CHECK:      |-VarDecl {{.*}} bf16_val_9 'decltype(0.BF16)':'BF16' cinit
+//CHECK-NEXT: | `-CXXStaticCastExpr {{.*}} 'decltype(0.BF16)':'BF16' static_cast<decltype(0.BF16)> <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'long double' 1.000000e+00
+decltype(0.0BF16) bf16_val_10 = static_cast<decltype(0.0BF16)>(1.0bf16);
+//CHECK:      |-VarDecl {{.*}} bf16_val_10 'decltype(0.BF16)':'BF16' cinit
+//CHECK-NEXT: | `-CXXStaticCastExpr {{.*}} 'decltype(0.BF16)':'BF16' static_cast<decltype(0.BF16)> <NoOp>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+
+float f_val_1 = 1.0f16;
+//CHECK:      |-VarDecl {{.*}} f_val_1 'float' cinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'float' <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+float f_val_2 = 1.0bf16;
+//CHECK:      |-VarDecl {{.*}} f_val_2 'float' cinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'float' <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+float f_val_3 = 1.0;
+//CHECK:      |-VarDecl {{.*}} f_val_3 'float' cinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'float' <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'double' 1.000000e+00
+float f_val_4 = 1.0l;
+//CHECK:      |-VarDecl {{.*}} f_val_4 'float' cinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'float' <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'long double' 1.000000e+00
+float f_val_5 = 1.0f;
+//CHECK:      |-VarDecl {{.*}} f_val_5 'float' cinit
+//CHECK-NEXT: | `-FloatingLiteral {{.*}} 'float' 1.000000e+00
+
+double d_val_1 = 1.0f16;
+//CHECK:      |-VarDecl {{.*}} d_val_1 'double' cinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'double' <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+double d_val_2 = 1.0bf16;
+//CHECK:      |-VarDecl {{.*}} d_val_2 'double' cinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'double' <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+double d_val_3 = 1.0f;
+//CHECK:      |-VarDecl {{.*}} d_val_3 'double' cinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'double' <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'float' 1.000000e+00
+double d_val_4 = 1.0l;
+//CHECK:      |-VarDecl {{.*}} d_val_4 'double' cinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'double' <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'long double' 1.000000e+00
+double d_val_5 = 1.0;
+//CHECK:      |-VarDecl {{.*}} d_val_5 'double' cinit
+//CHECK-NEXT: | `-FloatingLiteral {{.*}} 'double' 1.000000e+00
+
+long double ld_val_1 = 1.0f16;
+//CHECK:      |-VarDecl {{.*}} ld_val_1 'long double' cinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'long double' <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+long double ld_val_2 = 1.0bf16;
+//CHECK:      |-VarDecl {{.*}} ld_val_2 'long double' cinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'long double' <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+long double ld_val_3 = 1.0f;
+//CHECK:      |-VarDecl {{.*}} ld_val_3 'long double' cinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'long double' <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'float' 1.000000e+00
+long double ld_val_4 = 1.0;
+//CHECK:      |-VarDecl {{.*}} ld_val_4 'long double' cinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'long double' <FloatingCast>
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'double' 1.000000e+00
+long double ld_val_5 = 1.0l;
+//CHECK:      |-VarDecl {{.*}} ld_val_5 'long double' cinit
+//CHECK-NEXT: | `-FloatingLiteral {{.*}} 'long double' 1.000000e+00
+
+auto f16_bf16 = 1.0f16 + 1.0bf16; // expected-error {{invalid operands to binary expression ('_Float16' and 'BF16')}}
+auto f16_bf16_cast = 1.0f16 + static_cast<_Float16>(1.0bf16); // expected-error {{static_cast from 'BF16' to '_Float16' is not allowed}}
+auto f16_float = 1.0f16 + 1.0f;
+//CHECK:      |-VarDecl {{.*}} f16_float 'float':'float' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} 'float' '+'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'float' <FloatingCast>
+//CHECK-NEXT: |   | `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'float' 1.000000e+00
+auto f16_double = 1.0f16 + 1.0;
+//CHECK:      |-VarDecl {{.*}} f16_double 'double':'double' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} 'double' '+'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'double' <FloatingCast>
+//CHECK-NEXT: |   | `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'double' 1.000000e+00
+auto f16_ldouble = 1.0f16 + 1.0l;
+//CHECK:      |-VarDecl {{.*}} f16_ldouble 'long double':'long double' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} 'long double' '+'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'long double' <FloatingCast>
+//CHECK-NEXT: |   | `-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'long double' 1.000000e+00
+auto f16_int = 1.0f16 + 1;
+//CHECK:      |-VarDecl {{.*}} f16_int '_Float16':'_Float16' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} '_Float16' '+'
+//CHECK-NEXT: |   |-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} '_Float16' <IntegralToFloating>
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'int' 1
+auto f16_uint = 1.0f16 + 1u;
+//CHECK:      |-VarDecl {{.*}} f16_uint '_Float16':'_Float16' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} '_Float16' '+'
+//CHECK-NEXT: |   |-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} '_Float16' <IntegralToFloating>
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'unsigned int' 1
+auto f16_long = 1.0f16 + 1l;
+//CHECK:      |-VarDecl {{.*}} f16_long '_Float16':'_Float16' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} '_Float16' '+'
+//CHECK-NEXT: |   |-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} '_Float16' <IntegralToFloating>
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'long' 1
+auto f16_ulong = 1.0f16 + 1ul;
+//CHECK:      |-VarDecl {{.*}} f16_ulong '_Float16':'_Float16' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} '_Float16' '+'
+//CHECK-NEXT: |   |-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} '_Float16' <IntegralToFloating>
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'unsigned long' 1
+auto f16_llong = 1.0f16 + 1ll;
+//CHECK:      |-VarDecl {{.*}} f16_llong '_Float16':'_Float16' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} '_Float16' '+'
+//CHECK-NEXT: |   |-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} '_Float16' <IntegralToFloating>
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'long long' 1
+auto f16_ullong = 1.0f16 + 1ull;
+//CHECK:      |-VarDecl {{.*}} f16_ullong '_Float16':'_Float16' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} '_Float16' '+'
+//CHECK-NEXT: |   |-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} '_Float16' <IntegralToFloating>
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'unsigned long long' 1
+auto f16_bool = 1.0f16 + true;
+//CHECK:      |-VarDecl {{.*}} f16_bool '_Float16':'_Float16' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} '_Float16' '+'
+//CHECK-NEXT: |   |-FloatingLiteral {{.*}} '_Float16' 1.000000e+00
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} '_Float16' <IntegralToFloating>
+//CHECK-NEXT: |     `-ImplicitCastExpr {{.*}} 'int' <IntegralCast>
+//CHECK-NEXT: |       `-CXXBoolLiteralExpr {{.*}} 'bool' true
+
+auto bf16_fp16 = 1.0bf16 + 1.0f16; // expected-error {{invalid operands to binary expression ('BF16' and '_Float16')}}
+auto bf16_fp16_cast = 1.0bf16 + static_cast<decltype(0.0BF16)>(1.0f16); // expected-error {{static_cast from '_Float16' to 'decltype(0.BF16)' (aka 'BF16') is not allowed}}
+auto bf16_float = 1.0bf16 + 1.0f;
+//CHECK:      |-VarDecl {{.*}} bf16_float 'float':'float' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} 'float' '+'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'float' <FloatingCast>
+//CHECK-NEXT: |   | `-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'float' 1.000000e+00
+auto bf16_double = 1.0bf16 + 1.0;
+//CHECK:      |-VarDecl {{.*}} bf16_double 'double':'double' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} 'double' '+'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'double' <FloatingCast>
+//CHECK-NEXT: |   | `-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'double' 1.000000e+00
+auto bf16_ldouble = 1.0bf16 + 1.0l;
+//CHECK:      |-VarDecl {{.*}} bf16_ldouble 'long double':'long double' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} 'long double' '+'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'long double' <FloatingCast>
+//CHECK-NEXT: |   | `-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+//CHECK-NEXT: |   `-FloatingLiteral {{.*}} 'long double' 1.000000e+00
+auto bf16_int = 1.0bf16 + 1;
+//CHECK:      |-VarDecl {{.*}} bf16_int 'BF16':'BF16' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} 'BF16' '+'
+//CHECK-NEXT: |   |-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'BF16' <IntegralToFloating>
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'int' 1
+auto bf16_uint = 1.0bf16 + 1u;
+//CHECK:      |-VarDecl {{.*}} bf16_uint 'BF16':'BF16' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} 'BF16' '+'
+//CHECK-NEXT: |   |-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'BF16' <IntegralToFloating>
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'unsigned int' 1
+auto bf16_long = 1.0bf16 + 1l;
+//CHECK:      |-VarDecl {{.*}} bf16_long 'BF16':'BF16' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} 'BF16' '+'
+//CHECK-NEXT: |   |-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'BF16' <IntegralToFloating>
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'long' 1
+auto bf16_ulong = 1.0bf16 + 1ul;
+//CHECK:      |-VarDecl {{.*}} bf16_ulong 'BF16':'BF16' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} 'BF16' '+'
+//CHECK-NEXT: |   |-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'BF16' <IntegralToFloating>
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'unsigned long' 1
+auto bf16_llong = 1.0bf16 + 1ll;
+//CHECK:      |-VarDecl {{.*}} bf16_llong 'BF16':'BF16' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} 'BF16' '+'
+//CHECK-NEXT: |   |-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'BF16' <IntegralToFloating>
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'long long' 1
+auto bf16_ullong = 1.0bf16 + 1ull;
+//CHECK:      |-VarDecl {{.*}} bf16_ullong 'BF16':'BF16' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} 'BF16' '+'
+//CHECK-NEXT: |   |-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'BF16' <IntegralToFloating>
+//CHECK-NEXT: |     `-IntegerLiteral {{.*}} 'unsigned long long' 1
+auto bf16_bool = 1.0bf16 + true;
+//CHECK:      |-VarDecl {{.*}} bf16_bool 'BF16':'BF16' cinit
+//CHECK-NEXT: | `-BinaryOperator {{.*}} 'BF16' '+'
+//CHECK-NEXT: |   |-FloatingLiteral {{.*}} 'BF16' 1.000000e+00
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'BF16' <IntegralToFloating>
+//CHECK-NEXT: |     `-ImplicitCastExpr {{.*}} 'int' <IntegralCast>
+//CHECK-NEXT: |       `-CXXBoolLiteralExpr {{.*}} 'bool' true
+
+int f(decltype(0.0BF16)) {}
+int f(_Float16) {}
+int f(float) {}
+int f(double) {}
+int f(long double) {}
+int f(int) {}
+
+decltype(0.0BF16) bf16_val = 1.0bf16;
+_Float16 float16_val = 1.0f16;
+float float_val = 1.0f;
+double double_val = 1.0;
+long double long_double_val = 1.0l;
+int int_val = 1;
+
+int test1 = f(bf16_val); // calls f(decltype(0.BF16))
+//CHECK:      |-VarDecl {{.*}} test1 'int' cinit
+//CHECK-NEXT: | `-CallExpr {{.*}} 'int'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'int (*)(decltype(0.BF16))' <FunctionToPointerDecay>
+//CHECK-NEXT: |   | `-DeclRefExpr {{.*}} 'int (decltype(0.BF16))' lvalue Function {{.*}} 'f' 'int (decltype(0.BF16))'
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'decltype(0.BF16)':'BF16' <LValueToRValue>
+//CHECK-NEXT: |     `-DeclRefExpr {{.*}} 'decltype(0.BF16)':'BF16' lvalue Var {{.*}} 'bf16_val' 'decltype(0.BF16)':'BF16'
+int test2 = f(float16_val); // calls f(_Float16)
+//CHECK:      |-VarDecl {{.*}} test2 'int' cinit
+//CHECK-NEXT: | `-CallExpr {{.*}} 'int'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'int (*)(_Float16)' <FunctionToPointerDecay>
+//CHECK-NEXT: |   | `-DeclRefExpr {{.*}} 'int (_Float16)' lvalue Function {{.*}} 'f' 'int (_Float16)'
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK-NEXT: |     `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'float16_val' '_Float16'
+int test3 = f(float_val); // calls f(float)
+//CHECK:      |-VarDecl {{.*}} test3 'int' cinit
+//CHECK-NEXT: | `-CallExpr {{.*}} 'int'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'int (*)(float)' <FunctionToPointerDecay>
+//CHECK-NEXT: |   | `-DeclRefExpr {{.*}} 'int (float)' lvalue Function {{.*}} 'f' 'int (float)'
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'float' <LValueToRValue>
+//CHECK-NEXT: |     `-DeclRefExpr {{.*}} 'float' lvalue Var {{.*}} 'float_val' 'float'
+int test4 = f(double_val); // calls f(double)
+//CHECK:      |-VarDecl {{.*}} test4 'int' cinit
+//CHECK-NEXT: | `-CallExpr {{.*}} 'int'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'int (*)(double)' <FunctionToPointerDecay>
+//CHECK-NEXT: |   | `-DeclRefExpr {{.*}} 'int (double)' lvalue Function {{.*}} 'f' 'int (double)'
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'double' <LValueToRValue>
+//CHECK-NEXT: |     `-DeclRefExpr {{.*}} 'double' lvalue Var {{.*}} 'double_val' 'double'
+int test5 = f(long_double_val); // calls f(long double)
+//CHECK:      |-VarDecl {{.*}} test5 'int' cinit
+//CHECK-NEXT: | `-CallExpr {{.*}} 'int'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'int (*)(long double)' <FunctionToPointerDecay>
+//CHECK-NEXT: |   | `-DeclRefExpr {{.*}} 'int (long double)' lvalue Function {{.*}} 'f' 'int (long double)'
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'long double' <LValueToRValue>
+//CHECK-NEXT: |     `-DeclRefExpr {{.*}} 'long double' lvalue Var {{.*}} 'long_double_val' 'long double'
+int test6 = f(int_val); // calls f(int)
+//CHECK:      |-VarDecl {{.*}} test6 'int' cinit
+//CHECK-NEXT: | `-CallExpr {{.*}} 'int'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'int (*)(int)' <FunctionToPointerDecay>
+//CHECK-NEXT: |   | `-DeclRefExpr {{.*}} 'int (int)' lvalue Function {{.*}} 'f' 'int (int)'
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'int' <LValueToRValue>
+//CHECK-NEXT: |     `-DeclRefExpr {{.*}} 'int' lvalue Var {{.*}} 'int_val' 'int'
+
+int f_1(float) {} // expected-note {{candidate function}} expected-note {{candidate function}}
+int f_1(double) {} // expected-note {{candidate function}} expected-note {{candidate function}}
+
+// Ambiguous cases
+int test_7 = f_1(bf16_val); // expected-error {{call to 'f_1' is ambiguous}}
+int test_8 = f_1(float16_val); // expected-error {{call to 'f_1' is ambiguous}}
+
+int f_2(long double) {}
+int test_9 = f_2(float_val);
+//CHECK:      |-VarDecl {{.*}} test_9 'int' cinit
+//CHECK-NEXT: | `-CallExpr {{.*}} 'int'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'int (*)(long double)' <FunctionToPointerDecay>
+//CHECK-NEXT: |   | `-DeclRefExpr {{.*}} 'int (long double)' lvalue Function {{.*}} 'f_2' 'int (long double)'
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'long double' <FloatingCast>
+//CHECK-NEXT: |     `-ImplicitCastExpr {{.*}} 'float' <LValueToRValue>
+//CHECK-NEXT: |       `-DeclRefExpr {{.*}} 'float' lvalue Var {{.*}} 'float_val' 'float'
+int test_10 = f_2(double_val);
+//CHECK:      |-VarDecl {{.*}} test_10 'int' cinit
+//CHECK-NEXT: | `-CallExpr {{.*}} 'int'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'int (*)(long double)' <FunctionToPointerDecay>
+//CHECK-NEXT: |   | `-DeclRefExpr {{.*}} 'int (long double)' lvalue Function {{.*}} 'f_2' 'int (long double)'
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'long double' <FloatingCast>
+//CHECK-NEXT: |     `-ImplicitCastExpr {{.*}} 'double' <LValueToRValue>
+//CHECK-NEXT: |       `-DeclRefExpr {{.*}} 'double' lvalue Var {{.*}} 'double_val' 'double'
+int test_11 = f_2(bf16_val);
+//CHECK:      |-VarDecl {{.*}} test_11 'int' cinit
+//CHECK-NEXT: | `-CallExpr {{.*}} 'int'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'int (*)(long double)' <FunctionToPointerDecay>
+//CHECK-NEXT: |   | `-DeclRefExpr {{.*}} 'int (long double)' lvalue Function {{.*}} 'f_2' 'int (long double)'
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'long double' <FloatingCast>
+//CHECK-NEXT: |     `-ImplicitCastExpr {{.*}} 'decltype(0.BF16)':'BF16' <LValueToRValue>
+//CHECK-NEXT: |       `-DeclRefExpr {{.*}} 'decltype(0.BF16)':'BF16' lvalue Var {{.*}} 'bf16_val' 'decltype(0.BF16)':'BF16'
+int test_12 = f_2(float16_val);
+//CHECK:      |-VarDecl {{.*}} test_12 'int' cinit
+//CHECK-NEXT: | `-CallExpr {{.*}} 'int'
+//CHECK-NEXT: |   |-ImplicitCastExpr {{.*}} 'int (*)(long double)' <FunctionToPointerDecay>
+//CHECK-NEXT: |   | `-DeclRefExpr {{.*}} 'int (long double)' lvalue Function {{.*}} 'f_2' 'int (long double)'
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'long double' <FloatingCast>
+//CHECK-NEXT: |     `-ImplicitCastExpr {{.*}} '_Float16' <LValueToRValue>
+//CHECK-NEXT: |       `-DeclRefExpr {{.*}} '_Float16' lvalue Var {{.*}} 'float16_val' '_Float16'
+
+int f_3(_Float16) {} // expected-note {{candidate function not viable: no known conversion from 'float' to '_Float16' for 1st argument}} expected-note {{no known conversion from 'decltype(0.BF16)' (aka 'BF16') to '_Float16' for 1st argument}}
+int test_13 = f_3(float_val); // expected-error {{no matching function for call to 'f_3'}}
+int test_14 = f_3(bf16_val); // expected-error {{no matching function for call to 'f_3'}}
+int test_15 = f_3(static_cast<_Float16>(bf16_val)); // expected-error {{static_cast from 'decltype(0.BF16)' (aka 'BF16') to '_Float16' is not allowed}}
+
+int f_4(decltype(0.0BF16)) {} // expected-note {{candidate function not viable: no known conversion from 'float' to 'decltype(0.BF16)' (aka 'BF16') for 1st argument}} expected-note {{candidate function not viable: no known conversion from '_Float16' to 'decltype(0.BF16)' (aka 'BF16') for 1st argument}}
+int test_16 = f_4(float_val); // expected-error {{no matching function for call to 'f_4'}}
+int test_17 = f_4(float16_val); // expected-error {{no matching function for call to 'f_4'}}
+int test_18 = f_4(static_cast<decltype(0.0BF16)>(float16_val)); // expected-error {{static_cast from '_Float16' to 'decltype(0.BF16)' (aka 'BF16') is not allowed}}
+
+struct S {
+  operator decltype(0.0BF16)() const {
+      return 0.0bf16;
+  }
+  operator _Float16() const {
+      return 0.0f16;
+  }
+  operator float() const {
+      return 0.0f;
+  }
+  operator double() const {
+      return 0.0;
+  }
+  operator long double() const {
+      return 0.0L;
+  }
+  operator int() const {
+      return 0;
+  }
+};
+
+
+S user_defined_val;
+// User-defined overload cases
+decltype(0.0BF16) bfloat16_val(user_defined_val); // calls operator decltype(0.BF16)()
+//CHECK:      |-VarDecl {{.*}} bfloat16_val 'decltype(0.BF16)':'BF16' callinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'decltype(0.BF16)':'BF16' <UserDefinedConversion>
+//CHECK-NEXT: |   `-CXXMemberCallExpr {{.*}} 'decltype(0.BF16)':'BF16'
+//CHECK-NEXT: |     `-MemberExpr {{.*}} '<bound member function type>' .operator BF16 {{.*}}
+//CHECK-NEXT: |       `-ImplicitCastExpr {{.*}} 'const S' lvalue <NoOp>
+//CHECK-NEXT: |         `-DeclRefExpr {{.*}} 'S':'S' lvalue Var {{.*}} 'user_defined_val' 'S':'S'
+_Float16 f16_val(user_defined_val); // calls operator _Float16()
+//CHECK:      |-VarDecl {{.*}} f16_val '_Float16' callinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} '_Float16' <UserDefinedConversion>
+//CHECK-NEXT: |   `-CXXMemberCallExpr {{.*}} '_Float16
+//CHECK-NEXT: |     `-MemberExpr {{.*}} '<bound member function type>' .operator _Float16 {{.*}}
+//CHECK-NEXT: |       `-ImplicitCastExpr {{.*}} 'const S' lvalue <NoOp>
+//CHECK-NEXT: |         `-DeclRefExpr {{.*}} 'S':'S' lvalue Var {{.*}} 'user_defined_val' 'S':'S'
+float f_val(user_defined_val); // calls operator float()
+//CHECK:      |-VarDecl {{.*}} f_val 'float' callinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'float' <UserDefinedConversion>
+//CHECK-NEXT: |   `-CXXMemberCallExpr {{.*}} 'float'
+//CHECK-NEXT: |     `-MemberExpr {{.*}} '<bound member function type>' .operator float {{.*}}
+//CHECK-NEXT: |       `-ImplicitCastExpr {{.*}} 'const S' lvalue <NoOp>
+//CHECK-NEXT: |         `-DeclRefExpr {{.*}} 'S':'S' lvalue Var {{.*}} 'user_defined_val' 'S':'S'
+double d_val(user_defined_val); // calls operator double()
+//CHECK:      |-VarDecl {{.*}} d_val 'double' callinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'double' <UserDefinedConversion>
+//CHECK-NEXT: |   `-CXXMemberCallExpr {{.*}} 'double'
+//CHECK-NEXT: |     `-MemberExpr {{.*}} '<bound member function type>' .operator double {{.*}}
+//CHECK-NEXT: |       `-ImplicitCastExpr {{.*}} 'const S' lvalue <NoOp>
+//CHECK-NEXT: |         `-DeclRefExpr {{.*}} 'S':'S' lvalue Var {{.*}} 'user_defined_val' 'S':'S'
+long double ld_val(user_defined_val); // calls operator long double()
+//CHECK:      |-VarDecl {{.*}} ld_val 'long double' callinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'long double' <UserDefinedConversion>
+//CHECK-NEXT: |   `-CXXMemberCallExpr {{.*}} 'long double'
+//CHECK-NEXT: |     `-MemberExpr {{.*}} '<bound member function type>' .operator long double {{.*}}
+//CHECK-NEXT: |       `-ImplicitCastExpr {{.*}} 'const S' lvalue <NoOp>
+//CHECK-NEXT: |         `-DeclRefExpr {{.*}} 'S':'S' lvalue Var {{.*}} 'user_defined_val' 'S':'S'
+int i_val(user_defined_val); // calls operator int()
+//CHECK:      |-VarDecl {{.*}} i_val 'int' callinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'int' <UserDefinedConversion>
+//CHECK-NEXT: |   `-CXXMemberCallExpr {{.*}} 'int'
+//CHECK-NEXT: |     `-MemberExpr {{.*}} '<bound member function type>' .operator int {{.*}}
+//CHECK-NEXT: |       `-ImplicitCastExpr {{.*}} 'const S' lvalue <NoOp>
+//CHECK-NEXT: |         `-DeclRefExpr {{.*}} 'S':'S' lvalue Var {{.*}} 'user_defined_val' 'S':'S'
+struct S1 {
+  operator _Float16() const {
+      return 0.0f16;
+  }
+  operator float() const {
+      return 0.0f;
+  }
+  operator double() const {
+      return 0.0;
+  }
+  operator long double() const {
+      return 0.0L;
+  }
+  operator int() const {
+      return 0;
+  }
+};
+
+S1 user_defined_val_2;
+// User-defined overload cases
+decltype(0.0BF16) bfloat16_val_2(user_defined_val_2); // calls operator int()
+//CHECK:      |-VarDecl {{.*}} bfloat16_val_2 'decltype(0.BF16)':'BF16' callinit
+//CHECK-NEXT: | `-ImplicitCastExpr {{.*}} 'decltype(0.BF16)':'BF16' <IntegralToFloating>
+//CHECK-NEXT: |   `-ImplicitCastExpr {{.*}} 'int' <UserDefinedConversion>
+//CHECK-NEXT: |     `-CXXMemberCallExpr {{.*}} 'int'
+//CHECK-NEXT: |       `-MemberExpr {{.*}} '<bound member function type>' .operator int {{.*}}
+//CHECK-NEXT: |         `-ImplicitCastExpr {{.*}} 'const S1' lvalue <NoOp>
+//CHECK-NEXT: |           `-DeclRefExpr {{.*}} 'S1':'S1' lvalue Var {{.*}} 'user_defined_val_2' 'S1':'S1'
+struct S2 {
+  operator decltype(0.0BF16)() const { // expected-note {{candidate function}}
+      return 0.0bf16;
+  }
+
+  operator _Float16() const { // expected-note {{candidate function}}
+      return 0.0f16;
+  }
+  operator double() const { // expected-note {{candidate function}}
+      return 0.0;
+  }
+  operator long double() const { // expected-note {{candidate function}}
+      return 0.0L;
+  }
+  operator int() const { // expected-note {{candidate function}}
+      return 0;
+  }
+};
+
+S2 user_defined_val_3;
+// User-defined overload cases
+float float_val_2(user_defined_val_3); // expected-error {{conversion from 'S2' to 'float' is ambiguous}}
 No newline at end of file

libcxxabi/test/test_demangle.pass.cpp

     {"_ZNK5clang4Type18isAnyCharacterTypeEv", "clang::Type::isAnyCharacterType() const"},
     {"_ZNK5clang4Type19isSignedIntegerTypeEv", "clang::Type::isSignedIntegerType() const"},
     {"_ZNK5clang4Type30hasSignedIntegerRepresentationEv", "clang::Type::hasSignedIntegerRepresentation() const"},
     {"_ZNK5clang4Type21isUnsignedIntegerTypeEv", "clang::Type::isUnsignedIntegerType() const"},
     {"_ZNK5clang4Type32hasUnsignedIntegerRepresentationEv", "clang::Type::hasUnsignedIntegerRepresentation() const"},
     {"_ZNK5clang4Type25hasFloatingRepresentationEv", "clang::Type::hasFloatingRepresentation() const"},
     {"_ZNK5clang4Type18isRealFloatingTypeEv", "clang::Type::isRealFloatingType() const"},
     {"_ZNK5clang4Type10isRealTypeEv", "clang::Type::isRealType() const"},
-    {"_ZNK5clang4Type16isArithmeticTypeEv", "clang::Type::isArithmeticType() const"},
+    {"_ZNK5clang4Type16isArithmeticTypeEv", "clang::Type::isArithmeticType(clang::ASTContext&) const"},
     {"_ZNK5clang4Type12isScalarTypeEv", "clang::Type::isScalarType() const"},
     {"_ZNK5clang4Type17getScalarTypeKindEv", "clang::Type::getScalarTypeKind() const"},
     {"_ZNK5clang4Type15isAggregateTypeEv", "clang::Type::isAggregateType() const"},
     {"_ZNK5clang4Type18isConstantSizeTypeEv", "clang::Type::isConstantSizeType() const"},
     {"_ZNK5clang4Type16isIncompleteTypeEv", "clang::Type::isIncompleteType() const"},
     {"_ZNK5clang7TagType7getDeclEv", "clang::TagType::getDecl() const"},
     {"_ZNK5clang4Type9isPODTypeEv", "clang::Type::isPODType() const"},
     {"_ZNK5clang4Type13isLiteralTypeEv", "clang::Type::isLiteralType() const"},