//! Canonical Cargo invocation for release Wasm guests (`SMH-SPEC-SPEC0001`). use std::{ env, ffi::OsString, path::{Path, PathBuf}, process::Command, }; /// Canonical release policy for embedded Wasm guests, independent of host preferences. pub(crate) const GUEST_RELEASE_PROFILE: &[(&str, &str)] = &[ ("CARGO_PROFILE_RELEASE_OPT_LEVEL", "3"), ("CARGO_PROFILE_RELEASE_LTO", "thin"), ("CARGO_PROFILE_RELEASE_CODEGEN_UNITS", "1"), ("CARGO_PROFILE_RELEASE_STRIP", "symbols"), ("CARGO_PROFILE_RELEASE_PANIC", "abort"), ("CARGO_PROFILE_RELEASE_DEBUG", "false"), ("CARGO_PROFILE_RELEASE_INCREMENTAL", "false"), ("CARGO_PROFILE_RELEASE_DEBUG_ASSERTIONS", "false"), ("CARGO_PROFILE_RELEASE_OVERFLOW_CHECKS", "false"), ("CARGO_PROFILE_RELEASE_RPATH", "false"), ]; /// Cargo invocation for a release guest whose bytes are embedded by a host. /// /// Rust records panic paths in component code. Map workspace and Cargo home to /// fixed prefixes so local and CI builds produce identical bytes. pub(crate) fn canonical_guest_cargo_command(workspace: &Path) -> Result { let workspace = workspace .canonicalize() .map_err(|error| format!("cannot resolve guest workspace directory: {error}"))?; let cargo_home = cargo_home(&workspace)?; let mut command = Command::new("cargo"); command .current_dir(&workspace) .env_remove("RUSTFLAGS") .env_remove("CARGO_ENCODED_RUSTFLAGS") .env( "CARGO_ENCODED_RUSTFLAGS", guest_rustflags(&workspace, &cargo_home)?, ) .envs(GUEST_RELEASE_PROFILE.iter().copied()); Ok(command) } /// Resolve Cargo's home exactly as Cargo does for this workspace invocation. fn cargo_home(workspace: &Path) -> Result { let home = match env::var_os("CARGO_HOME") { Some(home) => PathBuf::from(home), None => env::var_os("HOME") .map(PathBuf::from) .map(|home| home.join(".cargo")) .ok_or("cannot determine Cargo home: CARGO_HOME and HOME are unset")?, }; let home = if home.is_absolute() { home } else { workspace.join(home) }; home.canonicalize() .map_err(|error| format!("cannot resolve Cargo home {}: {error}", home.display())) } /// Rust flags separated by Cargo's documented unit-separator encoding. fn guest_rustflags(workspace: &Path, cargo_home: &Path) -> Result { let workspace = remap_path_flag(workspace, "/smith")?; let cargo_home = remap_path_flag(cargo_home, "/cargo")?; Ok([ OsString::from("-C"), OsString::from("target-cpu=generic"), workspace, cargo_home, ] .join(&OsString::from("\u{1f}"))) } /// One lossless remap flag; Rust flags cannot encode the unit separator. fn remap_path_flag(path: &Path, destination: &str) -> Result { let path = path .to_str() .ok_or_else(|| format!("guest path is not Unicode: {}", path.display()))?; if path.contains('\u{1f}') { return Err(format!("guest path contains Cargo flag separator: {path}")); } Ok(format!("--remap-path-prefix={path}={destination}").into()) }