NVM Architecture

NVM Programming Model

5 general purpose registers R0-R4
1 status word, set to either zero or one in accordance with results of various instructions
Stack pointer, sp. Pointer to top of 4 byte aligned stack.
Instruction pointer, ip. Pointer to current instruction.

Notation

Rn - refers to one of the general purpose registers. n occupies one byte of byte code.
Rd - refers to the destination register for an instruction. d occupies one byte of byte code.
Rs - refers to the source register for an instruction. s occupies one byte of byte code.
Addr32 - A 32 bit value representing a program or data address. Occupies 4 bytes of byte code.
Imm32 - 32 bit immediate data value. Occupies 4 bytes of byte code.
Len16 - 16 bit immediate data value. Occupies 2 bytes of byte code.
Imm8 - 8 bit immediate data value. Occupies 1 byte of byte code.
sz - Size specifier for the xor instruction, Occupies 1 byte of byte code

Instruction Set

push - Push 32 bit constant, address or register data onto stack

Operation
1. sp = sp - 4
2. [sp] = Imm32

cpush Imm32

Byte code: 0x00 0x00 <Imm32 ^ 0x37195411>

apush Addr32

Byte code: 0x00 0x01 <Addr32 - 0x0ADD01337>

rpush Rn
```
Byte code: 0x00 0x02 <Rn ^ 0x47>
```

pop - Pop a register value from the stack

Operation
1. Rn = [sp]
2. sp = sp + 4
pop Rn
```
Byte code: 0x00 0x03 <Rn ^ 0x66>
```

add_sp - Add offset to stack pointer

Operation
1. sp = sp + Imm8
add_sp Imm8
```
Byte code: 0x00 0x04 <Imm8 ^ 0x45>
```

xor - Xor memory indirect or register contents

Operation
1. Rd points to an 8, 16, or 32 bit int as specified by sz
2. [Rd] = [Rd] ^ Rs
3. sz = 0-byte, 1-word, 2-dword
xor.b [Rd],Rs
xor.w [Rd],Rs
xor.d [Rd],Rs
```
Byte code: 0x01 0x03 <Rs> <sz> <Rd>
```
Operation
1. Rd = Rd ^ Imm32
2. status word set to 0 if result is 0, 1 otherwise
xor Rn,Imm32
```
Byte code: 0x01 0x08 <Rn> <Imm32>
```

add - Add 32 bit register or constant to register

Operation
1. Rd = Rd + Imm32
2. status word set to 0 if result is 0, 1 otherwise
add Rn,Imm32
```
Byte code: 0x01 0x04 <Rn + 3> <Imm32>
```
Operation
1. Rd = Rd + Rs
2. status word set to 0 if result is 0, 1 otherwise
add Rd,Rs
```
Byte code: 0x01 0x09 <Rs + 1> <Rd + 3>
```

sub - Subtract constant from register

Operation
1. Rd = Rd - Imm32
2. status word set to 0 if result is 0, 1 otherwise
sub Rn,Imm32
```
Byte code: 0x01 0x05 <Rn + 2> <Imm32>
```

test - Test register with mask

Operation
1. Perform Rn & Imm32
2. status word set to 0 if result is 0, 1 otherwise
test Rn,Imm32
```
Byte code: 0x01 0x06 <Rn + 5> <Imm32>
```

or - Or register with constant

Operation
1. Rd = Rd | Imm32
2. status word set to 0 if result is 0, 1 otherwise
or Rn,Imm32
```
Byte code: 0x01 0x07 <Rn + 4> <Imm32>
```

cmp - Compare registers and assign

Operation
1. status word set to 0 if Rd == Rs, 1 otherwise
2. Rd = Rs
cmp Rd,Rs
```
Byte code: 0x01 0x0A <Rs + 2> <Rd + 1>
```

halt - Halt the virtual machine

halt
```
Byte code: 0x02 0x00
```

syscall - Call the system function whose thunk function is at the specified address

Operation
1. The API function at location Addr32 is called
2. Addr32 represents the address of the link table entry for the desired function
3. The function result is stored in R0
4. status word is set to 0 if the result is 0, 1 otherwise

syscall Addr32

Byte code: 0x02 0x01 <Addr32 - 0x0FEA731DE>

load - Load constant or memory value into register

Operation
1. Rn = Imm32

load Rn,Imm32

Byte code: 0x02 0x02 <Imm32 - 0x0AEFDED04> <Rn>

Operation
1. Rd = [Rs]
2. Rs points to an 8, 16, or 32 bit int
load.d Rd,[Rs]
```
Byte code: 0x02 0x08 <Rs> <Rd>
```
load.b Rd,[Rs]
```
Byte code: 0x02 0x0A <Rs> <Rd>
```
load.w Rd,[Rs]
```
Byte code: 0x02 0x0B <Rs> <Rd>
```

dec - Decrement register

Operation
1. Rn = Rn - 1
2. status word set to 0 if result is 0, 1 otherwise
dec Rn
```
Byte code: 0x02 0x03 <Rn>
```

inc - Increment register

Operation
1. Rn = Rn + 1
2. status word set to 0 if result is 0, 1 otherwise
inc Rn
```
Byte code: 0x02 0x04 <Rn>
```

clear Set the specified register to zero

Operation
1. Rn = 0
2. status word set to 0
clear Rn
```
Byte code: 0x02 0x05 <Rn>
```

scanb Search memory starting at [R0] for byte value

Operation
1. R0 is implied pointer to 8 bit memory location
2. Scan memory starting at R0 looking for first occurrence of Imm8
3. Maximum number of memory locations to scan is indicated by Len16
4. status word set to 0 if Imm8 is not found
5. If Imm8 is found, R0 is updated to point to memory location following the location containing Imm8
scanb Imm8,Len16
```
Byte code: 0x02 0x06 Imm8 Len16
```

trap Program interrupt

Operation
1. The NVM executes an x86 int3 to interrupt execution
trap
```
Byte code: 0x02 0x07
```

nop - No operation

Operation
1. No operation is performed. A register must be specified.
nop Rn
```
Byte code: 0x02 0x09 <Rn>
```

jmpeq - Compare top two dwords on stack and jump if they are equal

Operation
1. Compare [sp] to [sp+4]
2. sp = sp + 8
3. If the 2 values in step 1 were equal, ip = Addr32
jmpeq Addr32
```
Byte code: 0x03 0x00 <Addr32 + 0x31337>
```

jmp - Jump absolute

Operation
1. ip = Addr32

jmp Addr32

Byte code: 0x04 0x00 <Addr32 - 0x0DEADEAD>

jnz - Jump absolute if flag word is not zero

Operation
1. If the status register is non-zero, ip = Addr32

jnz Addr32

Byte code: 0x04 0x01 <Addr32 - 0x00E1BA3E>

jz - Jump absolute if flag word is zero

Operation
1. If the status register is zero, ip = Addr32

jz Addr32

Byte code: 0x04 0x02 <Addr32 - 0x0E1BA41>

call - Call subroutine

Operation
1. sp = sp - 4
2. [sp] = ip + 6
3. ip = Addr32
call Addr32
```
Byte code: 0x05 0x00 <Addr32>
```

ret - Return from subroutine

Operation
1. ip = [sp]
2. sp = sp + 4
ret
```
Byte code: 0x05 0x01
```