#[repr(C)]
pub struct Optimizer {
    _unused: [u8; 0],
}

#[repr(C)]
pub struct OptimizerOptions {
    _unused: [u8; 0],
}

#[derive(Copy, Clone, Debug)]
#[repr(C)]
#[allow(clippy::upper_case_acronyms)]
pub enum Passes {
    /// Create aggressive dead code elimination pass
    /// This pass eliminates unused code from the module. In addition,
    /// it detects and eliminates code which may have spurious uses but which do
    /// not contribute to the output of the function. The most common cause of
    /// such code sequences is summations in loops whose result is no longer used
    /// due to dead code elimination. This optimization has additional compile
    /// time cost over standard dead code elimination.
    ///
    /// This pass only processes entry point functions. It also only processes
    /// shaders with relaxed logical addressing (see opt/instruction.h). It
    /// currently will not process functions with function calls. Unreachable
    /// functions are deleted.
    ///
    /// This pass will be made more effective by first running passes that remove
    /// dead control flow and inlines function calls.
    ///
    /// This pass can be especially useful after running Local Access Chain
    /// Conversion, which tends to cause cycles of dead code to be left after
    /// Store/Load elimination passes are completed. These cycles cannot be
    /// eliminated with standard dead code elimination.
    AggressiveDCE,
    /// Replaces the extensions VK_AMD_shader_ballot,VK_AMD_gcn_shader, and
    /// VK_AMD_shader_trinary_minmax with equivalent code using core instructions and
    /// capabilities.
    AmdExtToKhr,
    /// Creates a block merge pass.
    /// This pass searches for blocks with a single Branch to a block with no
    /// other predecessors and merges the blocks into a single block. Continue
    /// blocks and Merge blocks are not candidates for the second block.
    ///
    /// The pass is most useful after Dead Branch Elimination, which can leave
    /// such sequences of blocks. Merging them makes subsequent passes more
    /// effective, such as single block local store-load elimination.
    ///
    /// While this pass reduces the number of occurrences of this sequence, at
    /// this time it does not guarantee all such sequences are eliminated.
    ///
    /// Presence of phi instructions can inhibit this optimization. Handling
    /// these is left for future improvements.
    BlockMerge,
    /// Creates a conditional constant propagation (CCP) pass.
    /// This pass implements the SSA-CCP algorithm in
    ///
    ///      Constant propagation with conditional branches,
    ///      Wegman and Zadeck, ACM TOPLAS 13(2):181-210.
    ///
    /// Constant values in expressions and conditional jumps are folded and
    /// simplified. This may reduce code size by removing never executed jump targets
    /// and computations with constant operands.
    ConditionalConstantPropagation,
    /// Creates a CFG cleanup pass.
    /// This pass removes cruft from the control flow graph of functions that are
    /// reachable from entry points and exported functions. It currently includes the
    /// following functionality:
    ///
    /// - Removal of unreachable basic blocks.
    CFGCleanup,
    /// Create a pass to do code sinking.  Code sinking is a transformation
    /// where an instruction is moved into a more deeply nested construct.
    CodeSinking,
    /// Create a pass to combine chained access chains.
    /// This pass looks for access chains fed by other access chains and combines
    /// them into a single instruction where possible.
    CombineAccessChains,
    /// Creates a compact ids pass.
    /// The pass remaps result ids to a compact and gapless range starting from %1.
    CompactIds,
    /// Create pass to convert relaxed precision instructions to half precision.
    /// This pass converts as many relaxed float32 arithmetic operations to half as
    /// possible. It converts any float32 operands to half if needed. It converts
    /// any resulting half precision values back to float32 as needed. No variables
    /// are changed. No image operations are changed.
    ///
    /// Best if run after function scope store/load and composite operation
    /// eliminations are run. Also best if followed by instruction simplification,
    /// redundancy elimination and DCE.
    ConvertRelaxedToHalf,
    /// Create copy propagate arrays pass.
    /// This pass looks to copy propagate memory references for arrays.  It looks
    /// for specific code patterns to recognize array copies.
    CopyPropagateArrays,
    /// Create dead branch elimination pass.
    /// For each entry point function, this pass will look for SelectionMerge
    /// BranchConditionals with constant condition and convert to a Branch to
    /// the indicated label. It will delete resulting dead blocks.
    ///
    /// For all phi functions in merge block, replace all uses with the id
    /// corresponding to the living predecessor.
    ///
    /// Note that some branches and blocks may be left to avoid creating invalid
    /// control flow. Improving this is left to future work.
    ///
    /// This pass is most effective when preceeded by passes which eliminate
    /// local loads and stores, effectively propagating constant values where
    /// possible.
    DeadBranchElim,
    /// Creates a dead insert elimination pass.
    /// This pass processes each entry point function in the module, searching for
    /// unreferenced inserts into composite types. These are most often unused
    /// stores to vector components. They are unused because they are never
    /// referenced, or because there is another insert to the same component between
    /// the insert and the reference. After removing the inserts, dead code
    /// elimination is attempted on the inserted values.
    ///
    /// This pass performs best after access chains are converted to inserts and
    /// extracts and local loads and stores are eliminated. While executing this
    /// pass can be advantageous on its own, it is also advantageous to execute
    /// this pass after CreateInsertExtractPass() as it will remove any unused
    /// inserts created by that pass.
    DeadInsertElim,
    /// Create dead variable elimination pass.
    /// This pass will delete module scope variables, along with their decorations,
    /// that are not referenced.
    DeadVariableElimination,
    /// Create descriptor scalar replacement pass.
    /// This pass replaces every array variable |desc| that has a DescriptorSet and
    /// Binding decorations with a new variable for each element of the array.
    /// Suppose |desc| was bound at binding |b|.  Then the variable corresponding to
    /// |desc[i]| will have binding |b+i|.  The descriptor set will be the same.  It
    /// is assumed that no other variable already has a binding that will used by one
    /// of the new variables.  If not, the pass will generate invalid Spir-V.  All
    /// accesses to |desc| must be OpAccessChain instructions with a literal index
    /// for the first index.
    DescriptorScalarReplacement,
    /// Creates a eliminate-dead-constant pass.
    /// A eliminate-dead-constant pass removes dead constants, including normal
    /// contants defined by OpConstant, OpConstantComposite, OpConstantTrue, or
    /// OpConstantFalse and spec constants defined by OpSpecConstant,
    /// OpSpecConstantComposite, OpSpecConstantTrue, OpSpecConstantFalse or
    /// OpSpecConstantOp.
    EliminateDeadConstant,
    /// Creates an eliminate-dead-functions pass.
    /// An eliminate-dead-functions pass will remove all functions that are not in
    /// the call trees rooted at entry points and exported functions.  These
    /// functions are not needed because they will never be called.
    EliminateDeadFunctions,
    /// Creates an eliminate-dead-members pass.
    /// An eliminate-dead-members pass will remove all unused members of structures.
    /// This will not affect the data layout of the remaining members.
    EliminateDeadMembers,
    /// Create a pass to fix incorrect storage classes.  In order to make code
    /// generation simpler, DXC may generate code where the storage classes do not
    /// match up correctly.  This pass will fix the errors that it can.
    FixStorageClass,
    /// Creates a flatten-decoration pass.
    /// A flatten-decoration pass replaces grouped decorations with equivalent
    /// ungrouped decorations.  That is, it replaces each OpDecorationGroup
    /// instruction and associated OpGroupDecorate and OpGroupMemberDecorate
    /// instructions with equivalent OpDecorate and OpMemberDecorate instructions.
    /// The pass does not attempt to preserve debug information for instructions
    /// it removes.
    FlattenDecoration,
    /// Creates a fold-spec-constant-op-and-composite pass.
    /// A fold-spec-constant-op-and-composite pass folds spec constants defined by
    /// OpSpecConstantOp or OpSpecConstantComposite instruction, to normal Constants
    /// defined by OpConstantTrue, OpConstantFalse, OpConstant, OpConstantNull, or
    /// OpConstantComposite instructions. Note that spec constants defined with
    /// OpSpecConstant, OpSpecConstantTrue, or OpSpecConstantFalse instructions are
    /// not handled, as these instructions indicate their value are not determined
    /// and can be changed in future. A spec constant is foldable if all of its
    /// value(s) can be determined from the module. E.g., an integer spec constant
    /// defined with OpSpecConstantOp instruction can be folded if its value won't
    /// change later. This pass will replace the original OpSpecContantOp instruction
    /// with an OpConstant instruction. When folding composite spec constants,
    /// new instructions may be inserted to define the components of the composite
    /// constant first, then the original spec constants will be replaced by
    /// OpConstantComposite instructions.
    ///
    /// There are some operations not supported yet:
    ///   OpSConvert, OpFConvert, OpQuantizeToF16 and
    ///   all the operations under Kernel capability.
    /// TODO(qining): Add support for the operations listed above.
    FoldSpecConstantOpAndComposite,
    /// Creates a freeze-spec-constant-value pass.
    /// A freeze-spec-constant pass specializes the value of spec constants to
    /// their default values. This pass only processes the spec constants that have
    /// SpecId decorations (defined by OpSpecConstant, OpSpecConstantTrue, or
    /// OpSpecConstantFalse instructions) and replaces them with their normal
    /// counterparts (OpConstant, OpConstantTrue, or OpConstantFalse). The
    /// corresponding SpecId annotation instructions will also be removed. This
    /// pass does not fold the newly added normal constants and does not process
    /// other spec constants defined by OpSpecConstantComposite or
    /// OpSpecConstantOp.
    FreezeSpecConstantValue,
    /// Creates a graphics robust access pass.
    ///
    /// This pass injects code to clamp indexed accesses to buffers and internal
    /// arrays, providing guarantees satisfying Vulkan's robustBufferAccess rules.
    ///
    /// TODO(dneto): Clamps coordinates and sample index for pointer calculations
    /// into storage images (OpImageTexelPointer).  For an cube array image, it
    /// assumes the maximum layer count times 6 is at most 0xffffffff.
    ///
    /// NOTE: This pass will fail with a message if:
    /// - The module is not a Shader module.
    /// - The module declares VariablePointers, VariablePointersStorageBuffer, or
    ///   RuntimeDescriptorArrayEXT capabilities.
    /// - The module uses an addressing model other than Logical
    /// - Access chain indices are wider than 64 bits.
    /// - Access chain index for a struct is not an OpConstant integer or is out
    ///  of range. (The module is already invalid if that is the case.)
    /// - TODO(dneto): The OpImageTexelPointer coordinate component is not 32-bits
    /// wide.
    ///
    /// NOTE: Access chain indices are always treated as signed integers.  So
    ///   if an array has a fixed size of more than 2^31 elements, then elements
    ///   from 2^31 and above are never accessible with a 32-bit index,
    ///   signed or unsigned.  For this case, this pass will clamp the index
    ///   between 0 and at 2^31-1, inclusive.
    ///   Similarly, if an array has more then 2^15 element and is accessed with
    ///   a 16-bit index, then elements from 2^15 and above are not accessible.
    ///   In this case, the pass will clamp the index between 0 and 2^15-1
    ///   inclusive.
    GraphicsRobustAccess,
    /// Creates a pass that converts if-then-else like assignments into OpSelect.
    IfConversion,
    /// Creates an exhaustive inline pass.
    /// An exhaustive inline pass attempts to exhaustively inline all function
    /// calls in all functions in an entry point call tree. The intent is to enable,
    /// albeit through brute force, analysis and optimization across function
    /// calls by subsequent optimization passes. As the inlining is exhaustive,
    /// there is no attempt to optimize for size or runtime performance. Functions
    /// that are not in the call tree of an entry point are not changed.
    InlineExhaustive,
    /// Creates an opaque inline pass.
    /// An opaque inline pass inlines all function calls in all functions in all
    /// entry point call trees where the called function contains an opaque type
    /// in either its parameter types or return type. An opaque type is currently
    /// defined as Image, Sampler or SampledImage. The intent is to enable, albeit
    /// through brute force, analysis and optimization across these function calls
    /// by subsequent passes in order to remove the storing of opaque types which is
    /// not legal in Vulkan. Functions that are not in the call tree of an entry
    /// point are not changed.
    InlineOpaque,
    /// Creates an insert/extract elimination pass.
    /// This pass processes each entry point function in the module, searching for
    /// extracts on a sequence of inserts. It further searches the sequence for an
    /// insert with indices identical to the extract. If such an insert can be
    /// found before hitting a conflicting insert, the extract's result id is
    /// replaced with the id of the values from the insert.
    ///
    /// Besides removing extracts this pass enables subsequent dead code elimination
    /// passes to delete the inserts. This pass performs best after access chains are
    /// converted to inserts and extracts and local loads and stores are eliminated.
    InsertExtractElim,
    /// Replaces the internal version of GLSLstd450 InterpolateAt* extended
    /// instructions with the externally valid version. The internal version allows
    /// an OpLoad of the interpolant for the first argument. This pass removes the
    /// OpLoad and replaces it with its pointer. glslang and possibly other
    /// frontends will create the internal version for HLSL. This pass will be part
    /// of HLSL legalization and should be called after interpolants have been
    /// propagated into their final positions.
    InterpolateFixup,
    /// Creates a local access chain conversion pass.
    /// A local access chain conversion pass identifies all function scope
    /// variables which are accessed only with loads, stores and access chains
    /// with constant indices. It then converts all loads and stores of such
    /// variables into equivalent sequences of loads, stores, extracts and inserts.
    ///
    /// This pass only processes entry point functions. It currently only converts
    /// non-nested, non-ptr access chains. It does not process modules with
    /// non-32-bit integer types present. Optional memory access options on loads
    /// and stores are ignored as we are only processing function scope variables.
    ///
    /// This pass unifies access to these variables to a single mode and simplifies
    /// subsequent analysis and elimination of these variables along with their
    /// loads and stores allowing values to propagate to their points of use where
    /// possible.
    LocalAccessChainConvert,
    /// Creates an SSA local variable load/store elimination pass.
    /// For every entry point function, eliminate all loads and stores of function
    /// scope variables only referenced with non-access-chain loads and stores.
    /// Eliminate the variables as well.
    ///
    /// The presence of access chain references and function calls can inhibit
    /// the above optimization.
    ///
    /// Only shader modules with relaxed logical addressing (see opt/instruction.h)
    /// are currently processed. Currently modules with any extensions enabled are
    /// not processed. This is left for future work.
    ///
    /// This pass is most effective if preceeded by Inlining and
    /// LocalAccessChainConvert. LocalSingleStoreElim and LocalSingleBlockElim
    /// will reduce the work that this pass has to do.
    LocalMultiStoreElim,
    /// Create value numbering pass.
    /// This pass will look for instructions in the same basic block that compute the
    /// same value, and remove the redundant ones.
    LocalRedundancyElimination,
    /// Creates a single-block local variable load/store elimination pass.
    /// For every entry point function, do single block memory optimization of
    /// function variables referenced only with non-access-chain loads and stores.
    /// For each targeted variable load, if previous store to that variable in the
    /// block, replace the load's result id with the value id of the store.
    /// If previous load within the block, replace the current load's result id
    /// with the previous load's result id. In either case, delete the current
    /// load. Finally, check if any remaining stores are useless, and delete store
    /// and variable if possible.
    ///
    /// The presence of access chain references and function calls can inhibit
    /// the above optimization.
    ///
    /// Only modules with relaxed logical addressing (see opt/instruction.h) are
    /// currently processed.
    ///
    /// This pass is most effective if preceeded by Inlining and
    /// LocalAccessChainConvert. This pass will reduce the work needed to be done
    /// by LocalSingleStoreElim and LocalMultiStoreElim.
    ///
    /// Only functions in the call tree of an entry point are processed.
    LocalSingleBlockLoadStoreElim,
    /// Creates a local single store elimination pass.
    /// For each entry point function, this pass eliminates loads and stores for
    /// function scope variable that are stored to only once, where possible. Only
    /// whole variable loads and stores are eliminated; access-chain references are
    /// not optimized. Replace all loads of such variables with the value that is
    /// stored and eliminate any resulting dead code.
    ///
    /// Currently, the presence of access chains and function calls can inhibit this
    /// pass, however the Inlining and LocalAccessChainConvert passes can make it
    /// more effective. In additional, many non-load/store memory operations are
    /// not supported and will prohibit optimization of a function. Support of
    /// these operations are future work.
    ///
    /// Only shader modules with relaxed logical addressing (see opt/instruction.h)
    /// are currently processed.
    ///
    /// This pass will reduce the work needed to be done by LocalSingleBlockElim
    /// and LocalMultiStoreElim and can improve the effectiveness of other passes
    /// such as DeadBranchElimination which depend on values for their analysis.
    LocalSingleStoreElim,
    /// Create LICM pass.
    /// This pass will look for invariant instructions inside loops and hoist them to
    /// the loops preheader.
    LoopInvariantCodeMotion,
    /// Creates a loop peeling pass.
    /// This pass will look for conditions inside a loop that are true or false only
    /// for the N first or last iteration. For loop with such condition, those N
    /// iterations of the loop will be executed outside of the main loop.
    /// To limit code size explosion, the loop peeling can only happen if the code
    /// size growth for each loop is under |code_growth_threshold|.
    LoopPeeling,
    /// Creates a loop unswitch pass.
    /// This pass will look for loop independent branch conditions and move the
    /// condition out of the loop and version the loop based on the taken branch.
    /// Works best after LICM and local multi store elimination pass.
    LoopUnswitch,
    /// create merge return pass.
    /// changes functions that have multiple return statements so they have a single
    /// return statement.
    ///
    /// for structured control flow it is assumed that the only unreachable blocks in
    /// the function are trivial merge and continue blocks.
    ///
    /// a trivial merge block contains the label and an opunreachable instructions,
    /// nothing else.  a trivial continue block contain a label and an opbranch to
    /// the header, nothing else.
    ///
    /// these conditions are guaranteed to be met after running dead-branch
    /// elimination.
    MergeReturn,
    /// Creates a null pass.
    /// A null pass does nothing to the SPIR-V module to be optimized.
    Null,
    /// Create a private to local pass.
    /// This pass looks for variables delcared in the private storage class that are
    /// used in only one function.  Those variables are moved to the function storage
    /// class in the function that they are used.
    PrivateToLocal,
    /// Create line propagation pass
    /// This pass propagates line information based on the rules for OpLine and
    /// OpNoline and clones an appropriate line instruction into every instruction
    /// which does not already have debug line instructions.
    ///
    /// This pass is intended to maximize preservation of source line information
    /// through passes which delete, move and clone instructions. Ideally it should
    /// be run before any such pass. It is a bookend pass with EliminateDeadLines
    /// which can be used to remove redundant line instructions at the end of a
    /// run of such passes and reduce final output file size.
    PropagateLineInfo,
    /// Create a pass to reduce the size of loads.
    /// This pass looks for loads of structures where only a few of its members are
    /// used.  It replaces the loads feeding an OpExtract with an OpAccessChain and
    /// a load of the specific elements.
    ReduceLoadSize,
    /// Create global value numbering pass.
    /// This pass will look for instructions where the same value is computed on all
    /// paths leading to the instruction.  Those instructions are deleted.
    RedundancyElimination,
    /// Create dead line elimination pass
    /// This pass eliminates redundant line instructions based on the rules for
    /// OpLine and OpNoline. Its main purpose is to reduce the size of the file
    /// need to store the SPIR-V without losing line information.
    ///
    /// This is a bookend pass with PropagateLines which attaches line instructions
    /// to every instruction to preserve line information during passes which
    /// delete, move and clone instructions. DeadLineElim should be run after
    /// PropagateLines and all such subsequent passes. Normally it would be one
    /// of the last passes to be run.
    RedundantLineInfoElim,
    /// Create relax float ops pass.
    /// This pass decorates all float32 result instructions with RelaxedPrecision
    /// if not already so decorated.
    RelaxFloatOps,
    /// Creates a remove duplicate pass.
    /// This pass removes various duplicates:
    /// * duplicate capabilities;
    /// * duplicate extended instruction imports;
    /// * duplicate types;
    /// * duplicate decorations.
    RemoveDuplicates,
    /// Creates a remove-unused-interface-variables pass.
    /// Removes variables referenced on the |OpEntryPoint| instruction that are not
    /// referenced in the entry point function or any function in its call tree.
    /// Note that this could cause the shader interface to no longer match other
    /// shader stages.
    RemoveUnusedInterfaceVariables,
    /// Creates a pass that will replace instructions that are not valid for the
    /// current shader stage by constants.  Has no effect on non-shader modules.
    ReplaceInvalidOpcode,
    /// Creates a pass that simplifies instructions using the instruction folder.
    Simplification,
    /// Create the SSA rewrite pass.
    /// This pass converts load/store operations on function local variables into
    /// operations on SSA IDs.  This allows SSA optimizers to act on these variables.
    /// Only variables that are local to the function and of supported types are
    /// processed (see IsSSATargetVar for details).
    SSARewrite,
    /// Creates a strength-reduction pass.
    /// A strength-reduction pass will look for opportunities to replace an
    /// instruction with an equivalent and less expensive one.  For example,
    /// multiplying by a power of 2 can be replaced by a bit shift.
    StrengthReduction,
    /// Creates a strip-debug-info pass.
    /// A strip-debug-info pass removes all debug instructions (as documented in
    /// Section 3.32.2 of the SPIR-V spec) of the SPIR-V module to be optimized.
    StripDebugInfo,
    /// Creates a strip-nonsemantic-info pass.
    /// A strip-nonsemantic-info pass removes all reflections and explicitly
    /// non-semantic instructions.
    StripNonSemanticInfo,
    /// Creates a unify-constant pass.
    /// A unify-constant pass de-duplicates the constants. Constants with the exact
    /// same value and identical form will be unified and only one constant will
    /// be kept for each unique pair of type and value.
    /// There are several cases not handled by this pass:
    ///  1) Constants defined by OpConstantNull instructions (null constants) and
    ///  constants defined by OpConstantFalse, OpConstant or OpConstantComposite
    ///  with value 0 (zero-valued normal constants) are not considered equivalent.
    ///  So null constants won't be used to replace zero-valued normal constants,
    ///  vice versa.
    ///  2) Whenever there are decorations to the constant's result id id, the
    ///  constant won't be handled, which means, it won't be used to replace any
    ///  other constants, neither can other constants replace it.
    ///  3) NaN in float point format with different bit patterns are not unified.
    UnifyConstant,
    /// Create a pass to upgrade to the VulkanKHR memory model.
    /// This pass upgrades the Logical GLSL450 memory model to Logical VulkanKHR.
    /// Additionally, it modifies memory, image, atomic and barrier operations to
    /// conform to that model's requirements.
    UpgradeMemoryModel,
    /// Create a vector dce pass.
    /// This pass looks for components of vectors that are unused, and removes them
    /// from the vector.  Note this would still leave around lots of dead code that
    /// a pass of ADCE will be able to remove.
    VectorDCE,
    /// Creates a workaround driver bugs pass.  This pass attempts to work around
    /// a known driver bug (issue #1209) by identifying the bad code sequences and
    /// rewriting them.
    ///
    /// Current workaround: Avoid OpUnreachable instructions in loops.
    Workaround1209,
    /// Create a pass to replace each OpKill instruction with a function call to a
    /// function that has a single OpKill.  Also replace each OpTerminateInvocation
    /// instruction  with a function call to a function that has a single
    /// OpTerminateInvocation.  This allows more code to be inlined.
    WrapOpKill,
}

extern "C" {
    pub fn optimizer_create(env: crate::shared::TargetEnv) -> *mut Optimizer;
    pub fn optimizer_destroy(opt: *mut Optimizer);

    pub fn optimizer_run(
        opt: *const Optimizer,
        input_ptr: *const u32,
        input_size: usize,
        binary: *mut *mut crate::shared::Binary,
        message_callback: crate::diagnostics::MessageCallback,
        message_ctx: *mut std::ffi::c_void,
        options: *const OptimizerOptions,
    ) -> crate::shared::SpirvResult;

    /// Creates an optimizer options object with default options. Returns a valid
    /// options object. The object remains valid until it is passed into
    /// |spvOptimizerOptionsDestroy|.
    #[link_name = "spvOptimizerOptionsCreate"]
    pub fn optimizer_options_create() -> *mut OptimizerOptions;

    /// Destroys the given optimizer options object.
    #[link_name = "spvOptimizerOptionsDestroy"]
    pub fn optimizer_options_destroy(options: *mut OptimizerOptions);

    /// Records whether or not the optimizer should run the validator before
    /// optimizing.  If |val| is true, the validator will be run.
    #[link_name = "spvOptimizerOptionsSetRunValidator"]
    pub fn optimizer_options_run_validator(options: *mut OptimizerOptions, run: bool);

    /// Records the validator options that should be passed to the validator if it is
    /// run.
    #[link_name = "spvOptimizerOptionsSetValidatorOptions"]
    pub fn optimizer_options_set_validator_options(
        options: *mut OptimizerOptions,
        validator_opts: *mut crate::val::ValidatorOptions,
    );

    /// Records the maximum possible value for the id bound.
    #[link_name = "spvOptimizerOptionsSetMaxIdBound"]
    pub fn optimizer_options_set_max_id_bound(options: *mut OptimizerOptions, max: u32);

    /// Records whether all bindings within the module should be preserved.
    #[link_name = "spvOptimizerOptionsSetPreserveBindings"]
    pub fn optimizer_options_preserve_bindings(options: *mut OptimizerOptions, preserve: bool);

    /// Records whether all specialization constants within the module
    /// should be preserved.
    #[link_name = "spvOptimizerOptionsSetPreserveSpecConstants"]
    pub fn optimizer_options_preserve_spec_constants(
        options: *mut OptimizerOptions,
        preserve: bool,
    );

    pub fn optimizer_register_pass(opt: *mut Optimizer, which: Passes);

    /// Registers passes that attempt to improve performance of generated code.
    /// This sequence of passes is subject to constant review and will change
    /// from time to time.
    pub fn optimizer_register_performance_passes(opt: *mut Optimizer);

    /// Registers passes that attempt to improve the size of generated code.
    /// This sequence of passes is subject to constant review and will change
    /// from time to time.
    pub fn optimizer_register_size_passes(opt: *mut Optimizer);

    /// Registers passes that have been prescribed for converting from Vulkan to
    /// WebGPU. This sequence of passes is subject to constant review and will
    /// change from time to time.
    pub fn optimizer_register_vulkan_to_webgpu_passes(opt: *mut Optimizer);

    /// Registers passes that have been prescribed for converting from WebGPU to
    /// Vulkan. This sequence of passes is subject to constant review and will
    /// change from time to time.
    pub fn optimizer_register_webgpu_to_vulkan_passes(opt: *mut Optimizer);

    /// Registers passes that attempt to legalize the generated code.
    ///
    /// Note: this recipe is specially designed for legalizing SPIR-V. It should be
    /// used by compilers after translating HLSL source code literally. It should
    /// *not* be used by general workloads for performance or size improvement.
    ///
    /// This sequence of passes is subject to constant review and will change
    /// from time to time.
    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

    // #[repr(C)]
    // pub struct SpecConstantDefault {
    //     pub id: u32,
    //     pub value_ptr: *const c_char,
    //     pub value_len: usize,
    // }

    // Creates a set-spec-constant-default-value pass from a mapping from spec-ids
    // to the default values in the form of string.
    // A set-spec-constant-default-value pass sets the default values for the
    // spec constants that have SpecId decorations (i.e., those defined by
    // OpSpecConstant{|True|False} instructions).
    // SetSpecConstantDefaultValuePass(
    //     const std::unordered_map<uint32_t, std::string>& id_value_map);

    // Create a pass to instrument OpDebugPrintf instructions.
    // This pass replaces all OpDebugPrintf instructions with instructions to write
    // a record containing the string id and the all specified values into a special
    // printf output buffer (if space allows). This pass is designed to support
    // the printf validation in the Vulkan validation layers.
    //
    // The instrumentation will write buffers in debug descriptor set |desc_set|.
    // It will write |shader_id| in each output record to identify the shader
    // module which generated the record.
    // InstDebugPrintfPass(uint32_t desc_set,
    //     uint32_t shader_id);

    // Create a pass to instrument bindless descriptor checking
    // This pass instruments all bindless references to check that descriptor
    // array indices are inbounds, and if the descriptor indexing extension is
    // enabled, that the descriptor has been initialized. If the reference is
    // invalid, a record is written to the debug output buffer (if space allows)
    // and a null value is returned. This pass is designed to support bindless
    // validation in the Vulkan validation layers.
    //
    // TODO(greg-lunarg): Add support for buffer references. Currently only does
    // checking for image references.
    //
    // Dead code elimination should be run after this pass as the original,
    // potentially invalid code is not removed and could cause undefined behavior,
    // including crashes. It may also be beneficial to run Simplification
    // (ie Constant Propagation), DeadBranchElim and BlockMerge after this pass to
    // optimize instrument code involving the testing of compile-time constants.
    // It is also generally recommended that this pass (and all
    // instrumentation passes) be run after any legalization and optimization
    // passes. This will give better analysis for the instrumentation and avoid
    // potentially de-optimizing the instrument code, for example, inlining
    // the debug record output function throughout the module.
    //
    // The instrumentation will read and write buffers in debug
    // descriptor set |desc_set|. It will write |shader_id| in each output record
    // to identify the shader module which generated the record.
    // |input_length_enable| controls instrumentation of runtime descriptor array
    // references, and |input_init_enable| controls instrumentation of descriptor
    // initialization checking, both of which require input buffer support.
    // InstBindlessCheckPass(
    //     uint32_t desc_set, uint32_t shader_id, bool input_length_enable = false,
    //     bool input_init_enable = false, bool input_buff_oob_enable = false);

    // // Create a pass to instrument physical buffer address checking
    // // This pass instruments all physical buffer address references to check that
    // // all referenced bytes fall in a valid buffer. If the reference is
    // // invalid, a record is written to the debug output buffer (if space allows)
    // // and a null value is returned. This pass is designed to support buffer
    // // address validation in the Vulkan validation layers.
    // //
    // // Dead code elimination should be run after this pass as the original,
    // // potentially invalid code is not removed and could cause undefined behavior,
    // // including crashes. Instruction simplification would likely also be
    // // beneficial. It is also generally recommended that this pass (and all
    // // instrumentation passes) be run after any legalization and optimization
    // // passes. This will give better analysis for the instrumentation and avoid
    // // potentially de-optimizing the instrument code, for example, inlining
    // // the debug record output function throughout the module.
    // //
    // // The instrumentation will read and write buffers in debug
    // // descriptor set |desc_set|. It will write |shader_id| in each output record
    // // to identify the shader module which generated the record.
    // InstBuffAddrCheckPass(uint32_t desc_set,
    //                                                  uint32_t shader_id);

    // Create loop unroller pass.
    // Creates a pass to unroll loops which have the "Unroll" loop control
    // mask set. The loops must meet a specific criteria in order to be unrolled
    // safely this criteria is checked before doing the unroll by the
    // LoopUtils::CanPerformUnroll method. Any loop that does not meet the criteria
    // won't be unrolled. See CanPerformUnroll LoopUtils.h for more information.
    //LoopUnrollPass(bool fully_unroll, int factor = 0);

    // Create scalar replacement pass.
    // This pass replaces composite function scope variables with variables for each
    // element if those elements are accessed individually.  The parameter is a
    // limit on the number of members in the composite variable that the pass will
    // consider replacing.
    //ScalarReplacementPass(uint32_t size_limit = 100);

    // Creates a loop fission pass.
    // This pass will split all top level loops whose register pressure exceedes the
    // given |threshold|.
    //LoopFissionPass(size_t threshold);

    // Creates a loop fusion pass.
    // This pass will look for adjacent loops that are compatible and legal to be
    // fused. The fuse all such loops as long as the register usage for the fused
    // loop stays under the threshold defined by |max_registers_per_loop|.
    //LoopFusionPass(size_t max_registers_per_loop);
}