Add a wasmtime settings command to print Cranelift settings.

This commit adds the `wasmtime settings` command to print out available
Cranelift settings for a target (defaults to the host).

The compile command has been updated to remove the Cranelift ISA options in
favor of encouraging users to use `wasmtime settings` to discover what settings
are available.  This will reduce the maintenance cost for syncing the compile
command with Cranelift ISA flags.

cranelift/codegen/meta/src/cdsl/settings.rs

@@ -20,6 +20,7 @@ pub(crate) enum SpecificSetting {
 #[derive(Hash, PartialEq, Eq)]
 pub(crate) struct Setting {
     pub name: &'static str,
+    pub description: &'static str,
     pub comment: &'static str,
     pub specific: SpecificSetting,
     pub byte_offset: u8,
@@ -88,6 +89,7 @@ impl Into<PresetType> for PresetIndex {
 #[derive(Hash, PartialEq, Eq)]
 pub(crate) struct Preset {
     pub name: &'static str,
+    pub description: &'static str,
     values: Vec<BoolSettingIndex>,
 }
 
@@ -169,6 +171,7 @@ pub(crate) enum ProtoSpecificSetting {
 /// This is the information provided during building for a setting.
 struct ProtoSetting {
     name: &'static str,
+    description: &'static str,
     comment: &'static str,
     specific: ProtoSpecificSetting,
 }
@@ -251,11 +254,13 @@ impl SettingGroupBuilder {
     fn add_setting(
         &mut self,
         name: &'static str,
+        description: &'static str,
         comment: &'static str,
         specific: ProtoSpecificSetting,
     ) {
         self.settings.push(ProtoSetting {
             name,
+            description,
             comment,
             specific,
         })
@@ -264,35 +269,63 @@ impl SettingGroupBuilder {
     pub fn add_bool(
         &mut self,
         name: &'static str,
+        description: &'static str,
         comment: &'static str,
         default: bool,
     ) -> BoolSettingIndex {
         assert!(
             self.predicates.is_empty(),
             "predicates must be added after the boolean settings"
         );
-        self.add_setting(name, comment, ProtoSpecificSetting::Bool(default));
+        self.add_setting(
+            name,
+            description,
+            comment,
+            ProtoSpecificSetting::Bool(default),
+        );
         BoolSettingIndex(self.settings.len() - 1)
     }
 
     pub fn add_enum(
         &mut self,
         name: &'static str,
+        description: &'static str,
         comment: &'static str,
         values: Vec<&'static str>,
     ) {
-        self.add_setting(name, comment, ProtoSpecificSetting::Enum(values));
+        self.add_setting(
+            name,
+            description,
+            comment,
+            ProtoSpecificSetting::Enum(values),
+        );
     }
 
-    pub fn add_num(&mut self, name: &'static str, comment: &'static str, default: u8) {
-        self.add_setting(name, comment, ProtoSpecificSetting::Num(default));
+    pub fn add_num(
+        &mut self,
+        name: &'static str,
+        description: &'static str,
+        comment: &'static str,
+        default: u8,
+    ) {
+        self.add_setting(
+            name,
+            description,
+            comment,
+            ProtoSpecificSetting::Num(default),
+        );
     }
 
     pub fn add_predicate(&mut self, name: &'static str, node: PredicateNode) {
         self.predicates.push(ProtoPredicate { name, node });
     }
 
-    pub fn add_preset(&mut self, name: &'static str, args: Vec<PresetType>) -> PresetIndex {
+    pub fn add_preset(
+        &mut self,
+        name: &'static str,
+        description: &'static str,
+        args: Vec<PresetType>,
+    ) -> PresetIndex {
         let mut values = Vec::new();
         for arg in args {
             match arg {
@@ -302,7 +335,11 @@ impl SettingGroupBuilder {
                 PresetType::BoolSetting(index) => values.push(index),
             }
         }
-        self.presets.push(Preset { name, values });
+        self.presets.push(Preset {
+            name,
+            description,
+            values,
+        });
         PresetIndex(self.presets.len() - 1)
     }
 
@@ -347,6 +384,7 @@ impl SettingGroupBuilder {
 
             group.settings.push(Setting {
                 name: s.name,
+                description: s.description,
                 comment: s.comment,
                 byte_offset,
                 specific,
@@ -367,6 +405,7 @@ impl SettingGroupBuilder {
             };
             group.settings.push(Setting {
                 name: s.name,
+                description: s.description,
                 comment: s.comment,
                 byte_offset: byte_offset + predicate_number / 8,
                 specific: SpecificSetting::Bool(BoolSetting {

cranelift/codegen/meta/src/gen_settings.rs

@@ -202,7 +202,7 @@ fn gen_enum_types(group: &SettingGroup, fmt: &mut Formatter) {
 
 /// Emit a getter function for `setting`.
 fn gen_getter(setting: &Setting, fmt: &mut Formatter) {
-    fmt.doc_comment(setting.comment);
+    fmt.doc_comment(format!("{}\n{}", setting.description, setting.comment));
     match setting.specific {
         SpecificSetting::Bool(BoolSetting {
             predicate_number, ..
@@ -320,6 +320,7 @@ fn gen_descriptors(group: &SettingGroup, fmt: &mut Formatter) {
             fmtln!(fmt, "detail::Descriptor {");
             fmt.indent(|fmt| {
                 fmtln!(fmt, "name: \"{}\",", setting.name);
+                fmtln!(fmt, "description: \"{}\",", setting.description);
                 fmtln!(fmt, "offset: {},", setting.byte_offset);
                 match setting.specific {
                     SpecificSetting::Bool(BoolSetting { bit_offset, .. }) => {
@@ -352,6 +353,7 @@ fn gen_descriptors(group: &SettingGroup, fmt: &mut Formatter) {
             fmtln!(fmt, "detail::Descriptor {");
             fmt.indent(|fmt| {
                 fmtln!(fmt, "name: \"{}\",", preset.name);
+                fmtln!(fmt, "description: \"{}\",", preset.description);
                 fmtln!(fmt, "offset: {},", (idx as u8) * group.settings_size);
                 fmtln!(fmt, "detail: detail::Detail::Preset,");
             });

cranelift/codegen/meta/src/isa/arm64/mod.rs

@@ -8,11 +8,8 @@ use crate::cdsl::settings::{SettingGroup, SettingGroupBuilder};
 use crate::shared::Definitions as SharedDefinitions;
 
 fn define_settings(_shared: &SettingGroup) -> SettingGroup {
-    // Note: Wasmtime's `compile` command exposes these settings as CLI options
-    // If the settings change, please update src/commands/compile.rs to match.
-
     let mut setting = SettingGroupBuilder::new("arm64");
-    let has_lse = setting.add_bool("has_lse", "Large System Extensions", false);
+    let has_lse = setting.add_bool("has_lse", "Has Large System Extensions support.", "", false);
 
     setting.add_predicate("use_lse", predicate!(has_lse));
     setting.build()

cranelift/codegen/meta/src/isa/riscv/mod.rs

@@ -17,33 +17,39 @@ fn define_settings(shared: &SettingGroup) -> SettingGroup {
     let supports_m = setting.add_bool(
         "supports_m",
         "CPU supports the 'M' extension (mul/div)",
+        "",
         false,
     );
     let supports_a = setting.add_bool(
         "supports_a",
         "CPU supports the 'A' extension (atomics)",
+        "",
         false,
     );
     let supports_f = setting.add_bool(
         "supports_f",
         "CPU supports the 'F' extension (float)",
+        "",
         false,
     );
     let supports_d = setting.add_bool(
         "supports_d",
         "CPU supports the 'D' extension (double)",
+        "",
         false,
     );
 
     let enable_m = setting.add_bool(
         "enable_m",
         "Enable the use of 'M' instructions if available",
+        "",
         true,
     );
 
     setting.add_bool(
         "enable_e",
         "Enable the 'RV32E' instruction set with only 16 registers",
+        "",
         false,
     );
 

cranelift/codegen/meta/src/isa/x86/settings.rs

@@ -3,48 +3,86 @@ use crate::cdsl::settings::{PredicateNode, SettingGroup, SettingGroupBuilder};
 pub(crate) fn define(shared: &SettingGroup) -> SettingGroup {
     let mut settings = SettingGroupBuilder::new("x86");
 
-    // Note: Wasmtime's `compile` command exposes these settings as CLI options
-    // If the settings change, please update src/commands/compile.rs to match.
-
     // CPUID.01H:ECX
-    let has_sse3 = settings.add_bool("has_sse3", "SSE3: CPUID.01H:ECX.SSE3[bit 0]", false);
-    let has_ssse3 = settings.add_bool("has_ssse3", "SSSE3: CPUID.01H:ECX.SSSE3[bit 9]", false);
-    let has_sse41 = settings.add_bool("has_sse41", "SSE4.1: CPUID.01H:ECX.SSE4_1[bit 19]", false);
-    let has_sse42 = settings.add_bool("has_sse42", "SSE4.2: CPUID.01H:ECX.SSE4_2[bit 20]", false);
-    let has_avx = settings.add_bool("has_avx", "AVX: CPUID.01H:ECX.AVX[bit 28]", false);
-    let has_avx2 = settings.add_bool("has_avx2", "AVX2: CPUID.07H:EBX.AVX2[bit 5]", false);
+    let has_sse3 = settings.add_bool(
+        "has_sse3",
+        "Has support for SSE3.",
+        "SSE3: CPUID.01H:ECX.SSE3[bit 0]",
+        false,
+    );
+    let has_ssse3 = settings.add_bool(
+        "has_ssse3",
+        "Has support for SSSE3.",
+        "SSSE3: CPUID.01H:ECX.SSSE3[bit 9]",
+        false,
+    );
+    let has_sse41 = settings.add_bool(
+        "has_sse41",
+        "Has support for SSE4.1.",
+        "SSE4.1: CPUID.01H:ECX.SSE4_1[bit 19]",
+        false,
+    );
+    let has_sse42 = settings.add_bool(
+        "has_sse42",
+        "Has support for SSE4.2.",
+        "SSE4.2: CPUID.01H:ECX.SSE4_2[bit 20]",
+        false,
+    );
+    let has_avx = settings.add_bool(
+        "has_avx",
+        "Has support for AVX.",
+        "AVX: CPUID.01H:ECX.AVX[bit 28]",
+        false,
+    );
+    let has_avx2 = settings.add_bool(
+        "has_avx2",
+        "Has support for AVX2.",
+        "AVX2: CPUID.07H:EBX.AVX2[bit 5]",
+        false,
+    );
     let has_avx512dq = settings.add_bool(
         "has_avx512dq",
+        "Has support for AVX512DQ.",
         "AVX512DQ: CPUID.07H:EBX.AVX512DQ[bit 17]",
         false,
     );
     let has_avx512vl = settings.add_bool(
         "has_avx512vl",
+        "Has support for AVX512VL.",
         "AVX512VL: CPUID.07H:EBX.AVX512VL[bit 31]",
         false,
     );
     let has_avx512f = settings.add_bool(
         "has_avx512f",
+        "Has support for AVX512F.",
         "AVX512F: CPUID.07H:EBX.AVX512F[bit 16]",
         false,
     );
-    let has_popcnt = settings.add_bool("has_popcnt", "POPCNT: CPUID.01H:ECX.POPCNT[bit 23]", false);
+    let has_popcnt = settings.add_bool(
+        "has_popcnt",
+        "Has support for POPCNT.",
+        "POPCNT: CPUID.01H:ECX.POPCNT[bit 23]",
+        false,
+    );
 
     // CPUID.(EAX=07H, ECX=0H):EBX
     let has_bmi1 = settings.add_bool(
         "has_bmi1",
+        "Has support for BMI1.",
         "BMI1: CPUID.(EAX=07H, ECX=0H):EBX.BMI1[bit 3]",
         false,
     );
     let has_bmi2 = settings.add_bool(
         "has_bmi2",
+        "Has support for BMI2.",
         "BMI2: CPUID.(EAX=07H, ECX=0H):EBX.BMI2[bit 8]",
         false,
     );
 
     // CPUID.EAX=80000001H:ECX
     let has_lzcnt = settings.add_bool(
         "has_lzcnt",
+        "Has support for LZCNT.",
         "LZCNT: CPUID.EAX=80000001H:ECX.LZCNT[bit 5]",
         false,
     );
@@ -107,21 +145,40 @@ pub(crate) fn define(shared: &SettingGroup) -> SettingGroup {
 
     // Presets corresponding to x86 CPUs.
 
-    settings.add_preset("baseline", preset!());
+    settings.add_preset(
+        "baseline",
+        "A baseline preset with no extensions enabled.",
+        preset!(),
+    );
     let nehalem = settings.add_preset(
         "nehalem",
+        "Nehalem microarchitecture.",
         preset!(has_sse3 && has_ssse3 && has_sse41 && has_sse42 && has_popcnt),
     );
     let haswell = settings.add_preset(
         "haswell",
+        "Haswell microarchitecture.",
         preset!(nehalem && has_bmi1 && has_bmi2 && has_lzcnt),
     );
-    let broadwell = settings.add_preset("broadwell", preset!(haswell));
-    let skylake = settings.add_preset("skylake", preset!(broadwell));
-    let cannonlake = settings.add_preset("cannonlake", preset!(skylake));
-    settings.add_preset("icelake", preset!(cannonlake));
+    let broadwell = settings.add_preset(
+        "broadwell",
+        "Broadwell microarchitecture.",
+        preset!(haswell),
+    );
+    let skylake = settings.add_preset("skylake", "Skylake microarchitecture.", preset!(broadwell));
+    let cannonlake = settings.add_preset(
+        "cannonlake",
+        "Canon Lake microarchitecture.",
+        preset!(skylake),
+    );
+    settings.add_preset(
+        "icelake",
+        "Ice Lake microarchitecture.",
+        preset!(cannonlake),
+    );
     settings.add_preset(
         "znver1",
+        "Zen (first generation) microarchitecture.",
         preset!(
             has_sse3
                 && has_ssse3