feat(quant): complete op × quant-format matrix — 30 Track-1 formats across every weight-bearing kernel

crates/metaltile-codegen/src/msl/features.rs

@@ -47,6 +47,11 @@ pub(super) struct KernelFeatures {
     pub needs_erf: bool,
     pub needs_erfinv: bool,
     pub needs_expm1: bool,
+    /// Block-scaled dequant decode helpers (`mt_decode_e2m1/e4m3/e5m2/int8`).
+    pub needs_decode_e2m1: bool,
+    pub needs_decode_e4m3: bool,
+    pub needs_decode_e5m2: bool,
+    pub needs_decode_int8: bool,
     pub needs_simd_product: bool,
     /// MetalPerformancePrimitives (`mpp::tensor_ops::matmul2d` / NAX) needed.
     /// Detected by scanning `Op::InlineMsl::source` for `"mpp::"` — kernels
@@ -71,6 +76,10 @@ impl MslGenerator {
             needs_erf: false,
             needs_erfinv: false,
             needs_expm1: false,
+            needs_decode_e2m1: false,
+            needs_decode_e4m3: false,
+            needs_decode_e5m2: false,
+            needs_decode_int8: false,
             needs_simd_product: false,
             needs_mpp: false,
         };
@@ -189,6 +198,10 @@ impl MslGenerator {
             Op::UnaryOp { op: UnaryOpKind::Erf, .. } => feat.needs_erf = true,
             Op::UnaryOp { op: UnaryOpKind::ErfInv, .. } => feat.needs_erfinv = true,
             Op::UnaryOp { op: UnaryOpKind::Expm1, .. } => feat.needs_expm1 = true,
+            Op::UnaryOp { op: UnaryOpKind::DecodeE2m1, .. } => feat.needs_decode_e2m1 = true,
+            Op::UnaryOp { op: UnaryOpKind::DecodeE4m3, .. } => feat.needs_decode_e4m3 = true,
+            Op::UnaryOp { op: UnaryOpKind::DecodeE5m2, .. } => feat.needs_decode_e5m2 = true,
+            Op::UnaryOp { op: UnaryOpKind::DecodeInt8, .. } => feat.needs_decode_int8 = true,
             Op::FusedElementwise { ops } =>
                 for inner in ops {
                     self.analyze_op(inner, feat);

crates/metaltile-codegen/src/msl/preamble.rs

@@ -156,6 +156,56 @@ impl super::MslGenerator {
             wl!(out, "template<typename T>");
             wl!(out, "inline T mt_expm1_impl(T x) {{ return T(mt_expm1_impl(float(x))); }}");
         }
+        // Block-scaled dequant decodes (mirror crates/metaltile-std quant::codec).
+        // Operand is the raw integer code; result is always f32.
+        if feat.needs_decode_e2m1 {
+            wl!(out);
+            wl!(out, "// E2M1 (fp4): codebook {{0,.5,1,1.5,2,3,4,6}}, sign in bit 3.");
+            wl!(out, "inline float mt_decode_e2m1(uint code) {{");
+            wl!(out, "    uint m = code & 7u;");
+            wl!(
+                out,
+                "    float mag = (m < 1u) ? 0.0f : (m < 2u) ? 0.5f : (m < 3u) ? 1.0f : \
+                 (m < 4u) ? 1.5f : (m < 5u) ? 2.0f : (m < 6u) ? 3.0f : (m < 7u) ? 4.0f : 6.0f;"
+            );
+            wl!(out, "    return (code & 8u) ? -mag : mag;");
+            wl!(out, "}}");
+        }
+        if feat.needs_decode_e4m3 {
+            wl!(out);
+            wl!(out, "// E4M3 (fp8): (1+m/8)*2^(e-7); subnormal m*2^-9; sign in bit 7.");
+            wl!(out, "inline float mt_decode_e4m3(uint bits) {{");
+            wl!(out, "    uint e = (bits >> 3u) & 15u;");
+            wl!(out, "    uint m = bits & 7u;");
+            wl!(
+                out,
+                "    float mag = (e < 1u) ? (float(m) * 0.001953125f) \
+                 : ((1.0f + float(m) * 0.125f) * exp2(float(e) - 7.0f));"
+            );
+            wl!(out, "    return ((bits >> 7u) & 1u) ? -mag : mag;");
+            wl!(out, "}}");
+        }
+        if feat.needs_decode_e5m2 {
+            wl!(out);
+            wl!(out, "// E5M2 (fp8): (1+m/4)*2^(e-15); subnormal m*2^-16; sign in bit 7.");
+            wl!(out, "inline float mt_decode_e5m2(uint bits) {{");
+            wl!(out, "    uint e = (bits >> 2u) & 31u;");
+            wl!(out, "    uint m = bits & 3u;");
+            wl!(
+                out,
+                "    float mag = (e < 1u) ? (float(m) * 0.0000152587890625f) \
+                 : ((1.0f + float(m) * 0.25f) * exp2(float(e) - 15.0f));"
+            );
+            wl!(out, "    return ((bits >> 7u) & 1u) ? -mag : mag;");
+            wl!(out, "}}");
+        }
+        if feat.needs_decode_int8 {
+            wl!(out);
+            wl!(out, "// Symmetric int8: reinterpret the byte as i8 (sign-extend low 8 bits).");
+            wl!(out, "inline float mt_decode_int8(uint bits) {{");
+            wl!(out, "    return float(int(bits << 24u) >> 24);");
+            wl!(out, "}}");
+        }
         if feat.needs_simd_product {
             wl!(out);
             // simd_size is only accessible as a kernel attribute, not in free functions.

crates/metaltile-codegen/src/passes/type_check.rs

@@ -482,6 +482,16 @@ fn infer_block(
                     env.insert(vid, TypedValue { dtype: tv.dtype, shape: tv.shape.clone() });
                 },
 
+            // Block-scaled decodes consume an integer code and always produce
+            // f32, so their result dtype is f32 regardless of the operand dtype.
+            Op::UnaryOp { op, value } if op.yields_f32() =>
+                if let Some(tv) = env.get(value) {
+                    env.insert(vid, TypedValue {
+                        dtype: metaltile_core::dtype::DType::F32,
+                        shape: tv.shape.clone(),
+                    });
+                },
+
             Op::UnaryOp { value, .. } | Op::Activation { value, .. } => {
                 if let Some(tv) = env.get(value) {
                     env.insert(vid, TypedValue { dtype: tv.dtype, shape: tv.shape.clone() });

crates/metaltile-core/src/ir/op.rs

@@ -59,6 +59,19 @@ pub enum UnaryOpKind {
     Log10,
     /// Inverse error function: `erfinv(x)`.
     ErfInv,
+    /// Decode a 4-bit E2M1 (fp4) code → signed f32 (codebook
+    /// `{0,.5,1,1.5,2,3,4,6}`, sign in bit 3). Operand is the `u32` code;
+    /// result is always f32. See `quant::codec::e2m1_decode`.
+    DecodeE2m1,
+    /// Decode an 8-bit E4M3 (fp8) byte → f32 (`(1+m/8)·2^(e-7)`, ±448, no inf).
+    /// Used for fp8 elements and nvfp4 micro-scales. See `quant::codec::e4m3_decode`.
+    DecodeE4m3,
+    /// Decode an 8-bit E5M2 (fp8) byte → f32 (IEEE-half high byte).
+    /// See `quant::codec::e5m2_decode`.
+    DecodeE5m2,
+    /// Decode a symmetric-int8 code (a `u8` reinterpreted as `i8`) → f32. The
+    /// per-group float scale is applied separately. See `quant::codec::int8_decode`.
+    DecodeInt8,
 }
 
 impl UnaryOpKind {
@@ -97,8 +110,24 @@ impl UnaryOpKind {
             UnaryOpKind::Expm1 => format!("mt_expm1_impl({arg})"),
             UnaryOpKind::Log10 => format!("log10({arg})"),
             UnaryOpKind::ErfInv => format!("mt_erfinv_impl({arg})"),
+            UnaryOpKind::DecodeE2m1 => format!("mt_decode_e2m1({arg})"),
+            UnaryOpKind::DecodeE4m3 => format!("mt_decode_e4m3({arg})"),
+            UnaryOpKind::DecodeE5m2 => format!("mt_decode_e5m2({arg})"),
+            UnaryOpKind::DecodeInt8 => format!("mt_decode_int8({arg})"),
         }
     }
+
+    /// True for the quant decode ops, whose result is always f32 regardless of
+    /// the (integer) operand dtype.
+    pub fn yields_f32(self) -> bool {
+        matches!(
+            self,
+            UnaryOpKind::DecodeE2m1
+                | UnaryOpKind::DecodeE4m3
+                | UnaryOpKind::DecodeE5m2
+                | UnaryOpKind::DecodeInt8
+        )
+    }
 }
 
 /// Neural activation function kind.

crates/metaltile-macros/src/kernel/body.rs

@@ -2181,6 +2181,11 @@ fn unary_op_kind(name: &str) -> Option<TokenStream> {
         "expm1" => quote! { UnaryOpKind::Expm1 },
         "log10" => quote! { UnaryOpKind::Log10 },
         "erfinv" => quote! { UnaryOpKind::ErfInv },
+        // Block-scaled dequant decodes: u32 code → f32 (see quant::codec).
+        "e2m1_decode" => quote! { UnaryOpKind::DecodeE2m1 },
+        "e4m3_decode" => quote! { UnaryOpKind::DecodeE4m3 },
+        "e5m2_decode" => quote! { UnaryOpKind::DecodeE5m2 },
+        "int8_decode" => quote! { UnaryOpKind::DecodeInt8 },
         _ => return None,
     })
 }