Initial assembly test setup

Author: madsmtm

Cargo.toml

@@ -7,4 +7,5 @@ members = [
     "block2",
     "block-sys",
     "tests",
+    "tests/assembly/*",
 ]

tests/Cargo.toml

@@ -18,6 +18,7 @@ build = "build.rs"
 #
 # Also, they're slower than most tests.
 ui = ["trybuild"]
+assembly = ["cargo_metadata"]
 
 [dependencies]
 block2 = { path = "../block2" }
@@ -29,9 +30,14 @@ objc2-foundation = { path = "../objc2-foundation" }
 
 # Put here instead of dev-dependencies because we want to make it optional
 trybuild = { version = "1.0", optional = true }
+cargo_metadata = { version = "0.14", optional = true }
 
 [build-dependencies]
 cc = "1.0"
 
 [dev-dependencies]
 paste = "1.0"
+
+[[bin]]
+name = "test_assembly"
+required-features = ["assembly"]

tests/assembly/test_msg_send_zero_cost/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "test_msg_send_zero_cost"
+version = "0.1.0"
+edition = "2018"
+publish = false
+
+[lib]
+path = "lib.rs"
+
+[dependencies]
+objc2 = { path = "../../../objc2" }

tests/assembly/test_msg_send_zero_cost/lib.rs

@@ -0,0 +1,9 @@
+//! Test that the inner part of msg_send! is inlined into an objc_msgSend
+
+use objc2::runtime::{Object, Sel};
+use objc2::MessageReceiver;
+
+#[no_mangle]
+pub fn handle(obj: &Object, sel: Sel) -> *mut Object {
+    unsafe { MessageReceiver::send_message(&obj, sel, ()).unwrap() }
+}

tests/build.rs

@@ -22,5 +22,8 @@ fn main() {
         builder.flag(flag);
     }
 
+    // For assembly tests
+    println!("cargo:rustc-env=TARGET={}", env::var("TARGET").unwrap());
+
     builder.compile("libencode_utils.a");
 }

tests/src/bin/test_assembly.rs

@@ -0,0 +1,119 @@
+//! A helper script for testing the assembly output.
+//!
+//! Similar to `trybuild` and `compiletest`, except specialized to our setup!
+
+use cargo_metadata::Message;
+use std::env;
+use std::env::args;
+use std::fmt::Write;
+use std::fs;
+use std::io;
+use std::path::Path;
+use std::process::{Command, Stdio};
+
+fn strip_section(data: &str, section: &str) -> String {
+    let mut res = String::with_capacity(data.len());
+    let mut in_removed_section = false;
+    for line in data.lines() {
+        // This only works for the __LLVM sections we're interested in
+        if line == "" {
+            in_removed_section = false;
+        }
+        if line.trim().starts_with(".section") {
+            in_removed_section = line.contains(section);
+        }
+        if !in_removed_section {
+            res.push_str(line);
+        } else {
+            write!(res, "; Stripped {section} line").unwrap();
+        }
+        res.push('\n');
+    }
+    res
+}
+
+fn read_assembly<P: AsRef<Path>>(path: P) -> io::Result<String> {
+    let s = fs::read_to_string(path)?;
+    let workspace_dir = Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .unwrap()
+        .as_os_str()
+        .to_str()
+        .unwrap();
+    let s = s.replace(workspace_dir, "$WORKSPACE");
+    // We remove the __LLVM,__bitcode and __LLVM,__cmdline sections because
+    // they're uninteresting for out use-case.
+    //
+    // See https://github.com/rust-lang/rust/blob/1.59.0/compiler/rustc_codegen_llvm/src/back/write.rs#L978-L1074
+    Ok(strip_section(&s, "__LLVM"))
+}
+
+fn main() {
+    let manifest_dir = Path::new(env!("CARGO_MANIFEST_DIR"));
+    let should_overwrite = option_env!("TEST_OVERWRITE").is_some();
+    let host = env!("TARGET");
+
+    for entry in manifest_dir.join("assembly").read_dir().unwrap() {
+        let package_path = entry.unwrap().path();
+        let package = package_path.file_name().unwrap().to_str().unwrap();
+
+        println!("Testing {package}.");
+
+        let result = Command::new(std::env::var("CARGO").unwrap_or("cargo".into()))
+            // .arg("+nightly")
+            // .arg("-Zbuild-std")
+            // .arg("-vv")
+            .arg("rustc")
+            .arg(format!("--package={package}"))
+            .args(args().skip(2))
+            .arg("--release")
+            .arg("--message-format=json-render-diagnostics")
+            .arg("--")
+            .arg("--emit=asm")
+            .stdout(Stdio::piped())
+            .stderr(Stdio::inherit())
+            .output()
+            .unwrap();
+
+        let artifact = Message::parse_stream(&*result.stdout)
+            .find_map(|message| {
+                if let Message::CompilerArtifact(artifact) = message.unwrap() {
+                    // Brittle!
+                    if artifact.target.name == package && artifact.filenames.len() == 2 {
+                        let path = artifact.filenames[1].clone();
+                        let stem = path.file_stem().unwrap().strip_prefix("lib").unwrap();
+                        return Some(path.with_file_name(format!("{stem}.s")));
+                    }
+                }
+                None
+            })
+            .unwrap_or_else(|| {
+                panic!(
+                    "Could not find package data:\n{}",
+                    String::from_utf8_lossy(&result.stdout)
+                )
+            });
+
+        // Very brittle!
+        let target = artifact
+            .components()
+            .map(|component| component.as_str())
+            .skip_while(|&component| component != "target")
+            .skip(1)
+            .next()
+            .unwrap_or(host);
+
+        println!("Target {target}.");
+
+        let expected_file = package_path.join("expected").join(format!("{target}.s"));
+
+        let actual = read_assembly(&artifact).unwrap();
+        if should_overwrite {
+            fs::write(expected_file, actual).unwrap();
+        } else if let Ok(expected) = read_assembly(expected_file) {
+            assert_eq!(expected, actual);
+        } else {
+            panic!("Missing assembly output for target {}:\n{}", target, actual);
+        }
+    }
+}