vm.c

   1 #include <stdio.h>
   2 #include <assert.h>
   3 #include "heap.h"
   4 #include "code.h"
   5 #include "symtab.h"
   6 #include "vm.h"
   7
   8 #define STACK_SIZE 4096
   9
  10 /*
  11  * Pilha de execucao.
  12  *
  13  * Essa pilha eh a usada por praticamente tds as
  14  * rotinas da maquina virtual
  15  */
  16 static int top = -1;
  17 static int stack[STACK_SIZE];
  18
  19 /*
  20  * Pilha usada para armazenar informacoes especificas
  21  * das chamadas de funcao
  22  */
  23 static int fun_top = -1;
  24 static int fun_stack[STACK_SIZE];
  25
  26 /* Program counter */
  27 static int pc = 0;
  28
  29 /* Operacoes binarias */
  30 enum {
  31   O_ADD, O_SUB, O_MUL, O_DIV, O_MOD,
  32   O_EQL, O_NE, O_GEQL, O_LEQL, O_GT, O_LT,
  33   O_OR, O_NOT, O_AND };
  34
  35 static void
  36 bin_op(int op)
  37 {
  38   assert(top >= 1);
  39   switch(op) {
  40   case O_ADD:
  41     stack[top-1] = stack[top-1] + stack[top];
  42     break;
  43   case O_SUB:
  44     stack[top-1] = stack[top-1] - stack[top];
  45     break;
  46   case O_MUL:
  47     stack[top-1] = stack[top-1] * stack[top];
  48     break;
  49   case O_DIV:
  50     stack[top-1] = stack[top-1] / stack[top];
  51     break;
  52   case O_MOD:
  53     stack[top-1] = stack[top-1] % stack[top];
  54     break;
  55   case O_EQL:
  56     stack[top-1] = stack[top-1] == stack[top];
  57     break;
  58   case O_NE:
  59     stack[top-1] = stack[top-1] != stack[top];
  60     break;
  61   case O_GEQL:
  62     stack[top-1] = stack[top-1] >= stack[top];
  63     break;
  64   case O_LEQL:
  65     stack[top-1] = stack[top-1] <= stack[top];
  66     break;
  67   case O_GT:
  68     stack[top-1] = stack[top-1] > stack[top];
  69     break;
  70   case O_LT:
  71     stack[top-1] = stack[top-1] < stack[top];
  72     break;
  73   case O_OR:
  74     stack[top-1] = stack[top-1] || stack[top];
  75     break;
  76   case O_AND:
  77     stack[top-1] = stack[top-1] && stack[top];
  78     break;
  79   case O_NOT:
  80     stack[top-1] = !stack[top-1];
  81     top++;                      /* we do not reduce the stack */
  82     break;
  83   default:
  84     fprintf(stderr, "Operacao %d nao reconhecida\n", op);
  85     break;
  86   }
  87   --top;
  88   pc++;
  89 }
  90
  91 void
  92 vm_halt(int arg)
  93 {
  94 }
  95
  96 void
  97 vm_add(int arg)
  98 {
  99   bin_op(O_ADD);
 100 }
 101
 102 void
 103 vm_sub(int arg)
 104 {
 105   bin_op(O_SUB);
 106 }
 107
 108 void
 109 vm_mul(int arg)
 110 {
 111   bin_op(O_MUL);
 112 }
 113
 114 void
 115 vm_div(int arg)
 116 {
 117   bin_op(O_DIV);
 118 }
 119
 120 void
 121 vm_mod(int arg)
 122 {
 123   bin_op(O_MOD);
 124 }
 125
 126 void
 127 vm_cmp_eql(int arg)
 128 {
 129   bin_op(O_EQL);
 130 }
 131
 132 void
 133 vm_cmp_ne(int arg)
 134 {
 135   bin_op(O_NE);
 136 }
 137
 138 void
 139 vm_cmp_geql(int arg)
 140 {
 141   bin_op(O_GEQL);
 142 }
 143
 144 void
 145 vm_cmp_leql(int arg)
 146 {
 147   bin_op(O_LEQL);
 148 }
 149
 150 void
 151 vm_cmp_gt(int arg)
 152 {
 153   bin_op(O_GT);
 154 }
 155
 156 void
 157 vm_cmp_lt(int arg)
 158 {
 159   bin_op(O_LT);
 160 }
 161
 162 void
 163 vm_cmp_or(int arg)
 164 {
 165   bin_op(O_OR);
 166 }
 167
 168 void
 169 vm_cmp_and(int arg)
 170 {
 171   bin_op(O_AND);
 172 }
 173
 174 void
 175 vm_cmp_not(int arg)
 176 {
 177   bin_op(O_NOT);
 178 }
 179
 180 void
 181 vm_load_var(int arg)
 182 {
 183   int off = stack[top--];
 184   stack[++top] = data_get(arg, off);
 185   pc++;
 186 }
 187
 188 void
 189 vm_load_int(int arg)
 190 {
 191   stack[++top] = arg;
 192   pc++;
 193 }
 194
 195 void
 196 vm_load_off(int arg)
 197 {
 198   stack[++top] = arg;
 199   pc++;
 200 }
 201
 202 void
 203 vm_store(int arg)
 204 {
 205   int off = stack[top--];
 206   assert(top >= 0);
 207   data_put(arg, off, stack[top]);
 208   top--;
 209   pc++;
 210 }
 211
 212 void
 213 vm_jmp_false(int arg)
 214 {
 215   if (stack[top] == 0)
 216     pc = arg;
 217   else
 218     pc++;
 219   top--;
 220 }
 221
 222 void
 223 vm_goto(int arg)
 224 {
 225   pc = arg;
 226 }
 227
 228 void
 229 vm_write_int(int arg)
 230 {
 231   printf("%d\n", stack[top]);
 232   top--;
 233   pc++;
 234 }
 235
 236 void
 237 vm_call(int arg)
 238 {
 239   int nargs = fun_stack[fun_top-1];
 240
 241   scope++;
 242   /* store the base pointer */
 243   fun_stack[++fun_top] = top-nargs+1;
 244   pc = arg;
 245 }
 246
 247 void
 248 vm_push_int(int arg)
 249 {
 250   fun_stack[++fun_top] = arg;
 251   pc++;
 252 }
 253
 254 void
 255 vm_push_var(int arg)
 256 {
 257   fun_stack[++fun_top] = data_get(arg, stack[top--]);
 258   pc++;
 259 }
 260
 261 void
 262 vm_ret(int arg)
 263 {
 264   int nargs;
 265
 266   fun_top--;                    /* take off the base pointer */
 267   pc = fun_stack[fun_top--];
 268   nargs = fun_stack[fun_top--];
 269
 270   top -= nargs;
 271
 272   assert(fun_top >= -1 && top >= -1);
 273
 274   scoperem(scope--);
 275 }
 276
 277 void
 278 vm_shift(int arg)
 279 {
 280   int bp = fun_stack[fun_top];
 281   stack[++top] = stack[bp];
 282   fun_stack[fun_top]++;
 283   pc++;
 284 }
 285
 286 int
 287 vm_loop(void)
 288 {
 289   while (code[pc].op != HALT) {
 290     ops[code[pc].op].op(code[pc].arg);
 291   }
 292
 293   return 0;
 294 }