Allow use of prebuilt-nasm

Author: justsmth

aws-lc-sys/builder/cc_builder.rs

@@ -448,7 +448,7 @@ impl CcBuilder {
 
         let mut build_options = vec![];
         self.add_includes(&mut build_options);
-        let mut nasm_builder = NasmBuilder::new(self.out_dir.clone());
+        let mut nasm_builder = NasmBuilder::new(self.manifest_dir.clone(), self.out_dir.clone());
 
         for option in &build_options {
             option.apply_nasm(&mut nasm_builder);

aws-lc-sys/builder/nasm_builder.rs

@@ -1,7 +1,8 @@
 use std::ffi::OsString;
+use std::fs;
 use std::path::{Path, PathBuf};
 
-use crate::{execute_command, test_nasm_command};
+use crate::{execute_command, test_nasm_command, use_prebuilt_nasm};
 
 #[derive(Debug)]
 pub(crate) struct NasmBuilder {
@@ -10,16 +11,18 @@ pub(crate) struct NasmBuilder {
     defines: Vec<(String, Option<String>)>,
     flags: Vec<String>,
     out_dir: PathBuf,
+    manifest_dir: PathBuf,
 }
 
 impl NasmBuilder {
-    pub(crate) fn new(out_dir: PathBuf) -> Self {
+    pub(crate) fn new(manifest_dir: PathBuf, out_dir: PathBuf) -> Self {
         Self {
             files: Vec::new(),
             includes: Vec::new(),
             defines: Vec::new(),
             flags: Vec::new(),
             out_dir,
+            manifest_dir,
         }
     }
 
@@ -45,61 +48,86 @@ impl NasmBuilder {
     }
 
     pub(crate) fn compile_intermediates(&self) -> Vec<PathBuf> {
-        if !test_nasm_command() {
-            panic!("NASM command not found! Build cannot continue.");
-        }
-
         let mut objects = Vec::new();
 
-        for src in &self.files {
-            let obj_ext = "obj";
-            let obj_name = src
-                .file_name()
-                .unwrap()
-                .to_str()
-                .unwrap()
-                .replace(".asm", &format!(".{}", obj_ext));
-            let obj_path = self.out_dir.join(obj_name);
-
-            let mut args: Vec<OsString> = vec![
-                "-f".into(),
-                "win64".into(),
-                "-o".into(),
-                obj_path.as_os_str().into(),
-            ];
-
-            for inc in &self.includes {
-                args.push("-I".into());
-                args.push(inc.as_os_str().into());
-            }
+        if self.files.is_empty() {
+            return vec![];
+        }
 
-            for (key, val) in &self.defines {
-                let def = if let Some(v) = val {
-                    format!("-D{}={}", key, v)
-                } else {
-                    format!("-D{}", key)
-                };
-                args.push(def.into());
+        if !test_nasm_command() {
+            if use_prebuilt_nasm() {
+                let prebuilt_dir = self.manifest_dir.join("builder").join("prebuilt-nasm");
+                for src in &self.files {
+                    let obj_name = src
+                        .file_name()
+                        .unwrap()
+                        .to_str()
+                        .unwrap()
+                        .replace(".asm", ".obj");
+                    let obj_path = self.out_dir.join(&obj_name);
+                    let base_name = obj_name.strip_suffix(".obj").unwrap_or(&obj_name);
+                    let prebuilt_src = prebuilt_dir.join(format!("{}.obj", base_name));
+                    if prebuilt_src.exists() {
+                        fs::copy(&prebuilt_src, &obj_path)
+                            .expect("Failed to copy prebuilt NASM object");
+                    } else {
+                        panic!("Prebuilt NASM object not found: {}", prebuilt_src.display());
+                    }
+                    objects.push(obj_path);
+                }
+            } else {
+                panic!("NASM command not found! Build cannot continue.");
             }
-
-            args.extend(self.flags.iter().map(|s| s.into()));
-
-            args.push(src.as_os_str().into());
-
-            let result = execute_command(
-                "nasm".as_ref(),
-                &args.iter().map(|s| s.as_os_str()).collect::<Vec<_>>(),
-            );
-            if !result.status {
-                panic!(
-                    "NASM failed for {}:\n-----\n{}\n-----\n{}\n-----\n",
-                    src.display(),
-                    result.stdout,
-                    result.stderr
+        } else {
+            for src in &self.files {
+                let obj_name = src
+                    .file_name()
+                    .unwrap()
+                    .to_str()
+                    .unwrap()
+                    .replace(".asm", ".obj");
+                let obj_path = self.out_dir.join(obj_name);
+
+                let mut args: Vec<OsString> = vec![
+                    "-f".into(),
+                    "win64".into(),
+                    "-o".into(),
+                    obj_path.as_os_str().into(),
+                ];
+
+                for inc in &self.includes {
+                    args.push("-I".into());
+                    args.push(inc.as_os_str().into());
+                }
+
+                for (key, val) in &self.defines {
+                    let def = if let Some(v) = val {
+                        format!("-D{}={}", key, v)
+                    } else {
+                        format!("-D{}", key)
+                    };
+                    args.push(def.into());
+                }
+
+                args.extend(self.flags.iter().map(|s| s.into()));
+
+                args.push(src.as_os_str().into());
+
+                let result = execute_command(
+                    "nasm".as_ref(),
+                    &args.iter().map(|s| s.as_os_str()).collect::<Vec<_>>(),
                 );
+                if !result.status {
+                    panic!(
+                        "NASM failed for {}:\n-----\n{}\n-----\n{}\n-----\n",
+                        src.display(),
+                        result.stdout,
+                        result.stderr
+                    );
+                }
+
+                objects.push(obj_path);
             }
-
-            objects.push(obj_path);
         }
 
         objects