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

compiler/rustc_abi/src/lib.rs

@@ -1404,6 +1404,7 @@ impl Integer {
 #[cfg_attr(feature = "nightly", derive(StableHash))]
 pub enum Float {
     F16,
+    F16B,
     F32,
     F64,
     F128,
@@ -1415,6 +1416,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 +1428,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 +1440,7 @@ impl Float {
 
         match self {
             F16 => "f16",
+            F16B => "f16b",
             F32 => "f32",
             F64 => "f64",
             F128 => "f128",

compiler/rustc_attr_ir/src/lang_items.rs

@@ -276,6 +276,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;
+    BFloat,                  sym::bfloat,              bfloat_type,                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/lib.rs

@@ -560,6 +560,7 @@ fn target_config(sess: &Session, target_info: &LockedTargetInfo) -> TargetConfig
         // 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: false,
         has_reliable_f128,
         has_reliable_f128_math: has_reliable_f128,
     }

compiler/rustc_codegen_gcc/src/type_.rs

@@ -156,6 +156,10 @@ impl<'gcc, 'tcx> BaseTypeCodegenMethods for CodegenCx<'gcc, 'tcx> {
         bug!("unsupported float width 16")
     }
 
+    fn type_f16b(&self) -> Type<'gcc> {
+        bug!("f16b is not supported by the GCC codegen backend")
+    }
+
     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 => panic!("`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.
@@ -547,6 +549,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

@@ -1560,6 +1560,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::BFloat) => (),
                 _ => {
                     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));
     }
@@ -407,6 +410,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::BFloat, 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

@@ -522,6 +522,7 @@ symbols! {
         begin_panic,
         bench,
         bevy_ecs,
+        bfloat,
         bikeshed,
         bikeshed_guaranteed_no_drop,
         bin,
@@ -600,6 +601,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,
@@ -2103,6 +2106,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"),
                     Float::F32 => Some(Reg::f32()),
                     Float::F64 => Some(Reg::f64()),
                     Float::F128 => Some(Reg::f128()),

compiler/rustc_target/src/callconv/sparc64.rs

@@ -58,6 +58,7 @@ fn classify<'a, Ty, C>(
                         Float::F16 => {
                             // Match LLVM by passing `f16` in integer registers.
                         }
+                        Float::F16B => panic!("`f16b` unsupported"),
                     }
                 } else {
                     /* pass unaligned floats in integer registers */

compiler/rustc_ty_utils/src/layout.rs

@@ -12,6 +12,7 @@ use rustc_abi::{
 use rustc_data_structures::Limit;
 use rustc_hashes::Hash64;
 use rustc_hir as hir;
+use rustc_hir::attrs::lang_items::LangItem;
 use rustc_hir::find_attr;
 use rustc_index::{Idx as _, IndexVec};
 use rustc_middle::bug;
@@ -738,7 +739,7 @@ fn layout_of_uncached<'tcx>(
                         .is_sized(tcx, typing_env)
                 });
 
-            let layout = cx
+            let mut layout = cx
                 .calc
                 .layout_of_struct_or_enum(
                     &def.repr(),
@@ -805,6 +806,13 @@ fn layout_of_uncached<'tcx>(
                 }
             }
 
+            if tcx.is_lang_item(def.did(), LangItem::BFloat) {
+                let bfloat = scalar_unit(Primitive::Float(abi::Float::F16B));
+                assert_eq!(layout.size, abi::Float::F16B.size());
+                assert_eq!(layout.align, abi::Float::F16B.align(cx));
+                layout.backend_repr = BackendRepr::Scalar(bfloat);
+            }
+
             tcx.mk_layout(layout)
         }