feat: add aarch64-hyperlight-none target support

- Add aarch64-hyperlight-none target spec derived from
  aarch64-unknown-none with hyperlight customizations
- Select correct musl arch headers (aarch64 vs x86_64)
- Use appropriate clang --target for aarch64
- Make -mno-red-zone x86_64-only (aarch64 has no red zone)
- Fix get_spec to pass --target as CLI arg instead of env var

Signed-off-by: Ludvig Liljenberg <4257730+ludfjig@users.noreply.github.com>

Author: ludfjig

src/sysroot.rs

@@ -45,10 +45,27 @@ pub fn build(args: &Args) -> Result<()> {
             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"],
+                },
+            }) else {
+                unreachable!()
+            };
+            spec.extend(custom);
+            spec.remove("rustc-abi");
+            spec
+        }
         triplet => bail!(
             "Unsupported target triple: {triplet:?}
 Supported values are:
- * x86_64-hyperlight-none"
+ * x86_64-hyperlight-none
+ * aarch64-hyperlight-none"
         ),
     };
 
@@ -180,7 +197,8 @@ fn get_spec(args: &Args, triplet: impl AsRef<str>) -> Result<Map<String, Value>>
         .envs(args.env.iter())
         .current_dir(&args.current_dir)
         .arg("rustc")
-        .target(triplet)
+        .arg("--target")
+        .arg(triplet.as_ref())
         .manifest_path(&args.manifest_path)
         .arg("-Zunstable-options")
         .arg("--print=target-spec-json")

src/toolchain.rs

@@ -53,47 +53,52 @@ pub fn prepare(args: &Args) -> Result<()> {
     std::fs::create_dir_all(&include_dst_dir)
         .context("Failed to create sysroot include directory")?;
 
-    const INCLUDE_DIRS: &[&str] = &[
-        "third_party/printf/",
-        "third_party/musl/include",
-        "third_party/musl/arch/generic",
-        "third_party/musl/arch/x86_64",
-        "third_party/musl/src/internal",
-    ];
-
-    for dir in INCLUDE_DIRS {
-        let include_src_dir = hyperlight_guest_bin_dir.join(dir);
-        let files = glob::glob(&format!("{}/**/*.h", include_src_dir.display()))
-            .context("Failed to read include source directory")?;
-
-        for file in files {
-            let src = file.context("Failed to read include source file")?;
-            let dst = src.strip_prefix(&include_src_dir).unwrap();
-            let dst = include_dst_dir.join(dst);
-
-            std::fs::create_dir_all(dst.parent().unwrap())
-                .context("Failed to create include subdirectory")?;
-            std::fs::copy(&src, &dst).context("Failed to copy include file")?;
+    // Skip musl header copying on aarch64 — no musl/C support yet
+    if !args.target.starts_with("aarch64") {
+        let include_dirs: &[&str] = &[
+            "third_party/printf/",
+            "third_party/musl/include",
+            "third_party/musl/arch/generic",
+            "third_party/musl/arch/x86_64",
+            "third_party/musl/src/internal",
+        ];
+
+        for dir in include_dirs {
+            let include_src_dir = hyperlight_guest_bin_dir.join(dir);
+            let files = glob::glob(&format!("{}/**/*.h", include_src_dir.display()))
+                .context("Failed to read include source directory")?;
+
+            for file in files {
+                let src = file.context("Failed to read include source file")?;
+                let dst = src.strip_prefix(&include_src_dir).unwrap();
+                let dst = include_dst_dir.join(dst);
+
+                std::fs::create_dir_all(dst.parent().unwrap())
+                    .context("Failed to create include subdirectory")?;
+                std::fs::copy(&src, &dst).context("Failed to copy include file")?;
+            }
         }
     }
 
     Ok(())
 }
 
 pub fn cflags(args: &Args) -> OsString {
-    const FLAGS: &[&str] = &[
-        // terrible hack, see
-        // https://github.com/hyperlight-dev/hyperlight/blob/main/src/hyperlight_guest_bin/build.rs#L80
-        "--target=x86_64-unknown-linux-none",
+    let clang_target = if args.target.starts_with("aarch64") {
+        "--target=aarch64-unknown-linux-none"
+    } else {
+        "--target=x86_64-unknown-linux-none"
+    };
+
+    let common_flags: &[&str] = &[
+        clang_target,
         "-U__linux__",
-        // Our rust target also has this set since it based off "x86_64-unknown-none"
         "-fPIC",
         // We don't support stack protectors at the moment, but Arch Linux clang
         // auto-enables them for -linux platforms, so explicitly disable them.
         "-fno-stack-protector",
         "-fstack-clash-protection",
         "-mstack-probe-size=4096",
-        "-mno-red-zone",
         "-nostdinc",
         // Define HYPERLIGHT as we use this to conditionally enable/disable code
         // in the libc headers
@@ -102,10 +107,15 @@ pub fn cflags(args: &Args) -> OsString {
     ];
 
     let mut flags = OsString::new();
-    for flag in FLAGS {
+    for flag in common_flags {
         flags.push(flag);
         flags.push(" ");
     }
+
+    // x86_64-specific flags
+    if args.target.starts_with("x86_64") {
+        flags.push("-mno-red-zone ");
+    }
     flags.push(" ");
     flags.push("-isystem");
     flags.push(" ");