1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96
#[cfg(feature = "use-compiled-tools")] pub mod compiled; #[cfg(feature = "use-installed-tools")] pub mod tool; pub use spirv_tools_sys::val::ValidatorLimits; #[derive(Default, Clone)] pub struct ValidatorOptions { /// Record whether or not the validator should relax the rules on types for /// stores to structs. When relaxed, it will allow a type mismatch as long as /// the types are structs with the same layout. Two structs have the same layout /// if /// /// 1) the members of the structs are either the same type or are structs with /// same layout, and /// /// 2) the decorations that affect the memory layout are identical for both /// types. Other decorations are not relevant. pub relax_struct_store: bool, /// Records whether or not the validator should relax the rules on pointer usage /// in logical addressing mode. /// /// When relaxed, it will allow the following usage cases of pointers: /// 1) OpVariable allocating an object whose type is a pointer type /// 2) OpReturnValue returning a pointer value pub relax_logical_pointer: bool, /// Records whether or not the validator should relax the rules because it is /// expected that the optimizations will make the code legal. /// /// When relaxed, it will allow the following: /// 1) It will allow relaxed logical pointers. Setting this option will also /// set that option. /// 2) Pointers that are pass as parameters to function calls do not have to /// match the storage class of the formal parameter. /// 3) Pointers that are actaul parameters on function calls do not have to point /// to the same type pointed as the formal parameter. The types just need to /// logically match. pub before_legalization: bool, /// Records whether the validator should use "relaxed" block layout rules. /// Relaxed layout rules are described by Vulkan extension /// VK_KHR_relaxed_block_layout, and they affect uniform blocks, storage blocks, /// and push constants. /// /// This is enabled by default when targeting Vulkan 1.1 or later. /// Relaxed layout is more permissive than the default rules in Vulkan 1.0. pub relax_block_layout: Option<bool>, /// Records whether the validator should use standard block layout rules for /// uniform blocks. pub uniform_buffer_standard_layout: bool, /// Records whether the validator should use "scalar" block layout rules. /// Scalar layout rules are more permissive than relaxed block layout. /// /// See Vulkan extnesion VK_EXT_scalar_block_layout. The scalar alignment is /// defined as follows: /// - scalar alignment of a scalar is the scalar size /// - scalar alignment of a vector is the scalar alignment of its component /// - scalar alignment of a matrix is the scalar alignment of its component /// - scalar alignment of an array is the scalar alignment of its element /// - scalar alignment of a struct is the max scalar alignment among its /// members /// /// For a struct in Uniform, StorageClass, or PushConstant: /// - a member Offset must be a multiple of the member's scalar alignment /// - ArrayStride or MatrixStride must be a multiple of the array or matrix /// scalar alignment pub scalar_block_layout: bool, /// Records whether or not the validator should skip validating standard /// uniform/storage block layout. pub skip_block_layout: bool, /// Applies a maximum to one or more Universal limits pub max_limits: Vec<(ValidatorLimits, u32)>, } pub trait Validator: Default { fn with_env(target_env: crate::TargetEnv) -> Self; fn validate( &self, binary: impl AsRef<[u32]>, options: Option<ValidatorOptions>, ) -> Result<(), crate::error::Error>; } pub fn create(te: Option<crate::TargetEnv>) -> impl Validator { let target_env = te.unwrap_or_default(); #[cfg(feature = "use-compiled-tools")] { compiled::CompiledValidator::with_env(target_env) } #[cfg(all(feature = "use-installed-tools", not(feature = "use-compiled-tools")))] { tool::ToolValidator::with_env(target_env) } }