[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 ↗

(On Diff #518405)

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

27

What is this needed for?

2819

2820

2822

clang/include/clang/Basic/DiagnosticSemaKinds.td

8931

clang/include/clang/Basic/LangOptions.def

468 ↗

(On Diff #518589)

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).

7110

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

5 ↗

(On Diff #518589)

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

101 ↗

(On Diff #518589)

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

9 ↗

(On Diff #518589)

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 ↗

(On Diff #518589)

Definitely need the newline here.

[codemzs]

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

clang/include/clang/Basic/LangOptions.def

468 ↗

(On Diff #518589)

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

7110

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

5 ↗

(On Diff #518589)

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?

101 ↗

(On Diff #518589)

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

9 ↗

(On Diff #518589)

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 ↗

(On Diff #518589)

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

5 ↗

(On Diff #518589)

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

9 ↗

(On Diff #518589)

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 ↗

(On Diff #518589)

@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

1117–1119

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 ↗

(On Diff #520010)

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

2241–2251

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

7372–7376

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

6418–6420 ↗

(On Diff #520010)

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

84

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

84

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

2250

Remove

clang/lib/Basic/Targets/AMDGPU.h

122 ↗

(On Diff #522071)

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

84

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

711

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

1394

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

clang/lib/Sema/SemaExpr.cpp

1247–1249

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

4329

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

1394

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

1247–1249

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

4329

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.

7091–7095

clang/lib/Frontend/InitPreprocessor.cpp

460

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

clang/lib/Sema/SemaCast.cpp

1394

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

11749

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.

15488–15515

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

1247–1249

Ah, thank you. This looks good then.

1256–1259

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

4329

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

4–7

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

460

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

11749

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

4–7

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

56

Naming suggestion: FloatConvRankCompareResult.

1119

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

8931

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

11749

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/include/clang/AST/ASTContext.h

 #include "clang/AST/CommentCommandTraits.h"
 #include "clang/AST/ComparisonCategories.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclarationName.h"
 #include "clang/AST/ExternalASTSource.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/RawCommentList.h"
 #include "clang/AST/TemplateName.h"
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/PartialDiagnostic.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/MapVector.h"
 #include "llvm/ADT/PointerIntPair.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;
 struct BlockVarCopyInit;
 class BuiltinTemplateDecl;
 class CharUnits;
public:
   CanQualType ShortFractTy, FractTy, LongFractTy;
   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 Float16Ty; // C11 extension ISO/IEC TS 18661-3
+  CanQualType BFloat16Ty; // [C++23 6.8.3p5][basic.extended.fp]
+  CanQualType Float16Ty; // C11 extension ISO/IEC TS 18661-3 and [C++23 6.8.3p5][basic.extended.fp]
   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;
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
+  /// the subrank of \p LHS is greater than \p RHS, return
+  /// FRCR_Equal_Greater_Subrank. If \p LHS and \p RHS are equal but the subrank
+  /// of \p LHS is less than \p RHS, return FRCR_Equal_Lesser_Subrank. Subrank
+  /// and Unordered comparison were 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;
+
+  /// C++23 6.8.2p12 [basic.fundamental]
+  /// Checks if extended floating point rules apply to a pair of types.
+  /// It returns true if both the types are C++23 floating point types and
+  /// at least one of them is a C++23 extended floating point type. It returns
+  /// false for pairs of standard C++23 floating point types.
+  bool doCXX23ExtendedFpTypesRulesApply(QualType T1, QualType T2) const;
+
+  /// C++23 6.8.2p12 [basic.fundamental]
+  /// Returns true if \p Result is FRCR_Lesser or FRCR_Unordered rank.
+  bool
+  isCXX23SmallerOrUnorderedFloatingPointRank(FloatingRankCompareResult Result) const;
+
+  /// C++23 6.8.2p12 [basic.fundamental]
+  /// Returns true if \p Result is FRCR_Equal, FRCR_Equal_Lesser_Subrank or
+  /// FRCR_Equal_Greater_Subrank.
+  bool isCXX23EqualFloatingPointRank(FloatingRankCompareResult Result) 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/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)
+  /// C++23 6.8.2p12 [basic.fundamental] (standard floating point + extended
+  /// floating point)
+  bool isCXX23FloatingPointType(const ASTContext &Ctx) const;
+  /// C++23 6.8.2p12 [basic.fundamental] (standard floating point)
+  bool isCXX23StandardFloatingPointType(const ASTContext &Ctx) const;
+  /// C++23 6.8.2p12 [basic.fundamental] (extended floating point)
+  bool isCXX23ExtendedFloatingPointType(const ASTContext &Ctx) const;
   bool isHalfType() const;         // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
   bool isFloat16Type() const;      // C11 extension ISO/IEC TS 18661
   bool isBFloat16Type() const;
   bool isFloat128Type() const;
   bool isIbm128Type() const;
   bool isRealType() const;         // C99 6.2.5p17 (real floating + integer)
   bool isArithmeticType() const;   // C99 6.2.5p18 (integer + floating)
   bool isVoidType() const;         // C99 6.2.5p19
   bool isScalarType() const;       // C99 6.2.5p21 (arithmetic + pointers)
   bool isAggregateType() const;
   bool isFundamentalType() const;
   bool isCompoundType() const;
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::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_cxx23_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/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 (C23)
+  bool isBFloat16 : 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/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 {
 
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
 };
 
+constexpr unsigned CXX23FloatRankToIndex(clang::BuiltinType::Kind Kind) {
+  switch (Kind) {
+  case clang::BuiltinType::Float16:
+    return 0;
+  case clang::BuiltinType::BFloat16:
+    return 1;
+  case clang::BuiltinType::Float:
+    return 2;
+  case clang::BuiltinType::Double:
+    return 3;
+  case clang::BuiltinType::LongDouble:
+    return 4;
+  default:
+    // Both __float128 and __ibm128 are compiler extensions, not extended floating points.
+    // __float128 also predates the invention of floating-point types.
+    llvm_unreachable("Not a CXX23+ floating point builtin type");
+  }
+}
+
+// C++23 6.8.6p2 [conv.rank]
+// Grid to determine the rank of a floating point type when compared with
+// another floating point type.
+constexpr std::array<std::array<FloatingRankCompareResult, 5>, 5>
+    CXX23FloatingPointConversionRankMap = {
+        {// Float16 x Float16
+         // Float16 x BFloat16
+         // Float16 x Float
+         // Float16 x Double
+         // Float16 x LongDouble
+         {{FloatingRankCompareResult::FRCR_Equal,
+           FloatingRankCompareResult::FRCR_Unordered,
+           FloatingRankCompareResult::FRCR_Lesser,
+           FloatingRankCompareResult::FRCR_Lesser,
+           FloatingRankCompareResult::FRCR_Lesser}},
+
+         // BFloat16 x Float16
+         // BFloat16 x BFloat16
+         // BFloat16 x Float
+         // BFloat16 x Double
+         // BFloat16 x LongDouble
+         {{FloatingRankCompareResult::FRCR_Unordered,
+           FloatingRankCompareResult::FRCR_Equal,
+           FloatingRankCompareResult::FRCR_Lesser,
+           FloatingRankCompareResult::FRCR_Lesser,
+           FloatingRankCompareResult::FRCR_Lesser}},
+
+         // Float x Float16
+         // Float x BFloat16
+         // Float x Float
+         // Float x Double
+         // Float x LongDouble
+         {{FloatingRankCompareResult::FRCR_Greater,
+           FloatingRankCompareResult::FRCR_Greater,
+           FloatingRankCompareResult::FRCR_Equal,
+           FloatingRankCompareResult::FRCR_Lesser,
+           FloatingRankCompareResult::FRCR_Lesser}},
+
+         // Double x Float16
+         // Double x BFloat16
+         // Double x Float
+         // Double x Double
+         // Double x LongDouble
+         {{FloatingRankCompareResult::FRCR_Greater,
+           FloatingRankCompareResult::FRCR_Greater,
+           FloatingRankCompareResult::FRCR_Greater,
+           FloatingRankCompareResult::FRCR_Equal,
+           FloatingRankCompareResult::FRCR_Lesser}},
+
+         // LongDouble x Float16
+         // LongDouble x BFloat16
+         // LongDouble x Float
+         // LongDouble x Double
+         // LongDouble x LongDouble
+         {{FloatingRankCompareResult::FRCR_Greater,
+           FloatingRankCompareResult::FRCR_Greater,
+           FloatingRankCompareResult::FRCR_Greater,
+           FloatingRankCompareResult::FRCR_Greater,
+           FloatingRankCompareResult::FRCR_Equal}}}};
+
 /// \returns The locations that are relevant when searching for Doc comments
 /// related to \p D.
 static SmallVector<SourceLocation, 2>
 getDeclLocsForCommentSearch(const Decl *D, SourceManager &SourceMgr) {
   assert(D);
 
   // User can not attach documentation to implicit declarations.
   if (D->isImplicit())
static FloatingRank getFloatingRank(QualType T) {
   case BuiltinType::Double:     return DoubleRank;
   case BuiltinType::LongDouble: return LongDoubleRank;
   case BuiltinType::Float128:   return Float128Rank;
   case BuiltinType::BFloat16:   return BFloat16Rank;
   case BuiltinType::Ibm128:     return Ibm128Rank;
   }
 }
 
+/// 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 (LHS->isCXX23FloatingPointType(*this) &&
+      RHS->isCXX23FloatingPointType(*this)) {
+    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();
+    return CXX23FloatingPointConversionRankMap[CXX23FloatRankToIndex(LHSKind)]
+                                              [CXX23FloatRankToIndex(RHSKind)];
+  }
+
   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);
 }
 
+bool ASTContext::doCXX23ExtendedFpTypesRulesApply(QualType T1,
+                                                  QualType T2) const {
+  return (((T1->isCXX23FloatingPointType(*this) &&
+            T2->isCXX23FloatingPointType(*this))) &&
+          (T1->isCXX23ExtendedFloatingPointType(*this) ||
+           T2->isCXX23ExtendedFloatingPointType(*this)));
+}
+
+bool ASTContext::isCXX23SmallerOrUnorderedFloatingPointRank(
+    FloatingRankCompareResult Result) const {
+  return (Result == FRCR_Lesser) || (Result == FRCR_Unordered);
+}
+
+bool ASTContext::isCXX23EqualFloatingPointRank(
+    FloatingRankCompareResult Result) const {
+  return (Result == FRCR_Equal) || (Result == FRCR_Equal_Greater_Subrank) ||
+         (Result == FRCR_Equal_Lesser_Subrank);
+}
+
 /// 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");
 
   // Results in this 'losing' to any type of the same size, but winning if
   // larger.

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::BFloat16:   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::isCXX23StandardFloatingPointType(const ASTContext &Ctx) const {
+  if (!Ctx.getLangOpts().CPlusPlus23)
+    return false;
+  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(Ctx);
+  return false;
+}
+
+bool Type::isCXX23ExtendedFloatingPointType(const ASTContext &Ctx) const {
+  if (!Ctx.getLangOpts().CPlusPlus23)
+    return false;
+  if (const auto *BT = dyn_cast<BuiltinType>(CanonicalType))
+    return BT->getKind() == BuiltinType::Float16 ||
+           (Ctx.getTargetInfo().hasFullBFloat16Type() &&
+            (BT->getKind() == BuiltinType::BFloat16));
+  if (const auto *CT = dyn_cast<ComplexType>(CanonicalType))
+    return CT->getElementType()->isCXX23ExtendedFloatingPointType(Ctx);
+  return false;
+}
+
+bool Type::isCXX23FloatingPointType(const ASTContext &Ctx) const {
+  return isCXX23StandardFloatingPointType(Ctx) ||
+         isCXX23ExtendedFloatingPointType(Ctx);
+}
+
 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();
 }
 
if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
       return ET->getDecl()->isComplete() && !ET->getDecl()->isScoped();
   return isBitIntType();
 }
 
 bool Type::isArithmeticType() 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))
     // 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();
   return isa<ComplexType>(CanonicalType) || isBitIntType();

clang/lib/Frontend/InitPreprocessor.cpp

else if (LangOpts.C99)
       Builder.defineMacro("__STDC_VERSION__", "199901L");
     else if (!LangOpts.GNUMode && LangOpts.Digraphs)
       Builder.defineMacro("__STDC_VERSION__", "199409L");
   } else {
     //   -- __cplusplus
     if (LangOpts.CPlusPlus26)
       // FIXME: Use correct value for C++26.
       Builder.defineMacro("__cplusplus", "202400L");
-    else if (LangOpts.CPlusPlus23)
+    else if (LangOpts.CPlusPlus23) {
       Builder.defineMacro("__cplusplus", "202302L");
+      // [C++23] 15.11p2 [cpp.predefined]
+      Builder.defineMacro("__STDCPP_FLOAT16_T__", "1");
+      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/Lex/LiteralSupport.cpp

NumericLiteralParser::NumericLiteralParser(StringRef TokSpelling,
   isImaginary = false;
   isFloat16 = false;
   isFloat128 = false;
   MicrosoftInteger = 0;
   isFract = false;
   isAccum = false;
   hadError = false;
   isBitInt = false;
+  isBFloat16 = 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 (HasSize)
+          break;
+        HasSize = true;
+        s += 3;
+        isBFloat16 = 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;
+        isBFloat16 = 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 (Context.doCXX23ExtendedFpTypesRulesApply(ExprTy, TypeTy) &&
+      Kind == CK_FloatingCast && E->isPRValue() &&
+      (CCK == CCK_ImplicitConversion)) {
+    if (Context.isCXX23SmallerOrUnorderedFloatingPointRank(
+            Context.getFloatingTypeOrder(TypeTy, ExprTy))) {
+      Diag(E->getExprLoc(),
+           diag::err_cxx23_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() &&
+      Self.Context.doCXX23ExtendedFpTypesRulesApply(DestType, SrcType)) {
+    // FIXME: Support for cast between fp16 and bf16 doesn't exist yet.
+    if (!((DestType->isBFloat16Type() || DestType->isFloat16Type()) &&
+          (SrcType->isBFloat16Type() || 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.

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->isSveVLSBuiltinType())
     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);
       }
+      assert(Order != FRCR_Unordered &&
+             "Unordered floating types are not allowed.");
       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 (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.isBFloat16)
+      Ty = Context.BFloat16Ty;
     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) {
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 (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.doCXX23ExtendedFpTypesRulesApply(ScalarTy, VectorEltTy) &&
+          S.Context.isCXX23SmallerOrUnorderedFloatingPointRank(Order))
+        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);

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)) {
if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
 
     // Conversions between bfloat16 and float16 are currently not supported.
     if ((FromType->isBFloat16Type() &&
          (ToType->isFloat16Type() || ToType->isHalfType())) ||
         (ToType->isBFloat16Type() &&
          (FromType->isFloat16Type() || FromType->isHalfType())))
       return false;
 
+    // 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 (S.Context.doCXX23ExtendedFpTypesRulesApply(FromType, ToType) &&
+        S.Context.isCXX23SmallerOrUnorderedFloatingPointRank(
+            S.Context.getFloatingTypeOrder(ToType, FromType)))
+      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() &&
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().CPlusPlus23) {
+    if (SCS1.getFromType()->isCXX23FloatingPointType(S.Context) &&
+        S.Context.hasSameType(SCS1.getFromType(), SCS2.getFromType())) {
+
+      if ((SCS1.Second == ICK_Floating_Conversion) &&
+          SCS1.getToType(1)->isCXX23FloatingPointType(S.Context) &&
+          S.Context.isCXX23EqualFloatingPointRank(
+              S.Context.getFloatingTypeOrder(SCS1.getToType(1),
+                                             SCS1.getFromType()))) {
+
+        if (SCS2.getToType(1)->isArithmeticType()) {
+          if (!SCS2.getToType(1)->isCXX23FloatingPointType(S.Context)) {
+            return ImplicitConversionSequence::Better;
+          }
+
+          if (!S.Context.isCXX23EqualFloatingPointRank(
+                  S.Context.getFloatingTypeOrder(SCS2.getToType(1),
+                                                 SCS1.getFromType()))) {
+            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.getToType(1)->isCXX23FloatingPointType(S.Context) &&
+          S.Context.isCXX23EqualFloatingPointRank(
+              S.Context.getFloatingTypeOrder(SCS2.getToType(1),
+                                             SCS2.getFromType()))) {
+        if (SCS1.getToType(1)->isArithmeticType()) {
+          if (!SCS1.getToType(1)->isCXX23FloatingPointType(S.Context)) {
+            return ImplicitConversionSequence::Worse;
+          }
+
+          if (!S.Context.isCXX23EqualFloatingPointRank(
+                  S.Context.getFloatingTypeOrder(SCS1.getToType(1),
+                                                 SCS2.getFromType()))) {
+            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();
 
   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/test/CodeGenCXX/cxx23-fp-ext-std-names-p1467r9.cpp

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --function-signature
+// RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-linux-gnu -target-feature +fullbf16 -S -emit-llvm %s -o - | FileCheck %s  --check-prefix=CHECK
+
+// CHECK-LABEL: define {{[^@]+}}@_Z1fDF16b
+// CHECK-SAME: (bfloat noundef [[V:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK:         [[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: define {{[^@]+}}@_Z1fDF16_
+// CHECK-SAME: (half noundef [[V:%.*]]) #[[ATTR0]] {
+// CHECK:         [[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: define {{[^@]+}}@_Z1ff
+// CHECK-SAME: (float noundef [[V:%.*]]) #[[ATTR0]] {
+// CHECK:         [[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: define {{[^@]+}}@_Z1fd
+// CHECK-SAME: (double noundef [[V:%.*]]) #[[ATTR0]] {
+// CHECK:         [[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: define {{[^@]+}}@_Z1fe
+// CHECK-SAME: (x86_fp80 noundef [[V:%.*]]) #[[ATTR0]] {
+// CHECK:         [[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: define {{[^@]+}}@_Z1fi
+// CHECK-SAME: (i32 noundef [[V:%.*]]) #[[ATTR0]] {
+// CHECK:         [[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: define {{[^@]+}}@_Z3f_2e
+// CHECK-SAME: (x86_fp80 noundef [[V:%.*]]) #[[ATTR0]] {
+// CHECK:         [[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: define {{[^@]+}}@_Z5test1v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[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:    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:    ret void
+//
+void test1() {
+    _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);
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z5test2v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[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:    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:    ret void
+//
+void test2() {
+    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);
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z5test3v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[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:    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:    ret void
+//
+void test3() {
+    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;
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z5test4v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[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:    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:    ret void
+//
+void test4() {
+    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;
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z5test5v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[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:    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:    ret void
+//
+void test5() {
+    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;
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z5test6v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[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:    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:    ret void
+//
+void test6() {
+    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;
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z5test7v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[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:    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:    ret void
+//
+void test7() {
+    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;
+}
+
+//
+
+// CHECK-LABEL: define {{[^@]+}}@_Z7test8_1v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[BF16_VAL:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[TEST1:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST_9:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    store bfloat 0xR3F80, ptr [[BF16_VAL]], align 2
+// 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 bfloat, ptr [[BF16_VAL]], align 2
+// CHECK-NEXT:    [[CONV:%.*]] = fpext bfloat [[TMP1]] to x86_fp80
+// CHECK-NEXT:    [[CALL1:%.*]] = call noundef i32 @_Z3f_2e(x86_fp80 noundef [[CONV]])
+// CHECK-NEXT:    store i32 [[CALL1]], ptr [[TEST_9]], align 4
+// CHECK-NEXT:    ret void
+//
+void test8_1() {
+    decltype(0.BF16) bf16_val = 1.0bf16;
+    int test1 = f(bf16_val); // calls f(decltype(0.BF16))
+    int test_9 = f_2(bf16_val);
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z7test8_2v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[FLOAT16_VAL:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[TEST2:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST_10:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    store half 0xH3C00, ptr [[FLOAT16_VAL]], align 2
+// CHECK-NEXT:    [[TMP0:%.*]] = load half, ptr [[FLOAT16_VAL]], align 2
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef i32 @_Z1fDF16_(half noundef [[TMP0]])
+// CHECK-NEXT:    store i32 [[CALL]], ptr [[TEST2]], align 4
+// CHECK-NEXT:    [[TMP1:%.*]] = load half, ptr [[FLOAT16_VAL]], align 2
+// CHECK-NEXT:    [[CONV:%.*]] = fpext half [[TMP1]] to x86_fp80
+// CHECK-NEXT:    [[CALL1:%.*]] = call noundef i32 @_Z3f_2e(x86_fp80 noundef [[CONV]])
+// CHECK-NEXT:    store i32 [[CALL1]], ptr [[TEST_10]], align 4
+// CHECK-NEXT:    ret void
+//
+void test8_2() {
+    _Float16 float16_val = 1.0f16;
+    int test2 = f(float16_val); // calls f(_Float16)
+    int test_10 = f_2(float16_val);
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z7test8_3v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[FLOAT_VAL:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[TEST3:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST_7:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    store float 1.000000e+00, ptr [[FLOAT_VAL]], align 4
+// CHECK-NEXT:    [[TMP0:%.*]] = load float, ptr [[FLOAT_VAL]], align 4
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef i32 @_Z1ff(float noundef [[TMP0]])
+// CHECK-NEXT:    store i32 [[CALL]], ptr [[TEST3]], align 4
+// CHECK-NEXT:    [[TMP1:%.*]] = load float, ptr [[FLOAT_VAL]], align 4
+// CHECK-NEXT:    [[CONV:%.*]] = fpext float [[TMP1]] to x86_fp80
+// CHECK-NEXT:    [[CALL1:%.*]] = call noundef i32 @_Z3f_2e(x86_fp80 noundef [[CONV]])
+// CHECK-NEXT:    store i32 [[CALL1]], ptr [[TEST_7]], align 4
+// CHECK-NEXT:    ret void
+//
+void test8_3() {
+    float float_val = 1.0f;
+    int test3 = f(float_val); // calls f(float)
+    int test_7 = f_2(float_val);
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z7test8_4v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[DOUBLE_VAL:%.*]] = alloca double, align 8
+// CHECK-NEXT:    [[TEST4:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST_8:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    store double 1.000000e+00, ptr [[DOUBLE_VAL]], align 8
+// CHECK-NEXT:    [[TMP0:%.*]] = load double, ptr [[DOUBLE_VAL]], align 8
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef i32 @_Z1fd(double noundef [[TMP0]])
+// CHECK-NEXT:    store i32 [[CALL]], ptr [[TEST4]], align 4
+// CHECK-NEXT:    [[TMP1:%.*]] = load double, ptr [[DOUBLE_VAL]], align 8
+// CHECK-NEXT:    [[CONV:%.*]] = fpext double [[TMP1]] to x86_fp80
+// CHECK-NEXT:    [[CALL1:%.*]] = call noundef i32 @_Z3f_2e(x86_fp80 noundef [[CONV]])
+// CHECK-NEXT:    store i32 [[CALL1]], ptr [[TEST_8]], align 4
+// CHECK-NEXT:    ret void
+//
+void test8_4() {
+    double double_val = 1.0;
+    int test4 = f(double_val); // calls f(double)
+    int test_8 = f_2(double_val);
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z7test8_5v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[LONG_DOUBLE_VAL:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    [[TEST5:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    store x86_fp80 0xK3FFF8000000000000000, ptr [[LONG_DOUBLE_VAL]], align 16
+// CHECK-NEXT:    [[TMP0:%.*]] = load x86_fp80, ptr [[LONG_DOUBLE_VAL]], align 16
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef i32 @_Z1fe(x86_fp80 noundef [[TMP0]])
+// CHECK-NEXT:    store i32 [[CALL]], ptr [[TEST5]], align 4
+// CHECK-NEXT:    ret void
+//
+void test8_5() {
+    long double long_double_val = 1.0l;
+    int test5 = f(long_double_val); // calls f(long double)
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z7test8_6v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[INT_VAL:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[TEST6:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    store i32 1, ptr [[INT_VAL]], align 4
+// CHECK-NEXT:    [[TMP0:%.*]] = load i32, ptr [[INT_VAL]], align 4
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef i32 @_Z1fi(i32 noundef [[TMP0]])
+// CHECK-NEXT:    store i32 [[CALL]], ptr [[TEST6]], align 4
+// CHECK-NEXT:    ret void
+//
+void test8_6() {
+    int int_val = 1;
+    int test6 = f(int_val); // calls f(int)
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z7test9_1v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[USER_DEFINED_VAL:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-NEXT:    [[BFLOAT16_VAL:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef bfloat @_ZNK1ScvDF16bEv(ptr noundef nonnull align 1 dereferenceable(1) [[USER_DEFINED_VAL]])
+// CHECK-NEXT:    store bfloat [[CALL]], ptr [[BFLOAT16_VAL]], align 2
+// CHECK-NEXT:    ret void
+//
+void test9_1() {
+    S user_defined_val;
+    // User-defined overload cases
+    decltype(0.BF16) bfloat16_val(user_defined_val); // calls operator decltype(0.BF16)()
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z7test9_2v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[USER_DEFINED_VAL:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-NEXT:    [[F16_VAL:%.*]] = alloca half, align 2
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef half @_ZNK1ScvDF16_Ev(ptr noundef nonnull align 1 dereferenceable(1) [[USER_DEFINED_VAL]])
+// CHECK-NEXT:    store half [[CALL]], ptr [[F16_VAL]], align 2
+// CHECK-NEXT:    ret void
+//
+void test9_2() {
+    S user_defined_val;
+    // User-defined overload cases
+    _Float16 f16_val(user_defined_val); // calls operator _Float16()
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z7test9_3v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[USER_DEFINED_VAL:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-NEXT:    [[F_VAL:%.*]] = alloca float, align 4
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef float @_ZNK1ScvfEv(ptr noundef nonnull align 1 dereferenceable(1) [[USER_DEFINED_VAL]])
+// CHECK-NEXT:    store float [[CALL]], ptr [[F_VAL]], align 4
+// CHECK-NEXT:    ret void
+//
+void test9_3() {
+    S user_defined_val;
+    // User-defined overload cases
+    float f_val(user_defined_val); // calls operator float()
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z7test9_4v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[USER_DEFINED_VAL:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-NEXT:    [[D_VAL:%.*]] = alloca double, align 8
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef double @_ZNK1ScvdEv(ptr noundef nonnull align 1 dereferenceable(1) [[USER_DEFINED_VAL]])
+// CHECK-NEXT:    store double [[CALL]], ptr [[D_VAL]], align 8
+// CHECK-NEXT:    ret void
+//
+void test9_4() {
+    S user_defined_val;
+    // User-defined overload cases
+    double d_val(user_defined_val); // calls operator double()
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z7test9_5v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[USER_DEFINED_VAL:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-NEXT:    [[LD_VAL:%.*]] = alloca x86_fp80, align 16
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef x86_fp80 @_ZNK1ScveEv(ptr noundef nonnull align 1 dereferenceable(1) [[USER_DEFINED_VAL]])
+// CHECK-NEXT:    store x86_fp80 [[CALL]], ptr [[LD_VAL]], align 16
+// CHECK-NEXT:    ret void
+//
+void test9_5() {
+    S user_defined_val;
+    // User-defined overload cases
+    long double ld_val(user_defined_val); // calls operator long double()
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z7test9_6v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[USER_DEFINED_VAL:%.*]] = alloca [[STRUCT_S:%.*]], align 1
+// CHECK-NEXT:    [[I_VAL:%.*]] = alloca i32, align 4
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef i32 @_ZNK1ScviEv(ptr noundef nonnull align 1 dereferenceable(1) [[USER_DEFINED_VAL]])
+// CHECK-NEXT:    store i32 [[CALL]], ptr [[I_VAL]], align 4
+// CHECK-NEXT:    ret void
+//
+void test9_6() {
+    S user_defined_val;
+    // User-defined overload cases
+    int i_val(user_defined_val); // calls operator int()
+}
+
+// CHECK-LABEL: define {{[^@]+}}@_Z7test9_7v
+// CHECK-SAME: () #[[ATTR0]] {
+// CHECK:         [[USER_DEFINED_VAL_2:%.*]] = alloca [[STRUCT_S1:%.*]], align 1
+// CHECK-NEXT:    [[BFLOAT16_VAL_2:%.*]] = alloca bfloat, align 2
+// CHECK-NEXT:    [[CALL:%.*]] = call noundef i32 @_ZNK2S1cviEv(ptr noundef nonnull align 1 dereferenceable(1) [[USER_DEFINED_VAL_2]])
+// CHECK-NEXT:    [[CONV:%.*]] = sitofp i32 [[CALL]] to bfloat
+// CHECK-NEXT:    store bfloat [[CONV]], ptr [[BFLOAT16_VAL_2]], align 2
+// CHECK-NEXT:    ret void
+//
+void test9_7() {
+    S1 user_defined_val_2;
+    // User-defined overload cases
+    decltype(0.BF16) bfloat16_val_2(user_defined_val_2); // calls operator int()
+}

clang/test/CodeGenCXX/cxx23-vector-bfloat16.cpp

+// NOTE: Assertions have been autogenerated by utils/update_cc_test_checks.py UTC_ARGS: --version 2
+// RUN: %clang_cc1 -std=c++23 -triple x86_64-unknown-linux-gnu -target-feature +fullbf16 -S -emit-llvm %s -o - | FileCheck %s
+
+typedef decltype(0.0BF16) v8bfloat16 __attribute__((__vector_size__(16)));
+
+// CHECK-LABEL: define dso_local void @_Z11test_vectorDv8_DF16bS_
+// CHECK-SAME: (<8 x bfloat> noundef [[A:%.*]], <8 x bfloat> noundef [[B:%.*]]) #[[ATTR0:[0-9]+]] {
+// CHECK:         [[A_ADDR:%.*]] = alloca <8 x bfloat>, align 16
+// CHECK-NEXT:    [[B_ADDR:%.*]] = alloca <8 x bfloat>, align 16
+// CHECK-NEXT:    [[C:%.*]] = alloca <8 x bfloat>, align 16
+// CHECK-NEXT:    store <8 x bfloat> [[A]], ptr [[A_ADDR]], align 16
+// CHECK-NEXT:    store <8 x bfloat> [[B]], ptr [[B_ADDR]], align 16
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x bfloat>, ptr [[A_ADDR]], align 16
+// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x bfloat>, ptr [[B_ADDR]], align 16
+// CHECK-NEXT:    [[ADD:%.*]] = fadd <8 x bfloat> [[TMP0]], [[TMP1]]
+// CHECK-NEXT:    store <8 x bfloat> [[ADD]], ptr [[C]], align 16
+// CHECK-NEXT:    [[TMP2:%.*]] = load <8 x bfloat>, ptr [[A_ADDR]], align 16
+// CHECK-NEXT:    [[TMP3:%.*]] = load <8 x bfloat>, ptr [[B_ADDR]], align 16
+// CHECK-NEXT:    [[SUB:%.*]] = fsub <8 x bfloat> [[TMP2]], [[TMP3]]
+// CHECK-NEXT:    store <8 x bfloat> [[SUB]], ptr [[C]], align 16
+// CHECK-NEXT:    [[TMP4:%.*]] = load <8 x bfloat>, ptr [[A_ADDR]], align 16
+// CHECK-NEXT:    [[TMP5:%.*]] = load <8 x bfloat>, ptr [[B_ADDR]], align 16
+// CHECK-NEXT:    [[MUL:%.*]] = fmul <8 x bfloat> [[TMP4]], [[TMP5]]
+// CHECK-NEXT:    store <8 x bfloat> [[MUL]], ptr [[C]], align 16
+// CHECK-NEXT:    [[TMP6:%.*]] = load <8 x bfloat>, ptr [[A_ADDR]], align 16
+// CHECK-NEXT:    [[TMP7:%.*]] = load <8 x bfloat>, ptr [[B_ADDR]], align 16
+// CHECK-NEXT:    [[DIV:%.*]] = fdiv <8 x bfloat> [[TMP6]], [[TMP7]]
+// CHECK-NEXT:    store <8 x bfloat> [[DIV]], ptr [[C]], align 16
+// CHECK-NEXT:    ret void
+//
+void test_vector(v8bfloat16 a, v8bfloat16 b) {
+    v8bfloat16 c;
+    c = a + b;
+    c = a - b;
+    c = a * b;
+    c = a / b;
+}
+
+// CHECK-LABEL: define dso_local void @_Z13test_vector_2v
+// CHECK-SAME: () #[[ATTR1:[0-9]+]] {
+// CHECK:         [[A:%.*]] = alloca <8 x bfloat>, align 16
+// CHECK-NEXT:    [[DOTCOMPOUNDLITERAL:%.*]] = alloca <8 x bfloat>, align 16
+// CHECK-NEXT:    [[B:%.*]] = alloca <8 x bfloat>, align 16
+// CHECK-NEXT:    [[DOTCOMPOUNDLITERAL1:%.*]] = alloca <8 x bfloat>, align 16
+// CHECK-NEXT:    [[C:%.*]] = alloca <8 x bfloat>, align 16
+// CHECK-NEXT:    [[D:%.*]] = alloca <8 x bfloat>, align 16
+// CHECK-NEXT:    store <8 x bfloat> zeroinitializer, ptr [[DOTCOMPOUNDLITERAL]], align 16
+// CHECK-NEXT:    [[TMP0:%.*]] = load <8 x bfloat>, ptr [[DOTCOMPOUNDLITERAL]], align 16
+// CHECK-NEXT:    store <8 x bfloat> [[TMP0]], ptr [[A]], align 16
+// CHECK-NEXT:    store <8 x bfloat> <bfloat 0xR3F80, bfloat 0xR0000, bfloat 0xR0000, bfloat 0xR0000, bfloat 0xR0000, bfloat 0xR0000, bfloat 0xR0000, bfloat 0xR0000>, ptr [[DOTCOMPOUNDLITERAL1]], align 16
+// CHECK-NEXT:    [[TMP1:%.*]] = load <8 x bfloat>, ptr [[DOTCOMPOUNDLITERAL1]], align 16
+// CHECK-NEXT:    store <8 x bfloat> [[TMP1]], ptr [[B]], align 16
+// CHECK-NEXT:    [[TMP2:%.*]] = load <8 x bfloat>, ptr [[A]], align 16
+// CHECK-NEXT:    [[ELT_ABS:%.*]] = call <8 x bfloat> @llvm.fabs.v8bf16(<8 x bfloat> [[TMP2]])
+// CHECK-NEXT:    store <8 x bfloat> [[ELT_ABS]], ptr [[C]], align 16
+// CHECK-NEXT:    [[TMP3:%.*]] = load <8 x bfloat>, ptr [[C]], align 16
+// CHECK-NEXT:    [[ELT_ABS2:%.*]] = call <8 x bfloat> @llvm.fabs.v8bf16(<8 x bfloat> [[TMP3]])
+// CHECK-NEXT:    store <8 x bfloat> [[ELT_ABS2]], ptr [[D]], align 16
+// CHECK-NEXT:    ret void
+//
+void test_vector_2() {
+    v8bfloat16 a = (v8bfloat16){0.0bf16};
+    v8bfloat16 b = (v8bfloat16){1.0bf16};
+    v8bfloat16 c = __builtin_elementwise_abs(a);
+    v8bfloat16 d = __builtin_elementwise_abs(c);
+}
+

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

+// RUN: %clang_cc1 -fsyntax-only -std=c++23 -target-feature +fullbf16 -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;