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][..]));
+}