El CPU virtual consta de varios registros:
4 registros utilizables a modo usuario, el registro acumulador (*), puntero de instrucción, memoria de código y memoria de datos y un último registro de tamaño byte usado para establecer comparaciones.

La memoria de datos, los 4 registros de usuario y el registro acumulador son de tipo short int, esto quiere decir que pueden alcanzar valores desde 0x0000 hasta 0xFFFF, menos la memoria, que alcanza valores desde 0x1000 hasta 0x2000 (esto son 4kB).

La memoria de datos está programada para en un futuro poder utilizar varias en una misma CPU usadas como "módulos". Para utilizarla un ejemplo podría ser:
putl 1001 BB (guardar en posicion 1 valor 0xBB).
Es posible que en un futuro se junten las dos memorias (memoria de código y memoria de datos).

---

0x00	halt	detiene el cpu
0x01	lit	cargar en acumulador un valor inmediato
0x02	load	cargar en acumulador valor de un registro
0x03	store	almacenar valor acumulador en un registro
0x04	inc	incrementar por 1 el acumulador
0x05	dec	decrementar por 1 el acumulador
0x06	putl	poner en memoria un valor inmediato
0x07	putr	poner en registro un valor de memoria
0x08	geta	cargar en acumulador un valor de memoria
0x09	getr	cargar en registro un valor de memoria
0x0A	cmpl	comparar acumulador con valor inmediado. establece flag
0x0B	cmpr	comparar acumulador con valor registro. establece flag
0x0C	jmp	saltar a direccion de codigo (inicio == 0x00)
0x0D	jmpl	saltar a direccion de codigo si flag == 1 ( < )
0x0E	jmpe	saltar a direccion de codigo si flag == 2 ( = )
0x0F	jmpg	saltar a direccion de codigo si flag == 3 ( > )

---

#========================================
# CALCULAR RESTA DE DOS NUMEROS
#========================================
# Usando 2 registros se pueden hacer
# funciones de resta de números.
# resultado: r0
#========================================
 
# Inicializacion de los datos
 
lit 25		# ac: 25
store r0	# r0: 25
lit 17		# ac: 17
store r1	# r1: 17
lit 0		# ac: 0
 
# Bucles
 
load r1		# ac: r1
dec		# ac: ac--
store r1	# r1: ac
load r0		# ac: r0
dec		# ac: ac--
store r0	# r0: ac
 
lit 1		# ac: 1
cmpr r1		# comparar ac & r1
jmpg 16		# ac > r1 --> jmp 16
jmp 6 		# jmp 6
 
halt		# stop

char codigo[] = {0x01, 25, 0x03, 0x00, 0x01,
					   17, 0x03, 0x01, 0x01, 0x00,
					   0x02, 0x01, 0x05, 0x03, 0x01,
					   0x02, 0x00, 0x05, 0x03, 0x00,
					   0x01, 0x01, 0x0B, 0x01, 0x0F,
					   28, 0x0C, 10, 0x00};

#========================================
# CALCULAR SUMA DE DOS NUMEROS
#========================================
# Usando 2 registros se pueden hacer
# funciones de suma de números.
# resultado: r0
#========================================
 
# Inicializacion de los datos
 
lit 17		# ac: 17
store r0	# r0: 17
lit 25		# ac: 25
store r1	# r1: 25
lit 0		# ac: 0
 
# Bucles
 
load r1		# ac: r1
dec		# ac: ac--
store r1	# r1: ac
load r0		# ac: r0
inc		# ac: ac++
store r0	# r0: ac
 
lit 1		# ac: 1
cmpr r1		# comparar ac & r1
jmpg 16		# ac > r1 --> jmp 16
jmp 6 		# jmp 6
 
halt		# stop

char codigo[] = {0x01, 17, 0x03, 0x00, 0x01,
					   25, 0x03, 0x01, 0x01, 0x00,
					   0x02, 0x01, 0x05, 0x03, 0x01,
					   0x02, 0x00, 0x04, 0x03, 0x00,
					   0x01, 0x01, 0x0B, 0x01, 0x0F,
					   28, 0x0C, 10, 0x00};

#========================================
# CALCULAR MULTIPLICACION DE DOS NUMEROS
#========================================
# Utilizando 3 registros (incluso menos) se
# pueden hacer funciones de multiplicación
# de números.
# resultado: r2.
#========================================
 
# Inicialización de los datos
 
lit 10		# ac: 10
store r0	# r0: 10
lit 3		# ac: 3
store r1	# r1: 3
lit 0		# ac: 0
 
 
# Bucles
 
load r1		# ac: r1
dec		# ac: ac--
store r1	# r1: ac
cmpl 0		# comparar ac & 0
jmpe 23		# ac == 0 --> jmp 23
 
lit 10		# ac: 10
store r0	# r0: 10
 
load r2		# ac: r2
inc		# ac: ac++
store r2	# r2: ac
load r0		# ac: r0
dec		# ac: ac--
store r0	# r0: ac
lit 0		# ac: 0
cmpr r0		# comparar ac & r0
jmpl 13		# ac < r0 --> jmp 13
jmp 6		# jmp 6
 
lit 0		# ac: 0
store r1	# r1: 0
 
halt		# stop

char codigo[] = {0x01, 0x0A, 0x03, 0x00, 0x01,
					   0x03, 0x03, 0x01, 0x01, 0x00,			   
					   0x02, 0x01, 0x05, 0x03, 0x01, 0x0A, 0x00,
					   0x0D, 0x29,
					   0x01, 0x0A, 0x03, 0x00, 0x02, 0x02, 0x04,
					   0x03, 0x02, 0x02, 0x00, 0x05, 0x03, 0x00,
					   0x01, 0x00, 0x0B, 0x00, 0x0D, 23, 0x0C,
					   10, 0x01, 0x00, 0x03, 0x01, 0x00};

---

Espero opiniones, críticas y sus comentarios

Si, lose, pero la máquina virtual está programada en C/C++. Es por ello que quería las opiniones de que funciones servirían mejor, algoritmos de uso... para optimizar el código C.