Add assembler and example

Author: Jake-Shadle

Cargo.lock

@@ -7,6 +7,7 @@ build = "build.rs"
 license = "MIT OR Apache-2.0"
 
 [features]
+as = ["tools"]
 opt = ["val"]
 val = ["tools"]
 tools = []

spirv-tools-sys/Cargo.toml

@@ -0,0 +1,40 @@
+use crate::shared;
+
+#[repr(u32)] // SPV_FORCE_32_BIT_ENUM
+pub enum BinaryOptions {
+    None = 0x1,
+    PreserveNumberIds = 1 << 1,
+}
+
+#[repr(C)]
+pub struct Binary {
+    pub code: *const u32,
+    pub size: usize,
+}
+
+extern "C" {
+    /// Encodes the given SPIR-V assembly text to its binary representation. The
+    /// length parameter specifies the number of bytes for text. Encoded binary will
+    /// be stored into *binary. Any error will be written into *diagnostic if
+    /// diagnostic is non-null, otherwise the context's message consumer will be
+    /// used. The generated binary is independent of the context and may outlive it.
+    /// The SPIR-V binary version is set to the highest version of SPIR-V supported
+    /// by the context's target environment.
+    ///
+    /// The options parameter is a bit field of
+    /// spv_text_to_binary_options_t.
+    #[link_name = "spvTextToBinaryWithOptions"]
+    pub fn assemble(
+        tool: *const shared::ToolContext,
+        text: *const std::os::raw::c_char,
+        size: usize,
+        options: u32,
+        binary: *mut *mut Binary,
+        diagnostic: *mut *mut shared::Diagnostic,
+    ) -> crate::shared::SpirvResult;
+
+    /// Frees a binary stream from memory. This is a no-op if binary is a null
+    /// pointer.
+    #[link_name = "spvBinaryDestroy"]
+    pub fn binary_destroy(binary: *mut Binary);
+}

spirv-tools-sys/src/assembler.rs

@@ -5,3 +5,6 @@ pub mod opt;
 
 #[cfg(feature = "val")]
 pub mod val;
+
+#[cfg(feature = "as")]
+pub mod assembler;

spirv-tools-sys/src/lib.rs

@@ -6,8 +6,16 @@ edition = "2018"
 license = "MIT OR Apache-2.0"
 
 [features]
+as = ["spirv-tools-sys/as"]
 opt = ["spirv-tools-sys/opt"]
 val = ["spirv-tools-sys/val"]
 
 [dependencies]
 spirv-tools-sys = { path = "../spirv-tools-sys" }
+
+[dev-dependencies]
+structopt = "0.3"
+
+[[example]]
+name = "as"
+required-features = ["as"]

spirv-tools/Cargo.toml

@@ -0,0 +1,61 @@
+use structopt::StructOpt;
+
+/// Create a SPIR-V binary module from SPIR-V assembly text
+#[derive(StructOpt)]
+struct Args {
+    /// Set the output filename. Use '-' for stdout.
+    #[structopt(short, default_value = "out.spv")]
+    output: String,
+    /// Numeric IDs in the binary will have the same values as in the
+    /// source. Non-numeric IDs are allocated by filling in the gaps,
+    /// starting with 1 and going up.
+    #[structopt(long = "preserve-numeric-ids")]
+    preserve_ids: bool,
+    /// Use specified environment.
+    #[structopt(long = "target-env", parse(try_from_str))]
+    target_env: Option<spirv_tools::shared::TargetEnv>,
+    /// The input file. Use '-' for stdin.
+    #[structopt(name = "FILE")]
+    input: String,
+}
+
+fn main() {
+    use spirv_tools::assembler;
+
+    let args = Args::from_args();
+
+    let contents = if args.input == "-" {
+        use std::io::Read;
+        let mut v = Vec::with_capacity(1024);
+        std::io::stdin()
+            .read_to_end(&mut v)
+            .expect("failed to read stdin");
+        String::from_utf8(v).expect("stdin had invalid utf-8")
+    } else {
+        std::fs::read_to_string(&args.input).expect("failed to read input file")
+    };
+
+    let assembler_opts = assembler::AssemblerOptions {
+        preserve_numeric_ids: args.preserve_ids,
+    };
+
+    let assembler = assembler::Assembler::new(args.target_env.unwrap_or_default());
+
+    match assembler.assemble(&contents, assembler_opts) {
+        Ok(binary) => {
+            if args.output == "-" {
+                use std::io::Write;
+                std::io::stdout()
+                    .lock()
+                    .write(binary.as_ref())
+                    .expect("failed to write binary to stdout");
+            } else {
+                std::fs::write(args.output, &binary).expect("failed to write binary");
+            }
+        }
+        Err(e) => {
+            eprintln!("{}", e);
+            std::process::exit(1);
+        }
+    }
+}

spirv-tools/examples/as.rs

@@ -0,0 +1,119 @@
+use spirv_tools_sys::{assembler, shared};
+
+pub struct Binary {
+    inner: *mut assembler::Binary,
+}
+
+impl AsRef<[u32]> for Binary {
+    fn as_ref(&self) -> &[u32] {
+        unsafe { std::slice::from_raw_parts((*self.inner).code, (*self.inner).size) }
+    }
+}
+
+impl AsRef<[u8]> for Binary {
+    fn as_ref(&self) -> &[u8] {
+        unsafe {
+            std::slice::from_raw_parts(
+                (*self.inner).code as *const u8,
+                (*self.inner).size * std::mem::size_of::<u32>(),
+            )
+        }
+    }
+}
+
+impl Drop for Binary {
+    fn drop(&mut self) {
+        unsafe {
+            assembler::binary_destroy(self.inner);
+        }
+    }
+}
+
+#[derive(Copy, Clone, Default)]
+pub struct AssemblerOptions {
+    /// Numeric IDs in the binary will have the same values as in the source.
+    /// Non-numeric IDs are allocated by filling in the gaps, starting with 1
+    /// and going up.
+    pub preserve_numeric_ids: bool,
+}
+
+impl Into<u32> for AssemblerOptions {
+    fn into(self) -> u32 {
+        // This is weird, the "none" is 1, so I'm not sure if that means having
+        // it disables all other options or...?
+        let mut res = 0; //assembler::BinaryOptions::None as u32;
+
+        if self.preserve_numeric_ids {
+            res |= 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(
+        &self,
+        text: &str,
+        options: AssemblerOptions,
+    ) -> Result<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(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(Binary { inner: binary })
+                }
+                other => Err(crate::error::Error {
+                    inner: other,
+                    diagnostic,
+                }),
+            }
+        }
+    }
+}
+
+impl Drop for Assembler {
+    fn drop(&mut self) {
+        unsafe {
+            shared::context_destroy(self.inner);
+        }
+    }
+}

spirv-tools/src/assembler.rs

@@ -3,6 +3,9 @@ pub mod opt;
 #[cfg(feature = "val")]
 pub mod val;
 
+#[cfg(feature = "as")]
+pub mod assembler;
+
 pub use spirv_tools_sys::shared;
 
 pub mod error;