Struct RawModule

pub struct RawModule { /* private fields */ }

Minimal representation of a SPIR-V module.

Implementations

impl RawModule

pub fn load_module<P: AsRef<Path>>(path: P) -> Result<RawModule>

Load a module from a file

Examples found in repository

examples/dump_variables.rs (line 14)

fn main() {
    let mut args = env::args_os();
    args.next();

    let filename = args.next();

    let module = if let Some(filename) = filename {
        spirv_utils::RawModule::load_module(filename).unwrap()
    } else {
        spirv_utils::RawModule::load_module("examples/vert.spv").unwrap()
    };

    for inst in module.instructions() {
        if let instruction::Instruction::Variable { result_id, storage_class, .. } = *inst {
            if let Some(name) = get_name(&module, result_id.into()) {
                println!("Variable {: <15} {:?}", name, storage_class);
            }
        }
    }
}

pub fn read_module<R: Read>(reader: R) -> Result<RawModule>

Read a module

pub fn instructions<'a>(&'a self) -> &'a [Instruction]

Gets the instructions in the module

Examples found in repository

examples/dump_variables.rs (line 19)

fn main() {
    let mut args = env::args_os();
    args.next();

    let filename = args.next();

    let module = if let Some(filename) = filename {
        spirv_utils::RawModule::load_module(filename).unwrap()
    } else {
        spirv_utils::RawModule::load_module("examples/vert.spv").unwrap()
    };

    for inst in module.instructions() {
        if let instruction::Instruction::Variable { result_id, storage_class, .. } = *inst {
            if let Some(name) = get_name(&module, result_id.into()) {
                println!("Variable {: <15} {:?}", name, storage_class);
            }
        }
    }
}

pub fn def_index<I: Into<Id>>(&self, id: I) -> Option<usize>

Gets the index of the instruction that defines the given id, if any

pub fn use_indices<'a, I: Into<Id>>(&'a self, id: I) -> Option<&'a [usize]>

Gets the indices of the instructions that use the given id

pub fn def<'a, I: Into<Id>>(&'a self, id: I) -> Option<&'a Instruction>

Gets the instruction that defines the given Id, if any

pub fn uses<'a, I: Into<Id>>(&'a self, id: I) -> Uses<'a>

Returns an iterator over the uses of the given Id

Examples found in repository

examples/dump_variables.rs (line 29)

fn get_name<'a>(module: &'a spirv_utils::RawModule, id: desc::Id) -> Option<&'a str> {
    module.uses(id).filter_map(|inst| {
        if let instruction::Instruction::Name { ref name, .. } = *inst {
            Some(&name[..])
        } else {
            None
        }
    }).next()
}