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

/// Size of procedure stack adjustment
pub type FrameSize = u32;

/// Size of memory block to copy
pub type BlockSize = u32;

/// Offset within stack frame
pub type FrameOffset = u32;

pub type ArgOffset = u8;

/// Absolute instruction offset within code segment
// TODO: VM runtime bounds check: 0 < Address < instruction count
pub type Address = u32;

/// Literal value
pub type Literal = u32;

// These should match their opcodes
#[allow(non_camel_case_types)]
/// A QVM instruction
#[derive(Debug,PartialEq)]
pub enum Instruction {
    UNDEF,

    IGNORE,

    BREAK,

    ENTER(FrameSize),
    LEAVE(FrameSize),
    CALL,
    PUSH,
    POP,

    CONST(Literal),
    LOCAL(FrameOffset),

    JUMP,

    EQ(Address),
    NE(Address),

    LTI(Address),
    LEI(Address),
    GTI(Address),
    GEI(Address),

    LTU(Address),
    LEU(Address),
    GTU(Address),
    GEU(Address),

    EQF(Address),
    NEF(Address),

    LTF(Address),
    LEF(Address),
    GTF(Address),
    GEF(Address),

    LOAD1,
    LOAD2,
    LOAD4,
    STORE1,
    STORE2,
    STORE4,
    ARG(ArgOffset),

    BLOCK_COPY(BlockSize),

    SEX8,
    SEX16,

    NEGI,
    ADD,
    SUB,
    DIVI,
    DIVU,
    MODI,
    MODU,
    MULI,
    MULU,

    BAND,
    BOR,
    BXOR,
    BCOM,

    LSH,
    RSHI,
    RSHU,

    NEGF,
    ADDF,
    SUBF,
    DIVF,
    MULF,

    CVIF,
    CVFI,
}