spirv_tools_sys/val.rs
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 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152
use crate::shared;
#[repr(C)]
pub struct ValidatorOptions {
_unused: [u8; 0],
}
#[derive(Copy, Clone, Debug)]
#[repr(C)]
pub enum ValidatorLimits {
StructMembers,
StructDepth,
LocalVariables,
GlobalVariables,
SwitchBranches,
FunctionArgs,
ControlFlowNestingDepth,
AccessChainIndexes,
IdBound,
}
extern "C" {
/// Validates a SPIR-V binary for correctness. Any errors will be written into
/// *diagnostic if diagnostic is non-null, otherwise the context's message
/// consumer will be used.
///
/// Validate for SPIR-V spec rules for the SPIR-V version named in the
/// binary's header (at word offset 1). Additionally, if the context target
/// environment is a client API (such as Vulkan 1.1), then validate for that
/// client API version, to the extent that it is verifiable from data in the
/// binary itself.
#[link_name = "spvValidate"]
pub fn validate(
tool: *const shared::ToolContext,
binary: *const shared::Binary,
diagnostic: *mut *mut crate::diagnostics::Diagnostic,
) -> crate::shared::SpirvResult;
/// Validates a SPIR-V binary for correctness. Uses the provided Validator
/// options. Any errors will be written into *diagnostic if diagnostic is
/// non-null, otherwise the context's message consumer will be used.
///
/// Validate for SPIR-V spec rules for the SPIR-V version named in the
/// binary's header (at word offset 1). Additionally, if the context target
/// environment is a client API (such as Vulkan 1.1), then validate for that
/// client API version, to the extent that it is verifiable from data in the
/// binary itself, or in the validator options.
#[link_name = "spvValidateWithOptions"]
pub fn validate_with_options(
tool: *const shared::ToolContext,
options: *const ValidatorOptions,
binary: *const shared::Binary,
diagnostic: *mut *mut crate::diagnostics::Diagnostic,
) -> crate::shared::SpirvResult;
/// Creates a Validator options object with default options. Returns a valid
/// options object. The object remains valid until it is passed into
/// spvValidatorOptionsDestroy.
#[link_name = "spvValidatorOptionsCreate"]
pub fn validator_options_create() -> *mut ValidatorOptions;
/// Destroys the given Validator options object.
#[link_name = "spvValidatorOptionsDestroy"]
pub fn validator_options_destroy(opts: *mut ValidatorOptions);
/// Records the maximum Universal Limit that is considered valid in the given
/// Validator options object. <options> argument must be a valid options object.
#[link_name = "spvValidatorOptionsSetUniversalLimit"]
pub fn validator_options_set_limit(
opts: *mut ValidatorOptions,
limit_type: ValidatorLimits,
limit: u32,
);
/// 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.
#[link_name = "spvValidatorOptionsSetRelaxStoreStruct"]
pub fn validator_options_set_relax_store_struct(opts: *mut ValidatorOptions, toggle: 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
#[link_name = "spvValidatorOptionsSetRelaxLogicalPointer"]
pub fn validator_options_set_relax_logical_pointer(opts: *mut ValidatorOptions, toggle: 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.
#[link_name = "spvValidatorOptionsSetBeforeHlslLegalization"]
pub fn validator_options_set_before_legalization(opts: *mut ValidatorOptions, toggle: 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.
#[link_name = "spvValidatorOptionsSetRelaxBlockLayout"]
pub fn validator_options_set_relax_block_layout(opts: *mut ValidatorOptions, toggle: bool);
/// Records whether the validator should use standard block layout rules for
/// uniform blocks.
#[link_name = "spvValidatorOptionsSetUniformBufferStandardLayout"]
pub fn validator_options_set_uniform_buffer_standard_layout(
opts: *mut ValidatorOptions,
toggle: 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
#[link_name = "spvValidatorOptionsSetScalarBlockLayout"]
pub fn validator_options_set_scalar_block_layout(opts: *mut ValidatorOptions, toggle: bool);
/// Records whether or not the validator should skip validating standard
/// uniform/storage block layout.
#[link_name = "spvValidatorOptionsSetSkipBlockLayout"]
pub fn validator_options_set_skip_block_layout(opts: *mut ValidatorOptions, toggle: bool);
}