metal2vulkan 0.1.0

Translate Metal AIR / LLVM IR to Vulkan SPIR-V with a native Rust emitter
Documentation 
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

//! Shared singleton scalar/function type builders for retained passes.

use super::*;

impl Ctx {
    /// OpTypeFunction returning void with no parameters (`void ()`).
    pub(super) fn ty_fn_void(&mut self, void: Word) -> Word {
        if let Some(&id) = self.singleton_types.get(&SingletonType::FnVoid) {
            return id;
        }
        for inst in &self.module.types_global_values {
            if inst.class.opcode == Op::TypeFunction
                && inst.operands.len() == 1
                && inst.operands[0] == Operand::IdRef(void)
            {
                if let Some(rid) = inst.result_id {
                    self.singleton_types.insert(SingletonType::FnVoid, rid);
                    return rid;
                }
            }
        }
        let id = self.module.fresh_id();
        self.new_globals
            .push(type_inst(Op::TypeFunction, id, vec![Operand::IdRef(void)]));
        self.singleton_types.insert(SingletonType::FnVoid, id);
        id
    }

    pub(in crate::passes) fn ty_int8(&mut self) -> Word {
        if let Some(&id) = self.singleton_types.get(&SingletonType::Int8) {
            return id;
        }
        for inst in &self.module.types_global_values {
            if inst.class.opcode == Op::TypeInt
                && inst.operands.first() == Some(&Operand::LiteralBit32(8))
            {
                if let Some(rid) = inst.result_id {
                    self.singleton_types.insert(SingletonType::Int8, rid);
                    return rid;
                }
            }
        }
        let id = self.module.fresh_id();
        self.new_globals.push(type_inst(
            Op::TypeInt,
            id,
            vec![Operand::LiteralBit32(8), Operand::LiteralBit32(0)],
        ));
        self.singleton_types.insert(SingletonType::Int8, id);
        id
    }

    pub(in crate::passes) fn ty_int16(&mut self) -> Word {
        if let Some(&id) = self.singleton_types.get(&SingletonType::Int16) {
            return id;
        }
        for inst in &self.module.types_global_values {
            if inst.class.opcode == Op::TypeInt
                && inst.operands.first() == Some(&Operand::LiteralBit32(16))
                && inst.operands.get(1) == Some(&Operand::LiteralBit32(0))
            {
                if let Some(rid) = inst.result_id {
                    self.singleton_types.insert(SingletonType::Int16, rid);
                    return rid;
                }
            }
        }
        let id = self.module.fresh_id();
        self.new_globals.push(type_inst(
            Op::TypeInt,
            id,
            vec![Operand::LiteralBit32(16), Operand::LiteralBit32(0)],
        ));
        self.singleton_types.insert(SingletonType::Int16, id);
        id
    }
}