From ae12a1c300959d65a08e8556a79c4e10f72a0d19 Mon Sep 17 00:00:00 2001 From: Lucy Menon <168595099+syntactically@users.noreply.github.com> Date: Mon, 21 Sep 2026 21:26:25 +0100 Subject: [PATCH] Support new {aarch64,x86_64}-unknown-hyperlight upstream targets These are used on rustc 1.100 and above to allow stable rustc to build Hyperlight guests. Signed-off-by: Lucy Menon <168595099+syntactically@users.noreply.github.com> --- Cargo.lock | 47 +++-------- Cargo.toml | 4 +- examples/guest/Cargo.lock | 35 +++++--- src/cli.rs | 39 ++------- src/lib.rs | 1 + src/main.rs | 6 ++ src/new/host/_main.rs | 2 +- src/new/mod.rs | 6 +- src/sysroot.rs | 77 +---------------- src/target_info.rs | 173 ++++++++++++++++++++++++++++++++++++++ src/toolchain.rs | 6 +- 11 files changed, 235 insertions(+), 161 deletions(-) create mode 100644 src/target_info.rs diff --git a/Cargo.lock b/Cargo.lock index a82ee0c..e821b7b 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -80,7 +80,6 @@ dependencies = [ "anyhow", "clap", "console", - "const_format", "glob", "libc", "object", @@ -89,6 +88,7 @@ dependencies = [ "quote", "regex", "rustc-demangle", + "rustc_version", "semver", "serde", "serde_json", @@ -161,27 +161,6 @@ dependencies = [ "windows-sys", ] -[[package]] -name = "const_format" -version = "0.2.36" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4481a617ad9a412be3b97c5d403fef8ed023103368908b9c50af598ff467cc1e" -dependencies = [ - "const_format_proc_macros", - "konst", -] - -[[package]] -name = "const_format_proc_macros" -version = "0.2.34" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d57c2eccfb16dbac1f4e61e206105db5820c9d26c3c472bc17c774259ef7744" -dependencies = [ - "proc-macro2", - "quote", - "unicode-xid", -] - [[package]] name = "encode_unicode" version = "1.0.0" @@ -286,21 +265,6 @@ version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" -[[package]] -name = "konst" -version = "0.2.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "128133ed7824fcd73d6e7b17957c5eb7bacb885649bd8c69708b2331a10bcefb" -dependencies = [ - "konst_macro_rules", -] - -[[package]] -name = "konst_macro_rules" -version = "0.2.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a4933f3f57a8e9d9da04db23fb153356ecaf00cbd14aee46279c33dc80925c37" - [[package]] name = "leb128fmt" version = "0.1.0" @@ -430,6 +394,15 @@ version = "0.1.28" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "b74b56ffa8bb2830709a538c2cbcae9aa062db0d2a42563bfb09bdaae44020eb" +[[package]] +name = "rustc_version" +version = "0.4.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92" +dependencies = [ + "semver", +] + [[package]] name = "rustix" version = "1.1.4" diff --git a/Cargo.toml b/Cargo.toml index 6f7d81c..a7e7ac8 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -11,7 +11,6 @@ description = "cargo subcommand to build hyperlight guest binaries" anyhow = "1.0" clap = { version = "4", features = ["derive"] } console = "0.16" -const_format = "0.2" glob = "0.3" libc = "0.2" object = { version = "0.40", default-features = false, features = ["read", "elf"] } @@ -25,4 +24,5 @@ tempfile = "3" toml = "1.0" which = { version = "8", features = ["regex"] } quote = "1.0" -proc-macro2 = "1.0" \ No newline at end of file +proc-macro2 = "1.0" +rustc_version = "0.4.1" \ No newline at end of file diff --git a/examples/guest/Cargo.lock b/examples/guest/Cargo.lock index ca7c73c..267a36a 100644 --- a/examples/guest/Cargo.lock +++ b/examples/guest/Cargo.lock @@ -34,7 +34,7 @@ dependencies = [ "regex", "rustc-hash", "shlex", - "syn", + "syn 2.0.108", ] [[package]] @@ -54,7 +54,7 @@ dependencies = [ "regex", "rustc-hash", "shlex", - "syn", + "syn 2.0.108", ] [[package]] @@ -214,7 +214,7 @@ dependencies = [ "proc-macro-crate", "proc-macro2", "quote", - "syn", + "syn 2.0.108", ] [[package]] @@ -284,22 +284,22 @@ dependencies = [ [[package]] name = "linkme" -version = "0.3.36" +version = "0.3.38" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e83272d46373fb8decca684579ac3e7c8f3d71d4cc3aa693df8759e260ae41cf" +checksum = "10a4e12fd3f6b22d5bc28beccac0f53bb35db4a897c6ddb709c4a0161f72eb6e" dependencies = [ "linkme-impl", ] [[package]] name = "linkme-impl" -version = "0.3.36" +version = "0.3.38" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "32d59e20403c7d08fe62b4376edfe5c7fb2ef1e6b1465379686d0f21c8df444b" +checksum = "22cd04c256b1cd686a45898c8fd150c79b801d96a3eb7bae1075f9eb3b4b85c1" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 3.0.10", ] [[package]] @@ -352,7 +352,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "479ca8adacdd7ce8f1fb39ce9ecccbfe93a3f1344b3d0d97f20bc0196208f62b" dependencies = [ "proc-macro2", - "syn", + "syn 2.0.108", ] [[package]] @@ -470,7 +470,7 @@ checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.108", ] [[package]] @@ -512,6 +512,17 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "syn" +version = "3.0.10" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4ae9ccbea3a7b0b09443036490c8f34a8b1b760fd345e5c0dae0aac718faea79" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + [[package]] name = "thiserror" version = "2.0.18" @@ -529,7 +540,7 @@ checksum = "ebc4ee7f67670e9b64d05fa4253e753e016c6c95ff35b89b7941d6b856dec1d5" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.108", ] [[package]] @@ -581,7 +592,7 @@ checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da" dependencies = [ "proc-macro2", "quote", - "syn", + "syn 2.0.108", ] [[package]] diff --git a/src/cli.rs b/src/cli.rs index 19f8da6..e58ffae 100644 --- a/src/cli.rs +++ b/src/cli.rs @@ -1,13 +1,11 @@ use std::collections::HashMap; use std::convert::Infallible; use std::env; -use std::env::consts::ARCH; use std::ffi::{OsStr, OsString}; use std::fmt::Debug; use std::path::PathBuf; use anyhow::{Context, Result}; -use const_format::formatcp; use os_str_bytes::OsStrBytesExt as _; use crate::cargo_cmd::{CargoCmd as _, cargo_cmd}; @@ -16,7 +14,7 @@ use crate::toolchain; pub struct Args { pub manifest_path: Option, pub target_dir: PathBuf, - pub target: String, + pub target: crate::target_info::TargetInfo, pub host: String, pub with_guest_capi: bool, pub c_sysroot_dir: Option, @@ -151,28 +149,8 @@ impl Args { }, }; - let target = match value.target { - Some(triplet) => triplet, - None => match resolve_target(&value.env, &value.current_dir) { - Ok(triplet) => triplet, - Err(err) => warn.warning( - "could not resolve target triple", - err, - DEFAULT_TARGET.to_string(), - )?, - }, - }; - - let target = if target.ends_with("-hyperlight-none") { - target - } else { - let (arch, _) = target.split_once('-').unwrap_or((&target, "")); - warn.warning( - "requested target is not a hyperlight target", - anyhow::anyhow!("invalid hyperlight target: {target}"), - format!("{arch}-hyperlight-none"), - )? - }; + let target = + crate::target_info::resolve(warn, value.target, &value.env, &value.current_dir)?; let target_dir = value.current_dir.join(target_dir); @@ -196,8 +174,6 @@ impl Args { } } -const DEFAULT_TARGET: &str = const { formatcp!("{ARCH}-hyperlight-none") }; - #[derive(Default)] //#[command(disable_help_subcommand = true)] struct ArgsImpl { @@ -315,7 +291,10 @@ fn resolve_target_dir( Ok(metadata.target_directory) } -fn resolve_target(env: &HashMap, cwd: &PathBuf) -> Result { +pub(crate) fn resolve_target( + env: &HashMap, + cwd: &PathBuf, +) -> Result> { let output = cargo_cmd(env)? .current_dir(cwd) .arg("config") @@ -336,8 +315,8 @@ fn resolve_target(env: &HashMap, cwd: &PathBuf) -> Result Option { @@ -51,6 +52,7 @@ impl SpecialCommand { "perf" => Some(Perf), "new" => Some(New), "build-c-sysroot" => Some(BuildCSysroot), + "print-hyperlight-target" => Some(PrintHyperlightTarget), _ => FlagKind::parse(x).map(Flags), } } @@ -96,6 +98,10 @@ impl SpecialCommand { let flags = k.get_flags(&built_args).joined(); println!("{}", flags.to_str().ok_or(anyhow!("flags were not UTF-8"))?); } + PrintHyperlightTarget => { + let built_args = cargo()?.args(args).build_args(); + println!("{}", built_args.target); + } } Ok(()) } diff --git a/src/new/host/_main.rs b/src/new/host/_main.rs index 7b3b79a..2d1f092 100644 --- a/src/new/host/_main.rs +++ b/src/new/host/_main.rs @@ -4,7 +4,7 @@ fn main() -> hyperlight_host::Result<()> { // Create a sandbox from the guest binary. It starts uninitialized so you // can register host functions before the guest begins executing. let mut sandbox = UninitializedSandbox::new( - GuestBinary::FilePath("../guest/target/{arch}-hyperlight-none/debug/{guest_name}".into()), + GuestBinary::FilePath("../guest/target/{guest_target}/debug/{guest_name}".into()), None, )?; diff --git a/src/new/mod.rs b/src/new/mod.rs index 1a60534..ebc841f 100644 --- a/src/new/mod.rs +++ b/src/new/mod.rs @@ -6,7 +6,6 @@ use anyhow::{Context, Result, ensure}; use clap::Parser; const HYPERLIGHT_VERSION: &str = "0.16"; -const GUEST_ARCH: &str = std::env::consts::ARCH; const GUEST_CARGO_TOML: &str = include_str!("guest/_Cargo.toml"); const GUEST_MAIN_RS: &str = include_str!("guest/_main.rs"); @@ -102,7 +101,10 @@ fn write_host(dir: &Path, name: &str, guest_name: &str) -> Result<()> { let main_rs = HOST_MAIN_RS .replace("{name}", name) .replace("{guest_name}", guest_name) - .replace("{arch}", GUEST_ARCH); + .replace( + "{guest_target}", + cargo_hyperlight::target_info::default().as_ref(), + ); write_file(dir.join("Cargo.toml"), &cargo_toml)?; write_file(dir.join("src/main.rs"), &main_rs)?; Ok(()) diff --git a/src/sysroot.rs b/src/sysroot.rs index 30f7b08..62650e8 100644 --- a/src/sysroot.rs +++ b/src/sysroot.rs @@ -3,7 +3,6 @@ use std::path::PathBuf; use std::process::{Output, Stdio}; use anyhow::{Context, Result, bail, ensure}; -use serde_json::{Map, Value, json}; use crate::cargo_cmd::{CargoCmd, cargo_cmd, get_env_value, rustup_auto_install_enabled}; use crate::cli::Args; @@ -65,7 +64,7 @@ fn probe_target_spec(args: &Args, extra_flags: &[&str]) -> Result { .arg("--sysroot") .arg(args.sysroot_dir()) .arg("--target") - .arg(&args.target) + .arg::<&str>(args.target.as_ref()) .args(extra_flags) .arg("--print=cfg") .stdin(Stdio::null()) @@ -135,54 +134,6 @@ pub(crate) struct CargoBuildMessage { pub fn build(args: &mut Args) -> Result<()> { let cargo_version = cargo_version(args)?; - let target_spec = match args.target.as_str() { - "x86_64-hyperlight-none" => { - let mut spec = get_spec(args, "x86_64-unknown-none")?; - // entry_name seems to be ignored, use RUSTFLAGS with -Clink-args=-eentrypoint instead - //spec.entry_name = Some("entrypoint".into()); - let Value::Object(custom) = json!({ - "code-model": "small", - "linker": "rust-lld", - "linker-flavor": "gnu-lld", - "pre-link-args": { - "gnu-lld": ["-znostart-stop-gc"], - }, - "features": "-mmx,+sse,+sse2,-sse3,-ssse3,-sse4.1,-sse4.2,-avx,-avx2,-soft-float" - }) else { - unreachable!() - }; - spec.extend(custom); - spec.remove("rustc-abi"); - spec - } - "aarch64-hyperlight-none" => { - let mut spec = get_spec(args, "aarch64-unknown-none")?; - let Value::Object(custom) = json!({ - "code-model": "small", - "linker": "rust-lld", - "linker-flavor": "gnu-lld", - "pre-link-args": { - "gnu-lld": ["-znostart-stop-gc"], - }, - "relocation-model": "pic", - "direct-access-external-data": true, - "position-independent-executables": true, - "features": "+v8.1a,+strict-align,+neon,+fp-armv8" - }) else { - unreachable!() - }; - spec.extend(custom); - spec.remove("rustc-abi"); - spec - } - triplet => bail!( - "Unsupported target triple: {triplet:?} -Supported values are: - * x86_64-hyperlight-none - * aarch64-hyperlight-none" - ), - }; - let sysroot_dir = args.sysroot_dir(); let target_dir = args.build_dir(); let triplet_dir = args.triplet_dir(); @@ -190,11 +141,8 @@ Supported values are: let lib_dir = args.rust_libs_dir(); std::fs::create_dir_all(&triplet_dir).context("Failed to create sysroot directories")?; - std::fs::write( - triplet_dir.join("target.json"), - serde_json::to_string_pretty(&target_spec).unwrap(), - ) - .context("Failed to write target spec file")?; + + args.target.write_spec(args, &triplet_dir)?; check_target_spec_support(args)?; @@ -289,25 +237,6 @@ Supported values are: Ok(()) } -fn get_spec(args: &Args, triplet: impl AsRef) -> Result> { - let output = cargo_cmd(&args.env)? - .current_dir(&args.current_dir) - .arg("rustc") - .arg("--target") - .arg(triplet.as_ref()) - .manifest_path(&args.manifest_path) - .arg("-Zunstable-options") - .arg("--print=target-spec-json") - .arg("--") - .arg("-Zunstable-options") - // printing target-spec-json is an unstable feature - .allow_unstable() - .checked_output() - .context("Failed to get base target spec")?; - - serde_json::from_slice(&output.stdout).context("Failed to parse target spec JSON") -} - #[cfg(test)] mod tests { use super::*; diff --git a/src/target_info.rs b/src/target_info.rs new file mode 100644 index 0000000..6ca13e6 --- /dev/null +++ b/src/target_info.rs @@ -0,0 +1,173 @@ +use std::collections::HashMap; +use std::env::consts::ARCH; +use std::ffi::OsString; +use std::path::{Path, PathBuf}; +use std::sync::LazyLock; + +use anyhow::{Context, Result}; +use serde_json::{Map, Value, json}; + +use crate::cargo_cmd::{CargoCmd, cargo_cmd}; +use crate::cli::{Args, WarningLevel}; + +#[derive(Clone, Debug)] +pub struct TargetInfo { + suffix: String, + arch: String, + guest_target: String, +} +impl TargetInfo { + fn new() -> Self { + let v = rustc_version::version().unwrap(); + let suffix = if v > rustc_version::Version::parse("1.100.0").unwrap() { + "unknown-hyperlight" + } else { + "hyperlight-none" + }; + Self { + suffix: suffix.to_string(), + arch: ARCH.to_string(), + guest_target: format!("{ARCH}-{suffix}"), + } + } + + fn resolve( + &self, + warn: W, + args_override: Option, + env: &HashMap, + cwd: &PathBuf, + ) -> Result { + let manifest_override = crate::cli::resolve_target(env, cwd); + let manifest_override = match manifest_override { + Err(e) => warn.warning("could not query cargo about target", e, None)?, + Ok(o) => o, + }; + let target = args_override + .or(manifest_override) + .unwrap_or_else(|| self.guest_target.to_string()); + let (arch, suffix) = target.split_once('-').map_or_else( + || { + warn.warning( + "could not parse arch/suffix from target", + anyhow::anyhow!("could not parse arch/suffix from {target}"), + (ARCH, self.suffix.as_str()), + ) + }, + core::result::Result::Ok, + )?; + let suffix = if suffix != self.suffix { + warn.warning( + "requested target is not a hyperlight target", + anyhow::anyhow!("invalid hyperlight target suffix: {suffix}"), + self.suffix.as_str(), + )? + } else { + suffix + }; + Ok(Self { + suffix: suffix.to_string(), + arch: arch.to_string(), + // Re-create the target in case we have changed it via the + // validation/defaulting logic above + guest_target: format!("{arch}-{suffix}"), + }) + } + + pub(crate) fn write_spec(&self, args: &Args, triplet_dir: &Path) -> Result<()> { + if self.suffix == "hyperlight-none" { + // We are using the old downstream targets, so we need to + // write all our modifications into a spec json. + let base_target = format!("{}-unknown-none", self.arch); + let mut spec = get_base_spec(args, base_target)?; + let Value::Object(custom) = (match self.arch.as_str() { + "x86_64" => json!({ + "code-model": "small", + "linker": "rust-lld", + "linker-flavor": "gnu-lld", + "pre-link-args": { + "gnu-lld": ["-znostart-stop-gc"], + }, + "features": "-mmx,+sse,+sse2,-sse3,-ssse3,-sse4.1,-sse4.2,-avx,-avx2,-soft-float" + }), + "aarch64" => json!({ + "code-model": "small", + "linker": "rust-lld", + "linker-flavor": "gnu-lld", + "pre-link-args": { + "gnu-lld": ["-znostart-stop-gc"], + }, + "relocation-model": "pic", + "direct-access-external-data": true, + "position-independent-executables": true, + "features": "+v8.1a,+strict-align,+neon,+fp-armv8" + }), + _ => anyhow::bail!("Unknown architecture {}", self.arch), + }) else { + unreachable!() + }; + spec.extend(custom); + spec.remove("rustc-abi"); + + std::fs::write( + triplet_dir.join("target.json"), + serde_json::to_string_pretty(&spec).unwrap(), + ) + .context("Failed to write target spec file")? + } + Ok(()) + } + + pub(crate) fn is_x86_64(&self) -> bool { + self.arch == "x86_64" + } +} +impl AsRef for TargetInfo { + fn as_ref(&self) -> &str { + &self.guest_target + } +} +impl AsRef for TargetInfo { + fn as_ref(&self) -> &Path { + Path::new(&self.guest_target) + } +} +impl std::fmt::Display for TargetInfo { + fn fmt(&self, f: &mut std::fmt::Formatter) -> Result<(), std::fmt::Error> { + write!(f, "{}", self.guest_target) + } +} + +static DEFAULT_TARGET: LazyLock = LazyLock::new(TargetInfo::new); + +pub(crate) fn resolve( + warn: W, + args_override: Option, + env: &HashMap, + cwd: &PathBuf, +) -> Result { + (*DEFAULT_TARGET).resolve(warn, args_override, env, cwd) +} + +pub fn default() -> &'static TargetInfo { + &DEFAULT_TARGET +} + +fn get_base_spec(args: &Args, triplet: impl AsRef) -> Result> { + let output = cargo_cmd(&args.env)? + .current_dir(&args.current_dir) + .arg("rustc") + .arg("--target") + .arg(triplet.as_ref()) + .manifest_path(&args.manifest_path) + .arg("-Zunstable-options") + .arg("--print=target-spec-json") + .arg("--") + .arg("-Zunstable-options") + // printing target-spec-json is an unstable feature + .allow_unstable() + .checked_output() + .context("Failed to get base target spec")?; + + serde_json::from_slice(&output.stdout).context("Failed to parse target spec JSON") +} diff --git a/src/toolchain.rs b/src/toolchain.rs index 57ce26a..3e95dfd 100644 --- a/src/toolchain.rs +++ b/src/toolchain.rs @@ -164,7 +164,7 @@ fn build_wrappers(args: &Args) -> Result<()> { let includes_toks = path_to_tokens(args.includes_dir().strip_prefix(args.sysroot_dir())?); let c_libs_toks = path_to_tokens(args.c_libs_dir().strip_prefix(args.sysroot_dir())?); let wrapper_toks = path_to_tokens(args.wrapper_dir().strip_prefix(args.sysroot_dir())?); - let target = &args.target; + let target: &str = args.target.as_ref(); let with_guest_capi = args.with_guest_capi; std::fs::write( wrapper_src_src_dir.join("args.rs"), @@ -259,7 +259,7 @@ pub fn prepare(args: &Args) -> Result<()> { "third_party/picolibc/libc/stdio", "include", ]; - if !args.target.starts_with("aarch64") { + if args.target.is_x86_64() { include_dirs.push("third_party/musl/arch/x86_64"); } @@ -289,7 +289,7 @@ impl From<&Args> for toolchain_flags::Args { includes_dir: args.includes_dir(), c_libs_dir: args.c_libs_dir(), wrapper_dir: args.wrapper_dir(), - target: args.target.clone(), + target: args.target.to_string(), with_guest_capi: args.with_guest_capi, } }