[Backport to 11] Implement SPV_KHR_bfloat16 extension (#3252)

vsemenov368 · MrSidims · 0x12CC · web-flow · commit a56150668ca9 · 2025-07-09T12:01:41.000+02:00
The extension add translation from LLVM's bfloat type to OpTypeFloat %width% 16 %fp encoding% BFloat16KHR Mangling follows LLVM's rules for the type. Spec PR: KhronosGroup/SPIRV-Registry#323 --------- Signed-off-by: Sidorov, Dmitry <dmitry.sidorov@intel.com> Co-authored-by: Aziz, Michael <michael.aziz@intel.com> Signed-off-by: Sidorov, Dmitry <dmitry.sidorov@intel.com> Co-authored-by: Dmitry Sidorov <dmitry.sidorov@intel.com> Co-authored-by: Aziz, Michael <michael.aziz@intel.com> Signed-off-by: Sidorov, Dmitry <dmitry.sidorov@intel.com> Co-authored-by: Dmitry Sidorov <dmitry.sidorov@intel.com> Co-authored-by: Aziz, Michael <michael.aziz@intel.com>
diff --git a/include/LLVMSPIRVExtensions.inc b/include/LLVMSPIRVExtensions.inc
@@ -49,3 +49,4 @@ EXT(SPV_INTEL_hw_thread_queries)
 EXT(SPV_EXT_relaxed_printf_string_address_space)
 EXT(SPV_INTEL_global_variable_decorations)
 EXT(SPV_INTEL_maximum_registers)
+EXT(SPV_KHR_bfloat16)
diff --git a/lib/SPIRV/Mangler/ManglingUtils.cpp b/lib/SPIRV/Mangler/ManglingUtils.cpp
@@ -28,6 +28,7 @@ static const char *PrimitiveNames[PRIMITIVE_NUM] = {
     "half",
     "float",
     "double",
+    "__bf16",
     "void",
     "...",
     "image1d_ro_t",
@@ -89,8 +90,7 @@ static const char *PrimitiveNames[PRIMITIVE_NUM] = {
     "intel_sub_group_avc_ime_result_single_reference_streamout_t",
     "intel_sub_group_avc_ime_result_dual_reference_streamout_t",
     "intel_sub_group_avc_ime_result_single_reference_streamin_t",
-    "intel_sub_group_avc_ime_result_dual_reference_streamin_t"
-};
+    "intel_sub_group_avc_ime_result_dual_reference_streamin_t"};
 
 const char *MangledTypes[PRIMITIVE_NUM] = {
     "b",                                 // BOOL
@@ -105,6 +105,7 @@ const char *MangledTypes[PRIMITIVE_NUM] = {
     "Dh",                                // HALF
     "f",                                 // FLOAT
     "d",                                 // DOUBLE
+    "u6__bf16",                          // __BF16
     "v",                                 // VOID
     "z",                                 // VarArg
     "14ocl_image1d_ro",                  // PRIMITIVE_IMAGE1D_RO_T
@@ -157,21 +158,21 @@ const char *MangledTypes[PRIMITIVE_NUM] = {
     "i", // PRIMITIVE_MEMORY_ORDER
     "i", // PRIMITIVE_MEMORY_SCOPE
 #else
-    "12memory_order",  // PRIMITIVE_MEMORY_ORDER
-    "12memory_scope",  // PRIMITIVE_MEMORY_SCOPE
+    "12memory_order", // PRIMITIVE_MEMORY_ORDER
+    "12memory_scope", // PRIMITIVE_MEMORY_SCOPE
 #endif
     "37ocl_intel_sub_group_avc_mce_payload_t", // PRIMITIVE_SUB_GROUP_AVC_MCE_PAYLOAD_T
     "37ocl_intel_sub_group_avc_ime_payload_t", // PRIMITIVE_SUB_GROUP_AVC_IME_PAYLOAD_T
     "37ocl_intel_sub_group_avc_ref_payload_t", // PRIMITIVE_SUB_GROUP_AVC_REF_PAYLOAD_T
     "37ocl_intel_sub_group_avc_sic_payload_t", // PRIMITIVE_SUB_GROUP_AVC_SIC_PAYLOAD_T
-    "36ocl_intel_sub_group_avc_mce_result_t",  // PRIMITIVE_SUB_GROUP_AVC_MCE_RESULT_T
-    "36ocl_intel_sub_group_avc_ime_result_t",  // PRIMITIVE_SUB_GROUP_AVC_IME_RESULT_T
-    "36ocl_intel_sub_group_avc_ref_result_t",  // PRIMITIVE_SUB_GROUP_AVC_REF_RESULT_T
-    "36ocl_intel_sub_group_avc_sic_result_t",  // PRIMITIVE_SUB_GROUP_AVC_REF_RESULT_T
-    "63ocl_intel_sub_group_avc_ime_result_single_reference_streamout_t",  // PRIMITIVE_SUB_GROUP_AVC_IME_SINGLE_REF_STREAMOUT_T
-    "61ocl_intel_sub_group_avc_ime_result_dual_reference_streamout_t",    // PRIMITIVE_SUB_GROUP_AVC_IME_DUAL_REF_STREAMOUT_T
-    "55ocl_intel_sub_group_avc_ime_single_reference_streamin_t",          // PRIMITIVE_SUB_GROUP_AVC_IME_SINGLE_REF_STREAMIN_T
-    "53ocl_intel_sub_group_avc_ime_dual_reference_streamin_t"             // PRIMITIVE_SUB_GROUP_AVC_IME_DUAL_REF_STREAMIN_T
+    "36ocl_intel_sub_group_avc_mce_result_t", // PRIMITIVE_SUB_GROUP_AVC_MCE_RESULT_T
+    "36ocl_intel_sub_group_avc_ime_result_t", // PRIMITIVE_SUB_GROUP_AVC_IME_RESULT_T
+    "36ocl_intel_sub_group_avc_ref_result_t", // PRIMITIVE_SUB_GROUP_AVC_REF_RESULT_T
+    "36ocl_intel_sub_group_avc_sic_result_t", // PRIMITIVE_SUB_GROUP_AVC_REF_RESULT_T
+    "63ocl_intel_sub_group_avc_ime_result_single_reference_streamout_t", // PRIMITIVE_SUB_GROUP_AVC_IME_SINGLE_REF_STREAMOUT_T
+    "61ocl_intel_sub_group_avc_ime_result_dual_reference_streamout_t", // PRIMITIVE_SUB_GROUP_AVC_IME_DUAL_REF_STREAMOUT_T
+    "55ocl_intel_sub_group_avc_ime_single_reference_streamin_t", // PRIMITIVE_SUB_GROUP_AVC_IME_SINGLE_REF_STREAMIN_T
+    "53ocl_intel_sub_group_avc_ime_dual_reference_streamin_t" // PRIMITIVE_SUB_GROUP_AVC_IME_DUAL_REF_STREAMIN_T
 };
 
 const char *ReadableAttribute[ATTR_NUM] = {
@@ -197,6 +198,7 @@ static const SPIRversion PrimitiveSupportedVersions[PRIMITIVE_NUM] = {
     SPIR12, // HALF
     SPIR12, // FLOAT
     SPIR12, // DOUBLE
+    SPIR12, // __BF16
     SPIR12, // VOID
     SPIR12, // VarArg
     SPIR12, // PRIMITIVE_IMAGE1D_RO_T
diff --git a/lib/SPIRV/Mangler/ParameterType.h b/lib/SPIRV/Mangler/ParameterType.h
@@ -45,6 +45,7 @@ enum TypePrimitiveEnum {
   PRIMITIVE_HALF,
   PRIMITIVE_FLOAT,
   PRIMITIVE_DOUBLE,
+  PRIMITIVE_BFLOAT,
   PRIMITIVE_VOID,
   PRIMITIVE_VAR_ARG,
   PRIMITIVE_STRUCT_FIRST,
diff --git a/lib/SPIRV/SPIRVReader.cpp b/lib/SPIRV/SPIRVReader.cpp
@@ -265,6 +265,8 @@ Value *SPIRVToLLVM::mapFunction(SPIRVFunction *BF, Function *F) {
 Type *SPIRVToLLVM::transFPType(SPIRVType *T) {
   switch (T->getFloatBitWidth()) {
   case 16:
+    if (T->isTypeFloat(16, FPEncodingBFloat16KHR))
+      return Type::getBFloatTy(*Context);
     return Type::getHalfTy(*Context);
   case 32:
     return Type::getFloatTy(*Context);
@@ -467,6 +469,9 @@ std::string SPIRVToLLVM::transTypeToOCLTypeName(SPIRVType *T, bool IsSigned) {
   case OpTypeFloat:
     switch (T->getFloatBitWidth()) {
     case 16:
+      if (static_cast<SPIRVTypeFloat *>(T)->getFloatingPointEncoding() ==
+          FPEncodingBFloat16KHR)
+        return "bfloat16";
       return "half";
     case 32:
       return "float";
@@ -1299,7 +1304,9 @@ Value *SPIRVToLLVM::transValueWithoutDecoration(SPIRVValue *BV, Function *F,
       const llvm::fltSemantics *FS = nullptr;
       switch (BT->getFloatBitWidth()) {
       case 16:
-        FS = &APFloat::IEEEhalf();
+        FS =
+            (BT->isTypeFloat(16, FPEncodingBFloat16KHR) ? &APFloat::BFloat()
+                                                        : &APFloat::IEEEhalf());
         break;
       case 32:
         FS = &APFloat::IEEEsingle();
diff --git a/lib/SPIRV/SPIRVUtil.cpp b/lib/SPIRV/SPIRVUtil.cpp
@@ -1066,6 +1066,8 @@ static SPIR::RefParamType transTypeDesc(Type *Ty,
     return SPIR::RefParamType(new SPIR::PrimitiveType(SPIR::PRIMITIVE_FLOAT));
   if (Ty->isDoubleTy())
     return SPIR::RefParamType(new SPIR::PrimitiveType(SPIR::PRIMITIVE_DOUBLE));
+  if (Ty->isBFloatTy())
+    return SPIR::RefParamType(new SPIR::PrimitiveType(SPIR::PRIMITIVE_BFLOAT));
   if (auto *VecTy = dyn_cast<FixedVectorType>(Ty)) {
     return SPIR::RefParamType(new SPIR::VectorType(
         transTypeDesc(VecTy->getElementType(), Info), VecTy->getNumElements()));
diff --git a/lib/SPIRV/SPIRVWriter.cpp b/lib/SPIRV/SPIRVWriter.cpp
@@ -326,6 +326,16 @@ SPIRVType *LLVMToSPIRVBase::transType(Type *T) {
     }
   }
 
+  if (T->isBFloatTy()) {
+    BM->getErrorLog().checkError(
+        BM->isAllowedToUseExtension(ExtensionID::SPV_KHR_bfloat16),
+        SPIRVEC_RequiresExtension,
+        "SPV_KHR_bfloat16\n"
+        "NOTE: LLVM module contains bfloat type, translation of which "
+        "requires this extension");
+    return mapType(T, BM->addFloatType(16, FPEncodingBFloat16KHR));
+  }
+
   if (T->isFloatingPointTy())
     return mapType(T, BM->addFloatType(T->getPrimitiveSizeInBits()));
 
diff --git a/lib/SPIRV/libSPIRV/SPIRVEnum.h b/lib/SPIRV/libSPIRV/SPIRVEnum.h
@@ -197,6 +197,7 @@ template <> inline void SPIRVMap<SPIRVCapabilityKind, SPIRVCapVec>::init() {
                {CapabilitySubgroupAvcMotionEstimationINTEL});
   ADD_VEC_INIT(CapabilitySubgroupAvcMotionEstimationChromaINTEL,
                {CapabilitySubgroupAvcMotionEstimationIntraINTEL});
+  ADD_VEC_INIT(CapabilityBFloat16DotProductKHR, {CapabilityBFloat16TypeKHR});
 }
 
 template <> inline void SPIRVMap<SPIRVExecutionModelKind, SPIRVCapVec>::init() {
@@ -432,7 +433,6 @@ template <> inline void SPIRVMap<Decoration, SPIRVCapVec>::init() {
                {internal::CapabilityMemoryAccessAliasingINTEL});
   ADD_VEC_INIT(internal::DecorationNoAliasINTEL,
                {internal::CapabilityMemoryAccessAliasingINTEL});
-
   ADD_VEC_INIT(internal::DecorationHostAccessINTEL,
                {internal::CapabilityGlobalVariableDecorationsINTEL});
   ADD_VEC_INIT(internal::DecorationInitModeINTEL,
diff --git a/lib/SPIRV/libSPIRV/SPIRVInstruction.h b/lib/SPIRV/libSPIRV/SPIRVInstruction.h
@@ -652,6 +652,23 @@ class SPIRVBinary : public SPIRVInstTemplateBase {
       assert(0 && "Invalid op code!");
     }
   }
+  SPIRVWord getRequiredSPIRVVersion() const override {
+    if (isBinaryOpCode(OpCode))
+      return static_cast<SPIRVWord>(VersionNumber::SPIRV_1_4);
+    return static_cast<SPIRVWord>(VersionNumber::SPIRV_1_0);
+  }
+  SPIRVCapVec getRequiredCapability() const override {
+    if (OpCode == OpDot) {
+      const SPIRVType *OpTy = getValueType(Ops[0]);
+      if (OpTy && OpTy->isTypeVector()) {
+        OpTy = OpTy->getVectorComponentType();
+        if (OpTy && OpTy->isTypeFloat(16, FPEncodingBFloat16KHR)) {
+          return getVec(CapabilityBFloat16DotProductKHR);
+        }
+      }
+    }
+    return SPIRVInstruction::getRequiredCapability();
+  }
 };
 
 template <Op OC>
diff --git a/lib/SPIRV/libSPIRV/SPIRVModule.cpp b/lib/SPIRV/libSPIRV/SPIRVModule.cpp
@@ -228,7 +228,8 @@ class SPIRVModuleImpl : public SPIRVModule {
   template <class T> T *addType(T *Ty);
   SPIRVTypeArray *addArrayType(SPIRVType *, SPIRVConstant *) override;
   SPIRVTypeBool *addBoolType() override;
-  SPIRVTypeFloat *addFloatType(unsigned BitWidth) override;
+  SPIRVTypeFloat *addFloatType(unsigned BitWidth,
+                               unsigned FloatingPointEncoding) override;
   SPIRVTypeFunction *addFunctionType(SPIRVType *,
                                      const std::vector<SPIRVType *> &) override;
   SPIRVTypeInt *addIntegerType(unsigned BitWidth) override;
@@ -521,6 +522,8 @@ class SPIRVModuleImpl : public SPIRVModule {
   SPIRVCapMap CapMap;
   SPIRVUnknownStructFieldMap UnknownStructFieldMap;
   std::map<unsigned, SPIRVTypeInt *> IntTypeMap;
+  SmallDenseMap<std::pair<unsigned, unsigned>, SPIRVTypeFloat *, 4>
+      FloatTypeMap;
   std::map<unsigned, SPIRVConstant *> LiteralMap;
   std::vector<SPIRVExtInst *> DebugInstVec;
   std::vector<SPIRVModuleProcessed *> ModuleProcessedVec;
@@ -851,9 +854,15 @@ SPIRVTypeInt *SPIRVModuleImpl::addIntegerType(unsigned BitWidth) {
   return addType(Ty);
 }
 
-SPIRVTypeFloat *SPIRVModuleImpl::addFloatType(unsigned BitWidth) {
-  SPIRVTypeFloat *T = addType(new SPIRVTypeFloat(this, getId(), BitWidth));
-  return T;
+SPIRVTypeFloat *SPIRVModuleImpl::addFloatType(unsigned BitWidth,
+                                              unsigned FloatingPointEncoding) {
+  auto Desc = std::make_pair(BitWidth, FloatingPointEncoding);
+  auto Loc = FloatTypeMap.find(Desc);
+  if (Loc != FloatTypeMap.end())
+    return Loc->second;
+  auto *Ty = new SPIRVTypeFloat(this, getId(), BitWidth, FloatingPointEncoding);
+  FloatTypeMap[Desc] = Ty;
+  return addType(Ty);
 }
 
 SPIRVTypePointer *
diff --git a/lib/SPIRV/libSPIRV/SPIRVModule.h b/lib/SPIRV/libSPIRV/SPIRVModule.h
@@ -223,7 +223,7 @@ class SPIRVModule {
   // Type creation functions
   virtual SPIRVTypeArray *addArrayType(SPIRVType *, SPIRVConstant *) = 0;
   virtual SPIRVTypeBool *addBoolType() = 0;
-  virtual SPIRVTypeFloat *addFloatType(unsigned) = 0;
+  virtual SPIRVTypeFloat *addFloatType(unsigned, unsigned = FPEncodingMax) = 0;
   virtual SPIRVTypeFunction *
   addFunctionType(SPIRVType *, const std::vector<SPIRVType *> &) = 0;
   virtual SPIRVTypeImage *addImageType(SPIRVType *,
diff --git a/lib/SPIRV/libSPIRV/SPIRVNameMapEnum.h b/lib/SPIRV/libSPIRV/SPIRVNameMapEnum.h
@@ -567,6 +567,8 @@ template <> inline void SPIRVMap<Capability, std::string>::init() {
   add(CapabilityDebugInfoModuleINTEL, "DebugInfoModuleINTEL");
   add(CapabilityGroupUniformArithmeticKHR, "GroupUniformArithmeticKHR");
   add(CapabilityRegisterLimitsINTEL, "RegisterLimitsINTEL");
+  add(CapabilityBFloat16TypeKHR, "BFloat16TypeKHR");
+  add(CapabilityBFloat16DotProductKHR, "BFloat16DotProductKHR");
 
   // From spirv_internal.hpp
   add(internal::CapabilityOptNoneINTEL, "OptNoneINTEL");
diff --git a/lib/SPIRV/libSPIRV/SPIRVType.cpp b/lib/SPIRV/libSPIRV/SPIRVType.cpp
@@ -154,8 +154,15 @@ bool SPIRVType::isTypeComposite() const {
   return isTypeVector() || isTypeArray() || isTypeStruct();
 }
 
-bool SPIRVType::isTypeFloat(unsigned Bits) const {
-  return isType<SPIRVTypeFloat>(this, Bits);
+bool SPIRVType::isTypeFloat(unsigned Bits,
+                            unsigned FloatingPointEncoding) const {
+  if (!isType<SPIRVTypeFloat>(this))
+    return false;
+  if (Bits == 0)
+    return true;
+  const auto *ThisFloat = static_cast<const SPIRVTypeFloat *>(this);
+  return ThisFloat->getBitWidth() == Bits &&
+         ThisFloat->getFloatingPointEncoding() == FloatingPointEncoding;
 }
 
 bool SPIRVType::isTypeOCLImage() const {
diff --git a/lib/SPIRV/libSPIRV/SPIRVType.h b/lib/SPIRV/libSPIRV/SPIRVType.h
@@ -84,7 +84,8 @@ class SPIRVType : public SPIRVEntry {
   bool isTypeEvent() const;
   bool isTypeDeviceEvent() const;
   bool isTypeReserveId() const;
-  bool isTypeFloat(unsigned Bits = 0) const;
+  bool isTypeFloat(unsigned Bits = 0,
+                   unsigned FloatingPointEncoding = FPEncodingMax) const;
   bool isTypeImage() const;
   bool isTypeOCLImage() const;
   bool isTypePipe() const;
@@ -198,16 +199,31 @@ class SPIRVTypeFloat : public SPIRVType {
 public:
   static const Op OC = OpTypeFloat;
   // Complete constructor
-  SPIRVTypeFloat(SPIRVModule *M, SPIRVId TheId, unsigned TheBitWidth)
-      : SPIRVType(M, 3, OC, TheId), BitWidth(TheBitWidth) {}
+  SPIRVTypeFloat(SPIRVModule *M, SPIRVId TheId, unsigned TheBitWidth,
+                 unsigned TheFloatingPointEncoding)
+      : SPIRVType(M, 3 + (TheFloatingPointEncoding != FPEncodingMax), OC,
+                  TheId),
+        BitWidth(TheBitWidth), FloatingPointEncoding(TheFloatingPointEncoding) {
+  }
   // Incomplete constructor
-  SPIRVTypeFloat() : SPIRVType(OC), BitWidth(0) {}
+  SPIRVTypeFloat()
+      : SPIRVType(OC), BitWidth(0), FloatingPointEncoding(FPEncodingMax) {}
 
   unsigned getBitWidth() const { return BitWidth; }
 
+  unsigned getFloatingPointEncoding() const { return FloatingPointEncoding; }
+
+  llvm::Optional<ExtensionID> getRequiredExtension() const override {
+    if (isTypeFloat(16, FPEncodingBFloat16KHR))
+      return ExtensionID::SPV_KHR_bfloat16;
+    return {};
+  }
+
   SPIRVCapVec getRequiredCapability() const override {
     SPIRVCapVec CV;
-    if (isTypeFloat(16)) {
+    if (isTypeFloat(16, FPEncodingBFloat16KHR)) {
+      CV.push_back(CapabilityBFloat16TypeKHR);
+    } else if (isTypeFloat(16)) {
       CV.push_back(CapabilityFloat16Buffer);
       auto Extensions = getModule()->getSourceExtension();
       if (std::any_of(Extensions.begin(), Extensions.end(),
@@ -219,14 +235,34 @@ class SPIRVTypeFloat : public SPIRVType {
   }
 
 protected:
-  _SPIRV_DEF_ENCDEC2(Id, BitWidth)
+  void encode(spv_ostream &O) const override {
+    assert(WordCount == 3 || WordCount == 4);
+    auto Encoder = getEncoder(O);
+    Encoder << Id << BitWidth;
+    if (WordCount == 4)
+      Encoder << FloatingPointEncoding;
+  }
+
+  void decode(std::istream &I) override {
+    assert(WordCount == 3 || WordCount == 4);
+    auto Decoder = getDecoder(I);
+    Decoder >> Id >> BitWidth;
+    if (WordCount == 4)
+      Decoder >> FloatingPointEncoding;
+  }
+
   void validate() const override {
     SPIRVEntry::validate();
     assert(BitWidth >= 16 && BitWidth <= 64 && "Invalid bit width");
+    assert(
+        (FloatingPointEncoding == FPEncodingMax ||
+         (BitWidth == 16 && FloatingPointEncoding == FPEncodingBFloat16KHR)) &&
+        "Invalid floating point encoding");
   }
 
 private:
   unsigned BitWidth; // Bit width
+  unsigned FloatingPointEncoding;
 };
 
 class SPIRVTypePointer : public SPIRVType {
diff --git a/lib/SPIRV/libSPIRV/spirv.hpp b/lib/SPIRV/libSPIRV/spirv.hpp
@@ -1,19 +1,19 @@
 // Copyright (c) 2014-2020 The Khronos Group Inc.
-// 
+//
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and/or associated documentation files (the "Materials"),
 // to deal in the Materials without restriction, including without limitation
 // the rights to use, copy, modify, merge, publish, distribute, sublicense,
 // and/or sell copies of the Materials, and to permit persons to whom the
 // Materials are furnished to do so, subject to the following conditions:
-// 
+//
 // The above copyright notice and this permission notice shall be included in
 // all copies or substantial portions of the Materials.
-// 
+//
 // MODIFICATIONS TO THIS FILE MAY MEAN IT NO LONGER ACCURATELY REFLECTS KHRONOS
 // STANDARDS. THE UNMODIFIED, NORMATIVE VERSIONS OF KHRONOS SPECIFICATIONS AND
-// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/ 
-// 
+// HEADER INFORMATION ARE LOCATED AT https://www.khronos.org/registry/
+//
 // THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
@@ -27,7 +27,7 @@
 
 // Enumeration tokens for SPIR-V, in various styles:
 //   C, C++, C++11, JSON, Lua, Python, C#, D
-// 
+//
 // - C will have tokens with a "Spv" prefix, e.g.: SpvSourceLanguageGLSL
 // - C++ will have tokens in the "spv" name space, e.g.: spv::SourceLanguageGLSL
 // - C++11 will use enum classes in the spv namespace, e.g.: spv::SourceLanguage::GLSL
@@ -36,7 +36,7 @@
 // - C# will use enum classes in the Specification class located in the "Spv" namespace,
 //     e.g.: Spv.Specification.SourceLanguage.GLSL
 // - D will have tokens under the "spv" module, e.g: spv.SourceLanguage.GLSL
-// 
+//
 // Some tokens act like mask values, which can be OR'd together,
 // while others are mutually exclusive.  The mask-like ones have
 // "Mask" in their name, and a parallel enum that has the shift
@@ -959,6 +959,8 @@ enum Capability {
     CapabilityImageReadWriteLodAMD = 5015,
     CapabilityInt64ImageEXT = 5016,
     CapabilityShaderClockKHR = 5055,
+    CapabilityBFloat16TypeKHR = 5116,
+    CapabilityBFloat16DotProductKHR = 5117,
     CapabilitySampleMaskOverrideCoverageNV = 5249,
     CapabilityGeometryShaderPassthroughNV = 5251,
     CapabilityShaderViewportIndexLayerEXT = 5254,
@@ -1174,6 +1176,11 @@ enum NamedMaximumNumberOfRegisters {
     NamedMaximumNumberOfRegistersMax = 0x7fffffff,
 };
 
+enum FPEncoding {
+    FPEncodingBFloat16KHR = 0,
+    FPEncodingMax = 0x7fffffff,
+};
+
 enum Op {
     OpNop = 0,
     OpUndef = 1,
diff --git a/test/extensions/KHR/SPV_KHR_bfloat16/bfloat16.ll b/test/extensions/KHR/SPV_KHR_bfloat16/bfloat16.ll
diff --git a/test/extensions/KHR/SPV_KHR_bfloat16/bfloat16_dot.ll b/test/extensions/KHR/SPV_KHR_bfloat16/bfloat16_dot.ll
diff --git a/test/negative/SPV_INTEL_bfloat16_conversion/f2bf16_inval_output_ty.spt b/test/negative/SPV_INTEL_bfloat16_conversion/f2bf16_inval_output_ty.spt
