[meta] Move source generation responsibility into the meta crate itself;

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

@@ -18,7 +18,7 @@ pub enum Isa {
 
 impl Isa {
     /// Creates isa target using name.
-    pub fn new(name: &str) -> Option<Self> {
+    pub fn from_name(name: &str) -> Option<Self> {
         Isa::all()
             .iter()
             .cloned()
@@ -27,28 +27,20 @@ impl Isa {
     }
 
     /// Creates isa target from arch.
-    pub fn from_arch(arch: &str) -> Option<Isa> {
-        Isa::all()
-            .iter()
-            .cloned()
-            .filter(|isa| isa.is_arch_applicable(arch))
-            .next()
+    pub fn from_arch(arch: &str) -> Option<Self> {
+        match arch {
+            "riscv" => Some(Isa::Riscv),
+            "aarch64" => Some(Isa::Arm64),
+            x if ["x86_64", "i386", "i586", "i686"].contains(&x) => Some(Isa::X86),
+            x if x.starts_with("arm") || arch.starts_with("thumb") => Some(Isa::Arm32),
+            _ => None,
+        }
     }
 
     /// Returns all supported isa targets.
     pub fn all() -> [Isa; 4] {
         [Isa::Riscv, Isa::X86, Isa::Arm32, Isa::Arm64]
     }
-
-    /// Checks if arch is applicable for the isa target.
-    fn is_arch_applicable(&self, arch: &str) -> bool {
-        match *self {
-            Isa::Riscv => arch == "riscv",
-            Isa::X86 => ["x86_64", "i386", "i586", "i686"].contains(&arch),
-            Isa::Arm32 => arch.starts_with("arm") || arch.starts_with("thumb"),
-            Isa::Arm64 => arch == "aarch64",
-        }
-    }
 }
 
 impl fmt::Display for Isa {
@@ -62,11 +54,13 @@ impl fmt::Display for Isa {
     }
 }
 
-pub fn define_all(shared_settings: &SettingGroup) -> Vec<TargetIsa> {
-    vec![
-        riscv::define(shared_settings),
-        arm32::define(shared_settings),
-        arm64::define(shared_settings),
-        x86::define(shared_settings),
-    ]
+pub fn define(isas: &Vec<Isa>, shared_settings: &SettingGroup) -> Vec<TargetIsa> {
+    isas.iter()
+        .map(|isa| match isa {
+            Isa::Riscv => riscv::define(shared_settings),
+            Isa::X86 => x86::define(shared_settings),
+            Isa::Arm32 => arm32::define(shared_settings),
+            Isa::Arm64 => arm64::define(shared_settings),
+        })
+        .collect()
 }

cranelift/codegen/meta/src/lib.rs

@@ -2,12 +2,70 @@
 mod cdsl;
 
 pub mod error;
-pub mod gen_registers;
-pub mod gen_settings;
-pub mod gen_types;
 pub mod isa;
 
+mod gen_registers;
+mod gen_settings;
+mod gen_types;
+
 mod base;
 mod constant_hash;
 mod srcgen;
 mod unique_table;
+
+pub fn isa_from_arch(arch: &str) -> Result<Vec<isa::Isa>, String> {
+    isa::Isa::from_arch(arch)
+        .ok_or_else(|| format!("no supported isa found for arch `{}`", arch))
+        .and_then(|isa| Ok(vec![isa]))
+}
+
+pub fn isas_from_targets(targets: Vec<&str>) -> Result<Vec<isa::Isa>, String> {
+    type R<'a> = Vec<(&'a str, Option<isa::Isa>)>;
+
+    let (known, unknown): (R, R) = targets
+        .into_iter()
+        .map(|target| (target, isa::Isa::from_name(target)))
+        .partition(|(_, opt_isa)| opt_isa.is_some());
+
+    if !unknown.is_empty() {
+        let unknown_targets = unknown
+            .into_iter()
+            .map(|(target, _)| target)
+            .collect::<Vec<_>>()
+            .join(", ");
+        return Err(format!("unknown isa targets: {}", unknown_targets));
+    }
+
+    let isas = if known.is_empty() {
+        isa::Isa::all().to_vec()
+    } else {
+        known
+            .into_iter()
+            .map(|(_, opt_isa)| opt_isa.unwrap())
+            .collect()
+    };
+
+    Ok(isas)
+}
+
+pub fn all_isas() -> Result<Vec<isa::Isa>, String> {
+    isas_from_targets(vec![])
+}
+
+/// Generates all the Rust source files used in Cranelift from the meta-language.
+pub fn generate(isas: &Vec<isa::Isa>, out_dir: &str) -> Result<(), error::Error> {
+    // Common definitions.
+    let shared_settings = gen_settings::generate_common("new_settings.rs", &out_dir)?;
+
+    gen_types::generate("types.rs", &out_dir)?;
+
+    // Per ISA definitions.
+    let isas = isa::define(isas, &shared_settings);
+
+    for isa in isas {
+        gen_registers::generate(&isa, "registers", &out_dir)?;
+        gen_settings::generate(&isa, "new_settings", &out_dir)?;
+    }
+
+    Ok(())
+}