wasm2spirv 0.1.0

Compile your WebAssembly programs into SPIR-V shaders
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
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

#![allow(clippy::should_implement_trait)]

use super::{
    float::Float,
    integer::{ConstantSource, ConversionSource, Integer, IntegerKind, IntegerSource},
    pointer::Pointer,
};
use crate::error::Result;
use std::{cell::Cell, rc::Rc};

#[derive(Debug, Clone, PartialEq)]
pub struct Bool {
    pub(crate) translation: Cell<Option<rspirv::spirv::Word>>,
    pub source: BoolSource,
}

#[derive(Debug, Clone, PartialEq)]
pub enum BoolSource {
    Constant(bool),
    FromInteger(Rc<Integer>),
    Negated(Rc<Bool>),
    IntEquality {
        kind: Equality,
        op1: Rc<Integer>,
        op2: Rc<Integer>,
    },
    FloatEquality {
        kind: Equality,
        op1: Rc<Float>,
        op2: Rc<Float>,
    },
    IntComparison {
        kind: Comparison,
        signed: bool,
        op1: Rc<Integer>,
        op2: Rc<Integer>,
    },
    FloatComparison {
        kind: Comparison,
        op1: Rc<Float>,
        op2: Rc<Float>,
    },
    Loaded {
        pointer: Rc<Pointer>,
        log2_alignment: Option<u32>,
    },
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Comparison {
    Le,
    Lt,
    Gt,
    Ge,
}

#[derive(Debug, Clone, Copy, PartialEq)]
pub enum Equality {
    Eq,
    Ne,
}

impl Bool {
    pub fn new(source: BoolSource) -> Self {
        return Self {
            translation: Cell::new(None),
            source,
        };
    }

    pub fn to_integer(self: Rc<Self>, kind: IntegerKind) -> Result<Rc<Integer>> {
        return Ok(match (kind, self.get_constant_value()?) {
            (IntegerKind::Long, Some(true)) => Integer::new_constant_u64(1),
            (IntegerKind::Short, Some(true)) => Integer::new_constant_u32(1),
            (IntegerKind::Long, Some(false)) => Integer::new_constant_u64(0),
            (IntegerKind::Short, Some(false)) => Integer::new_constant_u32(0),
            (kind, None) => Integer::new(IntegerSource::Conversion(ConversionSource::FromBool(
                self, kind,
            ))),
        }
        .into());
    }

    pub fn get_constant_value(&self) -> Result<Option<bool>> {
        match &self.source {
            BoolSource::Constant(x) => Ok(Some(*x)),
            BoolSource::FromInteger(x) => match x.get_constant_value()? {
                Some(ConstantSource::Long(0) | ConstantSource::Short(0)) => Ok(Some(false)),
                Some(_) => Ok(Some(true)),
                None => Ok(None),
            },
            BoolSource::Negated(x) => Ok(x.get_constant_value()?.map(|x| !x)),
            _ => return Ok(None),
        }
    }
}