Simples VM ( Virtual Machine ) - PARTE 1

1. Simples VM ( Virtual Machine ) - PARTE 1

gokernel
(usa Linux Mint)

Enviado em 18/02/2016 - 20:08h

Olá !!!
Para quem está interessado em VM, um pequeno exemplo:

Implementei somente 8 OPCODES para melhor entender:



    OP_HALT

    OP_NOP

    OP_PUSH_LONG

    OP_PUSH_FLOAT

    OP_PUSH_VAR

    OP_SET_VAR

    OP_INC

    OP_PRINT

Depois implementarei: COMPARAÇÃO e LOOPS

OBS: tentei postar no ( codepad.org ) mas falhou ... depois tentarei e REeditarei este tópico.



/*

**-------------------------------------------------------------------

**

** Simples VM:

**

** COMPILE:

**   gcc vm.c -o vm -O2 -Wall

**   ou

**   g++ vm.c -o vm -O2 -Wall

**

**-------------------------------------------------------------------

*/

#include <stdio.h>

#include <stdlib.h>



#define NEXT          goto *(++vm->ip)->jmp

#define GTABLE_SIZE   255

#define GVAR_SIZE     255

#define STACK_SIZE    1024



typedef struct  VM      VM;

typedef union   VALUE   VALUE;

typedef struct  VAR     VAR;

typedef struct  OPCODE  OPCODE;

typedef struct  LABEL   LABEL;



struct VM {

    OPCODE  *ip;

    OPCODE  *code;

    LABEL   *label;

    int     pos;

};

union VALUE {

    long  l;

    float f;

    char  *s;

    void  *p;

};

struct VAR {

    char  *name;

    int   type;

    VALUE value;

};

struct OPCODE {

    void  *jmp;

    VALUE arg;  // argumento 1

};

struct LABEL {

    char  *text;

    int   pos;

    LABEL *next;

};

enum { // opcodes:



    OP_HALT = 0,    // para sair da VM

    OP_NOP,         // no opcode



    OP_PUSH_LONG,   // da um "push" ... e seta o topo da pilha ( *sp ) com um valor long

    OP_PUSH_FLOAT,  // da um "push" ... e seta o topo da pilha ( *sp ) com um valor float

    OP_PUSH_VAR,    // da um "push" ... e seta o topo da pilha ( *sp ) com uma variavel



    //-------------------------------------------

    // OBS: Essa instrucao utiliza 2 argumentos:

    // 1: short = o index de Gvar [ ]

    // 2: long  = o valor da variavel

    //-------------------------------------------

    OP_SET_VAR,     // seta um valor de uma variavel ... somente tipo long



    OP_INC,         // incrementa uma variavel ( Gvar[] )

    OP_PRINT        // imprime o valor de uma variavel



};



void  *Gtable [ GTABLE_SIZE ];

VAR   Gvar    [ GVAR_SIZE   ];

VALUE stack   [ STACK_SIZE  ];  // a pilha base

VALUE *sp;                      // o topo da pilha

int   flag_long;

float flag_float;



void vm_run (VM *vm)

{

    if (Gtable[0] == NULL) {



        Gtable [ OP_HALT        ] = && op_halt;

        Gtable [ OP_NOP         ] = && op_nop;



        Gtable [ OP_PUSH_LONG   ] = && op_push_long;

        Gtable [ OP_PUSH_FLOAT  ] = && op_push_float;

        Gtable [ OP_PUSH_VAR    ] = && op_push_var;



        Gtable [ OP_SET_VAR     ] = && op_set_var;



        Gtable [ OP_INC         ] = && op_inc;

        Gtable [ OP_PRINT       ] = && op_print;



        sp = stack;



  return;

    }



    if (!vm)

  return;



    vm->ip = vm->code;



    goto *vm->ip->jmp; // pula para a primeira "inctrucao"



//---------------------------------------------

//##########  OPCODES implementacao  ##########

//---------------------------------------------

//

op_halt:

    printf ("Instrucao OP_HALT ... saindo da VM\n");

    return;



op_nop:

    // sem opcode ...

    NEXT;



op_push_long: {

    sp++;

    sp->l = vm->ip->arg.l;

    } NEXT;



op_push_float: {

    sp++;

    sp->f = vm->ip->arg.f;

    } NEXT;



op_push_var: {

    sp++;

    // somente tipo long por enquanto

    sp->l = Gvar [ vm->ip->arg.l ].value.l;

    } NEXT;



op_set_var: {

    // somente tipo long por enquanto

    Gvar [ *(short*)vm->ip->arg.s ].value.l = *(long*)(vm->ip->arg.s+2);

    } NEXT;



op_inc: {

    // somente tipo long por enquanto

    Gvar [ vm->ip->arg.l ].value.l++;

    } NEXT;



op_print: {

    // somente tipo long por enquanto

    printf ("Gvar[ %ld ] = %ld\n", vm->ip->arg.l, Gvar [ vm->ip->arg.l ].value.l);

    } NEXT;

}



VM *vm_new (int size)

{

    VM *vm = (VM*) malloc (sizeof(VM));



    if (vm) {

        if ( (vm->code = (OPCODE*) malloc (sizeof(OPCODE)*size)) == NULL)

      return NULL;



        vm->ip = vm->code;

        vm->label = NULL;

        vm->pos = 0;

    }

    return vm;

}



//-------------------------------------------------------------------

//###########################  gen/emit  ############################

//-------------------------------------------------------------------

//

void g_halt (VM *vm)

{

    vm->code[vm->pos++].jmp = Gtable [ OP_HALT ];

}

void g_nop (VM *vm)

{

    vm->code[vm->pos++].jmp = Gtable [ OP_NOP ];

}

void g_set_var (VM *vm, short index, long value)

{

    vm->code[vm->pos].jmp = Gtable [ OP_SET_VAR ];

    vm->code[vm->pos].arg.s = (char*)malloc ((sizeof(short)+sizeof(long))+1);

    *(short*)(vm->code[vm->pos].arg.s) = index;

    *(long*)(vm->code[vm->pos].arg.s+2) = value;

    vm->pos++;

}

void g_inc (VM *vm, int index)

{

    vm->code[vm->pos].jmp = Gtable [ OP_INC ];

    vm->code[vm->pos].arg.l = index;

    vm->pos++;

}

void g_print (VM *vm, int index)

{

    vm->code[vm->pos].jmp = Gtable [ OP_PRINT ];

    vm->code[vm->pos].arg.l = index;

    vm->pos++;

}



int main (int argc, char *argv[])

{

    VM *vm;



    //-----------------------------------------

    // cria uma VM com maximo de 100 instrucoes

    //-----------------------------------------

    //

    if ((vm = vm_new(100)) != NULL) {



        vm_run (NULL); // setup Gtable [ ]



        //-------------------------

        //*******  gen/emit *******

        //-------------------------

        //

        g_set_var (vm, 10, 1500); // seta ( Gvar[10].arg.l ) com o valor 1500

        g_inc     (vm, 10);       // incrementa ( Gvar[10].arg.l )

        g_print   (vm, 10);       // imprime ( Gvar[10].arg.l )  ... 1501

        g_halt    (vm);           // o OPCODE mais importante para sair da VM



        vm_run (vm);  // agora executa a VM



        // aqui: falta liberar memoria ... fica para a proxima

        // ...

    }

    printf ("Saindo Com Sucesso !!!\n");

    return 0;

}

Lembrando que a VM funciona somente com 1 argumento para cada instrução ( OPCODE ) mas é possível funcionar com vários argumentos por instrução veja a instrução ( OP_SET_VAR ) .

T++.

2 0

Quote