Convert some WebAssembly run-make tests to Rust

This commit rewrites a number of `run-make` tests centered around wasm
to instead use `rmake.rs` and additionally use the `wasm32-wasip1`
target instead of `wasm32-unknown-unknown`. Testing no longer requires
Node.js and additionally uses the `wasmparser` crate from crates.io to
parse outputs and power assertions.

Author: alexcrichton

Cargo.lock

@@ -3298,6 +3298,9 @@ dependencies = [
 [[package]]
 name = "run_make_support"
 version = "0.0.0"
+dependencies = [
+ "wasmparser",
+]
 
 [[package]]
 name = "rust-demangler"

src/tools/run-make-support/Cargo.toml

@@ -4,3 +4,4 @@ version = "0.0.0"
 edition = "2021"
 
 [dependencies]
+wasmparser = "0.118.2"

src/tools/run-make-support/src/lib.rs

@@ -2,13 +2,16 @@ use std::env;
 use std::path::{Path, PathBuf};
 use std::process::{Command, Output};
 
+pub use wasmparser;
+
+pub fn out_dir() -> PathBuf {
+    env::var_os("TMPDIR").unwrap().into()
+}
+
 fn setup_common_build_cmd() -> Command {
     let rustc = env::var("RUSTC").unwrap();
     let mut cmd = Command::new(rustc);
-    cmd.arg("--out-dir")
-        .arg(env::var("TMPDIR").unwrap())
-        .arg("-L")
-        .arg(env::var("TMPDIR").unwrap());
+    cmd.arg("--out-dir").arg(out_dir()).arg("-L").arg(out_dir());
     cmd
 }
 
@@ -45,6 +48,11 @@ impl RustcInvocationBuilder {
         self
     }
 
+    pub fn args(&mut self, args: &[&str]) -> &mut RustcInvocationBuilder {
+        self.cmd.args(args);
+        self
+    }
+
     #[track_caller]
     pub fn run(&mut self) -> Output {
         let caller_location = std::panic::Location::caller();

tests/run-make/wasm-abi/Makefile

@@ -0,0 +1,22 @@
+(module
+  (func (export "two_i32") (result i32 i32)
+      i32.const 100
+      i32.const 101)
+  (func (export "two_i64") (result i64 i64)
+      i64.const 102
+      i64.const 103)
+  (func (export "two_f32") (result f32 f32)
+      f32.const 104
+      f32.const 105)
+  (func (export "two_f64") (result f64 f64)
+      f64.const 106
+      f64.const 107)
+
+  (func (export "mishmash") (result f64 f32 i32 i64 i32 i32)
+      f64.const 108
+      f32.const 109
+      i32.const 110
+      i64.const 111
+      i32.const 112
+      i32.const 113)
+)

tests/run-make/wasm-abi/foo.js

@@ -0,0 +1,43 @@
+extern crate run_make_support;
+
+use run_make_support::{out_dir, rustc};
+use std::path::Path;
+use std::process::Command;
+
+fn main() {
+    if std::env::var("TARGET").unwrap() != "wasm32-wasip1" {
+        return;
+    }
+
+    rustc().arg("foo.rs").arg("--target=wasm32-wasip1").run();
+    let file = out_dir().join("foo.wasm");
+
+    let has_wasmtime = match Command::new("wasmtime").arg("--version").output() {
+        Ok(s) => s.status.success(),
+        _ => false,
+    };
+    if !has_wasmtime {
+        println!("skipping test, wasmtime isn't available");
+        return;
+    }
+
+    run(&file, "return_two_i32", "1\n2\n");
+    run(&file, "return_two_i64", "3\n4\n");
+    run(&file, "return_two_f32", "5\n6\n");
+    run(&file, "return_two_f64", "7\n8\n");
+    run(&file, "return_mishmash", "9\n10\n11\n12\n13\n14\n");
+    run(&file, "call_imports", "");
+}
+
+fn run(file: &Path, method: &str, expected_output: &str) {
+    let output = Command::new("wasmtime")
+        .arg("run")
+        .arg("--preload=host=host.wat")
+        .arg("--invoke")
+        .arg(method)
+        .arg(file)
+        .output()
+        .unwrap();
+    assert!(output.status.success());
+    assert_eq!(expected_output, String::from_utf8_lossy(&output.stdout));
+}

tests/run-make/wasm-abi/host.wat

@@ -0,0 +1,28 @@
+extern crate run_make_support;
+
+use run_make_support::{out_dir, rustc, wasmparser};
+use std::collections::HashMap;
+
+fn main() {
+    if std::env::var("TARGET").unwrap() != "wasm32-wasip1" {
+        return;
+    }
+
+    rustc().arg("foo.rs").arg("--target=wasm32-wasip1").run();
+    rustc().arg("bar.rs").arg("--target=wasm32-wasip1").arg("-Clto").arg("-O").run();
+
+    let file = std::fs::read(&out_dir().join("bar.wasm")).unwrap();
+
+    let mut custom = HashMap::new();
+    for payload in wasmparser::Parser::new(0).parse_all(&file) {
+        let payload = payload.unwrap();
+        if let wasmparser::Payload::CustomSection(s) = payload {
+            let prev = custom.insert(s.name(), s.data());
+            assert!(prev.is_none());
+        }
+    }
+
+    assert_eq!(custom.remove("foo"), Some(&[5, 6, 1, 2][..]));
+    assert_eq!(custom.remove("bar"), Some(&[3, 4][..]));
+    assert_eq!(custom.remove("baz"), Some(&[7, 8][..]));
+}

tests/run-make/wasm-abi/rmake.rs

@@ -0,0 +1,30 @@
+extern crate run_make_support;
+
+use run_make_support::{out_dir, rustc, wasmparser};
+use std::collections::HashMap;
+use std::path::Path;
+
+fn main() {
+    if std::env::var("TARGET").unwrap() != "wasm32-wasip1" {
+        return;
+    }
+
+    rustc().arg("foo.rs").arg("--target=wasm32-wasip1").arg("-O").run();
+    verify(&out_dir().join("foo.wasm"));
+}
+
+fn verify(path: &Path) {
+    eprintln!("verify {path:?}");
+    let file = std::fs::read(&path).unwrap();
+
+    let mut custom = HashMap::new();
+    for payload in wasmparser::Parser::new(0).parse_all(&file) {
+        let payload = payload.unwrap();
+        if let wasmparser::Payload::CustomSection(s) = payload {
+            let prev = custom.insert(s.name(), s.data());
+            assert!(prev.is_none());
+        }
+    }
+
+    assert_eq!(custom.remove("foo"), Some(&[1, 2, 3, 4][..]));
+}

tests/run-make/wasm-custom-section/Makefile

@@ -0,0 +1,60 @@
+extern crate run_make_support;
+
+use run_make_support::{out_dir, rustc, wasmparser};
+use std::collections::HashMap;
+use std::path::Path;
+use wasmparser::ExternalKind::*;
+
+fn main() {
+    if std::env::var("TARGET").unwrap() != "wasm32-wasip1" {
+        return;
+    }
+
+    test(&[]);
+    test(&["-O"]);
+    test(&["-Clto"]);
+}
+
+fn test(args: &[&str]) {
+    eprintln!("running with {args:?}");
+    rustc().arg("bar.rs").arg("--target=wasm32-wasip1").args(args).run();
+    rustc().arg("foo.rs").arg("--target=wasm32-wasip1").args(args).run();
+    rustc().arg("main.rs").arg("--target=wasm32-wasip1").args(args).run();
+
+    verify_exports(
+        &out_dir().join("foo.wasm"),
+        &[("foo", Func), ("FOO", Global), ("memory", Memory)],
+    );
+    verify_exports(
+        &out_dir().join("main.wasm"),
+        &[
+            ("foo", Func),
+            ("FOO", Global),
+            ("_start", Func),
+            ("__main_void", Func),
+            ("memory", Memory),
+        ],
+    );
+}
+
+fn verify_exports(path: &Path, exports: &[(&str, wasmparser::ExternalKind)]) {
+    println!("verify {path:?}");
+    let file = std::fs::read(path).unwrap();
+    let mut wasm_exports = HashMap::new();
+    for payload in wasmparser::Parser::new(0).parse_all(&file) {
+        let payload = payload.unwrap();
+        if let wasmparser::Payload::ExportSection(s) = payload {
+            for export in s {
+                let export = export.unwrap();
+                wasm_exports.insert(export.name, export.kind);
+            }
+        }
+    }
+
+    eprintln!("found exports {wasm_exports:?}");
+
+    assert_eq!(exports.len(), wasm_exports.len());
+    for (export, expected_kind) in exports {
+        assert_eq!(wasm_exports[export], *expected_kind);
+    }
+}