Index: clang/include/clang-c/Index.h =================================================================== --- clang/include/clang-c/Index.h +++ clang/include/clang-c/Index.h @@ -2846,7 +2846,7 @@ 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, Index: clang/include/clang/AST/ASTContext.h =================================================================== --- clang/include/clang/AST/ASTContext.h +++ clang/include/clang/AST/ASTContext.h @@ -1099,7 +1099,7 @@ 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; Index: clang/include/clang/AST/BuiltinTypes.def =================================================================== --- clang/include/clang/AST/BuiltinTypes.def +++ clang/include/clang/AST/BuiltinTypes.def @@ -213,7 +213,7 @@ FLOATING_TYPE(Float16, HalfTy) // '__bf16' -FLOATING_TYPE(BFloat16, BFloat16Ty) +FLOATING_TYPE(BF16, BF16Ty) // '__float128' FLOATING_TYPE(Float128, Float128Ty) Index: clang/include/clang/AST/Type.h =================================================================== --- clang/include/clang/AST/Type.h +++ clang/include/clang/AST/Type.h @@ -2151,7 +2151,7 @@ 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) @@ -7244,8 +7244,8 @@ 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 { Index: clang/include/clang/Basic/DiagnosticSemaKinds.td =================================================================== --- clang/include/clang/Basic/DiagnosticSemaKinds.td +++ clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -8748,8 +8748,8 @@ 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< Index: clang/include/clang/Basic/Specifiers.h =================================================================== --- clang/include/clang/Basic/Specifiers.h +++ clang/include/clang/Basic/Specifiers.h @@ -67,7 +67,7 @@ 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, Index: clang/include/clang/Basic/TargetInfo.h =================================================================== --- clang/include/clang/Basic/TargetInfo.h +++ clang/include/clang/Basic/TargetInfo.h @@ -85,7 +85,7 @@ 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; @@ -128,7 +128,7 @@ 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 -------------------------------===// @@ -218,7 +218,7 @@ bool HalfArgsAndReturns; bool HasFloat128; bool HasFloat16; - bool HasBFloat16; + bool HasBF16; bool HasIbm128; bool HasLongDouble; bool HasFPReturn; @@ -647,8 +647,8 @@ /// 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; } @@ -712,10 +712,10 @@ 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; } @@ -756,7 +756,7 @@ } /// Return the mangled code of bfloat. - virtual const char *getBFloat16Mangling() const { + virtual const char *getBF16Mangling() const { llvm_unreachable("bfloat not implemented on this target"); } Index: clang/include/clang/Basic/arm_neon_incl.td =================================================================== --- clang/include/clang/Basic/arm_neon_incl.td +++ clang/include/clang/Basic/arm_neon_incl.td @@ -237,7 +237,7 @@ // 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. // Index: clang/include/clang/Sema/DeclSpec.h =================================================================== --- clang/include/clang/Sema/DeclSpec.h +++ clang/include/clang/Sema/DeclSpec.h @@ -285,7 +285,7 @@ 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; Index: clang/include/clang/Serialization/ASTBitCodes.h =================================================================== --- clang/include/clang/Serialization/ASTBitCodes.h +++ clang/include/clang/Serialization/ASTBitCodes.h @@ -1075,7 +1075,7 @@ 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, Index: clang/lib/AST/ASTContext.cpp =================================================================== --- clang/lib/AST/ASTContext.cpp +++ clang/lib/AST/ASTContext.cpp @@ -102,7 +102,7 @@ using namespace clang; enum FloatingRank { - BFloat16Rank, + BF16Rank, Float16Rank, HalfRank, FloatRank, @@ -1451,7 +1451,7 @@ // 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; @@ -1671,8 +1671,8 @@ switch (T->castAs()->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: @@ -2135,15 +2135,15 @@ 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: @@ -4004,13 +4004,13 @@ 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: \ @@ -4052,10 +4052,10 @@ 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; \ } @@ -7072,7 +7072,7 @@ 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; } } @@ -8059,7 +8059,7 @@ 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: @@ -11337,7 +11337,7 @@ 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 && Index: clang/lib/AST/ItaniumMangle.cpp =================================================================== --- clang/lib/AST/ItaniumMangle.cpp +++ clang/lib/AST/ItaniumMangle.cpp @@ -3141,13 +3141,13 @@ 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: { @@ -3614,7 +3614,7 @@ 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"); } @@ -3666,7 +3666,7 @@ return "Float32"; case BuiltinType::Double: return "Float64"; - case BuiltinType::BFloat16: + case BuiltinType::BF16: return "Bfloat16"; default: llvm_unreachable("Unexpected vector element base type"); @@ -3789,7 +3789,7 @@ case BuiltinType::Double: TypeName = "__SVFloat64_t"; break; - case BuiltinType::BFloat16: + case BuiltinType::BF16: TypeName = "__SVBfloat16_t"; break; default: Index: clang/lib/AST/MicrosoftMangle.cpp =================================================================== --- clang/lib/AST/MicrosoftMangle.cpp +++ clang/lib/AST/MicrosoftMangle.cpp @@ -2547,7 +2547,7 @@ Out << "$halff@"; break; - case BuiltinType::BFloat16: + case BuiltinType::BF16: mangleArtificialTagType(TTK_Struct, "__bf16", {"__clang"}); break; Index: clang/lib/AST/NSAPI.cpp =================================================================== --- clang/lib/AST/NSAPI.cpp +++ clang/lib/AST/NSAPI.cpp @@ -495,7 +495,7 @@ case BuiltinType::OMPArraySection: case BuiltinType::OMPArrayShaping: case BuiltinType::OMPIterator: - case BuiltinType::BFloat16: + case BuiltinType::BF16: break; } Index: clang/lib/AST/PrintfFormatString.cpp =================================================================== --- clang/lib/AST/PrintfFormatString.cpp +++ clang/lib/AST/PrintfFormatString.cpp @@ -755,7 +755,7 @@ case BuiltinType::UInt128: case BuiltinType::Int128: case BuiltinType::Half: - case BuiltinType::BFloat16: + case BuiltinType::BF16: case BuiltinType::Float16: case BuiltinType::Float128: case BuiltinType::Ibm128: Index: clang/lib/AST/Type.cpp =================================================================== --- clang/lib/AST/Type.cpp +++ clang/lib/AST/Type.cpp @@ -2184,7 +2184,7 @@ if (const auto *BT = dyn_cast(CanonicalType)) return BT->getKind() >= BuiltinType::Bool && BT->getKind() <= BuiltinType::Ibm128 && - BT->getKind() != BuiltinType::BFloat16; + BT->getKind() != BuiltinType::BF16; if (const auto *ET = dyn_cast(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. @@ -3122,7 +3122,7 @@ return "unsigned __int128"; case Half: return Policy.Half ? "half" : "__fp16"; - case BFloat16: + case BF16: return "__bf16"; case Float: return "float"; Index: clang/lib/AST/TypeLoc.cpp =================================================================== --- clang/lib/AST/TypeLoc.cpp +++ clang/lib/AST/TypeLoc.cpp @@ -391,7 +391,7 @@ 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. Index: clang/lib/Basic/TargetInfo.cpp =================================================================== --- clang/lib/Basic/TargetInfo.cpp +++ clang/lib/Basic/TargetInfo.cpp @@ -63,7 +63,7 @@ HasFloat128 = false; HasIbm128 = false; HasFloat16 = false; - HasBFloat16 = false; + HasBF16 = false; HasLongDouble = true; HasFPReturn = true; HasStrictFP = false; Index: clang/lib/Basic/Targets/AArch64.h =================================================================== --- clang/lib/Basic/Targets/AArch64.h +++ clang/lib/Basic/Targets/AArch64.h @@ -48,7 +48,7 @@ bool HasLS64 = false; bool HasRandGen = false; bool HasMatMul = false; - bool HasBFloat16 = false; + bool HasBF16 = false; bool HasSVE2 = false; bool HasSVE2AES = false; bool HasSVE2SHA3 = false; @@ -162,7 +162,7 @@ bool checkArithmeticFenceSupported() const override { return true; } - bool hasBFloat16Type() const override; + bool hasBF16Type() const override; CallingConvCheckResult checkCallingConvention(CallingConv CC) const override; @@ -189,7 +189,7 @@ 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; } Index: clang/lib/Basic/Targets/AArch64.cpp =================================================================== --- clang/lib/Basic/Targets/AArch64.cpp +++ clang/lib/Basic/Targets/AArch64.cpp @@ -64,7 +64,7 @@ HasWFxT = true; } if (ArchInfo->Version.getMinor() >= 6u) { - HasBFloat16 = true; + HasBF16 = true; HasMatMul = true; } if (ArchInfo->Version.getMinor() >= 5u) { @@ -97,7 +97,7 @@ HasWFxT = true; } if (ArchInfo->Version.getMinor() >= 1u) { - HasBFloat16 = true; + HasBF16 = true; HasMatMul = true; } FPU |= SveMode; @@ -153,8 +153,8 @@ 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; @@ -474,14 +474,14 @@ 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"); } @@ -656,9 +656,9 @@ .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) @@ -783,17 +783,17 @@ } 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; @@ -912,7 +912,7 @@ if (Feature == "+i8mm") HasMatMul = true; if (Feature == "+bf16") - HasBFloat16 = true; + HasBF16 = true; if (Feature == "+lse") HasLSE = true; if (Feature == "+ls64") @@ -1101,9 +1101,7 @@ return Ret; } -bool AArch64TargetInfo::hasBFloat16Type() const { - return true; -} +bool AArch64TargetInfo::hasBF16Type() const { return true; } TargetInfo::CallingConvCheckResult AArch64TargetInfo::checkCallingConvention(CallingConv CC) const { Index: clang/lib/Basic/Targets/AMDGPU.h =================================================================== --- clang/lib/Basic/Targets/AMDGPU.h +++ clang/lib/Basic/Targets/AMDGPU.h @@ -114,8 +114,8 @@ 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 ""; } Index: clang/lib/Basic/Targets/AMDGPU.cpp =================================================================== --- clang/lib/Basic/Targets/AMDGPU.cpp +++ clang/lib/Basic/Targets/AMDGPU.cpp @@ -225,8 +225,8 @@ 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; Index: clang/lib/Basic/Targets/ARM.h =================================================================== --- clang/lib/Basic/Targets/ARM.h +++ clang/lib/Basic/Targets/ARM.h @@ -146,7 +146,7 @@ bool hasFeature(StringRef Feature) const override; - bool hasBFloat16Type() const override; + bool hasBF16Type() const override; bool isValidCPUName(StringRef Name) const override; void fillValidCPUList(SmallVectorImpl &Values) const override; @@ -196,7 +196,7 @@ 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 { Index: clang/lib/Basic/Targets/ARM.cpp =================================================================== --- clang/lib/Basic/Targets/ARM.cpp +++ clang/lib/Basic/Targets/ARM.cpp @@ -25,8 +25,8 @@ 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(); @@ -78,8 +78,8 @@ 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; @@ -513,7 +513,7 @@ HasBTI = 0; HasFloat16 = true; ARMCDECoprocMask = 0; - HasBFloat16 = false; + HasBF16 = false; FPRegsDisabled = false; // This does not diagnose illegal cases like having both @@ -590,7 +590,7 @@ 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") { @@ -648,9 +648,9 @@ .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 { @@ -951,7 +951,7 @@ 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"); Index: clang/lib/Basic/Targets/NVPTX.h =================================================================== --- clang/lib/Basic/Targets/NVPTX.h +++ clang/lib/Basic/Targets/NVPTX.h @@ -180,8 +180,8 @@ } 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 Index: clang/lib/Basic/Targets/NVPTX.cpp =================================================================== --- clang/lib/Basic/Targets/NVPTX.cpp +++ clang/lib/Basic/Targets/NVPTX.cpp @@ -53,8 +53,8 @@ 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! Index: clang/lib/Basic/Targets/X86.h =================================================================== --- clang/lib/Basic/Targets/X86.h +++ clang/lib/Basic/Targets/X86.h @@ -169,8 +169,8 @@ 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; @@ -417,7 +417,7 @@ return getPointerWidthV(AddrSpace); } - const char *getBFloat16Mangling() const override { return "u6__bf16"; }; + const char *getBF16Mangling() const override { return "u6__bf16"; }; }; // X86-32 generic target Index: clang/lib/Basic/Targets/X86.cpp =================================================================== --- clang/lib/Basic/Targets/X86.cpp +++ clang/lib/Basic/Targets/X86.cpp @@ -376,7 +376,7 @@ HasFloat16 = SSELevel >= SSE2; - HasBFloat16 = SSELevel >= SSE2; + HasBF16 = SSELevel >= SSE2; MMX3DNowEnum ThreeDNowLevel = llvm::StringSwitch(Feature) .Case("+3dnowa", AMD3DNowAthlon) Index: clang/lib/CodeGen/ABIInfo.h =================================================================== --- clang/lib/CodeGen/ABIInfo.h +++ clang/lib/CodeGen/ABIInfo.h @@ -52,7 +52,7 @@ virtual ~ABIInfo(); - virtual bool allowBFloatArgsAndRet() const { return false; } + virtual bool allowBF16ArgsAndRet() const { return false; } CodeGen::CGCXXABI &getCXXABI() const; ASTContext &getContext() const; Index: clang/lib/CodeGen/CGBuiltin.cpp =================================================================== --- clang/lib/CodeGen/CGBuiltin.cpp +++ clang/lib/CodeGen/CGBuiltin.cpp @@ -5581,7 +5581,7 @@ NeonTypeFlags TypeFlags, bool HasLegalHalfType = true, bool V1Ty = false, - bool AllowBFloatArgsAndRet = true) { + bool AllowBF16ArgsAndRet = true) { int IsQuad = TypeFlags.isQuad(); switch (TypeFlags.getEltType()) { case NeonTypeFlags::Int8: @@ -5591,7 +5591,7 @@ 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)); @@ -6887,11 +6887,11 @@ 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; @@ -8345,7 +8345,7 @@ llvm::FixedVectorType *VTy = GetNeonType(this, Type, getTarget().hasLegalHalfType(), false, - getTarget().hasBFloat16Type()); + getTarget().hasBF16Type()); llvm::Type *Ty = VTy; if (!Ty) return nullptr; Index: clang/lib/CodeGen/CGDebugInfo.cpp =================================================================== --- clang/lib/CodeGen/CGDebugInfo.cpp +++ clang/lib/CodeGen/CGDebugInfo.cpp @@ -883,7 +883,7 @@ case BuiltinType::Float: case BuiltinType::LongDouble: case BuiltinType::Float16: - case BuiltinType::BFloat16: + case BuiltinType::BF16: case BuiltinType::Float128: case BuiltinType::Double: case BuiltinType::Ibm128: Index: clang/lib/CodeGen/CodeGenTypes.cpp =================================================================== --- clang/lib/CodeGen/CodeGenTypes.cpp +++ clang/lib/CodeGen/CodeGenTypes.cpp @@ -529,7 +529,7 @@ Context.getLangOpts().NativeHalfType || !Context.getTargetInfo().useFP16ConversionIntrinsics()); break; - case BuiltinType::BFloat16: + case BuiltinType::BF16: case BuiltinType::Float: case BuiltinType::Double: case BuiltinType::LongDouble: Index: clang/lib/CodeGen/ItaniumCXXABI.cpp =================================================================== --- clang/lib/CodeGen/ItaniumCXXABI.cpp +++ clang/lib/CodeGen/ItaniumCXXABI.cpp @@ -3316,7 +3316,7 @@ case BuiltinType::SatUShortFract: case BuiltinType::SatUFract: case BuiltinType::SatULongFract: - case BuiltinType::BFloat16: + case BuiltinType::BF16: return false; case BuiltinType::Dependent: Index: clang/lib/CodeGen/TargetInfo.cpp =================================================================== --- clang/lib/CodeGen/TargetInfo.cpp +++ clang/lib/CodeGen/TargetInfo.cpp @@ -2876,7 +2876,7 @@ } 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(); @@ -3008,7 +3008,7 @@ 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; @@ -5565,8 +5565,8 @@ Address EmitMSVAArg(CodeGenFunction &CGF, Address VAListAddr, QualType Ty) const override; - bool allowBFloatArgsAndRet() const override { - return getTarget().hasBFloat16Type(); + bool allowBF16ArgsAndRet() const override { + return getTarget().hasBF16Type(); } }; @@ -5728,7 +5728,7 @@ 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; @@ -6362,8 +6362,8 @@ ABIKind getABIKind() const { return Kind; } - bool allowBFloatArgsAndRet() const override { - return !IsFloatABISoftFP && getTarget().hasBFloat16Type(); + bool allowBF16ArgsAndRet() const override { + return !IsFloatABISoftFP && getTarget().hasBF16Type(); } private: @@ -6849,10 +6849,9 @@ // 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())) + (VT->getElementType()->isFloat16Type() || + VT->getElementType()->isHalfType())) || + (IsFloatABISoftFP && VT->getElementType()->isBF16Type())) return coerceIllegalVector(RetTy); } @@ -6949,10 +6948,9 @@ // 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())) + (VT->getElementType()->isFloat16Type() || + VT->getElementType()->isHalfType())) || + (IsFloatABISoftFP && VT->getElementType()->isBF16Type())) return true; if (isAndroid()) { // Android shipped using Clang 3.1, which supported a slightly different @@ -7004,7 +7002,7 @@ } else { if (const VectorType *VT = Ty->getAs()) return (VT->getElementType()->isFloat16Type() || - VT->getElementType()->isBFloat16Type() || + VT->getElementType()->isBF16Type() || VT->getElementType()->isHalfType()); return false; } Index: clang/lib/Index/USRGeneration.cpp =================================================================== --- clang/lib/Index/USRGeneration.cpp +++ clang/lib/Index/USRGeneration.cpp @@ -794,7 +794,7 @@ 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; Index: clang/lib/Parse/ParseDecl.cpp =================================================================== --- clang/lib/Parse/ParseDecl.cpp +++ clang/lib/Parse/ParseDecl.cpp @@ -4130,8 +4130,8 @@ 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, Index: clang/lib/Parse/ParseExprCXX.cpp =================================================================== --- clang/lib/Parse/ParseExprCXX.cpp +++ clang/lib/Parse/ParseExprCXX.cpp @@ -2318,7 +2318,7 @@ 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); Index: clang/lib/Sema/DeclSpec.cpp =================================================================== --- clang/lib/Sema/DeclSpec.cpp +++ clang/lib/Sema/DeclSpec.cpp @@ -373,7 +373,7 @@ 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; @@ -587,7 +587,7 @@ #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"; Index: clang/lib/Sema/Sema.cpp =================================================================== --- clang/lib/Sema/Sema.cpp +++ clang/lib/Sema/Sema.cpp @@ -1973,7 +1973,7 @@ (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); Index: clang/lib/Sema/SemaCast.cpp =================================================================== --- clang/lib/Sema/SemaCast.cpp +++ clang/lib/Sema/SemaCast.cpp @@ -3093,14 +3093,14 @@ } // 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; Index: clang/lib/Sema/SemaChecking.cpp =================================================================== --- clang/lib/Sema/SemaChecking.cpp +++ clang/lib/Sema/SemaChecking.cpp @@ -2861,7 +2861,7 @@ case NeonTypeFlags::Float64: return Context.DoubleTy; case NeonTypeFlags::BFloat16: - return Context.BFloat16Ty; + return Context.BF16Ty; } llvm_unreachable("Invalid NeonTypeFlag!"); } Index: clang/lib/Sema/SemaExpr.cpp =================================================================== --- clang/lib/Sema/SemaExpr.cpp +++ clang/lib/Sema/SemaExpr.cpp @@ -8990,7 +8990,7 @@ } // 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); } @@ -10785,8 +10785,8 @@ const VectorType *RHSVecType = RHSType->getAs(); 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 Index: clang/lib/Sema/SemaOverload.cpp =================================================================== --- clang/lib/Sema/SemaOverload.cpp +++ clang/lib/Sema/SemaOverload.cpp @@ -1996,7 +1996,7 @@ // 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 @@ -2018,7 +2018,7 @@ (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). Index: clang/lib/Sema/SemaTemplateVariadic.cpp =================================================================== --- clang/lib/Sema/SemaTemplateVariadic.cpp +++ clang/lib/Sema/SemaTemplateVariadic.cpp @@ -908,7 +908,7 @@ 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: Index: clang/lib/Sema/SemaType.cpp =================================================================== --- clang/lib/Sema/SemaType.cpp +++ clang/lib/Sema/SemaType.cpp @@ -1518,12 +1518,12 @@ 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: @@ -8133,7 +8133,7 @@ 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, Index: clang/lib/Serialization/ASTCommon.cpp =================================================================== --- clang/lib/Serialization/ASTCommon.cpp +++ clang/lib/Serialization/ASTCommon.cpp @@ -270,8 +270,8 @@ 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; } Index: clang/lib/Serialization/ASTReader.cpp =================================================================== --- clang/lib/Serialization/ASTReader.cpp +++ clang/lib/Serialization/ASTReader.cpp @@ -7024,8 +7024,8 @@ 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; Index: clang/tools/libclang/CXType.cpp =================================================================== --- clang/tools/libclang/CXType.cpp +++ clang/tools/libclang/CXType.cpp @@ -618,7 +618,7 @@ 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 Index: lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp =================================================================== --- lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp +++ lldb/source/Plugins/TypeSystem/Clang/TypeSystemClang.cpp @@ -4909,7 +4909,7 @@ 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;