aluvm 0.12.0

Functional registry-based RISC virtual machine
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
110
111
112
113
114

// Reference rust implementation of AluVM (arithmetic logic unit virtual machine).
// To find more on AluVM please check <https://aluvm.org>
//
// SPDX-License-Identifier: Apache-2.0
//
// Designed in 2021-2025 by Dr Maxim Orlovsky <orlovsky@ubideco.org>
// Written in 2021-2025 by Dr Maxim Orlovsky <orlovsky@ubideco.org>
//
// Copyright (C) 2021-2024 LNP/BP Standards Association, Switzerland.
// Copyright (C) 2024-2025 Laboratories for Ubiquitous Deterministic Computing (UBIDECO),
//                         Institute for Distributed and Cognitive Systems (InDCS), Switzerland.
// Copyright (C) 2021-2025 Dr Maxim Orlovsky.
// All rights under the above copyrights are reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
// in compliance with the License. You may obtain a copy of the License at
//
//        http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software distributed under the License
// is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
// or implied. See the License for the specific language governing permissions and limitations under
// the License.

extern crate alloc;

use aluvm::isa::{CtrlInstr, Instr};
use aluvm::regs::Status;
use aluvm::{aluasm, CompiledLib, CoreConfig, LibId, LibSite, Vm};

fn code() -> Vec<Instr<LibId>> {
    const MAIN: u16 = 0;
    const SUB: u16 = 1;
    const END: u16 = 2;

    aluasm! {
       routine MAIN:
        chk     CO;
        chk     CK;

        jif     CO, MAIN;
        jif     CO, -1;

        jif     CK, MAIN;
        jif     CK, -1;

        fail    CK;
        mov     CO, CK;
        chk     CK;
        not     CO;
        chk     CO;

        jmp     +5;
        jmp     MAIN; // this is skipped

        call    SUB;
        stop;

       routine  SUB:
        jmp     END;
       label    END:
        ret;
    }
}

#[test]
fn run() {
    let code = code();

    let lib = CompiledLib::compile(code.clone(), &[]).unwrap().into_lib();
    let mut disasm = lib.disassemble::<Instr<_>>().unwrap();
    assert_eq!(disasm[14], CtrlInstr::Fn { pos: 27 }.into());
    assert_eq!(disasm[17], CtrlInstr::Jmp { pos: 31 }.into());
    disasm[14] = CtrlInstr::Fn { pos: 1 }.into();
    disasm[17] = CtrlInstr::Jmp { pos: 2 }.into();
    assert_eq!(disasm, code);

    let mut vm_main =
        Vm::<Instr<LibId>>::with(CoreConfig { halt: false, complexity_lim: None }, ());
    let resolver = |_: LibId| Some(&lib);
    let status = vm_main.exec(LibSite::new(lib.lib_id(), 0), &(), resolver);
    assert_eq!(status, Status::Ok);
}

#[test]
fn print_disassemble() {
    let lib = CompiledLib::compile(code(), &[]).unwrap().into_lib();
    let mut buf = Vec::new();
    lib.print_disassemble::<Instr<_>>(&mut buf).unwrap();
    assert_eq!(
        String::from_utf8(buf).unwrap(),
        "offset 000000: nop
offset 000001: chk     CO
offset 000002: chk     CK
offset 000003: jif     CO, 0
offset 000006: jif     CO, -1
offset 000008: jif     CK, 0
offset 000011: jif     CK, -1
offset 000013: fail    CK
offset 000014: mov     CO, CK
offset 000015: chk     CK
offset 000016: not     CO
offset 000017: chk     CO
offset 000018: jmp     +5
offset 000020: jmp     0
offset 000023: call    27
offset 000026: stop
offset 000027: nop
offset 000028: jmp     31
offset 000031: nop
offset 000032: ret
"
    );
}