generator: Parse rustc --print cfg

Author: madsmtm

dev-tools/gen-target-info/src/read.rs

@@ -1,6 +1,30 @@
-use std::process;
+use std::{io::BufRead, process};
 
-use crate::{RustcTargetSpecs, TargetSpec};
+use crate::{Cfgs, RustcTargetSpecs, TargetSpec};
+
+fn get_cfgs(version: &str, target: &str) -> Cfgs {
+    let mut cmd = process::Command::new("rustc");
+    cmd.args([
+        version,
+        "-Zunstable-options",
+        "--print",
+        "cfg",
+        "--target",
+        target,
+    ]);
+    cmd.env("RUSTC_BOOTSTRAP", "1");
+    cmd.stdout(process::Stdio::piped());
+    cmd.stderr(process::Stdio::inherit());
+
+    let process::Output { status, stdout, .. } = cmd.output().unwrap();
+
+    if !status.success() {
+        panic!("{:?} failed with non-zero exit status: {}", cmd, status)
+    }
+
+    let cfgs: Vec<String> = stdout.lines().map(|line| line.unwrap()).collect();
+    Cfgs::parse(&cfgs)
+}
 
 pub fn get_targets_msrv() -> Vec<u8> {
     let mut cmd = process::Command::new("rustc");
@@ -37,7 +61,9 @@ pub fn get_target_spec_from_msrv(target: &str) -> TargetSpec {
         panic!("{:?} failed with non-zero exit status: {}", cmd, status)
     }
 
-    serde_json::from_slice(&stdout).unwrap()
+    let mut spec: TargetSpec = serde_json::from_slice(&stdout).unwrap();
+    spec.cfgs = get_cfgs("+1.63", target);
+    spec
 }
 
 pub fn get_target_specs_from_json() -> RustcTargetSpecs {
@@ -57,5 +83,9 @@ pub fn get_target_specs_from_json() -> RustcTargetSpecs {
         panic!("{:?} failed with non-zero exit status: {}", cmd, status)
     }
 
-    serde_json::from_slice(&stdout).unwrap()
+    let mut specs: RustcTargetSpecs = serde_json::from_slice(&stdout).unwrap();
+    for (target, spec) in &mut specs.0 {
+        spec.cfgs = get_cfgs("+nightly", target);
+    }
+    specs
 }

dev-tools/gen-target-info/src/target_specs.rs

@@ -23,7 +23,10 @@ pub struct TargetSpec {
     pub vendor: Option<String>,
     pub env: Option<String>,
     pub abi: Option<String>,
+    pub target_pointer_width: String,
     pub pre_link_args: Option<PreLinkArgs>,
+    #[serde(skip)]
+    pub cfgs: Cfgs,
 }
 
 #[derive(Debug, Deserialize)]
@@ -32,3 +35,49 @@ pub struct RustcTargetSpecs(
     /// First field in the tuple is the rustc target
     pub BTreeMap<String, TargetSpec>,
 );
+
+/// Potentially useful values from:
+/// https://doc.rust-lang.org/reference/conditional-compilation.html
+///
+/// That are not directly / easily exposed in `TargetSpec`.
+#[derive(Debug, Default)]
+pub struct Cfgs {
+    pub target_features: Vec<String>,
+    pub target_families: Vec<String>,
+    pub target_endian: String,
+    pub target_atomics: Vec<String>,
+    pub target_thread_local: bool,
+}
+
+impl Cfgs {
+    pub fn parse(cfgs: &[String]) -> Self {
+        let mut target_features = vec![];
+        let mut target_families = vec![];
+        let mut target_endian = None;
+        let mut target_atomics = vec![];
+        let mut target_thread_local = false;
+        for cfg in cfgs {
+            let (name, value) = cfg
+                .split_once('=')
+                .map(|(n, v)| (n.trim(), Some(v.trim().trim_matches('"'))))
+                .unwrap_or((cfg.trim(), None));
+
+            match (name, value) {
+                ("target_feature", Some(value)) => target_features.push(value.to_string()),
+                ("target_family", Some(value)) => target_families.push(value.to_string()),
+                ("target_endian", Some(value)) => target_endian = Some(value.to_string()),
+                ("target_has_atomic", Some(value)) => target_atomics.push(value.to_string()),
+                ("target_thread_local", None) => target_thread_local = true,
+                _ => {} // Ignore the rest
+            }
+        }
+
+        Self {
+            target_features,
+            target_families,
+            target_endian: target_endian.expect("must have target_endian cfg"),
+            target_atomics,
+            target_thread_local,
+        }
+    }
+}