weval 0.4.1

The WebAssembly partial evaluator
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
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! Symbolic and concrete values.

#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub(crate) enum WasmVal {
    I32(u32),
    I64(u64),
    F32(u32),
    F64(u64),
    V128(u128),
}

impl WasmVal {
    pub(crate) fn is_truthy(self) -> bool {
        match self {
            WasmVal::I32(i) => i != 0,
            // Only boolean-ish types (i32) can be evaluated for
            // truthiness.
            _ => panic!("Type error: non-i32 used in boolean-ish context"),
        }
    }

    pub(crate) fn integer_value(self) -> Option<u64> {
        match self {
            WasmVal::I32(i) => Some(i as u64),
            WasmVal::I64(i) => Some(i),
            _ => None,
        }
    }

    pub(crate) fn from_bits(ty: waffle::Type, bits: u64) -> Option<Self> {
        match ty {
            waffle::Type::I32 => Some(WasmVal::I32(bits as u32)),
            waffle::Type::I64 => Some(WasmVal::I64(bits)),
            waffle::Type::F32 => Some(WasmVal::F32(bits as u32)),
            waffle::Type::F64 => Some(WasmVal::F64(bits)),
            waffle::Type::V128 => Some(WasmVal::V128(bits as u128)),
            waffle::Type::FuncRef | waffle::Type::TypedFuncRef(..) => None,
        }
    }
}

impl std::convert::TryFrom<waffle::Operator> for WasmVal {
    type Error = ();
    fn try_from(op: waffle::Operator) -> Result<Self, Self::Error> {
        match op {
            waffle::Operator::I32Const { value } => Ok(WasmVal::I32(value)),
            waffle::Operator::I64Const { value } => Ok(WasmVal::I64(value)),
            waffle::Operator::F32Const { value } => Ok(WasmVal::F32(value)),
            waffle::Operator::F64Const { value } => Ok(WasmVal::F64(value)),
            _ => Err(()),
        }
    }
}

#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub(crate) enum AbstractValue {
    /// "top" default value; undefined.
    #[default]
    Top,
    /// A value known at specialization time.
    Concrete(WasmVal),
    /// A value that points to memory known at specialization time,
    /// with the given offset.
    ConcreteMemory(MemoryBufferIndex, u32),
    /// Static memory pointer.
    StaticMemory(u32),
    /// A value only computed at runtime. The instruction that
    /// computed it is specified, if known.
    Runtime(Option<waffle::Value>),
}

/// Memory pointed to by one of the incoming arguments to a
/// specialized function.
#[derive(Clone, Debug, Default, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub(crate) struct MemoryBufferIndex(pub u32);

impl AbstractValue {
    pub(crate) fn meet(a: &AbstractValue, b: &AbstractValue) -> AbstractValue {
        match (a, b) {
            (AbstractValue::Top, x) | (x, AbstractValue::Top) => x.clone(),
            (x, y) if x == y => x.clone(),
            (AbstractValue::Concrete(a), AbstractValue::Concrete(b)) if a == b => {
                AbstractValue::Concrete(*a)
            }
            (AbstractValue::Runtime(cause1), AbstractValue::Runtime(cause2)) => {
                log::debug!(
                    "runtime({:?} meet runtime({:?}) -> runtime({:?})",
                    cause1,
                    cause2,
                    cause1.or(*cause2)
                );
                AbstractValue::Runtime(cause1.or(*cause2))
            }
            (AbstractValue::Runtime(cause1), _x) | (_x, AbstractValue::Runtime(cause1)) => {
                AbstractValue::Runtime(*cause1)
            }
            (_av1, _av2) => AbstractValue::Runtime(None),
        }
    }

    pub(crate) fn as_const_u32(&self) -> Option<u32> {
        match self {
            &AbstractValue::Concrete(WasmVal::I32(k)) => Some(k),
            &AbstractValue::StaticMemory(addr) => Some(addr),
            _ => None,
        }
    }

    pub(crate) fn as_const_u32_or_mem_offset(&self) -> Option<u32> {
        match self {
            &AbstractValue::Concrete(WasmVal::I32(k)) => Some(k),
            &AbstractValue::ConcreteMemory(_, off) => Some(off),
            _ => None,
        }
    }

    pub(crate) fn as_const_u64(&self) -> Option<u64> {
        match self {
            &AbstractValue::Concrete(WasmVal::I64(k)) => Some(k),
            &AbstractValue::StaticMemory(addr) => Some(u64::from(addr)),
            _ => None,
        }
    }

    pub(crate) fn as_const_truthy(&self) -> Option<bool> {
        self.as_const_u32().map(|k| k != 0)
    }
}