Boop

Author: Jake-Shadle

rustc_codegen_spirv/Cargo.toml

@@ -13,9 +13,18 @@ repository = "https://github.com/EmbarkStudios/rust-gpu"
 crate-type = ["dylib"]
 
 [features]
+# By default, the use-compiled-tools is enabled, as doesn't require additional
+# setup steps for the user. This does however mean that you will need to disable
+# default features and explicitly enable `use-installed-tools` if you are using
+# this in an environment with spirv-tools in PATH, and you don't want to take
+# the compile time cost
+default = ["use-compiled-tools"]
 # If enabled, uses spirv-tools binaries installed in PATH, instead of
 # compiling and linking the spirv-tools C++ code
 use-installed-tools = ["spirv-tools/use-installed"]
+# If enabled will compile and link the C++ code for the spirv tools, the compiled
+# version is preferred if both this and `use-installed-tools` are enabled
+use-compiled-tools = ["spirv-tools/use-compiled"]
 
 [dependencies]
 bimap = "0.5"

rustc_codegen_spirv/src/link.rs

@@ -155,9 +155,15 @@ fn link_exe(
 }
 
 fn do_spirv_opt(sess: &Session, spv_binary: Vec<u32>, filename: &Path) -> Vec<u32> {
-    use spirv_tools::{error, opt};
-
-    let mut optimizer = opt::Optimizer::new(spirv_tools::TargetEnv::default());
+    use spirv_tools::{error, opt::{
+        self,
+        Optimizer,
+    }};
+
+    #[cfg(feature = "use-compiled-tools")]
+    let mut optimizer = opt::compiled::CompiledOptimizer;
+    #[cfg(all(feature = "use-installed-tools", not(feature = "use-compiled-tools")))]
+    let mut optimizer = opt::tool::ToolOptimizer;
 
     optimizer
         .register_size_passes()

spirv-tools-sys/Cargo.toml

@@ -11,6 +11,8 @@ license = "MIT OR Apache-2.0"
 # preserves the types so that spirv-tools can still work without needing
 # to keep copies of some of the basic enums etc
 use-installed = []
+# Forces compilation of the C++ code, even if `use-installed` is enabled
+use-compiled = []
 
 [build-dependencies]
 cc = { version = "1.0", features = ["parallel"] }

spirv-tools-sys/build.rs

@@ -219,7 +219,7 @@ fn val(build: &mut Build) {
 }
 
 fn main() {
-    if std::env::var("CARGO_FEATURE_USE_INSTALLED").is_ok() {
+    if std::env::var("CARGO_FEATURE_USE_INSTALLED").is_ok() && std::env::var("CARGO_FEATURE_USE_COMPILED").is_err() {
         println!("use-installed feature on, skipping compilation of C++ code");
         return;
     }

spirv-tools-sys/src/c/opt.cpp

@@ -242,7 +242,7 @@ extern "C" {
         ((spvtools::Optimizer*)optimizer)->RegisterWebGPUToVulkanPasses();
     }
 
-    SPIRV_TOOLS_EXPORT void optimizer_register_legalization_passes(Optimus* optimizer) {
+    SPIRV_TOOLS_EXPORT void optimizer_register_hlsl_legalization_passes(Optimus* optimizer) {
         ((spvtools::Optimizer*)optimizer)->RegisterLegalizationPasses();
     }
 }

spirv-tools-sys/src/opt.rs

@@ -582,7 +582,7 @@ extern "C" {
     ///
     /// This sequence of passes is subject to constant review and will change
     /// from time to time.
-    pub fn optimizer_register_legalization_passes(opt: *mut Optimizer);
+    pub fn optimizer_register_hlsl_legalization_passes(opt: *mut Optimizer);
 
 // Some passes take arguments, so we create those separately on a
 // case-by-case basis

spirv-tools/Cargo.toml

@@ -7,6 +7,7 @@ license = "MIT OR Apache-2.0"
 
 [features]
 use-installed = ["spirv-tools-sys/use-installed", "memchr"]
+use-compiled = ["spirv-tools-sys/use-compiled"]
 
 [dependencies]
 spirv-tools-sys = { path = "../spirv-tools-sys" }
@@ -18,3 +19,4 @@ structopt = "0.3"
 
 [[example]]
 name = "as"
+required-features = ["use-compiled"]

spirv-tools/examples/as.rs

@@ -13,14 +13,14 @@ struct Args {
     preserve_ids: bool,
     /// Use specified environment.
     #[structopt(long = "target-env", parse(try_from_str))]
-    target_env: Option<spirv_tools::shared::TargetEnv>,
+    target_env: Option<spirv_tools::TargetEnv>,
     /// The input file. Use '-' for stdin.
     #[structopt(name = "FILE")]
     input: String,
 }
 
 fn main() {
-    use spirv_tools::assembler;
+    use spirv_tools::assembler::{self, Assembler};
 
     let args = Args::from_args();
 
@@ -39,7 +39,7 @@ fn main() {
         preserve_numeric_ids: args.preserve_ids,
     };
 
-    let assembler = assembler::Assembler::new(args.target_env.unwrap_or_default());
+    let assembler = assembler::compiled::CompiledAssembler::default();
 
     match assembler.assemble(&contents, assembler_opts) {
         Ok(binary) => {

spirv-tools/src/assembler.rs

@@ -1,4 +1,8 @@
-use spirv_tools_sys::{assembler, shared};
+#[cfg(feature = "use-compiled")]
+pub mod compiled;
+
+#[cfg(feature = "use-installed")]
+pub mod tool;
 
 #[derive(Copy, Clone, Default)]
 pub struct AssemblerOptions {
@@ -15,76 +19,18 @@ impl Into<u32> for AssemblerOptions {
         let mut res = 0; //assembler::BinaryOptions::None as u32;
 
         if self.preserve_numeric_ids {
-            res |= assembler::BinaryOptions::PreserveNumberIds as u32;
+            res |= spirv_tools_sys::assembler::BinaryOptions::PreserveNumberIds as u32;
         }
 
         res
     }
 }
 
-pub struct Assembler {
-    inner: *mut shared::ToolContext,
-}
-
-impl Assembler {
-    pub fn new(target_env: shared::TargetEnv) -> Self {
-        Self {
-            inner: unsafe { shared::context_create(target_env) },
-        }
-    }
-
-    pub fn assemble(
+pub trait Assembler: Default {
+    fn with_env(target_env: crate::TargetEnv) -> Self;
+    fn assemble(
         &self,
         text: &str,
         options: AssemblerOptions,
-    ) -> Result<crate::shared::Binary, crate::error::Error> {
-        unsafe {
-            let mut binary = std::ptr::null_mut();
-            let mut diagnostic = std::ptr::null_mut();
-
-            let res = assembler::assemble(
-                self.inner,
-                text.as_ptr() as *const _,
-                text.len(),
-                options.into(),
-                &mut binary,
-                &mut diagnostic,
-            );
-
-            // Always wrap diagnostic, it's fine if it's null
-            use std::convert::TryFrom;
-            let diagnostic = crate::error::Diagnostic::try_from(diagnostic).ok();
-
-            match res {
-                shared::SpirvResult::Success => {
-                    if binary.is_null() {
-                        return Err(crate::error::Error {
-                            inner: shared::SpirvResult::InternalError,
-                            diagnostics: vec![crate::error::Diagnostic {
-                                line: 0,
-                                column: 0,
-                                index: 0,
-                                message: "spirv assemble indicated success but did not return a valid binary".to_owned(),
-                                is_text: true,
-                            }],
-                        });
-                    }
-
-                    Ok(crate::shared::Binary::new(binary))
-                }
-                other => Err(crate::error::Error {
-                    inner: other,
-                    diagnostics: vec![diagnostic],
-                }),
-            }
-        }
-    }
-}
-
-impl Drop for Assembler {
-    fn drop(&mut self) {
-        unsafe {
-            shared::context_destroy(self.inner);
-        }
-    }
-}
+    ) -> Result<crate::binary::Binary, crate::error::Error>;
+}

spirv-tools/src/assembler/compiled.rs

@@ -0,0 +1,70 @@
+use spirv_tools_sys::{assembler, shared};
+
+pub struct CompiledAssembler {
+    inner: *mut shared::ToolContext,
+}
+
+use super::Assembler;
+
+impl Assembler for CompiledAssembler {
+    fn with_env(target_env: crate::TargetEnv) -> Self {
+        Self {
+            inner: unsafe { shared::context_create(target_env) },
+        }
+    }
+
+    fn assemble(
+        &self,
+        text: &str,
+        options: super::AssemblerOptions,
+    ) -> Result<crate::binary::Binary, crate::error::Error> {
+        unsafe {
+            let mut binary = std::ptr::null_mut();
+            let mut diagnostic = std::ptr::null_mut();
+
+            let res = assembler::assemble(
+                self.inner,
+                text.as_ptr() as *const _,
+                text.len(),
+                options.into(),
+                &mut binary,
+                &mut diagnostic,
+            );
+
+            // Always wrap diagnostic, it's fine if it's null
+            use std::convert::TryFrom;
+            let diagnostic = crate::error::Diagnostic::try_from(diagnostic).ok();
+
+            match res {
+                shared::SpirvResult::Success => {
+                    if binary.is_null() {
+                        return Err(crate::error::Error {
+                            inner: shared::SpirvResult::InternalError,
+                            diagnostic: Some("spirv assemble indicated success but did not return a valid binary".to_owned().into()),
+                        });
+                    }
+
+                    Ok(crate::binary::Binary::External(crate::binary::external::ExternalBinary::new(binary)))
+                }
+                other => Err(crate::error::Error {
+                    inner: other,
+                    diagnostic,
+                }),
+            }
+        }
+    }
+}
+
+impl Default for CompiledAssembler {
+    fn default() -> Self {
+        Self::with_env(crate::TargetEnv::default())
+    }
+}
+
+impl Drop for CompiledAssembler {
+    fn drop(&mut self) {
+        unsafe {
+            shared::context_destroy(self.inner);
+        }
+    }
+}

spirv-tools/src/assembler/tool.rs

@@ -0,0 +1,39 @@
+pub struct ToolAssembler {
+    target_env: crate::TargetEnv,
+}
+
+use super::Assembler;
+
+impl Assembler for ToolAssembler {
+    fn with_env(target_env: crate::TargetEnv) -> Self {
+        Self {
+            target_env,
+        }
+    }
+
+    fn assemble(
+        &self,
+        text: &str,
+        options: super::AssemblerOptions,
+    ) -> Result<crate::binary::Binary, crate::error::Error> {
+        let mut cmd = std::process::Command::new("spirv-as");
+        cmd.arg("--target-env").arg(self.target_env.to_string());
+
+        if options.preserve_numeric_ids {
+            cmd.arg("--preserve-numeric-ids");
+        }
+
+        cmd.arg("-o").arg("-");
+
+        let cmd_output = crate::cmd::exec(cmd, Some(text.as_bytes()), crate::cmd::Output::Retrieve)?;
+
+        use std::convert::TryFrom;
+        crate::binary::Binary::try_from(cmd_output.binary)
+    }
+}
+
+impl Default for ToolAssembler {
+    fn default() -> Self {
+        Self::with_env(crate::TargetEnv::default())
+    }
+}