Fixup the generator and mostly finalize levels

Author: DJMcNab

fearless_simd_core/gen/src/main.rs

@@ -150,7 +150,7 @@ fn generate_x86_level(
 
     let level_struct_name = level.to_uppercase();
     // The target_feature(enable = "...") string.
-    let lcd_contents = lcd.join(", ");
+    let lcd_contents = lcd.join(",");
     // The fields of the new struct.
     let lcd_field_definitions = lcd
         .iter()
@@ -159,11 +159,13 @@ fn generate_x86_level(
                 .iter()
                 .find(|it| it.feature.feature_name == *feature)
                 .unwrap();
-            let type_path = format!(
-                "crate::x86::{}::{}",
-                normalized.feature.module, normalized.feature.struct_name
-            );
-            format!("{feature}: {type_path},\n")
+            let type_path = format!("crate::x86::{level}::{}", normalized.feature.struct_name);
+            let feature = feature.replace(".", "_");
+            format!(
+                "/// The contained proof that {} is available.\n\
+            pub {feature}: {type_path},\n",
+                normalized.feature.feature_docs_name
+            )
         })
         .collect::<String>();
     // The enabled FEATURES.
@@ -180,14 +182,12 @@ fn generate_x86_level(
                 .iter()
                 .find(|it| it.feature.feature_name == *feature)
                 .unwrap();
-            let type_path = format!(
-                "crate::x86::{}::{}",
-                normalized.feature.module, normalized.feature.struct_name
-            );
+            let type_path = format!("crate::x86::{level}::{}", normalized.feature.struct_name);
+            let feature = feature.replace(".", "_");
             format!("{type_path} = self.{feature}")
         })
         .collect::<Vec<_>>()
-        .join(",");
+        .join(", ");
     // The version of the struct initializer in `try_new`.
     let struct_initializer_try_new = lcd
         .iter()
@@ -196,10 +196,8 @@ fn generate_x86_level(
                 .iter()
                 .find(|it| it.feature.feature_name == *feature)
                 .unwrap();
-            let type_path = format!(
-                "crate::x86::{}::{}",
-                normalized.feature.module, normalized.feature.struct_name
-            );
+            let type_path = format!("crate::x86::{level}::{}", normalized.feature.struct_name);
+            let feature = feature.replace(".", "_");
             // We rely on rustfmt to get the tab spacing right.
             format!("\t{feature}: {type_path}::try_new()?,\n")
         })
@@ -212,10 +210,8 @@ fn generate_x86_level(
                 .iter()
                 .find(|it| it.feature.feature_name == *feature)
                 .unwrap();
-            let type_path = format!(
-                "crate::x86::{}::{}",
-                normalized.feature.module, normalized.feature.struct_name
-            );
+            let type_path = format!("crate::x86::{level}::{}", normalized.feature.struct_name);
+            let feature = feature.replace(".", "_");
             format!("\t{feature}: {type_path}::new(),\n")
         })
         .collect::<String>();
@@ -226,10 +222,7 @@ fn generate_x86_level(
             .iter()
             .find(|it| it.feature.feature_name == *child)
             .unwrap();
-        let type_path = format!(
-            "crate::x86::{}::{}",
-            from_feature.feature.module, from_feature.feature.struct_name
-        );
+        let type_path = format!("crate::x86::{level}::{}", from_feature.feature.struct_name);
         write!(
                 from_impls,
                 "\n\
@@ -249,6 +242,9 @@ impl From<LEVEL_STRUCT_NAME> for {type_path} {{
     );
     // We replace the from impls first, as they use template variables from the rest of this.
     result = result.replace("/*{FROM_IMPLS}*/", &from_impls);
+    result = result.replace("LEVEL_STRUCT_NAME", &level_struct_name);
+    result = result.replace("{LEVEL_ID}", level);
+    result = result.replace("{LEVEL_FEATURE_LCD_CONTENTS}", &lcd_contents);
     result = result.replace(
         "/*{LEVEL_FEATURE_LCD_FIELD_DEFINITIONS}*/",
         &lcd_field_definitions,

fearless_simd_core/gen/templates/x86_level.rs

@@ -81,6 +81,8 @@ impl LEVEL_STRUCT_NAME {
         }
     }
 }
+// TODO: From impls to convert into lower x86 versions.
+
 /*{FROM_IMPLS}*/
 
 const _: () = {

fearless_simd_core/src/x86/adx/adx.rs

@@ -37,12 +37,15 @@ impl Debug for Adx {
     }
 }
 
+// Safety: This token can only be constructed if you have proof that all the requisite
+// target feature is enabled.
 unsafe impl TargetFeatureToken for Adx {
     const FEATURES: &[&str] = &["adx"];
 
     #[inline(always)]
     fn vectorize<R>(self, f: impl FnOnce() -> R) -> R {
-        // Because we want this constant to be eagerly evaluated.
+        // Because we need the safety check to be eagerly evaluated, it uses an constant item.
+        // This means we can't use `Self = self` here, unfortunately.
         trampoline!([Adx = self] => "adx", <(R)> fn<(R)>(f: impl FnOnce() -> R = f) -> R { f() })
     }
 }

fearless_simd_core/src/x86/avx/avx.rs

@@ -37,12 +37,15 @@ impl Debug for Avx {
     }
 }
 
+// Safety: This token can only be constructed if you have proof that all the requisite
+// target feature is enabled.
 unsafe impl TargetFeatureToken for Avx {
     const FEATURES: &[&str] = &["avx", "sse", "sse2", "sse3", "sse4.1", "sse4.2", "ssse3"];
 
     #[inline(always)]
     fn vectorize<R>(self, f: impl FnOnce() -> R) -> R {
-        // Because we want this constant to be eagerly evaluated.
+        // Because we need the safety check to be eagerly evaluated, it uses an constant item.
+        // This means we can't use `Self = self` here, unfortunately.
         trampoline!([Avx = self] => "avx", <(R)> fn<(R)>(f: impl FnOnce() -> R = f) -> R { f() })
     }
 }

fearless_simd_core/src/x86/avx/avx2.rs

@@ -37,14 +37,17 @@ impl Debug for Avx2 {
     }
 }
 
+// Safety: This token can only be constructed if you have proof that all the requisite
+// target feature is enabled.
 unsafe impl TargetFeatureToken for Avx2 {
     const FEATURES: &[&str] = &[
         "avx2", "avx", "sse", "sse2", "sse3", "sse4.1", "sse4.2", "ssse3",
     ];
 
     #[inline(always)]
     fn vectorize<R>(self, f: impl FnOnce() -> R) -> R {
-        // Because we want this constant to be eagerly evaluated.
+        // Because we need the safety check to be eagerly evaluated, it uses an constant item.
+        // This means we can't use `Self = self` here, unfortunately.
         trampoline!([Avx2 = self] => "avx2", <(R)> fn<(R)>(f: impl FnOnce() -> R = f) -> R { f() })
     }
 }

fearless_simd_core/src/x86/avx/avxifma.rs

@@ -37,14 +37,17 @@ impl Debug for Avxifma {
     }
 }
 
+// Safety: This token can only be constructed if you have proof that all the requisite
+// target feature is enabled.
 unsafe impl TargetFeatureToken for Avxifma {
     const FEATURES: &[&str] = &[
         "avxifma", "avx", "avx2", "sse", "sse2", "sse3", "sse4.1", "sse4.2", "ssse3",
     ];
 
     #[inline(always)]
     fn vectorize<R>(self, f: impl FnOnce() -> R) -> R {
-        // Because we want this constant to be eagerly evaluated.
+        // Because we need the safety check to be eagerly evaluated, it uses an constant item.
+        // This means we can't use `Self = self` here, unfortunately.
         trampoline!([Avxifma = self] => "avxifma", <(R)> fn<(R)>(f: impl FnOnce() -> R = f) -> R { f() })
     }
 }

fearless_simd_core/src/x86/avx/avxneconvert.rs

@@ -37,6 +37,8 @@ impl Debug for Avxneconvert {
     }
 }
 
+// Safety: This token can only be constructed if you have proof that all the requisite
+// target feature is enabled.
 unsafe impl TargetFeatureToken for Avxneconvert {
     const FEATURES: &[&str] = &[
         "avxneconvert",
@@ -52,7 +54,8 @@ unsafe impl TargetFeatureToken for Avxneconvert {
 
     #[inline(always)]
     fn vectorize<R>(self, f: impl FnOnce() -> R) -> R {
-        // Because we want this constant to be eagerly evaluated.
+        // Because we need the safety check to be eagerly evaluated, it uses an constant item.
+        // This means we can't use `Self = self` here, unfortunately.
         trampoline!([Avxneconvert = self] => "avxneconvert", <(R)> fn<(R)>(f: impl FnOnce() -> R = f) -> R { f() })
     }
 }

fearless_simd_core/src/x86/avx/avxvnni.rs

@@ -37,14 +37,17 @@ impl Debug for Avxvnni {
     }
 }
 
+// Safety: This token can only be constructed if you have proof that all the requisite
+// target feature is enabled.
 unsafe impl TargetFeatureToken for Avxvnni {
     const FEATURES: &[&str] = &[
         "avxvnni", "avx", "avx2", "sse", "sse2", "sse3", "sse4.1", "sse4.2", "ssse3",
     ];
 
     #[inline(always)]
     fn vectorize<R>(self, f: impl FnOnce() -> R) -> R {
-        // Because we want this constant to be eagerly evaluated.
+        // Because we need the safety check to be eagerly evaluated, it uses an constant item.
+        // This means we can't use `Self = self` here, unfortunately.
         trampoline!([Avxvnni = self] => "avxvnni", <(R)> fn<(R)>(f: impl FnOnce() -> R = f) -> R { f() })
     }
 }

fearless_simd_core/src/x86/avx/avxvnniint16.rs

@@ -37,6 +37,8 @@ impl Debug for Avxvnniint16 {
     }
 }
 
+// Safety: This token can only be constructed if you have proof that all the requisite
+// target feature is enabled.
 unsafe impl TargetFeatureToken for Avxvnniint16 {
     const FEATURES: &[&str] = &[
         "avxvnniint16",
@@ -52,7 +54,8 @@ unsafe impl TargetFeatureToken for Avxvnniint16 {
 
     #[inline(always)]
     fn vectorize<R>(self, f: impl FnOnce() -> R) -> R {
-        // Because we want this constant to be eagerly evaluated.
+        // Because we need the safety check to be eagerly evaluated, it uses an constant item.
+        // This means we can't use `Self = self` here, unfortunately.
         trampoline!([Avxvnniint16 = self] => "avxvnniint16", <(R)> fn<(R)>(f: impl FnOnce() -> R = f) -> R { f() })
     }
 }

fearless_simd_core/src/x86/avx/avxvnniint8.rs

@@ -37,6 +37,8 @@ impl Debug for Avxvnniint8 {
     }
 }
 
+// Safety: This token can only be constructed if you have proof that all the requisite
+// target feature is enabled.
 unsafe impl TargetFeatureToken for Avxvnniint8 {
     const FEATURES: &[&str] = &[
         "avxvnniint8",
@@ -52,7 +54,8 @@ unsafe impl TargetFeatureToken for Avxvnniint8 {
 
     #[inline(always)]
     fn vectorize<R>(self, f: impl FnOnce() -> R) -> R {
-        // Because we want this constant to be eagerly evaluated.
+        // Because we need the safety check to be eagerly evaluated, it uses an constant item.
+        // This means we can't use `Self = self` here, unfortunately.
         trampoline!([Avxvnniint8 = self] => "avxvnniint8", <(R)> fn<(R)>(f: impl FnOnce() -> R = f) -> R { f() })
     }
 }