core::num::f16b Rust's 16bit Brain Float

compiler/rustc_abi/src/layout/ty.rs

@@ -325,7 +325,7 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
                 | Primitive::Float(Float::F16 | Float::F32 | Float::F64 | Float::F128) => {
                     Some(primitive)
                 }
-                Primitive::Pointer(..) => None,
+                Primitive::Pointer(..) | Primitive::Float(Float::F16B) => None,
             }
         } else {
             None

compiler/rustc_abi/src/lib.rs

@@ -1404,6 +1404,10 @@ impl Integer {
 #[cfg_attr(feature = "nightly", derive(StableHash))]
 pub enum Float {
     F16,
+    /// `f16b`. This is not a builtin type in Rust (it is exposed as a lang item),
+    /// but it is a builtin type in LLVM so needs to be explicitly represented
+    /// in the backend.
+    F16B,
     F32,
     F64,
     F128,
@@ -1415,6 +1419,7 @@ impl Float {
 
         match self {
             F16 => Size::from_bits(16),
+            F16B => Size::from_bits(16),
             F32 => Size::from_bits(32),
             F64 => Size::from_bits(64),
             F128 => Size::from_bits(128),
@@ -1426,7 +1431,7 @@ impl Float {
         let dl = cx.data_layout();
 
         AbiAlign::new(match self {
-            F16 => dl.f16_align,
+            F16 | F16B => dl.f16_align,
             F32 => dl.f32_align,
             F64 => dl.f64_align,
             F128 => dl.f128_align,
@@ -1438,6 +1443,7 @@ impl Float {
 
         match self {
             F16 => "f16",
+            F16B => "f16b",
             F32 => "f32",
             F64 => "f64",
             F128 => "f128",

compiler/rustc_attr_ir/src/lang_items.rs

@@ -281,6 +281,7 @@ language_item_table! {
     PartialEq,               sym::eq,                  eq_trait,                   Target::Trait,          GenericRequirement::Exact(1);
     PartialOrd,              sym::partial_ord,         partial_ord_trait,          Target::Trait,          GenericRequirement::Exact(1);
     CVoid,                   sym::c_void,              c_void,                     Target::Enum,           GenericRequirement::None;
+    F16B,                    sym::f16b,                f16b,                       Target::Struct,         GenericRequirement::Exact(0);
 
     Type,                    sym::type_info,           type_struct,                Target::Struct,         GenericRequirement::None;
     TypeGeneric,             sym::type_info_generic,   type_generic,               Target::Enum,         GenericRequirement::None;

compiler/rustc_codegen_cranelift/src/common.rs

@@ -34,6 +34,7 @@ pub(crate) fn scalar_to_clif_type(tcx: TyCtxt<'_>, scalar: Scalar) -> Type {
         },
         Primitive::Float(float) => match float {
             Float::F16 => types::F16,
+            Float::F16B => bug!("f16b is not supported by the Cranelift codegen backend"),
             Float::F32 => types::F32,
             Float::F64 => types::F64,
             Float::F128 => types::F128,

compiler/rustc_codegen_cranelift/src/lib.rs

@@ -190,6 +190,7 @@ impl CodegenBackend for CraneliftCodegenBackend {
             // available in Cranelift.
             has_reliable_f16: has_reliable_f16_f128,
             has_reliable_f16_math: has_reliable_f16_f128,
+            has_reliable_f16b: false,
             has_reliable_f128: has_reliable_f16_f128,
             has_reliable_f128_math,
         }

compiler/rustc_codegen_gcc/src/base.rs

@@ -214,6 +214,7 @@ pub fn compile_codegen_unit(
             // -fsyntax-only), forbid the compilation when get_target_info() is called on a
             // context.
             let f16_type_supported = target_info.supports_target_dependent_type(CType::Float16);
+            let f16b_type_supported = target_info.supports_target_dependent_type(CType::BFloat16);
             let f32_type_supported = target_info.supports_target_dependent_type(CType::Float32);
             let f64_type_supported = target_info.supports_target_dependent_type(CType::Float64);
             let f128_type_supported = target_info.supports_target_dependent_type(CType::Float128);
@@ -225,6 +226,7 @@ pub fn compile_codegen_unit(
                 tcx,
                 u128_type_supported,
                 f16_type_supported,
+                f16b_type_supported,
                 f32_type_supported,
                 f64_type_supported,
                 f128_type_supported,

compiler/rustc_codegen_gcc/src/context.rs

@@ -73,6 +73,7 @@ pub struct CodegenCx<'gcc, 'tcx> {
 
     pub supports_128bit_integers: bool,
     pub supports_f16_type: bool,
+    pub supports_f16b_type: bool,
     pub supports_f32_type: bool,
     pub supports_f64_type: bool,
     pub supports_f128_type: bool,
@@ -141,6 +142,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
         tcx: TyCtxt<'tcx>,
         supports_128bit_integers: bool,
         supports_f16_type: bool,
+        supports_f16b_type: bool,
         supports_f32_type: bool,
         supports_f64_type: bool,
         supports_f128_type: bool,
@@ -277,6 +279,7 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
 
             supports_128bit_integers,
             supports_f16_type,
+            supports_f16b_type,
             supports_f32_type,
             supports_f64_type,
             supports_f128_type,

compiler/rustc_codegen_gcc/src/lib.rs

@@ -553,13 +553,15 @@ fn target_config(sess: &Session, target_info: &LockedTargetInfo) -> TargetConfig
     );
 
     let has_reliable_f16 = target_info.supports_target_dependent_type(CType::Float16);
+    let has_reliable_f16b = target_info.supports_target_dependent_type(CType::BFloat16);
     let has_reliable_f128 = target_info.supports_target_dependent_type(CType::Float128);
 
     TargetConfig {
         internal_target_features,
         // There are no known bugs with GCC support for f16 or f128
         has_reliable_f16,
         has_reliable_f16_math: has_reliable_f16,
+        has_reliable_f16b,
         has_reliable_f128,
         has_reliable_f128_math: has_reliable_f128,
     }

compiler/rustc_codegen_gcc/src/type_.rs

@@ -156,6 +156,14 @@ impl<'gcc, 'tcx> BaseTypeCodegenMethods for CodegenCx<'gcc, 'tcx> {
         bug!("unsupported float width 16")
     }
 
+    fn type_f16b(&self) -> Type<'gcc> {
+        #[cfg(feature = "master")]
+        if self.supports_f16b_type {
+            return self.context.new_c_type(CType::BFloat16);
+        }
+        bug!("unsupported type bfloat16")
+    }
+
     fn type_f32(&self) -> Type<'gcc> {
         #[cfg(feature = "master")]
         if self.supports_f32_type {

compiler/rustc_codegen_llvm/src/abi.rs

@@ -158,6 +158,7 @@ impl LlvmType for Reg {
                     },
                     Primitive::Float(float) => match float {
                         Float::F16 => cx.type_f16(),
+                        Float::F16B => cx.type_f16b(),
                         Float::F32 => cx.type_f32(),
                         Float::F64 => cx.type_f64(),
                         Float::F128 => cx.type_f128(),

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -332,6 +332,9 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                     Primitive::Float(Float::F16) => {
                         bug!("the va_arg intrinsic does not support `f16`")
                     }
+                    Primitive::Float(Float::F16B) => {
+                        bug!("the va_arg intrinsic does not support `f16b`")
+                    }
                     Primitive::Float(Float::F32) => {
                         // c_double is actually f32 on avr.
                         if self.cx().sess().target.arch != Arch::Avr {

compiler/rustc_codegen_llvm/src/llvm_util.rs

@@ -353,6 +353,7 @@ pub(crate) fn target_config(sess: &Session) -> TargetConfig {
         internal_target_features,
         has_reliable_f16: true,
         has_reliable_f16_math: true,
+        has_reliable_f16b: true,
         has_reliable_f128: true,
         has_reliable_f128_math: true,
     };
@@ -390,6 +391,21 @@ fn update_target_reliable_float_cfg(sess: &Session, cfg: &mut TargetConfig) {
         _ => true,
     };
 
+    // The heuristic for evaluating to true is twofold, namely;
+    //
+    // 1. Can LLVM compile an IR snippet containing `fpext bfloat %<var> to float`
+    // 2. Does the documentation indicate `bf16` support, can be seen in the
+    //    tracking issue; <https://github.com/rust-lang/rust/issues/160630>
+    cfg.has_reliable_f16b = match (target_arch, target_os) {
+        // This is similar to <https://github.com/llvm/llvm-project/issues/94434>, however
+        // does not work until LLVM 23 on Windows.
+        (Arch::Arm64EC, _) => major >= 23,
+        (Arch::AArch64, _) | (Arch::X86_64, _) | (Arch::RiscV64, _) | (Arch::LoongArch64, _) => {
+            major >= 21
+        }
+        _ => false,
+    };
+
     cfg.has_reliable_f128 = match (target_arch, target_os) {
         // Unsupported https://github.com/llvm/llvm-project/issues/121122
         (Arch::AmdGpu, _) => false,

compiler/rustc_codegen_llvm/src/type_.rs

@@ -214,6 +214,10 @@ impl<'ll, CX: Borrow<SCx<'ll>>> BaseTypeCodegenMethods for GenericCx<'ll, CX> {
         unsafe { llvm::LLVMHalfTypeInContext(self.llcx()) }
     }
 
+    fn type_f16b(&self) -> &'ll Type {
+        unsafe { llvm::LLVMBFloatTypeInContext(self.llcx()) }
+    }
+
     fn type_f32(&self) -> &'ll Type {
         unsafe { llvm::LLVMFloatTypeInContext(self.llcx()) }
     }

compiler/rustc_codegen_llvm/src/va_arg.rs

@@ -95,7 +95,7 @@ fn get_param_type_alignment<'ll, 'tcx>(
                 Integer::I128 => return Align::EIGHT,
             },
             Primitive::Float(float) => match float {
-                Float::F16 | Float::F32 => unreachable!(),
+                Float::F16 | Float::F16B | Float::F32 => unreachable!(),
                 Float::F64 => { /* fall through */ }
                 Float::F128 => return Align::from_bytes(16).unwrap(),
             },

compiler/rustc_codegen_ssa/src/lib.rs

@@ -316,6 +316,9 @@ pub struct TargetConfig {
     pub has_reliable_f16: bool,
     /// Option for `cfg(target_has_reliable_f16_math)`, true if `f16` math calls work.
     pub has_reliable_f16_math: bool,
+    /// Option for `cfg(target_has_reliable_f16b)`, presently true if both the ABI
+    /// and LLVM version supports `f16b`.
+    pub has_reliable_f16b: bool,
     /// Option for `cfg(target_has_reliable_f128)`, true if `f128` basic arithmetic works.
     pub has_reliable_f128: bool,
     /// Option for `cfg(target_has_reliable_f128_math)`, true if `f128` math calls work.

compiler/rustc_codegen_ssa/src/mir/naked_asm.rs

@@ -506,6 +506,7 @@ fn wasm_primitive(primitive: Primitive, ptr_type: &'static str) -> &'static str
             Integer::I128 => "i64, i64",
         },
         Primitive::Float(float) => match float {
+            Float::F16B => bug!("`f16b` unsupported on wasm"),
             Float::F16 | Float::F32 => "f32",
             Float::F64 => "f64",
             Float::F128 => "i64, i64",

compiler/rustc_codegen_ssa/src/traits/backend.rs

@@ -49,6 +49,7 @@ pub trait CodegenBackend {
             // support the float types, rather than accidentally quietly skipping all tests.
             has_reliable_f16: true,
             has_reliable_f16_math: true,
+            has_reliable_f16b: true,
             has_reliable_f128: true,
             has_reliable_f128_math: true,
         }

compiler/rustc_codegen_ssa/src/traits/type_.rs

@@ -18,6 +18,7 @@ pub trait BaseTypeCodegenMethods: BackendTypes {
     fn type_isize(&self) -> Self::Type;
 
     fn type_f16(&self) -> Self::Type;
+    fn type_f16b(&self) -> Self::Type;
     fn type_f32(&self) -> Self::Type;
     fn type_f64(&self) -> Self::Type;
     fn type_f128(&self) -> Self::Type;
@@ -67,6 +68,7 @@ pub trait DerivedTypeCodegenMethods<'tcx>:
         use Float::*;
         match f {
             F16 => self.type_f16(),
+            F16B => self.type_f16b(),
             F32 => self.type_f32(),
             F64 => self.type_f64(),
             F128 => self.type_f128(),

compiler/rustc_feature/src/builtin_attrs.rs

@@ -40,6 +40,11 @@ const GATED_CFGS: &[GatedCfg] = &[
         sym::cfg_target_has_reliable_f16_f128,
         Features::cfg_target_has_reliable_f16_f128,
     ),
+    (
+        sym::target_has_reliable_f16b,
+        sym::cfg_target_has_reliable_f16b,
+        Features::cfg_target_has_reliable_f16b,
+    ),
     (
         sym::target_has_reliable_f128,
         sym::cfg_target_has_reliable_f16_f128,

compiler/rustc_feature/src/unstable.rs

@@ -254,6 +254,8 @@ declare_features! (
     (unstable, anonymous_lifetime_in_impl_trait, "1.63.0", None),
     /// Allows checking whether or not the backend correctly supports unstable float types.
     (internal, cfg_target_has_reliable_f16_f128, "1.88.0", None),
+    /// Allows checking whether or not the backend correctly supports the unstable `f16b` type.
+    (internal, cfg_target_has_reliable_f16b, "CURRENT_RUSTC_VERSION", None),
     /// Allows checking whether or not the target might have thread support.
     (internal, cfg_target_has_threads, "CURRENT_RUSTC_VERSION", None),
     /// Allows identifying the `compiler_builtins` crate.
@@ -545,6 +547,8 @@ declare_features! (
     (unstable, f128, "1.78.0", Some(116909)),
     /// Allow using 16-bit (half precision) floating point numbers.
     (unstable, f16, "1.78.0", Some(116909)),
+    /// Allow using bfloat16 floating point numbers.
+    (unstable, f16b, "CURRENT_RUSTC_VERSION", Some(160630)),
     /// Allows the use of `#[ffi_const]` on foreign functions.
     (unstable, ffi_const, "1.45.0", Some(58328)),
     /// Allows the use of `#[ffi_pure]` on foreign functions.

compiler/rustc_hir_analysis/src/check/check.rs

@@ -1566,6 +1566,8 @@ fn check_scalable_vector(tcx: TyCtxt<'_>, span: Span, def_id: LocalDefId, scalab
             // bools
             match element_ty.kind() {
                 ty::Int(_) | ty::Uint(_) | ty::Float(_) | ty::Bool => (),
+                // We need to treat a `bfloat` (`f16b`) as a primitive scalar
+                ty::Adt(def, _) if tcx.is_lang_item(def.did(), LangItem::F16B) => (),
                 _ => {
                     let mut err = tcx.dcx().struct_span_err(
                         span,

compiler/rustc_interface/src/util.rs

@@ -78,6 +78,9 @@ pub(crate) fn add_configuration(
     if tf_cfg.has_reliable_f16_math {
         cfg.insert((sym::target_has_reliable_f16_math, None));
     }
+    if tf_cfg.has_reliable_f16b {
+        cfg.insert((sym::target_has_reliable_f16b, None));
+    }
     if tf_cfg.has_reliable_f128 {
         cfg.insert((sym::target_has_reliable_f128, None));
     }
@@ -401,6 +404,7 @@ impl CodegenBackend for DummyCodegenBackend {
             internal_target_features,
             has_reliable_f16: true,
             has_reliable_f16_math: true,
+            has_reliable_f16b: true,
             has_reliable_f128: true,
             has_reliable_f128_math: true,
         }

compiler/rustc_middle/src/ty/layout.rs

@@ -139,6 +139,11 @@ impl abi::Float {
         use abi::Float::*;
         match *self {
             F16 => tcx.types.f16,
+            F16B => Ty::new_adt(
+                tcx,
+                tcx.adt_def(tcx.require_lang_item(LangItem::F16B, DUMMY_SP)),
+                ty::List::empty(),
+            ),
             F32 => tcx.types.f32,
             F64 => tcx.types.f64,
             F128 => tcx.types.f128,

compiler/rustc_public/src/abi.rs

@@ -353,6 +353,7 @@ pub enum IntegerLength {
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Serialize)]
 pub enum FloatLength {
     F16,
+    F16B,
     F32,
     F64,
     F128,
@@ -373,7 +374,7 @@ impl IntegerLength {
 impl FloatLength {
     pub fn bits(self) -> usize {
         match self {
-            FloatLength::F16 => 16,
+            FloatLength::F16 | FloatLength::F16B => 16,
             FloatLength::F32 => 32,
             FloatLength::F64 => 64,
             FloatLength::F128 => 128,

compiler/rustc_public/src/unstable/convert/stable/abi.rs

@@ -388,6 +388,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::Float {
     fn stable(&self, _: &mut Tables<'_, BridgeTys>, _: &CompilerCtxt<'_, BridgeTys>) -> Self::T {
         match self {
             rustc_abi::Float::F16 => FloatLength::F16,
+            rustc_abi::Float::F16B => FloatLength::F16B,
             rustc_abi::Float::F32 => FloatLength::F32,
             rustc_abi::Float::F64 => FloatLength::F64,
             rustc_abi::Float::F128 => FloatLength::F128,

compiler/rustc_session/src/config/cfg.rs

@@ -154,6 +154,7 @@ pub(crate) fn disallow_cfgs(sess: &Session, user_cfgs: &Cfg) {
             | (sym::target_has_atomic_load_store, Some(_))
             | (sym::target_has_reliable_f16, None | Some(_))
             | (sym::target_has_reliable_f16_math, None | Some(_))
+            | (sym::target_has_reliable_f16b, None | Some(_))
             | (sym::target_has_reliable_f128, None | Some(_))
             | (sym::target_has_reliable_f128_math, None | Some(_))
             | (sym::target_thread_local, None) => disallow(cfg, "--target"),

compiler/rustc_span/src/symbol.rs

@@ -521,6 +521,7 @@ symbols! {
         begin_panic,
         bench,
         bevy_ecs,
+        bfloat,
         bikeshed,
         bikeshed_guaranteed_no_drop,
         bin,
@@ -599,6 +600,7 @@ symbols! {
         cfg_target_has_atomic,
         cfg_target_has_atomic_equal_alignment,
         cfg_target_has_reliable_f16_f128,
+        cfg_target_has_reliable_f16b,
         cfg_target_has_threads,
         cfg_target_object_format,
         cfg_target_thread_local,
@@ -944,6 +946,7 @@ symbols! {
         external_doc,
         f16,
         f16_nan,
+        f16b,
         f16c_target_feature,
         f32,
         f32_nan,
@@ -2106,6 +2109,7 @@ symbols! {
         target_has_atomic_primitive_alignment,
         target_has_reliable_f16,
         target_has_reliable_f16_math,
+        target_has_reliable_f16b,
         target_has_reliable_f128,
         target_has_reliable_f128_math,
         target_has_threads,

compiler/rustc_target/src/callconv/mips64.rs

@@ -31,6 +31,8 @@ where
                 match float {
                     // C does not have the f16 type
                     Float::F16 => None,
+                    // No `f16b` type
+                    Float::F16B => panic!("`f16b` unsupported on mips64"),
                     Float::F32 => Some(Reg::f32()),
                     Float::F64 => Some(Reg::f64()),
                     Float::F128 => Some(Reg::f128()),