Llevo ya desarroyando una máquina virtual largo tiempo, pero no tengo mucho tiempo, estoy con otros proyectos más importantes. Las funciones actuales (no creo que implemente alguna función más, sólo características y ampliaciones):
| 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 | pushl | poner en pila un valor inmediato |
| 0x07 | pushr | poner en pila valor de un registro |
| 0x08 | pop | eliminar 'cima de pila' (tos) |
| 0x09 | loadt | almacenar valor retorno de pop en acumulador |
| 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 ( > ) |
No es un juego de instrucciones completo ni facil de usar, pero teoricamente cualquier otra operación se puede hacer con esas instrucciones, de echo, hice una operación de multiplicar dos números (30 * 3):
#========================================
# CALCULAR MULTIPLICACION DE DOS NUMEROS
#========================================
# Utilizando tres registros se
# pueden hacer funciones de multiplicación
# de números.
#========================================
# 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
A la hora de ser compilado para la máquina virtual, queda una matriz como:
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};
Cuya alternativa en código C:
int num1, num2 = 3;
int mult = 0;
for (; num2 > 0; num2--) {
for(num1 = 10; num1 > 0; num1--) {
mult++;
}
}
Pueden si quieres crear sus propios algoritmos y postearlos en este mensaje, me ayudaría mucho, estoy intentando implementar "funciones externas", un archivo que incluya funciones para simplificar el trabajo. Esto es una multiplicación simple, seguramente se puede hacer optimizable y/o más corta, cualquier código que quieran crear utilizando esas funciones me ayudaria para probar la máquina virtual.
En aproximadamente 2 semanas espero publicar el código fuente completo... no me gusta sacar 100 versiones para una aplicacion!
Saludos
Puedes coger ideas de mi Máquina Virtual del procesador MIPS y un pequeño ensamblador que hice:
http://mipsvirtualmachine.wordpress.com/
https://github.com/tanisperez/MIPS-Virtual-Machine
Saludos.