shape-vm 0.3.1

Stack-based bytecode virtual machine for the Shape programming language
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
97
98
99
100
101
102
103
104
105
106
107
108
109

//! v2 sized integer (i32) arithmetic and comparison handlers.
//!
//! Values flow through the kinded VM stack as i64-shaped bits with
//! `NativeKind::Int32` (Wave 6.5 cluster C — ADR-006 §2.7.7). Operations
//! are performed at i32 width with wrapping semantics; the result is
//! sign-extended to i64 for the slot's u64 payload.

use crate::bytecode::{Instruction, OpCode};
use crate::executor::VirtualMachine;
use shape_value::{NativeKind, VMError};

impl VirtualMachine {
    /// Execute a v2 sized integer (i32) opcode.
    ///
    /// All operands arrive as raw bits with `NativeKind::Int32` — the
    /// compiler proves this at emission time, so the kinded pop reads the
    /// bits as i64 (sign-extended) and discards the kind tag.
    pub(crate) fn exec_v2_sized_int(&mut self, instruction: &Instruction) -> Result<(), VMError> {
        match instruction.opcode {
            OpCode::AddI32 => {
                let (b_bits, _b_kind) = self.pop_kinded()?;
                let (a_bits, _a_kind) = self.pop_kinded()?;
                let b = b_bits as i64 as i32;
                let a = a_bits as i64 as i32;
                self.push_kinded(a.wrapping_add(b) as i64 as u64, NativeKind::Int32)
            }
            OpCode::SubI32 => {
                let (b_bits, _b_kind) = self.pop_kinded()?;
                let (a_bits, _a_kind) = self.pop_kinded()?;
                let b = b_bits as i64 as i32;
                let a = a_bits as i64 as i32;
                self.push_kinded(a.wrapping_sub(b) as i64 as u64, NativeKind::Int32)
            }
            OpCode::MulI32 => {
                let (b_bits, _b_kind) = self.pop_kinded()?;
                let (a_bits, _a_kind) = self.pop_kinded()?;
                let b = b_bits as i64 as i32;
                let a = a_bits as i64 as i32;
                self.push_kinded(a.wrapping_mul(b) as i64 as u64, NativeKind::Int32)
            }
            OpCode::DivI32 => {
                let (b_bits, _b_kind) = self.pop_kinded()?;
                let (a_bits, _a_kind) = self.pop_kinded()?;
                let b = b_bits as i64 as i32;
                let a = a_bits as i64 as i32;
                if b == 0 {
                    return Err(VMError::DivisionByZero);
                }
                self.push_kinded(a.wrapping_div(b) as i64 as u64, NativeKind::Int32)
            }
            OpCode::ModI32 => {
                let (b_bits, _b_kind) = self.pop_kinded()?;
                let (a_bits, _a_kind) = self.pop_kinded()?;
                let b = b_bits as i64 as i32;
                let a = a_bits as i64 as i32;
                if b == 0 {
                    return Err(VMError::DivisionByZero);
                }
                self.push_kinded(a.wrapping_rem(b) as i64 as u64, NativeKind::Int32)
            }
            OpCode::EqI32 => {
                let (b_bits, _b_kind) = self.pop_kinded()?;
                let (a_bits, _a_kind) = self.pop_kinded()?;
                let b = b_bits as i64 as i32;
                let a = a_bits as i64 as i32;
                self.push_kinded((a == b) as u64, NativeKind::Bool)
            }
            OpCode::NeqI32 => {
                let (b_bits, _b_kind) = self.pop_kinded()?;
                let (a_bits, _a_kind) = self.pop_kinded()?;
                let b = b_bits as i64 as i32;
                let a = a_bits as i64 as i32;
                self.push_kinded((a != b) as u64, NativeKind::Bool)
            }
            OpCode::LtI32 => {
                let (b_bits, _b_kind) = self.pop_kinded()?;
                let (a_bits, _a_kind) = self.pop_kinded()?;
                let b = b_bits as i64 as i32;
                let a = a_bits as i64 as i32;
                self.push_kinded((a < b) as u64, NativeKind::Bool)
            }
            OpCode::GtI32 => {
                let (b_bits, _b_kind) = self.pop_kinded()?;
                let (a_bits, _a_kind) = self.pop_kinded()?;
                let b = b_bits as i64 as i32;
                let a = a_bits as i64 as i32;
                self.push_kinded((a > b) as u64, NativeKind::Bool)
            }
            OpCode::LteI32 => {
                let (b_bits, _b_kind) = self.pop_kinded()?;
                let (a_bits, _a_kind) = self.pop_kinded()?;
                let b = b_bits as i64 as i32;
                let a = a_bits as i64 as i32;
                self.push_kinded((a <= b) as u64, NativeKind::Bool)
            }
            OpCode::GteI32 => {
                let (b_bits, _b_kind) = self.pop_kinded()?;
                let (a_bits, _a_kind) = self.pop_kinded()?;
                let b = b_bits as i64 as i32;
                let a = a_bits as i64 as i32;
                self.push_kinded((a >= b) as u64, NativeKind::Bool)
            }
            _ => Err(VMError::RuntimeError(format!(
                "unhandled v2 sized int opcode: {:?}",
                instruction.opcode
            ))),
        }
    }
}