ckb-vm 0.24.14

CKB's 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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use super::super::machine::Machine;
use crate::RISCV_GENERAL_REGISTER_NUMBER;
use ckb_vm_definitions::instructions::{self as insts, InstructionOpcode};

// Inspired from https://github.com/riscv/riscv-isa-sim/blob/master/riscv/decode.h#L105-L106
#[inline(always)]
pub fn x(instruction_bits: u32, lower: usize, length: usize, shifts: usize) -> u32 {
    ((instruction_bits >> lower) & ((1 << length) - 1)) << shifts
}

#[inline(always)]
pub fn xs(instruction_bits: u32, lower: usize, length: usize, shifts: usize) -> u32 {
    ((instruction_bits as i32) << (32 - lower - length) >> (32 - length) << shifts) as u32
}

#[inline(always)]
pub fn opcode(instruction_bits: u32) -> u32 {
    x(instruction_bits, 0, 7, 0)
}

#[inline(always)]
pub fn funct3(instruction_bits: u32) -> u32 {
    x(instruction_bits, 12, 3, 0)
}

#[inline(always)]
pub fn funct7(instruction_bits: u32) -> u32 {
    x(instruction_bits, 25, 7, 0)
}

#[inline(always)]
pub fn rd(instruction_bits: u32) -> usize {
    x(instruction_bits, 7, 5, 0) as usize
}

#[inline(always)]
pub fn rs1(instruction_bits: u32) -> usize {
    x(instruction_bits, 15, 5, 0) as usize
}

#[inline(always)]
pub fn rs2(instruction_bits: u32) -> usize {
    x(instruction_bits, 20, 5, 0) as usize
}

#[inline(always)]
pub fn btype_immediate(instruction_bits: u32) -> i32 {
    (x(instruction_bits, 8, 4, 1)
        | x(instruction_bits, 25, 6, 5)
        | x(instruction_bits, 7, 1, 11)
        | xs(instruction_bits, 31, 1, 12)) as i32
}

#[inline(always)]
pub fn jtype_immediate(instruction_bits: u32) -> i32 {
    (x(instruction_bits, 21, 10, 1)
        | x(instruction_bits, 20, 1, 11)
        | x(instruction_bits, 12, 8, 12)
        | xs(instruction_bits, 31, 1, 20)) as i32
}

#[inline(always)]
pub fn itype_immediate(instruction_bits: u32) -> i32 {
    xs(instruction_bits, 20, 12, 0) as i32
}

#[inline(always)]
pub fn stype_immediate(instruction_bits: u32) -> i32 {
    (x(instruction_bits, 7, 5, 0) | xs(instruction_bits, 25, 7, 5)) as i32
}

#[inline(always)]
pub fn utype_immediate(instruction_bits: u32) -> i32 {
    xs(instruction_bits, 12, 20, 12) as i32
}

pub fn update_register<M: Machine>(machine: &mut M, register_index: usize, value: M::REG) {
    let register_index = register_index % RISCV_GENERAL_REGISTER_NUMBER;
    // In RISC-V, x0 is a special zero register with the following properties:
    //
    // * All writes to this register are silently ignored
    // * All reads from this register will respond with 0
    //
    // The goal here is to maintain a place where we can read zeros to allow for
    // compact encoding. Hence we are ignoring all writes to x0 register here.
    if register_index > 0 {
        machine.set_register(register_index, value);
    }
}

#[inline(always)]
pub fn jalr(version: u32) -> InstructionOpcode {
    if version >= 1 {
        insts::OP_JALR_VERSION1
    } else {
        insts::OP_JALR_VERSION0
    }
}

#[inline(always)]
pub fn lb(version: u32) -> InstructionOpcode {
    if version >= 1 {
        insts::OP_LB_VERSION1
    } else {
        insts::OP_LB_VERSION0
    }
}

#[inline(always)]
pub fn lbu(version: u32) -> InstructionOpcode {
    if version >= 1 {
        insts::OP_LBU_VERSION1
    } else {
        insts::OP_LBU_VERSION0
    }
}

#[inline(always)]
pub fn ld(version: u32) -> InstructionOpcode {
    if version >= 1 {
        insts::OP_LD_VERSION1
    } else {
        insts::OP_LD_VERSION0
    }
}

#[inline(always)]
pub fn lh(version: u32) -> InstructionOpcode {
    if version >= 1 {
        insts::OP_LH_VERSION1
    } else {
        insts::OP_LH_VERSION0
    }
}

#[inline(always)]
pub fn lhu(version: u32) -> InstructionOpcode {
    if version >= 1 {
        insts::OP_LHU_VERSION1
    } else {
        insts::OP_LHU_VERSION0
    }
}

#[inline(always)]
pub fn lw(version: u32) -> InstructionOpcode {
    if version >= 1 {
        insts::OP_LW_VERSION1
    } else {
        insts::OP_LW_VERSION0
    }
}

#[inline(always)]
pub fn lwu(version: u32) -> InstructionOpcode {
    if version >= 1 {
        insts::OP_LWU_VERSION1
    } else {
        insts::OP_LWU_VERSION0
    }
}