NASM draft

Author: justsmth

aws-lc-sys/builder/cc_builder.rs

@@ -15,6 +15,7 @@ mod universal;
 mod win_aarch64;
 mod win_x86_64;
 
+use crate::nasm_builder::NasmBuilder;
 use crate::{
     cargo_env, emit_warning, env_var_to_bool, execute_command, get_crate_cflags, is_no_asm,
     optional_env_optional_crate_target, optional_env_target, out_dir, requested_c_std,
@@ -137,6 +138,15 @@ impl BuildOption {
             }
         }
     }
+
+    pub(crate) fn apply_nasm<'a>(&self, nasm_builder: &'a mut NasmBuilder) -> &'a mut NasmBuilder {
+        match self {
+            BuildOption::FLAG(val) => nasm_builder.flag(val),
+            BuildOption::DEFINE(key, val) => nasm_builder.define(key, Some(val.as_str())),
+            BuildOption::INCLUDE(path) => nasm_builder.include(path.as_path()),
+            _ => nasm_builder, // STD ignored for NASM
+        }
+    }
 }
 
 impl CcBuilder {
@@ -436,6 +446,14 @@ impl CcBuilder {
                 .display()
         ));
 
+        let mut build_options = vec![];
+        self.add_includes(&mut build_options);
+        let mut nasm_builder = NasmBuilder::new(self.out_dir.clone());
+
+        for option in &build_options {
+            option.apply_nasm(&mut nasm_builder);
+        }
+
         let s2n_bignum_source_feature_map = Self::build_s2n_bignum_source_feature_map();
         let compiler_features = self.compiler_features.take();
         for source in sources {
@@ -470,6 +488,8 @@ impl CcBuilder {
                 }
             } else if is_jitter_entropy {
                 jitter_entropy_builder.file(source_path);
+            } else if source_path.extension() == Some("asm".as_ref()) {
+                nasm_builder.file(source_path);
             } else {
                 cc_build.file(source_path);
             }
@@ -483,6 +503,10 @@ impl CcBuilder {
         for object in jitter_entropy_object_files {
             cc_build.object(object);
         }
+        let nasm_object_files = nasm_builder.compile_intermediates();
+        for object in nasm_object_files {
+            cc_build.object(object);
+        }
         cc_build.file(PathBuf::from_str("rust_wrapper.c").unwrap());
     }
 

aws-lc-sys/builder/main.rs

@@ -104,6 +104,7 @@ bindgen_available!(
 );
 mod cc_builder;
 mod cmake_builder;
+mod nasm_builder;
 
 pub(crate) fn get_aws_lc_include_path(manifest_dir: &Path) -> PathBuf {
     manifest_dir.join("aws-lc").join("include")

aws-lc-sys/builder/nasm_builder.rs

@@ -0,0 +1,98 @@
+use std::ffi::OsString;
+use std::path::{Path, PathBuf};
+
+use crate::execute_command;
+
+#[derive(Debug)]
+pub(crate) struct NasmBuilder {
+    files: Vec<PathBuf>,
+    includes: Vec<PathBuf>,
+    defines: Vec<(String, Option<String>)>,
+    flags: Vec<String>,
+    out_dir: PathBuf,
+}
+
+impl NasmBuilder {
+    pub(crate) fn new(out_dir: PathBuf) -> Self {
+        Self {
+            files: Vec::new(),
+            includes: Vec::new(),
+            defines: Vec::new(),
+            flags: Vec::new(),
+            out_dir,
+        }
+    }
+
+    pub(crate) fn file<P: AsRef<Path>>(&mut self, p: P) -> &mut Self {
+        self.files.push(p.as_ref().to_path_buf());
+        self
+    }
+
+    pub(crate) fn include<P: AsRef<Path>>(&mut self, dir: P) -> &mut Self {
+        self.includes.push(dir.as_ref().to_path_buf());
+        self
+    }
+
+    pub(crate) fn define(&mut self, key: &str, val: Option<&str>) -> &mut Self {
+        self.defines
+            .push((key.to_string(), val.map(|s| s.to_string())));
+        self
+    }
+
+    pub(crate) fn flag(&mut self, flag: &str) -> &mut Self {
+        self.flags.push(flag.to_string());
+        self
+    }
+
+    pub(crate) fn compile_intermediates(&self) -> Vec<PathBuf> {
+        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());
+            }
+
+            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 {}: {}", src.display(), result.stderr);
+            }
+
+            objects.push(obj_path);
+        }
+
+        objects
+    }
+}