Add spirv-val flags to spirv-builder

crates/rustc_codegen_spirv/src/codegen_cx/mod.rs

@@ -277,6 +277,14 @@ pub struct CodegenArgs {
  pub disassemble_fn: Option<String>,
  pub disassemble_entry: Option<String>,
  pub disassemble_globals: bool,
+
+ // spirv-val flags
+ pub relax_struct_store: bool,
+ pub relax_logical_pointer: bool,
+ pub relax_block_layout: Option<bool>,
+ pub uniform_buffer_standard_layout: bool,
+ pub scalar_block_layout: bool,
+ pub skip_block_layout: bool,
 }
 
 impl CodegenArgs {
@@ -305,19 +313,44 @@ impl CodegenArgs {
  "NAME",
  );
  opts.optflagopt("", "disassemble-globals", "print globals to stderr", "");
+
+ opts.optflagopt("", "relax-struct-store", "Allow store from one struct type to a different type with compatible layout and members.", "");
+ opts.optflagopt("", "relax-logical-pointer", "Allow allocating an object of a pointer type and returning a pointer value from a function in logical addressing mode", "");
+ opts.optflagopt("", "relax-block-layout", "Enable VK_KHR_relaxed_block_layout when checking standard uniform, storage buffer, and push constant layouts. This is the default when targeting Vulkan 1.1 or later.", "");
+ opts.optflagopt("", "uniform-buffer-standard-layout", "Enable VK_KHR_uniform_buffer_standard_layout when checking standard uniform buffer layouts.", "");
+ opts.optflagopt("", "scalar-block-layout", "Enable VK_EXT_scalar_block_layout when checking standard uniform, storage buffer, and push constant layouts. Scalar layout rules are more permissive than relaxed block layout so in effect this will override the --relax-block-layout option.", "");
+ opts.optflagopt("", "skip-block-layout", "Skip checking standard uniform/storage buffer layout. Overrides any --relax-block-layout or --scalar-block-layout option.", "");
+
  let matches = opts.parse(args)?;
  let module_output_type =
  matches.opt_get_default("module-output", ModuleOutputType::Single)?;
  let disassemble = matches.opt_present("disassemble");
  let disassemble_fn = matches.opt_str("disassemble-fn");
  let disassemble_entry = matches.opt_str("disassemble-entry");
  let disassemble_globals = matches.opt_present("disassemble-globals");
+
+ let relax_struct_store = matches.opt_present("relax-struct-store");
+ let relax_logical_pointer = matches.opt_present("relax-logical-pointer");
+ let relax_block_layout = matches.opt_present("relax-block-layout");
+ let uniform_buffer_standard_layout = matches.opt_present("uniform-buffer-standard-layout");
+ let scalar_block_layout = matches.opt_present("scalar-block-layout");
+ let skip_block_layout = matches.opt_present("skip-block-layout");
+
+ let relax_block_layout = if relax_block_layout { Some(true) } else { None };
+
  Ok(Self {
  module_output_type,
  disassemble,
  disassemble_fn,
  disassemble_entry,
  disassemble_globals,
+
+ relax_struct_store,
+ relax_logical_pointer,
+ relax_block_layout,
+ uniform_buffer_standard_layout,
+ scalar_block_layout,
+ skip_block_layout,
  })
  }
 

crates/rustc_codegen_spirv/src/link.rs

@@ -153,7 +153,7 @@ fn link_exe(
  linker::LinkResult::SingleModule(spv_binary) => {
  let mut module_filename = out_dir;
  module_filename.push("module");
- post_link_single_module(sess, spv_binary.assemble(), &module_filename);
+ post_link_single_module(sess, &cg_args, spv_binary.assemble(), &module_filename);
  cg_args.do_disassemble(&spv_binary);
  let module_result = ModuleResult::SingleModule(module_filename);
  CompileResult {
@@ -167,7 +167,7 @@ fn link_exe(
  for (name, spv_binary) in map {
  let mut module_filename = out_dir.clone();
  module_filename.push(sanitize_filename::sanitize(&name));
- post_link_single_module(sess, spv_binary.assemble(), &module_filename);
+ post_link_single_module(sess, &cg_args, spv_binary.assemble(), &module_filename);
  hashmap.insert(name, module_filename);
  }
  let module_result = ModuleResult::MultiModule(hashmap);
@@ -191,24 +191,46 @@ fn entry_points(module: &rspirv::dr::Module) -> Vec<String> {
  .collect()
 }
 
-fn post_link_single_module(sess: &Session, spv_binary: Vec<u32>, out_filename: &Path) {
+fn post_link_single_module(
+ sess: &Session,
+ cg_args: &crate::codegen_cx::CodegenArgs,
+ spv_binary: Vec<u32>,
+ out_filename: &Path,
+) {
  if let Ok(ref path) = std::env::var("DUMP_POST_LINK") {
  File::create(path)
  .unwrap()
  .write_all(spirv_tools::binary::from_binary(&spv_binary))
  .unwrap();
  }
 
+ let val_options = spirv_tools::val::ValidatorOptions {
+ relax_struct_store: cg_args.relax_struct_store,
+ relax_logical_pointer: cg_args.relax_logical_pointer,
+ before_legalization: false,
+ relax_block_layout: cg_args.relax_block_layout,
+ uniform_buffer_standard_layout: cg_args.uniform_buffer_standard_layout,
+ scalar_block_layout: cg_args.scalar_block_layout,
+ skip_block_layout: cg_args.skip_block_layout,
+ max_limits: vec![],
+ };
+ let opt_options = spirv_tools::opt::Options {
+ validator_options: Some(val_options.clone()),
+ max_id_bound: None,
+ preserve_bindings: false,
+ preserve_spec_constants: false,
+ };
+
  let spv_binary = if sess.opts.optimize != OptLevel::No || sess.opts.debuginfo == DebugInfo::None
  {
  let _timer = sess.timer("link_spirv_opt");
- do_spirv_opt(sess, spv_binary, out_filename)
+ do_spirv_opt(sess, spv_binary, out_filename, opt_options)
  } else {
  spv_binary
  };
 
  if env::var("NO_SPIRV_VAL").is_err() {
- do_spirv_val(sess, &spv_binary, out_filename);
+ do_spirv_val(sess, &spv_binary, out_filename, val_options);
  }
 
  {
@@ -225,13 +247,18 @@ fn post_link_single_module(sess: &Session, spv_binary: Vec<u32>, out_filename: &
  }
 }
 
-fn do_spirv_opt(sess: &Session, spv_binary: Vec<u32>, filename: &Path) -> Vec<u32> {
+fn do_spirv_opt(
+ sess: &Session,
+ spv_binary: Vec<u32>,
+ filename: &Path,
+ options: spirv_tools::opt::Options,
+) -> Vec<u32> {
  use spirv_tools::{
  error,
  opt::{self, Optimizer},
  };
 
- let mut optimizer = opt::create(None);
+ let mut optimizer = opt::create(sess.target.options.env.parse().ok());
 
  match sess.opts.optimize {
  OptLevel::No => {}
@@ -266,9 +293,7 @@ fn do_spirv_opt(sess: &Session, spv_binary: Vec<u32>, filename: &Path) -> Vec<u3
  err.note(&format!("module `{}`", filename.display()));
  err.emit();
  },
- // We currently run the validator separately after optimization or even
- // if we don't run optimization, the default options don't run the validator
- None,
+ Some(options),
  );
 
  match result {
@@ -283,12 +308,17 @@ fn do_spirv_opt(sess: &Session, spv_binary: Vec<u32>, filename: &Path) -> Vec<u3
  }
 }
 
-fn do_spirv_val(sess: &Session, spv_binary: &[u32], filename: &Path) {
+fn do_spirv_val(
+ sess: &Session,
+ spv_binary: &[u32],
+ filename: &Path,
+ options: spirv_tools::val::ValidatorOptions,
+) {
  use spirv_tools::val::{self, Validator};
 
  let validator = val::create(sess.target.options.env.parse().ok());
 
- if let Err(e) = validator.validate(spv_binary, None) {
+ if let Err(e) = validator.validate(spv_binary, Some(options)) {
  let mut err = sess.struct_err(&e.to_string());
  err.note("spirv-val failed");
  err.note(&format!("module `{}`", filename.display()));

crates/spirv-builder/src/lib.rs

@@ -61,6 +61,7 @@ use std::collections::HashMap;
 use std::env;
 use std::error::Error;
 use std::fmt;
+use std::fmt::Write;
 use std::fs::File;
 use std::io::BufReader;
 use std::path::{Path, PathBuf};
@@ -115,6 +116,14 @@ pub struct SpirvBuilder {
  multimodule: bool,
  capabilities: Vec<Capability>,
  extensions: Vec<String>,
+
+ // spirv-val flags
+ pub relax_struct_store: bool,
+ pub relax_logical_pointer: bool,
+ pub relax_block_layout: bool,
+ pub uniform_buffer_standard_layout: bool,
+ pub scalar_block_layout: bool,
+ pub skip_block_layout: bool,
 }
 
 impl SpirvBuilder {
@@ -128,6 +137,13 @@ impl SpirvBuilder {
  multimodule: false,
  capabilities: Vec::new(),
  extensions: Vec::new(),
+
+ relax_struct_store: false,
+ relax_logical_pointer: false,
+ relax_block_layout: false,
+ uniform_buffer_standard_layout: false,
+ scalar_block_layout: false,
+ skip_block_layout: false,
  }
  }
 
@@ -172,6 +188,48 @@ impl SpirvBuilder {
  self
  }
 
+ /// Allow store from one struct type to a different type with compatible layout and members.
+ pub fn relax_struct_store(mut self, v: bool) -> Self {
+ self.relax_struct_store = v;
+ self
+ }
+
+ /// Allow allocating an object of a pointer type and returning a pointer value from a function
+ /// in logical addressing mode
+ pub fn relax_logical_pointer(mut self, v: bool) -> Self {
+ self.relax_logical_pointer = v;
+ self
+ }
+
+ /// Enable `VK_KHR_relaxed_block_layout` when checking standard uniform, storage buffer, and
+ /// push constant layouts. This is the default when targeting Vulkan 1.1 or later.
+ pub fn relax_block_layout(mut self, v: bool) -> Self {
+ self.relax_block_layout = v;
+ self
+ }
+
+ /// Enable `VK_KHR_uniform_buffer_standard_layout` when checking standard uniform buffer
+ /// layouts.
+ pub fn uniform_buffer_standard_layout(mut self, v: bool) -> Self {
+ self.uniform_buffer_standard_layout = v;
+ self
+ }
+
+ /// Enable `VK_EXT_scalar_block_layout` when checking standard uniform, storage buffer, and
+ /// push constant layouts. Scalar layout rules are more permissive than relaxed block layout so
+ /// in effect this will override the --relax-block-layout option.
+ pub fn scalar_block_layout(mut self, v: bool) -> Self {
+ self.scalar_block_layout = v;
+ self
+ }
+
+ /// Skip checking standard uniform/storage buffer layout. Overrides any --relax-block-layout or
+ /// --scalar-block-layout option.
+ pub fn skip_block_layout(mut self, v: bool) -> Self {
+ self.skip_block_layout = v;
+ self
+ }
+
  /// Builds the module. If `print_metadata` is true, you usually don't have to inspect the path
  /// in the result, as the environment variable for the path to the module will already be set.
  pub fn build(self) -> Result<CompileResult, SpirvBuilderError> {
@@ -245,10 +303,44 @@ fn invoke_rustc(builder: &SpirvBuilder) -> Result<PathBuf, SpirvBuilderError> {
  // rustc expects a full path, instead of a filename looked up via LD_LIBRARY_PATH, so we need
  // to copy cargo's understanding of library lookup and find the library and its full path.
  let rustc_codegen_spirv = find_rustc_codegen_spirv();
- let llvm_args = builder
- .multimodule
- .then(|| " -C llvm-args=--module-output=multiple")
- .unwrap_or_default();
+
+ let mut llvm_args = Vec::new();
+ if builder.multimodule {
+ llvm_args.push("--module-output=multiple");
+ }
+ if builder.relax_struct_store {
+ llvm_args.push("--relax-struct-store");
+ }
+ if builder.relax_logical_pointer {
+ llvm_args.push("--relax-logical-pointer");
+ }
+ if builder.relax_block_layout {
+ llvm_args.push("--relax-block-layout");
+ }
+ if builder.uniform_buffer_standard_layout {
+ llvm_args.push("--uniform-buffer-standard-layout");
+ }
+ if builder.scalar_block_layout {
+ llvm_args.push("--scalar-block-layout");
+ }
+ if builder.skip_block_layout {
+ llvm_args.push("--skip-block-layout");
+ }
+
+ let llvm_args = if llvm_args.is_empty() {
+ String::new()
+ } else {
+ // Cargo's handling of RUSTFLAGS is a little cursed. -Cllvm-args is documented as "The list
+ // must be separated by spaces", but if we set RUSTFLAGS='-C llvm-args="--foo --bar"', then
+ // cargo will pass -C 'llvm-args="--foo' '--bar"' to rustc. Like, really? c'mon.
+ // Thankfully, passing -C llvm-args multiple times appends to a list, instead of
+ // overwriting.
+ let mut result = String::new();
+ for arg in llvm_args {
+ write!(result, " -C llvm-args={}", arg).unwrap();
+ }
+ result
+ };
 
  let mut target_features = Vec::new();