[Clang] Rename internal type identifier(s) for __bf16 to BF16Ty

[codemzs]

Summary

This change updates internal type identifiers for __bf16 from BFloat16Ty to BF16Ty and renames any associated variables and function names accordingly. The rationale for this change comes from the review feedback on https://reviews.llvm.org/D149573, which pointed out the confusing naming issues between __bf16 and the upcoming std::bfloat16_t. This modification only affects LLVM/Clang specific code and does not interfere with target-specific code, such as NeonEmitters, SVE Type, AArch64, X86, etc. It is important to note that BF16Ty will represent the storage-only __bf16 type and bfloat16 format, which will be shared with the upcoming std::bfloat16_t type. However, std::bfloat16_t will have the correct semantics and mangling to be an arithmetic type. The existing names are being updated to enhance clarity and maintainability in the codebase. The change is made in a separate patch, as suggested in the review, to ensure a smooth integration of std::bfloat16_t support.

[tahonermann]

This looks great, thank you for doing this!

Requested changes are just to undo some of the style changes.

clang/include/clang/Basic/Specifiers.h

84–89

Whitespace changes to code that is otherwise not being changed are discouraged due to the impact on tools like git blame. If you want to make such a change, please do so as a separate commit and add the commit to .git-blame-ignore-revs.

clang/lib/AST/ASTContext.cpp

7075–7076

Please keep the same style here (I know clang-format might want to do differently; just ignore it in this case).

clang/lib/AST/ItaniumMangle.cpp

3617–3618

Likewise, please maintain consistent style here.

Thank you for *not* changing the literal! :)

clang/lib/Sema/DeclSpec.cpp

590–591

Please maintain consistent style here.

[codemzs]

PR feedback: Revert style changes.

[codemzs]

@tahonermann Thank you for pointing that out and for reviewing my code. I appreciate your guidance. I was following the LLVM contribution guidelines to use git clang-format, but I understand the importance of maintaining existing code styles that may be altered by git-clang format. I will be more mindful of this in the future. I have reverted the style changes and updated the patch as per your feedback.

[tahonermann]

I was following the LLVM contribution guidelines to use git clang-format, but I understand the importance of maintaining existing code styles that may be altered by git-clang format.

The guidelines are slightly in conflict in that regard so, yeah, its a judgement call.

I added two more suggested edits targeting some comments.

This looks good to me, but I think we should make sure AMD and ARM folks are aware of the change. @foad, @lenary, any concerns?

clang/include/clang/Basic/TargetInfo.h

650–651

clang/include/clang/Basic/arm_neon_incl.td

240

[tahonermann]

Heads up @clang-vendors. This patch changes the names of many internal identifiers for enumerators, class data members, and functions (including virtual functions) that are related to support for the __bf16 type. The changes are roughly to replace "bfloat16" with "bf16" to make the association obvious and to avoid confusion when support for the C++ std::bfloat16_t type lands (and to make room for a potential matching _BFloat16 type in C in the future). There are no changes to ABI or code generation; mangling continues to use the same names even where those have "bfloat16" in them. These changes will likely cause compilation failures in downstream projects that will require (simple) identifier updates to resolve.

[codemzs]

Update comments as per feedback from @tahonermann

[barannikov88]

clang/lib/AST/Type.cpp

2189

Looks like another clang-format quirk.

clang/lib/CodeGen/TargetInfo.cpp

5567–5568

Should the name of the method be updated?

[tahonermann]

Thanks for all the updates @codemzs! I'm going to go ahead and accept. But please wait a few days for recently subscribed folks to have a chance to comment before landing this.

[barannikov88]

The summary as it is will be hard to read in git log. Please split it into multiple lines 72~80 chars each.
https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html

[codemzs]

In D150291#4335360, @barannikov88 wrote:

The summary as it is will be hard to read in git log. Please split it into multiple lines 72~80 chars each.
https://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html

I've provided the git log message that I see on my end below. I ensured that it is split into multiple lines, with each line not exceeding the character limit. Please let me know if this isn't inline with the LLVM contribution standards.

[barannikov88]

In D150291#4335414, @codemzs wrote:

I've provided the git log message that I see on my end below. I ensured that it is split into multiple lines, with each line not exceeding the character limit. Please let me know if this isn't inline with the LLVM contribution standards.

Looks great, thanks.
One note: if you are going to land the changes via arcanist, you will need to update the
message in the web form. (arc ignores git commit message and takes it from the web.)

[codemzs]

Addressing feedback from @barannikov88

[codemzs]

In D150291#4335352, @tahonermann wrote:

Thanks for all the updates @codemzs! I'm going to go ahead and accept. But please wait a few days for recently subscribed folks to have a chance to comment before landing this.

Thank you, @tahonermann, for the review. I will hold off on landing this until next week to allow sufficient time for others who are subscribed to review as well.

[stuij]

Regarding this particular change, we at Arm are happy with the name change. I saw BFloat16 instead of BF16 as tech debt that we didn't get round to fixing.

I do wonder if we need two bfloat implementations, but for that I'll leave a comment on D149573.

BTW, unfortunately @lenary doesn't work at Arm anymore.

[tahonermann]

I do wonder if we need two bfloat implementations, but for that I'll leave a comment on D149573.

Given the discussions occurring in D149573, let's hold off on landing this for now. It is sounding like we might have direction for repurposing __bf16 for std::bfloat16_t (and a future _BFloat16 C type; with __bf16 retained as an alternate spelling). If we go in that direction, then we would presumably want a change that goes in the opposite direction of this patch; a change that migrates "bf16" names towards "bfloat16". Let's focus on confirming that direction first. I'll mark this as requesting changes for now while we figure this out.

[codemzs]

In D150291#4338118, @tahonermann wrote:

I do wonder if we need two bfloat implementations, but for that I'll leave a comment on D149573.

Given the discussions occurring in D149573, let's hold off on landing this for now. It is sounding like we might have direction for repurposing __bf16 for std::bfloat16_t (and a future _BFloat16 C type; with __bf16 retained as an alternate spelling). If we go in that direction, then we would presumably want a change that goes in the opposite direction of this patch; a change that migrates "bf16" names towards "bfloat16". Let's focus on confirming that direction first. I'll mark this as requesting changes for now while we figure this out.

Thank you for your guidance, @tahonermann. I agree it's prudent to establish a confirmed direction for reusing __bf16 to implement std::bfloat16_t as an arithmetic type before proceeding. If we decide to take this route, I understand that we'll be looking towards a change that aligns "bf16" names more closely with "bfloat16".

In the meantime, I will revert to my initial change in D149573 which repurposed __bf16 type, and present it for further discussion. This, along with a summary of the RFC discussion, should help us reach a consensus. I welcome any further insights or considerations you might think pertinent to this process.

[codemzs]

Closing this as it has been resolved by D150913.

clang/include/clang-c/Index.h

enum CXTypeKind {
   CXType_Half = 31,
   CXType_Float16 = 32,
   CXType_ShortAccum = 33,
   CXType_Accum = 34,
   CXType_LongAccum = 35,
   CXType_UShortAccum = 36,
   CXType_UAccum = 37,
   CXType_ULongAccum = 38,
-  CXType_BFloat16 = 39,
+  CXType_BF16 = 39,
   CXType_Ibm128 = 40,
   CXType_FirstBuiltin = CXType_Void,
   CXType_LastBuiltin = CXType_Ibm128,
 
   CXType_Complex = 100,
   CXType_Pointer = 101,
   CXType_BlockPointer = 102,
   CXType_LValueReference = 103,

clang/include/clang/AST/ASTContext.h

public:
   CanQualType UnsignedShortFractTy, UnsignedFractTy, UnsignedLongFractTy;
   CanQualType SatShortAccumTy, SatAccumTy, SatLongAccumTy;
   CanQualType SatUnsignedShortAccumTy, SatUnsignedAccumTy,
       SatUnsignedLongAccumTy;
   CanQualType SatShortFractTy, SatFractTy, SatLongFractTy;
   CanQualType SatUnsignedShortFractTy, SatUnsignedFractTy,
       SatUnsignedLongFractTy;
   CanQualType HalfTy; // [OpenCL 6.1.1.1], ARM NEON
-  CanQualType BFloat16Ty;
+  CanQualType BF16Ty;
   CanQualType Float16Ty; // C11 extension ISO/IEC TS 18661-3
   CanQualType VoidPtrTy, NullPtrTy;
   CanQualType DependentTy, OverloadTy, BoundMemberTy, UnknownAnyTy;
   CanQualType BuiltinFnTy;
   CanQualType PseudoObjectTy, ARCUnbridgedCastTy;
   CanQualType ObjCBuiltinIdTy, ObjCBuiltinClassTy, ObjCBuiltinSelTy;
   CanQualType ObjCBuiltinBoolTy;
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) \

clang/include/clang/AST/BuiltinTypes.def

 
 // 'long double'
 FLOATING_TYPE(LongDouble, LongDoubleTy)
 
 // '_Float16'
 FLOATING_TYPE(Float16, HalfTy)
 
 // '__bf16'
-FLOATING_TYPE(BFloat16, BFloat16Ty)
+FLOATING_TYPE(BF16, BF16Ty)
 
 // '__float128'
 FLOATING_TYPE(Float128, Float128Ty)
 
 // '__ibm128'
 FLOATING_TYPE(Ibm128, Ibm128Ty)
 
 //===- Language-specific types --------------------------------------------===//

clang/include/clang/AST/Type.h

public:
   bool isRealFloatingType() const; // C99 6.2.5p10 (float, double, long double)
   /// isComplexType() does *not* include complex integers (a GCC extension).
   /// isComplexIntegerType() can be used to test for complex integers.
   bool isComplexType() const;      // C99 6.2.5p11 (complex)
   bool isAnyComplexType() const;   // C99 6.2.5p11 (complex) + Complex Int.
   bool isFloatingType() const;     // C99 6.2.5p11 (real floating + complex)
   bool isHalfType() const;         // OpenCL 6.1.1.1, NEON (IEEE 754-2008 half)
   bool isFloat16Type() const;      // C11 extension ISO/IEC TS 18661
-  bool isBFloat16Type() const;
+  bool isBF16Type() const;
   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;
inline bool Type::isHalfType() const {
   // FIXME: Should we allow complex __fp16? Probably not.
   return isSpecificBuiltinType(BuiltinType::Half);
 }
 
 inline bool Type::isFloat16Type() const {
   return isSpecificBuiltinType(BuiltinType::Float16);
 }
 
-inline bool Type::isBFloat16Type() const {
-  return isSpecificBuiltinType(BuiltinType::BFloat16);
+inline bool Type::isBF16Type() const {
+  return isSpecificBuiltinType(BuiltinType::BF16);
 }
 
 inline bool Type::isFloat128Type() const {
   return isSpecificBuiltinType(BuiltinType::Float128);
 }
 
 inline bool Type::isIbm128Type() const {
   return isSpecificBuiltinType(BuiltinType::Ibm128);

clang/include/clang/Basic/DiagnosticSemaKinds.td

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

clang/include/clang/Basic/Specifiers.h

enum TypeSpecifierType {
     TST_char32, // C++11 char32_t
     TST_int,
     TST_int128,
     TST_bitint,  // Bit-precise integer types.
     TST_half,    // OpenCL half, ARM NEON __fp16
     TST_Float16, // C11 extension ISO/IEC TS 18661-3
     TST_Accum,   // ISO/IEC JTC1 SC22 WG14 N1169 Extension
     TST_Fract,
-    TST_BFloat16,
+    TST_BF16,
     TST_float,
     TST_double,
     TST_float128,
     TST_ibm128,
     TST_bool,       // _Bool
     TST_decimal32,  // _Decimal32
     TST_decimal64,  // _Decimal64
     TST_decimal128, // _Decimal128
     TST_enum,
     TST_union,
     TST_struct,
     TST_class,     // C++ class type
     TST_interface, // C++ (Microsoft-specific) __interface type
     TST_typename,  // Typedef, C++ class-name or enum name, etc.
     TST_typeofType,        // C2x (and GNU extension) typeof(type-name)
     TST_typeofExpr,        // C2x (and GNU extension) typeof(expression)
     TST_typeof_unqualType, // C2x typeof_unqual(type-name)
     TST_typeof_unqualExpr, // C2x typeof_unqual(expression)
     TST_decltype, // C++11 decltype
 #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait) TST_##Trait,
 #include "clang/Basic/TransformTypeTraits.def"
     TST_auto,            // C++11 auto
     TST_decltype_auto,   // C++1y decltype(auto)
     TST_auto_type,       // __auto_type extension
     TST_unknown_anytype, // __unknown_anytype extension
     TST_atomic,          // C11 _Atomic
 #define GENERIC_IMAGE_TYPE(ImgType, Id) TST_##ImgType##_t, // OpenCL image types

clang/include/clang/Basic/TargetInfo.h

 /// Fields controlling how types are laid out in memory; these may need to
 /// be copied for targets like AMDGPU that base their ABIs on an auxiliary
 /// CPU target.
 struct TransferrableTargetInfo {
   unsigned char PointerWidth, PointerAlign;
   unsigned char BoolWidth, BoolAlign;
   unsigned char IntWidth, IntAlign;
   unsigned char HalfWidth, HalfAlign;
-  unsigned char BFloat16Width, BFloat16Align;
+  unsigned char BF16Width, BF16Align;
   unsigned char FloatWidth, FloatAlign;
   unsigned char DoubleWidth, DoubleAlign;
   unsigned char LongDoubleWidth, LongDoubleAlign, Float128Align, Ibm128Align;
   unsigned char LargeArrayMinWidth, LargeArrayAlign;
   unsigned char LongWidth, LongAlign;
   unsigned char LongLongWidth, LongLongAlign;
   unsigned char Int128Align;
 
struct TransferrableTargetInfo {
   unsigned char DefaultAlignForAttributeAligned;
   unsigned char MinGlobalAlign;
 
   unsigned short SuitableAlign;
   unsigned short NewAlign;
   unsigned MaxVectorAlign;
   unsigned MaxTLSAlign;
 
-  const llvm::fltSemantics *HalfFormat, *BFloat16Format, *FloatFormat,
+  const llvm::fltSemantics *HalfFormat, *BF16Format, *FloatFormat,
       *DoubleFormat, *LongDoubleFormat, *Float128Format, *Ibm128Format;
 
   ///===---- Target Data Type Query Methods -------------------------------===//
   enum IntType {
     NoInt = 0,
     SignedChar,
     UnsignedChar,
     SignedShort,
protected:
   bool TLSSupported;
   bool VLASupported;
   bool NoAsmVariants;  // True if {|} are normal characters.
   bool HasLegalHalfType; // True if the backend supports operations on the half
                          // LLVM IR type.
   bool HalfArgsAndReturns;
   bool HasFloat128;
   bool HasFloat16;
-  bool HasBFloat16;
+  bool HasBF16;
   bool HasIbm128;
   bool HasLongDouble;
   bool HasFPReturn;
   bool HasStrictFP;
 
   unsigned char MaxAtomicPromoteWidth, MaxAtomicInlineWidth;
   std::string DataLayoutString;
   const char *UserLabelPrefix;
public:
   virtual bool allowHalfArgsAndReturns() const { return HalfArgsAndReturns; }
 
   /// Determine whether the __float128 type is supported on this target.
   virtual bool hasFloat128Type() const { return HasFloat128; }
 
   /// Determine whether the _Float16 type is supported on this target.
   virtual bool hasFloat16Type() const { return HasFloat16; }
 
-  /// Determine whether the _BFloat16 type is supported on this target.
-  virtual bool hasBFloat16Type() const { return HasBFloat16; }
+  /// Determine whether the __bf16 type is supported on this target.
+  virtual bool hasBF16Type() const { return HasBF16; }
 
   /// Determine whether the __ibm128 type is supported on this target.
   virtual bool hasIbm128Type() const { return HasIbm128; }
 
   /// Determine whether the long double type is supported on this target.
   virtual bool hasLongDoubleType() const { return HasLongDouble; }
 
   /// Determine whether return of a floating point value is supported
public:
   unsigned getHalfAlign() const { return HalfAlign; }
   const llvm::fltSemantics &getHalfFormat() const { return *HalfFormat; }
 
   /// getFloatWidth/Align/Format - Return the size/align/format of 'float'.
   unsigned getFloatWidth() const { return FloatWidth; }
   unsigned getFloatAlign() const { return FloatAlign; }
   const llvm::fltSemantics &getFloatFormat() const { return *FloatFormat; }
 
-  /// getBFloat16Width/Align/Format - Return the size/align/format of '__bf16'.
-  unsigned getBFloat16Width() const { return BFloat16Width; }
-  unsigned getBFloat16Align() const { return BFloat16Align; }
-  const llvm::fltSemantics &getBFloat16Format() const { return *BFloat16Format; }
+  /// getBF16Width/Align/Format - Return the size/align/format of '__bf16'.
+  unsigned getBF16Width() const { return BF16Width; }
+  unsigned getBF16Align() const { return BF16Align; }
+  const llvm::fltSemantics &getBF16Format() const { return *BF16Format; }
 
   /// getDoubleWidth/Align/Format - Return the size/align/format of 'double'.
   unsigned getDoubleWidth() const { return DoubleWidth; }
   unsigned getDoubleAlign() const { return DoubleAlign; }
   const llvm::fltSemantics &getDoubleFormat() const { return *DoubleFormat; }
 
   /// getLongDoubleWidth/Align/Format - Return the size/align/format of 'long
   /// double'.
public:
   virtual const char *getFloat128Mangling() const { return "g"; }
 
   /// Return the mangled code of __ibm128.
   virtual const char *getIbm128Mangling() const {
     llvm_unreachable("ibm128 not implemented on this target");
   }
 
   /// Return the mangled code of bfloat.
-  virtual const char *getBFloat16Mangling() const {
+  virtual const char *getBF16Mangling() const {
     llvm_unreachable("bfloat not implemented on this target");
   }
 
   /// Return the value for the C99 FLT_EVAL_METHOD macro.
   virtual LangOptions::FPEvalMethodKind getFPEvalMethod() const {
     return LangOptions::FPEvalMethodKind::FEM_Source;
   }
 

clang/include/clang/Basic/arm_neon_incl.td

 // Each type modifier is either a single character, or a group surrounded by
 // parentheses.
 //
 // .: default
 // v: change to void category.
 // S: change to signed integer category.
 // U: change to unsigned integer category.
 // F: change to floating category.
-// B: change to BFloat16
+// B: change to __bf16.
 // P: change to polynomial category.
 // p: change polynomial to equivalent integer category. Otherwise nop.
 //
 // >: double element width (vector size unchanged).
 // <: half element width (vector size unchanged).
 //
 // 1: change to scalar.
 // 2: change to struct of two vectors.

clang/include/clang/Sema/DeclSpec.h

public:
   static const TST TST_wchar = clang::TST_wchar;
   static const TST TST_char8 = clang::TST_char8;
   static const TST TST_char16 = clang::TST_char16;
   static const TST TST_char32 = clang::TST_char32;
   static const TST TST_int = clang::TST_int;
   static const TST TST_int128 = clang::TST_int128;
   static const TST TST_bitint = clang::TST_bitint;
   static const TST TST_half = clang::TST_half;
-  static const TST TST_BFloat16 = clang::TST_BFloat16;
+  static const TST TST_BF16 = clang::TST_BF16;
   static const TST TST_float = clang::TST_float;
   static const TST TST_double = clang::TST_double;
   static const TST TST_float16 = clang::TST_Float16;
   static const TST TST_accum = clang::TST_Accum;
   static const TST TST_fract = clang::TST_Fract;
   static const TST TST_float128 = clang::TST_float128;
   static const TST TST_ibm128 = clang::TST_ibm128;
   static const TST TST_bool = clang::TST_bool;

clang/include/clang/Serialization/ASTBitCodes.h

enum PredefinedTypeIDs {
 
   /// The placeholder type for OpenMP iterator expression.
   PREDEF_TYPE_OMP_ITERATOR = 71,
 
   /// A placeholder type for incomplete matrix index operations.
   PREDEF_TYPE_INCOMPLETE_MATRIX_IDX = 72,
 
   /// \brief The '__bf16' type
-  PREDEF_TYPE_BFLOAT16_ID = 73,
+  PREDEF_TYPE_BF16_ID = 73,
 
   /// \brief The '__ibm128' type
   PREDEF_TYPE_IBM128_ID = 74,
 
 /// OpenCL image types with auto numeration
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix)                   \
   PREDEF_TYPE_##Id##_ID,
 #include "clang/Basic/OpenCLImageTypes.def"

clang/lib/AST/ASTContext.cpp

 #include <optional>
 #include <string>
 #include <tuple>
 #include <utility>
 
 using namespace clang;
 
 enum FloatingRank {
-  BFloat16Rank,
+  BF16Rank,
   Float16Rank,
   HalfRank,
   FloatRank,
   DoubleRank,
   LongDoubleRank,
   Float128Rank,
   Ibm128Rank
 };
#include "clang/Basic/WebAssemblyReferenceTypes.def"
   }
 
   // nullptr type (C++0x 2.14.7)
   InitBuiltinType(NullPtrTy,           BuiltinType::NullPtr);
 
   // half type (OpenCL 6.1.1.1) / ARM NEON __fp16
   InitBuiltinType(HalfTy, BuiltinType::Half);
 
-  InitBuiltinType(BFloat16Ty, BuiltinType::BFloat16);
+  InitBuiltinType(BF16Ty, BuiltinType::BF16);
 
   // Builtin type used to help define __builtin_va_list.
   VaListTagDecl = nullptr;
 
   // MSVC predeclares struct _GUID, and we need it to create MSGuidDecls.
   if (LangOpts.MicrosoftExt || LangOpts.Borland) {
     MSGuidTagDecl = buildImplicitRecord("_GUID");
     getTranslationUnitDecl()->addDecl(MSGuidTagDecl);

 //===----------------------------------------------------------------------===//
 
 /// getFloatTypeSemantics - Return the APFloat 'semantics' for the specified
 /// scalar floating point type.
 const llvm::fltSemantics &ASTContext::getFloatTypeSemantics(QualType T) const {
   switch (T->castAs<BuiltinType>()->getKind()) {
   default:
     llvm_unreachable("Not a floating point type!");
-  case BuiltinType::BFloat16:
-    return Target->getBFloat16Format();
+  case BuiltinType::BF16:
+    return Target->getBF16Format();
   case BuiltinType::Float16:
     return Target->getHalfFormat();
   case BuiltinType::Half:
     // For HLSL, when the native half type is disabled, half will be treat as
     // float.
     if (getLangOpts().HLSL)
       if (getLangOpts().NativeHalfType)
         return Target->getHalfFormat();
case BuiltinType::SatUFract:
       break;
     case BuiltinType::LongFract:
     case BuiltinType::ULongFract:
     case BuiltinType::SatLongFract:
     case BuiltinType::SatULongFract:
       Width = Target->getLongFractWidth();
       Align = Target->getLongFractAlign();
       break;
-    case BuiltinType::BFloat16:
-      if (Target->hasBFloat16Type()) {
-        Width = Target->getBFloat16Width();
-        Align = Target->getBFloat16Align();
+    case BuiltinType::BF16:
+      if (Target->hasBF16Type()) {
+        Width = Target->getBF16Width();
+        Align = Target->getBF16Align();
       } else if ((getLangOpts().SYCLIsDevice ||
                   (getLangOpts().OpenMP && getLangOpts().OpenMPIsDevice)) &&
-                 AuxTarget->hasBFloat16Type()) {
-        Width = AuxTarget->getBFloat16Width();
-        Align = AuxTarget->getBFloat16Align();
+                 AuxTarget->hasBF16Type()) {
+        Width = AuxTarget->getBF16Width();
+        Align = AuxTarget->getBF16Align();
       }
       break;
     case BuiltinType::Float16:
     case BuiltinType::Half:
       if (Target->hasFloat16Type() || !getLangOpts().OpenMP ||
           !getLangOpts().OpenMPIsDevice) {
         Width = Target->getHalfWidth();
         Align = Target->getHalfAlign();
case BuiltinType::SveFloat64:
     return SVE_ELTTY(DoubleTy, 2, 1);
   case BuiltinType::SveFloat64x2:
     return SVE_ELTTY(DoubleTy, 2, 2);
   case BuiltinType::SveFloat64x3:
     return SVE_ELTTY(DoubleTy, 2, 3);
   case BuiltinType::SveFloat64x4:
     return SVE_ELTTY(DoubleTy, 2, 4);
   case BuiltinType::SveBFloat16:
-    return SVE_ELTTY(BFloat16Ty, 8, 1);
+    return SVE_ELTTY(BF16Ty, 8, 1);
   case BuiltinType::SveBFloat16x2:
-    return SVE_ELTTY(BFloat16Ty, 8, 2);
+    return SVE_ELTTY(BF16Ty, 8, 2);
   case BuiltinType::SveBFloat16x3:
-    return SVE_ELTTY(BFloat16Ty, 8, 3);
+    return SVE_ELTTY(BF16Ty, 8, 3);
   case BuiltinType::SveBFloat16x4:
-    return SVE_ELTTY(BFloat16Ty, 8, 4);
+    return SVE_ELTTY(BF16Ty, 8, 4);
 #define RVV_VECTOR_TYPE_INT(Name, Id, SingletonId, NumEls, ElBits, NF,         \
                             IsSigned)                                          \
   case BuiltinType::Id:                                                        \
     return {getIntTypeForBitwidth(ElBits, IsSigned),                           \
             llvm::ElementCount::getScalable(NumEls), NF};
 #define RVV_VECTOR_TYPE_FLOAT(Name, Id, SingletonId, NumEls, ElBits, NF)       \
   case BuiltinType::Id:                                                        \
     return {ElBits == 16 ? Float16Ty : (ElBits == 32 ? FloatTy : DoubleTy),    \
QualType ASTContext::getScalableVectorType(QualType EltTy,
                                            unsigned NumElts) const {
   if (Target->hasAArch64SVETypes()) {
     uint64_t EltTySize = getTypeSize(EltTy);
 #define SVE_VECTOR_TYPE(Name, MangledName, Id, SingletonId, NumEls, ElBits,    \
                         IsSigned, IsFP, IsBF)                                  \
   if (!EltTy->isBooleanType() &&                                               \
       ((EltTy->hasIntegerRepresentation() &&                                   \
         EltTy->hasSignedIntegerRepresentation() == IsSigned) ||                \
-       (EltTy->hasFloatingRepresentation() && !EltTy->isBFloat16Type() &&      \
-        IsFP && !IsBF) ||                                                      \
-       (EltTy->hasFloatingRepresentation() && EltTy->isBFloat16Type() &&       \
-        IsBF && !IsFP)) &&                                                     \
+       (EltTy->hasFloatingRepresentation() && !EltTy->isBF16Type() && IsFP &&  \
+        !IsBF) ||                                                              \
+       (EltTy->hasFloatingRepresentation() && EltTy->isBF16Type() && IsBF &&   \
+        !IsFP)) &&                                                             \
       EltTySize == ElBits && NumElts == NumEls) {                              \
     return SingletonId;                                                        \
   }
 #define SVE_PREDICATE_TYPE(Name, MangledName, Id, SingletonId, NumEls)         \
   if (EltTy->isBooleanType() && NumElts == NumEls)                             \
     return SingletonId;
 #define SVE_OPAQUE_TYPE(Name, MangledName, Id, SingleTonId)
 #include "clang/Basic/AArch64SVEACLETypes.def"
static FloatingRank getFloatingRank(QualType T) {
   switch (T->castAs<BuiltinType>()->getKind()) {
   default: llvm_unreachable("getFloatingRank(): not a floating type");
   case BuiltinType::Float16:    return Float16Rank;
   case BuiltinType::Half:       return HalfRank;
   case BuiltinType::Float:      return FloatRank;
   case BuiltinType::Double:     return DoubleRank;
   case BuiltinType::LongDouble: return LongDoubleRank;
   case BuiltinType::Float128:   return Float128Rank;
-  case BuiltinType::BFloat16:   return BFloat16Rank;
+  case BuiltinType::BF16:       return BF16Rank;
   case BuiltinType::Ibm128:     return Ibm128Rank;
   }
 }
 
 /// 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 {
case BuiltinType::Long:
       return C->getTargetInfo().getLongWidth() == 32 ? 'l' : 'q';
     case BuiltinType::LongLong:   return 'q';
     case BuiltinType::Int128:     return 't';
     case BuiltinType::Float:      return 'f';
     case BuiltinType::Double:     return 'd';
     case BuiltinType::LongDouble: return 'D';
     case BuiltinType::NullPtr:    return '*'; // like char*
 
-    case BuiltinType::BFloat16:
+    case BuiltinType::BF16:
     case BuiltinType::Float16:
     case BuiltinType::Float128:
     case BuiltinType::Ibm128:
     case BuiltinType::Half:
     case BuiltinType::ShortAccum:
     case BuiltinType::Accum:
     case BuiltinType::LongAccum:
     case BuiltinType::UShortAccum:
static QualType DecodeTypeFromStr(const char *&Str, const ASTContext &Context,
   case 'x':
     assert(HowLong == 0 && !Signed && !Unsigned &&
            "Bad modifiers used with 'x'!");
     Type = Context.Float16Ty;
     break;
   case 'y':
     assert(HowLong == 0 && !Signed && !Unsigned &&
            "Bad modifiers used with 'y'!");
-    Type = Context.BFloat16Ty;
+    Type = Context.BF16Ty;
     break;
   case 'v':
     assert(HowLong == 0 && !Signed && !Unsigned &&
            "Bad modifiers used with 'v'!");
     Type = Context.VoidTy;
     break;
   case 'h':
     assert(HowLong == 0 && !Signed && !Unsigned &&

clang/lib/AST/ItaniumMangle.cpp

void CXXNameMangler::mangleType(const BuiltinType *T) {
   case BuiltinType::Float128: {
     const TargetInfo *TI = getASTContext().getLangOpts().OpenMP &&
                                    getASTContext().getLangOpts().OpenMPIsDevice
                                ? getASTContext().getAuxTargetInfo()
                                : &getASTContext().getTargetInfo();
     Out << TI->getFloat128Mangling();
     break;
   }
-  case BuiltinType::BFloat16: {
+  case BuiltinType::BF16: {
     const TargetInfo *TI = ((getASTContext().getLangOpts().OpenMP &&
                              getASTContext().getLangOpts().OpenMPIsDevice) ||
                             getASTContext().getLangOpts().SYCLIsDevice)
                                ? getASTContext().getAuxTargetInfo()
                                : &getASTContext().getTargetInfo();
-    Out << TI->getBFloat16Mangling();
+    Out << TI->getBF16Mangling();
     break;
   }
   case BuiltinType::Ibm128: {
     const TargetInfo *TI = &getASTContext().getTargetInfo();
     Out << TI->getIbm128Mangling();
     break;
   }
   case BuiltinType::NullPtr:
if (T->getVectorKind() == VectorType::NeonPolyVector) {
     case BuiltinType::UShort:    EltName = "uint16_t"; break;
     case BuiltinType::Int:       EltName = "int32_t"; break;
     case BuiltinType::UInt:      EltName = "uint32_t"; break;
     case BuiltinType::LongLong:  EltName = "int64_t"; break;
     case BuiltinType::ULongLong: EltName = "uint64_t"; break;
     case BuiltinType::Double:    EltName = "float64_t"; break;
     case BuiltinType::Float:     EltName = "float32_t"; break;
     case BuiltinType::Half:      EltName = "float16_t"; break;
-    case BuiltinType::BFloat16:  EltName = "bfloat16_t"; break;
+    case BuiltinType::BF16:      EltName = "bfloat16_t"; break;
     default:
       llvm_unreachable("unexpected Neon vector element type");
     }
   }
   const char *BaseName = nullptr;
   unsigned BitSize = (T->getNumElements() *
                       getASTContext().getTypeSize(EltType));
   if (BitSize == 64)
     BaseName = "__simd64_";
static StringRef mangleAArch64VectorBase(const BuiltinType *EltType) {
   case BuiltinType::ULongLong:
     return "Uint64";
   case BuiltinType::Half:
     return "Float16";
   case BuiltinType::Float:
     return "Float32";
   case BuiltinType::Double:
     return "Float64";
-  case BuiltinType::BFloat16:
+  case BuiltinType::BF16:
     return "Bfloat16";
   default:
     llvm_unreachable("Unexpected vector element base type");
   }
 }
 
 // AArch64's ABI for Neon vector types specifies that they should be mangled as
 // the equivalent internal name. The vector type must be one of the special
case BuiltinType::Half:
     TypeName = "__SVFloat16_t";
     break;
   case BuiltinType::Float:
     TypeName = "__SVFloat32_t";
     break;
   case BuiltinType::Double:
     TypeName = "__SVFloat64_t";
     break;
-  case BuiltinType::BFloat16:
+  case BuiltinType::BF16:
     TypeName = "__SVBfloat16_t";
     break;
   default:
     llvm_unreachable("unexpected element type for fixed-length SVE vector!");
   }
 
   unsigned VecSizeInBits = getASTContext().getTypeInfo(T).Width;
 

clang/lib/AST/MicrosoftMangle.cpp

case BuiltinType::Half:
     if (!getASTContext().getLangOpts().HLSL)
       mangleArtificialTagType(TTK_Struct, "_Half", {"__clang"});
     else if (getASTContext().getLangOpts().NativeHalfType)
       Out << "$f16@";
     else
       Out << "$halff@";
     break;
 
-  case BuiltinType::BFloat16:
+  case BuiltinType::BF16:
     mangleArtificialTagType(TTK_Struct, "__bf16", {"__clang"});
     break;
 
 #define WASM_REF_TYPE(InternalName, MangledName, Id, SingletonId, AS)          \
   case BuiltinType::Id:                                                        \
     mangleArtificialTagType(TTK_Struct, MangledName);                          \
     mangleArtificialTagType(TTK_Struct, MangledName, {"__clang"});             \
     break;

clang/lib/AST/NSAPI.cpp

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

clang/lib/AST/PrintfFormatString.cpp

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

clang/lib/AST/Type.cpp

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 &&
-           BT->getKind() != BuiltinType::BFloat16;
+           BT->getKind() != BuiltinType::BF16;
   if (const auto *ET = dyn_cast<EnumType>(CanonicalType))
     // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2).
     // If a body isn't seen by the time we get here, return false.
     //
     // C++0x: Enumerations are not arithmetic types. For now, just return
     // false for scoped enumerations since that will disable any
     // unwanted implicit conversions.
     return !ET->getDecl()->isScoped() && ET->getDecl()->isComplete();
   return isa<ComplexType>(CanonicalType) || isBitIntType();
 }
StringRef BuiltinType::getName(const PrintingPolicy &Policy) const {
   case ULong:
     return "unsigned long";
   case ULongLong:
     return "unsigned long long";
   case UInt128:
     return "unsigned __int128";
   case Half:
     return Policy.Half ? "half" : "__fp16";
-  case BFloat16:
+  case BF16:
     return "__bf16";
   case Float:
     return "float";
   case Double:
     return "double";
   case LongDouble:
     return "long double";
   case ShortAccum:

clang/lib/AST/TypeLoc.cpp

TypeSpecifierType BuiltinTypeLoc::getWrittenTypeSpec() const {
   case BuiltinType::SatUAccum:
   case BuiltinType::SatULongAccum:
   case BuiltinType::SatShortFract:
   case BuiltinType::SatFract:
   case BuiltinType::SatLongFract:
   case BuiltinType::SatUShortFract:
   case BuiltinType::SatUFract:
   case BuiltinType::SatULongFract:
-  case BuiltinType::BFloat16:
+  case BuiltinType::BF16:
     llvm_unreachable("Builtin type needs extra local data!");
     // Fall through, if the impossible happens.
 
   case BuiltinType::NullPtr:
   case BuiltinType::Overload:
   case BuiltinType::Dependent:
   case BuiltinType::BoundMember:
   case BuiltinType::UnknownAny:

clang/lib/Basic/TargetInfo.cpp

TargetInfo::TargetInfo(const llvm::Triple &T) : Triple(T) {
   TLSSupported = true;
   VLASupported = true;
   NoAsmVariants = false;
   HasLegalHalfType = false;
   HalfArgsAndReturns = false;
   HasFloat128 = false;
   HasIbm128 = false;
   HasFloat16 = false;
-  HasBFloat16 = false;
+  HasBF16 = false;
   HasLongDouble = true;
   HasFPReturn = true;
   HasStrictFP = false;
   PointerWidth = PointerAlign = 32;
   BoolWidth = BoolAlign = 8;
   IntWidth = IntAlign = 32;
   LongWidth = LongAlign = 32;
   LongLongWidth = LongLongAlign = 64;

clang/lib/Basic/Targets/AArch64.h

class LLVM_LIBRARY_VISIBILITY AArch64TargetInfo : public TargetInfo {
   bool HasDotProd = false;
   bool HasFP16FML = false;
   bool HasMTE = false;
   bool HasTME = false;
   bool HasPAuth = false;
   bool HasLS64 = false;
   bool HasRandGen = false;
   bool HasMatMul = false;
-  bool HasBFloat16 = false;
+  bool HasBF16 = false;
   bool HasSVE2 = false;
   bool HasSVE2AES = false;
   bool HasSVE2SHA3 = false;
   bool HasSVE2SM4 = false;
   bool HasSVE2BitPerm = false;
   bool HasMatmulFP64 = false;
   bool HasMatmulFP32 = false;
   bool HasLSE = false;
void setFeatureEnabled(llvm::StringMap<bool> &Features, StringRef Name,
                          bool Enabled) const override;
   bool handleTargetFeatures(std::vector<std::string> &Features,
                             DiagnosticsEngine &Diags) override;
   ParsedTargetAttr parseTargetAttr(StringRef Str) const override;
   bool supportsTargetAttributeTune() const override { return true; }
 
   bool checkArithmeticFenceSupported() const override { return true; }
 
-  bool hasBFloat16Type() const override;
+  bool hasBF16Type() const override;
 
   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override;
 
   bool isCLZForZeroUndef() const override;
 
   BuiltinVaListKind getBuiltinVaListKind() const override;
 
   ArrayRef<const char *> getGCCRegNames() const override;
public:
 
   StringRef getConstraintRegister(StringRef Constraint,
                                   StringRef Expression) const override {
     return Expression;
   }
 
   int getEHDataRegisterNumber(unsigned RegNo) const override;
 
-  const char *getBFloat16Mangling() const override { return "u6__bf16"; };
+  const char *getBF16Mangling() const override { return "u6__bf16"; };
   bool hasInt128Type() const override;
 
   bool hasBitIntType() const override { return true; }
 };
 
 class LLVM_LIBRARY_VISIBILITY AArch64leTargetInfo : public AArch64TargetInfo {
 public:
   AArch64leTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);

clang/lib/Basic/Targets/AArch64.cpp

if (*ArchInfo == llvm::AArch64::ARMV8R) {
     HasCRC = true;
     HasLSE = true;
     HasRDM = true;
   } else if (ArchInfo->Version.getMajor() == 8) {
     if (ArchInfo->Version.getMinor() >= 7u) {
       HasWFxT = true;
     }
     if (ArchInfo->Version.getMinor() >= 6u) {
-      HasBFloat16 = true;
+      HasBF16 = true;
       HasMatMul = true;
     }
     if (ArchInfo->Version.getMinor() >= 5u) {
       HasAlternativeNZCV = true;
       HasFRInt3264 = true;
       HasSSBS = true;
       HasSB = true;
       HasPredRes = true;
if (ArchInfo->Version.getMinor() >= 1u) {
       HasLSE = true;
       HasRDM = true;
     }
   } else if (ArchInfo->Version.getMajor() == 9) {
     if (ArchInfo->Version.getMinor() >= 2u) {
       HasWFxT = true;
     }
     if (ArchInfo->Version.getMinor() >= 1u) {
-      HasBFloat16 = true;
+      HasBF16 = true;
       HasMatMul = true;
     }
     FPU |= SveMode;
     HasSVE2 = true;
     HasFullFP16 = true;
     HasAlternativeNZCV = true;
     HasFRInt3264 = true;
     HasSSBS = true;
AArch64TargetInfo::AArch64TargetInfo(const llvm::Triple &Triple,
 
   MaxVectorAlign = 128;
   MaxAtomicInlineWidth = 128;
   MaxAtomicPromoteWidth = 128;
 
   LongDoubleWidth = LongDoubleAlign = SuitableAlign = 128;
   LongDoubleFormat = &llvm::APFloat::IEEEquad();
 
-  BFloat16Width = BFloat16Align = 16;
-  BFloat16Format = &llvm::APFloat::BFloat();
+  BF16Width = BF16Align = 16;
+  BF16Format = &llvm::APFloat::BFloat();
 
   // Make __builtin_ms_va_list available.
   HasBuiltinMSVaList = true;
 
   // Make the SVE types available.  Note that this deliberately doesn't
   // depend on SveMode, since in principle it should be possible to turn
   // SVE on and off within a translation unit.  It should also be possible
   // to compile the global declaration:
if (HasTME)
     Builder.defineMacro("__ARM_FEATURE_TME", "1");
 
   if (HasMatMul)
     Builder.defineMacro("__ARM_FEATURE_MATMUL_INT8", "1");
 
   if (HasLSE)
     Builder.defineMacro("__ARM_FEATURE_ATOMICS", "1");
 
-  if (HasBFloat16) {
+  if (HasBF16) {
     Builder.defineMacro("__ARM_FEATURE_BF16", "1");
     Builder.defineMacro("__ARM_FEATURE_BF16_VECTOR_ARITHMETIC", "1");
     Builder.defineMacro("__ARM_BF16_FORMAT_ALTERNATIVE", "1");
     Builder.defineMacro("__ARM_FEATURE_BF16_SCALAR_ARITHMETIC", "1");
   }
 
-  if ((FPU & SveMode) && HasBFloat16) {
+  if ((FPU & SveMode) && HasBF16) {
     Builder.defineMacro("__ARM_FEATURE_SVE_BF16", "1");
   }
 
   if ((FPU & SveMode) && HasMatmulFP64)
     Builder.defineMacro("__ARM_FEATURE_SVE_MATMUL_FP64", "1");
 
   if ((FPU & SveMode) && HasMatmulFP32)
     Builder.defineMacro("__ARM_FEATURE_SVE_MATMUL_FP32", "1");
return llvm::StringSwitch<bool>(Feature)
       .Cases("aes", "pmull", HasAES)
       .Cases("fp16", "fullfp16", HasFullFP16)
       .Case("dit", HasDIT)
       .Case("dpb", HasCCPP)
       .Case("dpb2", HasCCDP)
       .Case("rcpc", HasRCPC)
       .Case("frintts", HasFRInt3264)
       .Case("i8mm", HasMatMul)
-      .Case("bf16", HasBFloat16)
+      .Case("bf16", HasBF16)
       .Case("sve", FPU & SveMode)
-      .Case("sve-bf16", FPU & SveMode && HasBFloat16)
+      .Case("sve-bf16", FPU & SveMode && HasBF16)
       .Case("sve-i8mm", FPU & SveMode && HasMatMul)
       .Case("f32mm", FPU & SveMode && HasMatmulFP32)
       .Case("f64mm", FPU & SveMode && HasMatmulFP64)
       .Case("sve2", FPU & SveMode && HasSVE2)
       .Case("sve2-pmull128", FPU & SveMode && HasSVE2AES)
       .Case("sve2-bitperm", FPU & SveMode && HasSVE2BitPerm)
       .Case("sve2-sha3", FPU & SveMode && HasSVE2SHA3)
       .Case("sve2-sm4", FPU & SveMode && HasSVE2SM4)
for (const auto &Feature : Features) {
     if (Feature == "+f64mm") {
       FPU |= NeonMode;
       FPU |= SveMode;
       HasFullFP16 = true;
       HasMatmulFP64 = true;
     }
     if (Feature == "+sme") {
       HasSME = true;
-      HasBFloat16 = true;
+      HasBF16 = true;
     }
     if (Feature == "+sme-f64f64") {
       HasSME = true;
       HasSMEF64F64 = true;
-      HasBFloat16 = true;
+      HasBF16 = true;
     }
     if (Feature == "+sme-i16i64") {
       HasSME = true;
       HasSMEI16I64 = true;
-      HasBFloat16 = true;
+      HasBF16 = true;
     }
     if (Feature == "+sb")
       HasSB = true;
     if (Feature == "+predres")
       HasPredRes = true;
     if (Feature == "+ssbs")
       HasSSBS = true;
     if (Feature == "+bti")
if (Feature == "+mte")
       HasMTE = true;
     if (Feature == "+tme")
       HasTME = true;
     if (Feature == "+pauth")
       HasPAuth = true;
     if (Feature == "+i8mm")
       HasMatMul = true;
     if (Feature == "+bf16")
-      HasBFloat16 = true;
+      HasBF16 = true;
     if (Feature == "+lse")
       HasLSE = true;
     if (Feature == "+ls64")
       HasLS64 = true;
     if (Feature == "+rand")
       HasRandGen = true;
     if (Feature == "+flagm")
       HasFlagM = true;
if (Feature.startswith("arch=")) {
         Ret.Features.push_back(FeatureName.str());
       else
         Ret.Features.push_back("+" + Feature.str());
     }
   }
   return Ret;
 }
 
-bool AArch64TargetInfo::hasBFloat16Type() const {
-  return true;
-}
+bool AArch64TargetInfo::hasBF16Type() const { return true; }
 
 TargetInfo::CallingConvCheckResult
 AArch64TargetInfo::checkCallingConvention(CallingConv CC) const {
   switch (CC) {
   case CC_C:
   case CC_Swift:
   case CC_SwiftAsync:
   case CC_PreserveMost:

clang/lib/Basic/Targets/AMDGPU.h

public:
   uint64_t getPointerAlignV(LangAS AddrSpace) const override {
     return getPointerWidthV(AddrSpace);
   }
 
   uint64_t getMaxPointerWidth() const override {
     return getTriple().getArch() == llvm::Triple::amdgcn ? 64 : 32;
   }
 
-  bool hasBFloat16Type() const override { return isAMDGCN(getTriple()); }
-  const char *getBFloat16Mangling() const override { return "u6__bf16"; };
+  bool hasBF16Type() const override { return isAMDGCN(getTriple()); }
+  const char *getBF16Mangling() const override { return "u6__bf16"; };
 
   std::string_view getClobbers() const override { return ""; }
 
   ArrayRef<const char *> getGCCRegNames() const override;
 
   ArrayRef<TargetInfo::GCCRegAlias> getGCCRegAliases() const override {
     return std::nullopt;
   }

clang/lib/Basic/Targets/AMDGPU.cpp

resetDataLayout(isAMDGCN(getTriple()) ? DataLayoutStringAMDGCN
                                         : DataLayoutStringR600);
 
   setAddressSpaceMap(Triple.getOS() == llvm::Triple::Mesa3D ||
                      !isAMDGCN(Triple));
   UseAddrSpaceMapMangling = true;
 
   if (isAMDGCN(Triple)) {
     // __bf16 is always available as a load/store only type on AMDGCN.
-    BFloat16Width = BFloat16Align = 16;
-    BFloat16Format = &llvm::APFloat::BFloat();
+    BF16Width = BF16Align = 16;
+    BF16Format = &llvm::APFloat::BFloat();
   }
 
   HasLegalHalfType = true;
   HasFloat16 = true;
   WavefrontSize = GPUFeatures & llvm::AMDGPU::FEATURE_WAVE32 ? 32 : 64;
   AllowAMDGPUUnsafeFPAtomics = Opts.AllowAMDGPUUnsafeFPAtomics;
 
   // Set pointer width and alignment for the generic address space.

clang/lib/Basic/Targets/ARM.h

bool isValidFeatureName(StringRef Feature) const override {
     return Feature != "soft-float-abi";
   }
 
   bool handleTargetFeatures(std::vector<std::string> &Features,
                             DiagnosticsEngine &Diags) override;
 
   bool hasFeature(StringRef Feature) const override;
 
-  bool hasBFloat16Type() const override;
+  bool hasBF16Type() const override;
 
   bool isValidCPUName(StringRef Name) const override;
   void fillValidCPUList(SmallVectorImpl<StringRef> &Values) const override;
 
   bool setCPU(const std::string &Name) override;
 
   bool setFPMath(StringRef Name) override;
 
public:
   CallingConvCheckResult checkCallingConvention(CallingConv CC) const override;
 
   int getEHDataRegisterNumber(unsigned RegNo) const override;
 
   bool hasSjLjLowering() const override;
 
   bool hasBitIntType() const override { return true; }
 
-  const char *getBFloat16Mangling() const override { return "u6__bf16"; };
+  const char *getBF16Mangling() const override { return "u6__bf16"; };
 };
 
 class LLVM_LIBRARY_VISIBILITY ARMleTargetInfo : public ARMTargetInfo {
 public:
   ARMleTargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts);
   void getTargetDefines(const LangOptions &Opts,
                         MacroBuilder &Builder) const override;
 };

clang/lib/Basic/Targets/ARM.cpp

 
 using namespace clang;
 using namespace clang::targets;
 
 void ARMTargetInfo::setABIAAPCS() {
   IsAAPCS = true;
 
   DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
-  BFloat16Width = BFloat16Align = 16;
-  BFloat16Format = &llvm::APFloat::BFloat();
+  BF16Width = BF16Align = 16;
+  BF16Format = &llvm::APFloat::BFloat();
 
   const llvm::Triple &T = getTriple();
 
   bool IsNetBSD = T.isOSNetBSD();
   bool IsOpenBSD = T.isOSOpenBSD();
   if (!T.isOSWindows() && !IsNetBSD && !IsOpenBSD)
     WCharType = UnsignedInt;
 
void ARMTargetInfo::setABIAPCS(bool IsAAPCS16) {
   const llvm::Triple &T = getTriple();
 
   IsAAPCS = false;
 
   if (IsAAPCS16)
     DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 64;
   else
     DoubleAlign = LongLongAlign = LongDoubleAlign = SuitableAlign = 32;
-  BFloat16Width = BFloat16Align = 16;
-  BFloat16Format = &llvm::APFloat::BFloat();
+  BF16Width = BF16Align = 16;
+  BF16Format = &llvm::APFloat::BFloat();
 
   WCharType = SignedInt;
 
   // Do not respect the alignment of bit-field types when laying out
   // structures. This corresponds to PCC_BITFIELD_TYPE_MATTERS in gcc.
   UseBitFieldTypeAlignment = false;
 
   /// gcc forces the alignment to 4 bytes, regardless of the type of the
bool ARMTargetInfo::handleTargetFeatures(std::vector<std::string> &Features,
   // Note that SoftFloatABI is initialized in our constructor.
   HWDiv = 0;
   DotProd = 0;
   HasMatMul = 0;
   HasPAC = 0;
   HasBTI = 0;
   HasFloat16 = true;
   ARMCDECoprocMask = 0;
-  HasBFloat16 = false;
+  HasBF16 = false;
   FPRegsDisabled = false;
 
   // This does not diagnose illegal cases like having both
   // "+vfpv2" and "+vfpv3" or having "+neon" and "-fp64".
   for (const auto &Feature : Features) {
     if (Feature == "+soft-float") {
       SoftFloat = true;
     } else if (Feature == "+vfp2sp" || Feature == "+vfp2") {
if (Feature == "+soft-float") {
       HW_FP |= HW_FP_SP | HW_FP_HP;
     } else if (Feature == "+i8mm") {
       HasMatMul = 1;
     } else if (Feature.size() == strlen("+cdecp0") && Feature >= "+cdecp0" &&
                Feature <= "+cdecp7") {
       unsigned Coproc = Feature.back() - '0';
       ARMCDECoprocMask |= (1U << Coproc);
     } else if (Feature == "+bf16") {
-      HasBFloat16 = true;
+      HasBF16 = true;
     } else if (Feature == "-fpregs") {
       FPRegsDisabled = true;
     } else if (Feature == "+pacbti") {
       HasPAC = 1;
       HasBTI = 1;
     }
   }
 
return llvm::StringSwitch<bool>(Feature)
       .Case("neon", (FPU & NeonFPU) && !SoftFloat)
       .Case("vfp", FPU && !SoftFloat)
       .Case("hwdiv", HWDiv & HWDivThumb)
       .Case("hwdiv-arm", HWDiv & HWDivARM)
       .Case("mve", hasMVE())
       .Default(false);
 }
 
-bool ARMTargetInfo::hasBFloat16Type() const {
+bool ARMTargetInfo::hasBF16Type() const {
   // The __bf16 type is generally available so long as we have any fp registers.
-  return HasBFloat16 || (FPU && !SoftFloat);
+  return HasBF16 || (FPU && !SoftFloat);
 }
 
 bool ARMTargetInfo::isValidCPUName(StringRef Name) const {
   return Name == "generic" ||
          llvm::ARM::parseCPUArch(Name) != llvm::ARM::ArchKind::INVALID;
 }
 
 void ARMTargetInfo::fillValidCPUList(SmallVectorImpl<StringRef> &Values) const {
if (HasMatMul)
     Builder.defineMacro("__ARM_FEATURE_MATMUL_INT8", "1");
 
   if (HasPAC)
     Builder.defineMacro("__ARM_FEATURE_PAUTH", "1");
 
   if (HasBTI)
     Builder.defineMacro("__ARM_FEATURE_BTI", "1");
 
-  if (HasBFloat16) {
+  if (HasBF16) {
     Builder.defineMacro("__ARM_FEATURE_BF16", "1");
     Builder.defineMacro("__ARM_FEATURE_BF16_VECTOR_ARITHMETIC", "1");
     Builder.defineMacro("__ARM_BF16_FORMAT_ALTERNATIVE", "1");
   }
 
   if (Opts.BranchTargetEnforcement)
     Builder.defineMacro("__ARM_FEATURE_BTI_DEFAULT", "1");
 

clang/lib/Basic/Targets/NVPTX.h

CallingConvCheckResult checkCallingConvention(CallingConv CC) const override {
     // TODO: We should warn if you apply a non-default CC to anything other than
     // a host function.
     if (HostTarget)
       return HostTarget->checkCallingConvention(CC);
     return CCCR_Warning;
   }
 
   bool hasBitIntType() const override { return true; }
-  bool hasBFloat16Type() const override { return true; }
-  const char *getBFloat16Mangling() const override { return "u6__bf16"; };
+  bool hasBF16Type() const override { return true; }
+  const char *getBF16Mangling() const override { return "u6__bf16"; };
 };
 } // namespace targets
 } // namespace clang
 #endif // LLVM_CLANG_LIB_BASIC_TARGETS_NVPTX_H

clang/lib/Basic/Targets/NVPTX.cpp

for (const StringRef Feature : Opts.FeaturesAsWritten) {
     PTXVersion = PTXV; // TODO: should it be max(PTXVersion, PTXV)?
   }
 
   TLSSupported = false;
   VLASupported = false;
   AddrSpaceMap = &NVPTXAddrSpaceMap;
   UseAddrSpaceMapMangling = true;
   // __bf16 is always available as a load/store only type.
-  BFloat16Width = BFloat16Align = 16;
-  BFloat16Format = &llvm::APFloat::BFloat();
+  BF16Width = BF16Align = 16;
+  BF16Format = &llvm::APFloat::BFloat();
 
   // Define available target features
   // These must be defined in sorted order!
   NoAsmVariants = true;
   GPU = CudaArch::SM_20;
 
   if (TargetPointerWidth == 32)
     resetDataLayout("e-p:32:32-i64:64-i128:128-v16:16-v32:32-n16:32:64");

clang/lib/Basic/Targets/X86.h

 protected:
   llvm::X86::CPUKind CPU = llvm::X86::CK_None;
 
   enum FPMathKind { FP_Default, FP_SSE, FP_387 } FPMath = FP_Default;
 
 public:
   X86TargetInfo(const llvm::Triple &Triple, const TargetOptions &)
       : TargetInfo(Triple) {
-    BFloat16Width = BFloat16Align = 16;
-    BFloat16Format = &llvm::APFloat::BFloat();
+    BF16Width = BF16Align = 16;
+    BF16Format = &llvm::APFloat::BFloat();
     LongDoubleFormat = &llvm::APFloat::x87DoubleExtended();
     AddrSpaceMap = &X86AddrSpaceMap;
     HasStrictFP = true;
 
     bool IsWinCOFF =
         getTriple().isOSWindows() && getTriple().isOSBinFormatCOFF();
     if (IsWinCOFF)
       MaxVectorAlign = MaxTLSAlign = 8192u * getCharWidth();
if (TargetAddrSpace == ptr64)
       return 64;
     return PointerWidth;
   }
 
   uint64_t getPointerAlignV(LangAS AddrSpace) const override {
     return getPointerWidthV(AddrSpace);
   }
 
-  const char *getBFloat16Mangling() const override { return "u6__bf16"; };
+  const char *getBF16Mangling() const override { return "u6__bf16"; };
 };
 
 // X86-32 generic target
 class LLVM_LIBRARY_VISIBILITY X86_32TargetInfo : public X86TargetInfo {
 public:
   X86_32TargetInfo(const llvm::Triple &Triple, const TargetOptions &Opts)
       : X86TargetInfo(Triple, Opts) {
     DoubleAlign = LongLongAlign = 32;

clang/lib/Basic/Targets/X86.cpp

X86SSEEnum Level = llvm::StringSwitch<X86SSEEnum>(Feature)
                            .Case("+sse3", SSE3)
                            .Case("+sse2", SSE2)
                            .Case("+sse", SSE1)
                            .Default(NoSSE);
     SSELevel = std::max(SSELevel, Level);
 
     HasFloat16 = SSELevel >= SSE2;
 
-    HasBFloat16 = SSELevel >= SSE2;
+    HasBF16 = SSELevel >= SSE2;
 
     MMX3DNowEnum ThreeDNowLevel = llvm::StringSwitch<MMX3DNowEnum>(Feature)
                                       .Case("+3dnowa", AMD3DNowAthlon)
                                       .Case("+3dnow", AMD3DNow)
                                       .Case("+mmx", MMX)
                                       .Default(NoMMX3DNow);
     MMX3DNowLevel = std::max(MMX3DNowLevel, ThreeDNowLevel);
 

clang/lib/CodeGen/ABIInfo.h

protected:
     CodeGen::CodeGenTypes &CGT;
     llvm::CallingConv::ID RuntimeCC;
   public:
     ABIInfo(CodeGen::CodeGenTypes &cgt)
         : CGT(cgt), RuntimeCC(llvm::CallingConv::C) {}
 
     virtual ~ABIInfo();
 
-    virtual bool allowBFloatArgsAndRet() const { return false; }
+    virtual bool allowBF16ArgsAndRet() const { return false; }
 
     CodeGen::CGCXXABI &getCXXABI() const;
     ASTContext &getContext() const;
     llvm::LLVMContext &getVMContext() const;
     const llvm::DataLayout &getDataLayout() const;
     const TargetInfo &getTarget() const;
     const CodeGenOptions &getCodeGenOpts() const;
 

clang/lib/CodeGen/CGBuiltin.cpp

Value *CodeGenFunction::EmitTargetBuiltinExpr(unsigned BuiltinID,
   return EmitTargetArchBuiltinExpr(this, BuiltinID, E, ReturnValue,
                                    getTarget().getTriple().getArch());
 }
 
 static llvm::FixedVectorType *GetNeonType(CodeGenFunction *CGF,
                                           NeonTypeFlags TypeFlags,
                                           bool HasLegalHalfType = true,
                                           bool V1Ty = false,
-                                          bool AllowBFloatArgsAndRet = true) {
+                                          bool AllowBF16ArgsAndRet = true) {
   int IsQuad = TypeFlags.isQuad();
   switch (TypeFlags.getEltType()) {
   case NeonTypeFlags::Int8:
   case NeonTypeFlags::Poly8:
     return llvm::FixedVectorType::get(CGF->Int8Ty, V1Ty ? 1 : (8 << IsQuad));
   case NeonTypeFlags::Int16:
   case NeonTypeFlags::Poly16:
     return llvm::FixedVectorType::get(CGF->Int16Ty, V1Ty ? 1 : (4 << IsQuad));
   case NeonTypeFlags::BFloat16:
-    if (AllowBFloatArgsAndRet)
+    if (AllowBF16ArgsAndRet)
       return llvm::FixedVectorType::get(CGF->BFloatTy, V1Ty ? 1 : (4 << IsQuad));
     else
       return llvm::FixedVectorType::get(CGF->Int16Ty, V1Ty ? 1 : (4 << IsQuad));
   case NeonTypeFlags::Float16:
     if (HasLegalHalfType)
       return llvm::FixedVectorType::get(CGF->HalfTy, V1Ty ? 1 : (4 << IsQuad));
     else
       return llvm::FixedVectorType::get(CGF->Int16Ty, V1Ty ? 1 : (4 << IsQuad));
Value *CodeGenFunction::EmitCommonNeonBuiltinExpr(
   if (!NeonTypeConst)
     return nullptr;
 
   // Determine the type of this overloaded NEON intrinsic.
   NeonTypeFlags Type(NeonTypeConst->getZExtValue());
   bool Usgn = Type.isUnsigned();
   bool Quad = Type.isQuad();
   const bool HasLegalHalfType = getTarget().hasLegalHalfType();
-  const bool AllowBFloatArgsAndRet =
-      getTargetHooks().getABIInfo().allowBFloatArgsAndRet();
+  const bool AllowBF16ArgsAndRet =
+      getTargetHooks().getABIInfo().allowBF16ArgsAndRet();
 
   llvm::FixedVectorType *VTy =
-      GetNeonType(this, Type, HasLegalHalfType, false, AllowBFloatArgsAndRet);
+      GetNeonType(this, Type, HasLegalHalfType, false, AllowBF16ArgsAndRet);
   llvm::Type *Ty = VTy;
   if (!Ty)
     return nullptr;
 
   auto getAlignmentValue32 = [&](Address addr) -> Value* {
     return Builder.getInt32(addr.getAlignment().getQuantity());
   };
 
Value *CodeGenFunction::EmitARMBuiltinExpr(unsigned BuiltinID,
 
   // Determine the type of this overloaded NEON intrinsic.
   NeonTypeFlags Type = Result->getZExtValue();
   bool usgn = Type.isUnsigned();
   bool rightShift = false;
 
   llvm::FixedVectorType *VTy =
       GetNeonType(this, Type, getTarget().hasLegalHalfType(), false,
-                  getTarget().hasBFloat16Type());
+                  getTarget().hasBF16Type());
   llvm::Type *Ty = VTy;
   if (!Ty)
     return nullptr;
 
   // Many NEON builtins have identical semantics and uses in ARM and
   // AArch64. Emit these in a single function.
   auto IntrinsicMap = ArrayRef(ARMSIMDIntrinsicMap);
   const ARMVectorIntrinsicInfo *Builtin = findARMVectorIntrinsicInMap(

clang/lib/CodeGen/CGDebugInfo.cpp

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

clang/lib/CodeGen/CodeGenTypes.cpp

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

clang/lib/CodeGen/ItaniumCXXABI.cpp

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

clang/lib/CodeGen/TargetInfo.cpp

if (const BuiltinType *BT = Ty->getAs<BuiltinType>()) {
     if (k == BuiltinType::Void) {
       Current = NoClass;
     } else if (k == BuiltinType::Int128 || k == BuiltinType::UInt128) {
       Lo = Integer;
       Hi = Integer;
     } else if (k >= BuiltinType::Bool && k <= BuiltinType::LongLong) {
       Current = Integer;
     } else if (k == BuiltinType::Float || k == BuiltinType::Double ||
-               k == BuiltinType::Float16 || k == BuiltinType::BFloat16) {
+               k == BuiltinType::Float16 || k == BuiltinType::BF16) {
       Current = SSE;
     } else if (k == BuiltinType::LongDouble) {
       const llvm::fltSemantics *LDF = &getTarget().getLongDoubleFormat();
       if (LDF == &llvm::APFloat::IEEEquad()) {
         Lo = SSE;
         Hi = SSEUp;
       } else if (LDF == &llvm::APFloat::x87DoubleExtended()) {
         Lo = X87;
if (const ComplexType *CT = Ty->getAs<ComplexType>()) {
 
     uint64_t Size = getContext().getTypeSize(Ty);
     if (ET->isIntegralOrEnumerationType()) {
       if (Size <= 64)
         Current = Integer;
       else if (Size <= 128)
         Lo = Hi = Integer;
     } else if (ET->isFloat16Type() || ET == getContext().FloatTy ||
-               ET->isBFloat16Type()) {
+               ET->isBF16Type()) {
       Current = SSE;
     } else if (ET == getContext().DoubleTy) {
       Lo = Hi = SSE;
     } else if (ET == getContext().LongDoubleTy) {
       const llvm::fltSemantics *LDF = &getTarget().getLongDoubleFormat();
       if (LDF == &llvm::APFloat::IEEEquad())
         Current = Memory;
       else if (LDF == &llvm::APFloat::x87DoubleExtended())
Address EmitVAArg(CodeGenFunction &CGF, Address VAListAddr,
 
     return Kind == Win64 ? EmitMSVAArg(CGF, VAListAddr, Ty)
                          : isDarwinPCS() ? EmitDarwinVAArg(VAListAddr, Ty, CGF)
                                          : EmitAAPCSVAArg(VAListAddr, Ty, CGF);
   }
 
   Address EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr,
                       QualType Ty) const override;
 
-  bool allowBFloatArgsAndRet() const override {
-    return getTarget().hasBFloat16Type();
+  bool allowBF16ArgsAndRet() const override {
+    return getTarget().hasBF16Type();
   }
 };
 
 class AArch64SwiftABIInfo : public SwiftABIInfo {
 public:
   explicit AArch64SwiftABIInfo(CodeGenTypes &CGT)
       : SwiftABIInfo(CGT, /*SwiftErrorInRegister=*/true) {}
 
if (VT->getVectorKind() == VectorType::SveFixedLengthDataVector) {
     case BuiltinType::Float:
       ResType = llvm::ScalableVectorType::get(
           llvm::Type::getFloatTy(getVMContext()), 4);
       break;
     case BuiltinType::Double:
       ResType = llvm::ScalableVectorType::get(
           llvm::Type::getDoubleTy(getVMContext()), 2);
       break;
-    case BuiltinType::BFloat16:
+    case BuiltinType::BF16:
       ResType = llvm::ScalableVectorType::get(
           llvm::Type::getBFloatTy(getVMContext()), 8);
       break;
     }
     return ABIArgInfo::getDirect(ResType);
   }
 
   uint64_t Size = getContext().getTypeSize(Ty);
case llvm::Triple::MuslEABIHF:
       return true;
     default:
       return false;
     }
   }
 
   ABIKind getABIKind() const { return Kind; }
 
-  bool allowBFloatArgsAndRet() const override {
-    return !IsFloatABISoftFP && getTarget().hasBFloat16Type();
+  bool allowBF16ArgsAndRet() const override {
+    return !IsFloatABISoftFP && getTarget().hasBF16Type();
   }
 
 private:
   ABIArgInfo classifyReturnType(QualType RetTy, bool isVariadic,
                                 unsigned functionCallConv) const;
   ABIArgInfo classifyArgumentType(QualType RetTy, bool isVariadic,
                                   unsigned functionCallConv) const;
   ABIArgInfo classifyHomogeneousAggregate(QualType Ty, const Type *Base,
ABIArgInfo ARMABIInfo::classifyReturnType(QualType RetTy, bool isVariadic,
 
   if (const VectorType *VT = RetTy->getAs<VectorType>()) {
     // Large vector types should be returned via memory.
     if (getContext().getTypeSize(RetTy) > 128)
       return getNaturalAlignIndirect(RetTy);
     // TODO: FP16/BF16 vectors should be converted to integer vectors
     // This check is similar  to isIllegalVectorType - refactor?
     if ((!getTarget().hasLegalHalfType() &&
          (VT->getElementType()->isFloat16Type() ||
           VT->getElementType()->isHalfType())) ||
-        (IsFloatABISoftFP &&
-         VT->getElementType()->isBFloat16Type()))
+        (IsFloatABISoftFP && VT->getElementType()->isBF16Type()))
       return coerceIllegalVector(RetTy);
   }
 
   if (!isAggregateTypeForABI(RetTy)) {
     // Treat an enum type as its underlying type.
     if (const EnumType *EnumTy = RetTy->getAs<EnumType>())
       RetTy = EnumTy->getDecl()->getIntegerType();
 
bool ARMABIInfo::isIllegalVectorType(QualType Ty) const {
   if (const VectorType *VT = Ty->getAs<VectorType> ()) {
     // On targets that don't support half, fp16 or bfloat, they are expanded
     // into float, and we don't want the ABI to depend on whether or not they
     // are supported in hardware. Thus return false to coerce vectors of these
     // types into integer vectors.
     // We do not depend on hasLegalHalfType for bfloat as it is a
     // separate IR type.
     if ((!getTarget().hasLegalHalfType() &&
          (VT->getElementType()->isFloat16Type() ||
           VT->getElementType()->isHalfType())) ||
-        (IsFloatABISoftFP &&
-         VT->getElementType()->isBFloat16Type()))
+        (IsFloatABISoftFP && VT->getElementType()->isBF16Type()))
       return true;
     if (isAndroid()) {
       // Android shipped using Clang 3.1, which supported a slightly different
       // vector ABI. The primary differences were that 3-element vector types
       // were legal, and so were sub 32-bit vectors (i.e. <2 x i8>). This path
       // accepts that legacy behavior for Android only.
       // Check whether VT is legal.
       unsigned NumElements = VT->getNumElements();
if (llvm::any_of(RD->fields(), [this](FieldDecl *FD) {
           return FD && containsAnyFP16Vectors(FD->getType());
         }))
       return true;
 
     return false;
   } else {
     if (const VectorType *VT = Ty->getAs<VectorType>())
       return (VT->getElementType()->isFloat16Type() ||
-              VT->getElementType()->isBFloat16Type() ||
+              VT->getElementType()->isBF16Type() ||
               VT->getElementType()->isHalfType());
     return false;
   }
 }
 
 bool ARMSwiftABIInfo::isLegalVectorType(CharUnits VectorSize, llvm::Type *EltTy,
                                         unsigned NumElts) const {
   if (!llvm::isPowerOf2_32(NumElts))

clang/lib/Index/USRGeneration.cpp

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

clang/lib/Parse/ParseDecl.cpp

case tok::kw___int128:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec,
                                      DiagID, Policy);
       break;
     case tok::kw_half:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec,
                                      DiagID, Policy);
       break;
     case tok::kw___bf16:
-      isInvalid = DS.SetTypeSpecType(DeclSpec::TST_BFloat16, Loc, PrevSpec,
-                                     DiagID, Policy);
+      isInvalid =
+          DS.SetTypeSpecType(DeclSpec::TST_BF16, Loc, PrevSpec, DiagID, Policy);
       break;
     case tok::kw_float:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec,
                                      DiagID, Policy);
       break;
     case tok::kw_double:
       isInvalid = DS.SetTypeSpecType(DeclSpec::TST_double, Loc, PrevSpec,
                                      DiagID, Policy);

clang/lib/Parse/ParseExprCXX.cpp

case tok::kw_char:
     break;
   case tok::kw_int:
     DS.SetTypeSpecType(DeclSpec::TST_int, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw___int128:
     DS.SetTypeSpecType(DeclSpec::TST_int128, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw___bf16:
-    DS.SetTypeSpecType(DeclSpec::TST_BFloat16, Loc, PrevSpec, DiagID, Policy);
+    DS.SetTypeSpecType(DeclSpec::TST_BF16, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw_half:
     DS.SetTypeSpecType(DeclSpec::TST_half, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw_float:
     DS.SetTypeSpecType(DeclSpec::TST_float, Loc, PrevSpec, DiagID, Policy);
     break;
   case tok::kw_double:

clang/lib/Sema/DeclSpec.cpp

switch (DS.getTypeSpecType()) {
     case TST_bitint:
     case TST_struct:
     case TST_interface:
     case TST_union:
     case TST_unknown_anytype:
     case TST_unspecified:
     case TST_void:
     case TST_wchar:
-    case TST_BFloat16:
+    case TST_BF16:
 #define GENERIC_IMAGE_TYPE(ImgType, Id) case TST_##ImgType##_t:
 #include "clang/Basic/OpenCLImageTypes.def"
       return false;
 
     case TST_decltype_auto:
       // This must have an initializer, so can't be a function declaration,
       // even if the initializer has function type.
       return false;
const char *DeclSpec::getSpecifierName(DeclSpec::TST T,
   case DeclSpec::TST_decltype:    return "(decltype)";
   case DeclSpec::TST_decltype_auto: return "decltype(auto)";
 #define TRANSFORM_TYPE_TRAIT_DEF(_, Trait)                                     \
   case DeclSpec::TST_##Trait:                                                  \
     return "__" #Trait;
 #include "clang/Basic/TransformTypeTraits.def"
   case DeclSpec::TST_unknown_anytype: return "__unknown_anytype";
   case DeclSpec::TST_atomic: return "_Atomic";
-  case DeclSpec::TST_BFloat16: return "__bf16";
+  case DeclSpec::TST_BF16: return "__bf16";
 #define GENERIC_IMAGE_TYPE(ImgType, Id) \
   case DeclSpec::TST_##ImgType##_t: \
     return #ImgType "_t";
 #include "clang/Basic/OpenCLImageTypes.def"
   case DeclSpec::TST_error:       return "(error)";
   }
   llvm_unreachable("Unknown typespec!");
 }
 

clang/lib/Sema/Sema.cpp

if (Ty->isRealFloatingType() && Context.getTypeSize(Ty) == 128) {
         LongDoubleMismatched = true;
     }
 
     if ((Ty->isFloat16Type() && !Context.getTargetInfo().hasFloat16Type()) ||
         (Ty->isFloat128Type() && !Context.getTargetInfo().hasFloat128Type()) ||
         (Ty->isIbm128Type() && !Context.getTargetInfo().hasIbm128Type()) ||
         (Ty->isIntegerType() && Context.getTypeSize(Ty) == 128 &&
          !Context.getTargetInfo().hasInt128Type()) ||
-        (Ty->isBFloat16Type() && !Context.getTargetInfo().hasBFloat16Type() &&
+        (Ty->isBF16Type() && !Context.getTargetInfo().hasBF16Type() &&
          !LangOpts.CUDAIsDevice) ||
         LongDoubleMismatched) {
       PartialDiagnostic PD = PDiag(diag::err_target_unsupported_type);
       if (D)
         PD << D;
       else
         PD << "expression";
 

clang/lib/Sema/SemaCast.cpp

void CastOperation::CheckCStyleCast() {
 
   if (isa<ObjCSelectorExpr>(SrcExpr.get())) {
     Self.Diag(SrcExpr.get()->getExprLoc(), diag::err_cast_selector_expr);
     SrcExpr = ExprError();
     return;
   }
 
   // Can't cast to or from bfloat
-  if (DestType->isBFloat16Type() && !SrcType->isBFloat16Type()) {
-    Self.Diag(SrcExpr.get()->getExprLoc(), diag::err_cast_to_bfloat16)
+  if (DestType->isBF16Type() && !SrcType->isBF16Type()) {
+    Self.Diag(SrcExpr.get()->getExprLoc(), diag::err_cast_to_bf16)
         << SrcExpr.get()->getSourceRange();
     SrcExpr = ExprError();
     return;
   }
-  if (SrcType->isBFloat16Type() && !DestType->isBFloat16Type()) {
-    Self.Diag(SrcExpr.get()->getExprLoc(), diag::err_cast_from_bfloat16)
+  if (SrcType->isBF16Type() && !DestType->isBF16Type()) {
+    Self.Diag(SrcExpr.get()->getExprLoc(), diag::err_cast_from_bf16)
         << SrcExpr.get()->getSourceRange();
     SrcExpr = ExprError();
     return;
   }
 
   // If either type is a pointer, the other type has to be either an
   // integer or a pointer.
   if (!DestType->isArithmeticType()) {

clang/lib/Sema/SemaChecking.cpp

case NeonTypeFlags::Poly128:
     break;
   case NeonTypeFlags::Float16:
     return Context.HalfTy;
   case NeonTypeFlags::Float32:
     return Context.FloatTy;
   case NeonTypeFlags::Float64:
     return Context.DoubleTy;
   case NeonTypeFlags::BFloat16:
-    return Context.BFloat16Ty;
+    return Context.BF16Ty;
   }
   llvm_unreachable("Invalid NeonTypeFlag!");
 }
 
 bool Sema::CheckSVEBuiltinFunctionCall(unsigned BuiltinID, CallExpr *TheCall) {
   // Range check SVE intrinsics that take immediate values.
   SmallVector<std::tuple<int,int,int>, 3> ImmChecks;
 

clang/lib/Sema/SemaExpr.cpp

if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) {
 
     LHS = ImpCastExprToType(LHS.get(), ResTy, PrepareScalarCast(LHS, ResTy));
     RHS = ImpCastExprToType(RHS.get(), ResTy, PrepareScalarCast(RHS, ResTy));
 
     return ResTy;
   }
 
   // And if they're both bfloat (which isn't arithmetic), that's fine too.
-  if (LHSTy->isBFloat16Type() && RHSTy->isBFloat16Type()) {
+  if (LHSTy->isBF16Type() && RHSTy->isBF16Type()) {
     return Context.getCommonSugaredType(LHSTy, RHSTy);
   }
 
   // If both operands are the same structure or union type, the result is that
   // type.
   if (const RecordType *LHSRT = LHSTy->getAs<RecordType>()) {    // C99 6.5.15p3
     if (const RecordType *RHSRT = RHSTy->getAs<RecordType>())
       if (LHSRT->getDecl() == RHSRT->getDecl())
QualType Sema::CheckVectorOperands(ExprResult &LHS, ExprResult &RHS,
   // For example, "const float" and "float" are equivalent.
   QualType LHSType = LHS.get()->getType().getUnqualifiedType();
   QualType RHSType = RHS.get()->getType().getUnqualifiedType();
 
   const VectorType *LHSVecType = LHSType->getAs<VectorType>();
   const VectorType *RHSVecType = RHSType->getAs<VectorType>();
   assert(LHSVecType || RHSVecType);
 
-  if ((LHSVecType && LHSVecType->getElementType()->isBFloat16Type()) ||
-      (RHSVecType && RHSVecType->getElementType()->isBFloat16Type()))
+  if ((LHSVecType && LHSVecType->getElementType()->isBF16Type()) ||
+      (RHSVecType && RHSVecType->getElementType()->isBF16Type()))
     return ReportInvalid ? InvalidOperands(Loc, LHS, RHS) : QualType();
 
   // AltiVec-style "vector bool op vector bool" combinations are allowed
   // for some operators but not others.
   if (!AllowBothBool &&
       LHSVecType && LHSVecType->getVectorKind() == VectorType::AltiVecBool &&
       RHSVecType && RHSVecType->getVectorKind() == VectorType::AltiVecBool)
     return ReportInvalid ? InvalidOperands(Loc, LHS, RHS) : QualType();

clang/lib/Sema/SemaOverload.cpp

if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
     SCS.Second = ICK_Complex_Real;
     FromType = ToType.getUnqualifiedType();
   } else if (FromType->isRealFloatingType() && ToType->isRealFloatingType()) {
     // FIXME: disable conversions between long double, __ibm128 and __float128
     // if their representation is different until there is back end support
     // We of course allow this conversion if long double is really double.
 
     // Conversions between bfloat and other floats are not permitted.
-    if (FromType == S.Context.BFloat16Ty || ToType == S.Context.BFloat16Ty)
+    if (FromType == S.Context.BF16Ty || ToType == S.Context.BF16Ty)
       return false;
 
     // Conversions between IEEE-quad and IBM-extended semantics are not
     // permitted.
     const llvm::fltSemantics &FromSem =
         S.Context.getFloatTypeSemantics(FromType);
     const llvm::fltSemantics &ToSem = S.Context.getFloatTypeSemantics(ToType);
     if ((&FromSem == &llvm::APFloat::PPCDoubleDouble() &&
          &ToSem == &llvm::APFloat::IEEEquad()) ||
         (&FromSem == &llvm::APFloat::IEEEquad() &&
          &ToSem == &llvm::APFloat::PPCDoubleDouble()))
       return false;
 
     // Floating point conversions (C++ 4.8).
     SCS.Second = ICK_Floating_Conversion;
     FromType = ToType.getUnqualifiedType();
   } else if ((FromType->isRealFloatingType() &&
               ToType->isIntegralType(S.Context)) ||
              (FromType->isIntegralOrUnscopedEnumerationType() &&
               ToType->isRealFloatingType())) {
     // Conversions between bfloat and int are not permitted.
-    if (FromType->isBFloat16Type() || ToType->isBFloat16Type())
+    if (FromType->isBF16Type() || ToType->isBF16Type())
       return false;
 
     // Floating-integral conversions (C++ 4.9).
     SCS.Second = ICK_Floating_Integral;
     FromType = ToType.getUnqualifiedType();
   } else if (S.IsBlockPointerConversion(FromType, ToType, FromType)) {
     SCS.Second = ICK_Block_Pointer_Conversion;
   } else if (AllowObjCWritebackConversion &&

clang/lib/Sema/SemaTemplateVariadic.cpp

#include "clang/Basic/TransformTypeTraits.def"
   case TST_enum:
   case TST_union:
   case TST_struct:
   case TST_interface:
   case TST_class:
   case TST_auto:
   case TST_auto_type:
   case TST_decltype_auto:
-  case TST_BFloat16:
+  case TST_BF16:
 #define GENERIC_IMAGE_TYPE(ImgType, Id) case TST_##ImgType##_t:
 #include "clang/Basic/OpenCLImageTypes.def"
   case TST_unknown_anytype:
   case TST_error:
     break;
   }
 
   for (unsigned I = 0, N = D.getNumTypeObjects(); I != N; ++I) {

clang/lib/Sema/SemaType.cpp

case DeclSpec::TST_float16:
     // ToDo: more precise diagnostics for CUDA.
     if (!S.Context.getTargetInfo().hasFloat16Type() && !S.getLangOpts().CUDA &&
         !(S.getLangOpts().OpenMP && S.getLangOpts().OpenMPIsDevice))
       S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported)
         << "_Float16";
     Result = Context.Float16Ty;
     break;
   case DeclSpec::TST_half:    Result = Context.HalfTy; break;
-  case DeclSpec::TST_BFloat16:
-    if (!S.Context.getTargetInfo().hasBFloat16Type() &&
+  case DeclSpec::TST_BF16:
+    if (!S.Context.getTargetInfo().hasBF16Type() &&
         !(S.getLangOpts().OpenMP && S.getLangOpts().OpenMPIsDevice) &&
         !S.getLangOpts().SYCLIsDevice)
       S.Diag(DS.getTypeSpecTypeLoc(), diag::err_type_unsupported) << "__bf16";
-    Result = Context.BFloat16Ty;
+    Result = Context.BF16Ty;
     break;
   case DeclSpec::TST_float:   Result = Context.FloatTy; break;
   case DeclSpec::TST_double:
     if (DS.getTypeSpecWidth() == TypeSpecifierWidth::Long)
       Result = Context.LongDoubleTy;
     else
       Result = Context.DoubleTy;
     if (S.getLangOpts().OpenCL) {
return BTy->getKind() == BuiltinType::SChar ||
          BTy->getKind() == BuiltinType::Int ||
          BTy->getKind() == BuiltinType::UInt ||
          BTy->getKind() == BuiltinType::Long ||
          BTy->getKind() == BuiltinType::ULong ||
          BTy->getKind() == BuiltinType::LongLong ||
          BTy->getKind() == BuiltinType::ULongLong ||
          BTy->getKind() == BuiltinType::Float ||
          BTy->getKind() == BuiltinType::Half ||
-         BTy->getKind() == BuiltinType::BFloat16;
+         BTy->getKind() == BuiltinType::BF16;
 }
 
 static bool verifyValidIntegerConstantExpr(Sema &S, const ParsedAttr &Attr,
                                            llvm::APSInt &Result) {
   const auto *AttrExpr = Attr.getArgAsExpr(0);
   if (!AttrExpr->isTypeDependent()) {
     if (std::optional<llvm::APSInt> Res =
             AttrExpr->getIntegerConstantExpr(S.Context)) {

clang/lib/Serialization/ASTCommon.cpp

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

clang/lib/Serialization/ASTReader.cpp

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

clang/tools/libclang/CXType.cpp

switch (K) {
     TKIND(Vector);
     TKIND(ExtVector);
     TKIND(MemberPointer);
     TKIND(Auto);
     TKIND(Elaborated);
     TKIND(Pipe);
     TKIND(Attributed);
     TKIND(BTFTagAttributed);
-    TKIND(BFloat16);
+    TKIND(BF16);
 #define IMAGE_TYPE(ImgType, Id, SingletonId, Access, Suffix) TKIND(Id);
 #include "clang/Basic/OpenCLImageTypes.def"
 #undef IMAGE_TYPE
 #define EXT_OPAQUE_TYPE(ExtTYpe, Id, Ext) TKIND(Id);
 #include "clang/Basic/OpenCLExtensionTypes.def"
     TKIND(OCLSampler);
     TKIND(OCLEvent);
     TKIND(OCLQueue);

lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp

case clang::BuiltinType::SatULongFract:
       break;
 
     case clang::BuiltinType::Half:
     case clang::BuiltinType::Float:
     case clang::BuiltinType::Float16:
     case clang::BuiltinType::Float128:
     case clang::BuiltinType::Double:
     case clang::BuiltinType::LongDouble:
-    case clang::BuiltinType::BFloat16:
+    case clang::BuiltinType::BF16:
     case clang::BuiltinType::Ibm128:
       return lldb::eEncodingIEEE754;
 
     case clang::BuiltinType::ObjCClass:
     case clang::BuiltinType::ObjCId:
     case clang::BuiltinType::ObjCSel:
       return lldb::eEncodingUint;