Struct rspirv::dr::Module

pub struct Module {

    pub header: Option<ModuleHeader>,
    pub capabilities: Vec<Instruction>,
    pub extensions: Vec<Instruction>,
    pub ext_inst_imports: Vec<Instruction>,
    pub memory_model: Option<Instruction>,
    pub entry_points: Vec<Instruction>,
    pub execution_modes: Vec<Instruction>,
    pub debug_string_source: Vec<Instruction>,
    pub debug_names: Vec<Instruction>,
    pub debug_module_processed: Vec<Instruction>,
    pub annotations: Vec<Instruction>,
    pub types_global_values: Vec<Instruction>,
    pub functions: Vec<Function>,
}

Data representation of a SPIR-V module.

Most of the fields are just vectors of Instructions, but some fields store values decomposed from Instructions for better investigation.

The order of its fields basically reveal the requirements in the Logical Layout of a Module of the SPIR-V of the SPIR-V specification.

Fields

header: Option<ModuleHeader>

The module header.

capabilities: Vec<Instruction>

All OpCapability instructions.

extensions: Vec<Instruction>

All OpExtension instructions.

ext_inst_imports: Vec<Instruction>

All OpExtInstImport instructions.

memory_model: Option<Instruction>

The OpMemoryModel instruction.

Although it is required by the specification to appear exactly once per module, we keep it optional here to allow flexibility.

entry_points: Vec<Instruction>

All entry point declarations, using OpEntryPoint.

execution_modes: Vec<Instruction>

All execution mode declarations, using OpExecutionMode.

debug_string_source: Vec<Instruction>

Debug subsection: All OpString, OpSourceExtension, OpSource, and OpSourceContinued.

debug_names: Vec<Instruction>

Debug subsection: All OpName and all OpMemberName.

debug_module_processed: Vec<Instruction>

Debug subsection: All OpModuleProcessed instructions.

annotations: Vec<Instruction>

All annotation instructions.

types_global_values: Vec<Instruction>

All types, constants, and global variables.

As per the specification, they have to be bundled together because they can depend on one another.

functions: Vec<Function>

All functions.

Implementations

impl Module

pub fn new() -> Self

Creates a new empty Module instance.

pub fn global_inst_iter(&self) -> impl Iterator<Item = &Instruction>

Returns an iterator over all global instructions.

pub fn global_inst_iter_mut(&mut self) -> impl Iterator<Item = &mut Instruction>

Returns a mut iterator over all global instructions.

pub fn all_inst_iter(&self) -> impl Iterator<Item = &Instruction>

Returns a iterator over all instructions.

pub fn all_inst_iter_mut(&mut self) -> impl Iterator<Item = &mut Instruction>

Returns a mut iterator over all instructions.

Trait Implementations

impl Assemble for Module

fn assemble_into(&self, result: &mut Vec<u32>)

Assembles the current object into the result vector, reducing the need for lots of allocations

fn assemble(&self) -> Vec<u32>

Assembles the current object and returns the binary code. Helper method to remain backwards compatible, calls assemble_into

impl Clone for Module

fn clone(&self) -> Module

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Module

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Module

fn default() -> Module

Returns the “default value” for a type.

impl Disassemble for Module

fn disassemble(&self) -> String

Disassembles this module and returns the disassembly text.

This method will try to link information together to be wise. E.g., If the extended instruction set is recognized, the symbolic opcode for instructions in it will be shown.