exec.c

   1 #include "gmqcc.h"
   2
   3 #include "exec.h"
   4
   5 qc_program* prog_load(const char *filename)
   6 {
   7     qc_program *prog;
   8     prog_header header;
   9     FILE *file;
  10
  11     file = fopen(filename, "rb");
  12     if (!file)
  13         return NULL;
  14
  15     if (fread(&header, sizeof(header), 1, file) != 1) {
  16         perror("read");
  17         fclose(file);
  18         return NULL;
  19     }
  20
  21     if (header.version != 6) {
  22         printf("header says this is a version %i progs, we need version 6\n",
  23                header.version);
  24         fclose(file);
  25         return NULL;
  26     }
  27
  28     prog = (qc_program*)mem_a(sizeof(qc_program));
  29     if (!prog) {
  30         fclose(file);
  31         printf("failed to allocate program data\n");
  32         return NULL;
  33     }
  34     memset(prog, 0, sizeof(*prog));
  35
  36     prog->entityfields = header.entfield;
  37
  38     prog->filename = util_strdup(filename);
  39     if (!prog->filename)
  40         goto error;
  41 #define read_data(hdrvar, progvar, type)                                         \
  42     if (fseek(file, header.hdrvar.offset, SEEK_SET) != 0) {                      \
  43         perror("fseek");                                                         \
  44         goto error;                                                              \
  45     }                                                                            \
  46     prog->progvar##_alloc = header.hdrvar.length;                                \
  47     prog->progvar##_count = header.hdrvar.length;                                \
  48     prog->progvar = (type*)mem_a(header.hdrvar.length * sizeof(*prog->progvar)); \
  49     if (!prog->progvar)                                                          \
  50         goto error;                                                              \
  51     if (fread(prog->progvar, sizeof(*prog->progvar), header.hdrvar.length, file) \
  52         != header.hdrvar.length) {                                               \
  53         perror("read");                                                          \
  54         goto error;                                                              \
  55     }
  56 #define read_data1(x, y) read_data(x, x, y)
  57
  58     read_data (statements, code, prog_statement);
  59     read_data1(defs,             prog_def);
  60     read_data1(fields,           prog_def);
  61     read_data1(functions,        prog_function);
  62     read_data1(strings,          char);
  63     read_data1(globals,          qcint);
  64
  65     fclose(file);
  66
  67     /* profile counters */
  68     if (!qc_program_profile_resize(prog, prog->code_count))
  69         goto error;
  70
  71     /* Add tempstring area */
  72     prog->tempstring_start = prog->strings_count;
  73     prog->tempstring_at    = prog->strings_count;
  74     if (!qc_program_strings_resize(prog, prog->strings_count + 16*1024))
  75         goto error;
  76
  77     return prog;
  78
  79 error:
  80     if (prog->filename)   mem_d(prog->filename);
  81     if (prog->code)       mem_d(prog->code);
  82     if (prog->defs)       mem_d(prog->defs);
  83     if (prog->fields)     mem_d(prog->fields);
  84     if (prog->functions)  mem_d(prog->functions);
  85     if (prog->strings)    mem_d(prog->strings);
  86     if (prog->globals)    mem_d(prog->globals);
  87     if (prog->entitydata) mem_d(prog->entitydata);
  88     mem_d(prog);
  89     return NULL;
  90 }
  91
  92 void prog_delete(qc_program *prog)
  93 {
  94     if (prog->filename) mem_d(prog->filename);
  95     MEM_VECTOR_CLEAR(prog, code);
  96     MEM_VECTOR_CLEAR(prog, defs);
  97     MEM_VECTOR_CLEAR(prog, fields);
  98     MEM_VECTOR_CLEAR(prog, functions);
  99     MEM_VECTOR_CLEAR(prog, strings);
 100     MEM_VECTOR_CLEAR(prog, globals);
 101     MEM_VECTOR_CLEAR(prog, entitydata);
 102     MEM_VECTOR_CLEAR(prog, localstack);
 103     MEM_VECTOR_CLEAR(prog, stack);
 104     MEM_VECTOR_CLEAR(prog, profile);
 105     mem_d(prog);
 106 }
 107
 108 /***********************************************************************
 109  * VM code
 110  */
 111
 112 char* prog_getstring(qc_program *prog, qcint str)
 113 {
 114     if (str < 0 || str >= prog->strings_count)
 115         return "<<<invalid string>>>";
 116     return prog->strings + str;
 117 }
 118
 119 prog_def* prog_entfield(qc_program *prog, qcint off)
 120 {
 121     size_t i;
 122     for (i = 0; i < prog->fields_count; ++i) {
 123         if (prog->fields[i].offset == off)
 124             return (prog->fields + i);
 125     }
 126     return NULL;
 127 }
 128
 129 prog_def* prog_getdef(qc_program *prog, qcint off)
 130 {
 131     size_t i;
 132     for (i = 0; i < prog->defs_count; ++i) {
 133         if (prog->defs[i].offset == off)
 134             return (prog->defs + i);
 135     }
 136     return NULL;
 137 }
 138
 139 qcany* prog_getedict(qc_program *prog, qcint e)
 140 {
 141     return (qcany*)(prog->entitydata + (prog->entityfields + e));
 142 }
 143
 144 qcint prog_tempstring(qc_program *prog, const char *_str)
 145 {
 146     /* we don't access it, but the macro-generated functions don't use
 147      * const
 148      */
 149     char *str = (char*)_str;
 150
 151     size_t len = strlen(str);
 152     size_t at = prog->tempstring_at;
 153
 154     /* when we reach the end we start over */
 155     if (at + len >= prog->strings_count)
 156         at = prog->tempstring_start;
 157
 158     /* when it doesn't fit, reallocate */
 159     if (at + len >= prog->strings_count)
 160     {
 161         prog->strings_count = at;
 162         if (!qc_program_strings_append(prog, str, len+1)) {
 163             prog->vmerror = VMERR_TEMPSTRING_ALLOC;
 164             return 0;
 165         }
 166         return at;
 167     }
 168
 169     /* when it fits, just copy */
 170     memcpy(prog->strings + at, str, len+1);
 171     prog->tempstring_at += len+1;
 172     return at;
 173 }
 174
 175 static void trace_print_global(qc_program *prog, unsigned int glob, int vtype)
 176 {
 177     static char spaces[16+1] = "            ";
 178     prog_def *def;
 179     qcany    *value;
 180     int       len;
 181
 182     if (!glob)
 183         return;
 184
 185     def = prog_getdef(prog, glob);
 186     value = (qcany*)(&prog->globals[glob]);
 187
 188     if (def) {
 189         len = printf("[%s] ", prog_getstring(prog, def->name));
 190         vtype = def->type;
 191     }
 192     else
 193         len = printf("[#%u] ", glob);
 194
 195     switch (vtype) {
 196         case TYPE_VOID:
 197         case TYPE_ENTITY:
 198         case TYPE_FIELD:
 199         case TYPE_FUNCTION:
 200         case TYPE_POINTER:
 201             len += printf("%i,", value->_int);
 202             break;
 203         case TYPE_VECTOR:
 204             len += printf("'%g %g %g',", value->vector[0],
 205                                          value->vector[1],
 206                                          value->vector[2]);
 207             break;
 208         case TYPE_STRING:
 209             len += printf("\"%s\",", prog_getstring(prog, value->string));
 210             break;
 211         case TYPE_FLOAT:
 212         default:
 213             len += printf("%g,", value->_float);
 214             break;
 215     }
 216     if (len < 16) {
 217         spaces[16-len] = 0;
 218         printf(spaces);
 219         spaces[16-len] = ' ';
 220     }
 221 }
 222
 223 static void prog_print_statement(qc_program *prog, prog_statement *st)
 224 {
 225     if (st->opcode >= (sizeof(asm_instr)/sizeof(asm_instr[0]))) {
 226         printf("<illegal instruction %d>\n", st->opcode);
 227         return;
 228     }
 229     printf("%-12s", asm_instr[st->opcode].m);
 230     if (st->opcode >= INSTR_IF &&
 231         st->opcode <= INSTR_IFNOT)
 232     {
 233         trace_print_global(prog, st->o1.u1, TYPE_FLOAT);
 234         printf("%d\n", st->o2.s1);
 235     }
 236     else if (st->opcode >= INSTR_CALL0 &&
 237              st->opcode <= INSTR_CALL8)
 238     {
 239         printf("\n");
 240     }
 241     else if (st->opcode == INSTR_GOTO)
 242     {
 243         printf("%i\n", st->o1.s1);
 244     }
 245     else
 246     {
 247         int t[3] = { TYPE_FLOAT, TYPE_FLOAT, TYPE_FLOAT };
 248         switch (st->opcode)
 249         {
 250             case INSTR_MUL_FV:
 251                 t[1] = t[2] = TYPE_VECTOR;
 252                 break;
 253             case INSTR_MUL_VF:
 254                 t[0] = t[2] = TYPE_VECTOR;
 255                 break;
 256             case INSTR_MUL_V:
 257                 t[0] = t[1] = TYPE_VECTOR;
 258                 break;
 259             case INSTR_ADD_V:
 260             case INSTR_SUB_V:
 261             case INSTR_EQ_V:
 262             case INSTR_NE_V:
 263                 t[0] = t[1] = t[2] = TYPE_VECTOR;
 264                 break;
 265             case INSTR_EQ_S:
 266             case INSTR_NE_S:
 267                 t[0] = t[1] = TYPE_STRING;
 268                 break;
 269             case INSTR_STORE_V:
 270                 t[0] = t[1] = TYPE_VECTOR; t[2] = -1;
 271                 break;
 272             case INSTR_STORE_S:
 273                 t[0] = t[1] = TYPE_STRING; t[2] = -1;
 274                 break;
 275         }
 276         if (t[0] >= 0) trace_print_global(prog, st->o1.u1, t[0]);
 277         if (t[1] >= 0) trace_print_global(prog, st->o2.u1, t[1]);
 278         if (t[2] >= 0) trace_print_global(prog, st->o3.u1, t[2]);
 279         printf("\n");
 280     }
 281 }
 282
 283 static qcint prog_enterfunction(qc_program *prog, prog_function *func)
 284 {
 285     qc_exec_stack st;
 286     prog_function *cur = NULL;
 287
 288     if (prog->stack_count)
 289         cur = prog->stack[prog->stack_count-1].function;
 290
 291     /* back up locals */
 292     st.localsp  = prog->localstack_count;
 293     st.stmt     = prog->statement;
 294     st.function = func;
 295
 296     if (cur)
 297     {
 298         qcint *globals = prog->globals + cur->firstlocal;
 299         if (!qc_program_localstack_append(prog, globals, cur->locals))
 300         {
 301             printf("out of memory\n");
 302             exit(1);
 303         }
 304     }
 305
 306     if (!qc_program_stack_add(prog, st)) {
 307         printf("out of memory\n");
 308         exit(1);
 309     }
 310
 311     return func->entry;
 312 }
 313
 314 static qcint prog_leavefunction(qc_program *prog)
 315 {
 316     qc_exec_stack st = prog->stack[prog->stack_count-1];
 317     if (!qc_program_stack_remove(prog, prog->stack_count-1)) {
 318         printf("out of memory\n");
 319         exit(1);
 320     }
 321
 322     if (st.localsp != prog->localstack_count) {
 323         if (!qc_program_localstack_resize(prog, st.localsp)) {
 324             printf("out of memory\n");
 325             exit(1);
 326         }
 327     }
 328
 329     return st.stmt;
 330 }
 331
 332 bool prog_exec(qc_program *prog, prog_function *func, size_t flags, long maxjumps)
 333 {
 334     long jumpcount = 0;
 335     prog_statement *st;
 336
 337     st = prog->code + prog_enterfunction(prog, func);
 338     --st;
 339     switch (flags)
 340     {
 341         default:
 342         case 0:
 343         {
 344 #define QCVM_PROFILE 0
 345 #define QCVM_TRACE   0
 346 #           include "qcvm_execprogram.h"
 347             break;
 348         }
 349         case (VMXF_TRACE):
 350         {
 351 #define QCVM_PROFILE 0
 352 #define QCVM_TRACE   1
 353 #           include "qcvm_execprogram.h"
 354             break;
 355         }
 356         case (VMXF_PROFILE):
 357         {
 358 #define QCVM_PROFILE 1
 359 #define QCVM_TRACE   0
 360 #           include "qcvm_execprogram.h"
 361             break;
 362         }
 363         case (VMXF_TRACE|VMXF_PROFILE):
 364         {
 365 #define QCVM_PROFILE 1
 366 #define QCVM_TRACE   1
 367 #           include "qcvm_execprogram.h"
 368             break;
 369         }
 370     };
 371
 372 cleanup:
 373     prog->localstack_count = 0;
 374     prog->stack_count = 0;
 375     return true;
 376 }
 377
 378 /***********************************************************************
 379  * main for when building the standalone executor
 380  */
 381
 382 #if defined(QCVM_EXECUTOR)
 383 int main(int argc, char **argv)
 384 {
 385     size_t      i;
 386     qcint       fnmain = -1;
 387     qc_program *prog;
 388
 389     if (argc != 2) {
 390         printf("usage: %s file\n", argv[0]);
 391         exit(1);
 392     }
 393
 394     prog = prog_load(argv[1]);
 395     if (!prog) {
 396         printf("failed to load program '%s'\n", argv[1]);
 397         exit(1);
 398     }
 399
 400     for (i = 1; i < prog->functions_count; ++i) {
 401         const char *name = prog_getstring(prog, prog->functions[i].name);
 402         printf("Found function: %s\n", name);
 403         if (!strcmp(name, "main"))
 404             fnmain = (qcint)i;
 405     }
 406     if (fnmain > 0)
 407     {
 408         prog_exec(prog, &prog->functions[fnmain], VMXF_TRACE, JUMPS_DEFAULT);
 409     }
 410     else
 411         printf("No main function found\n");
 412
 413     prog_delete(prog);
 414     return 0;
 415 }
 416 #endif