No more globals for codegen
authorDale Weiler <killfieldengine@gmail.com>
Thu, 25 Apr 2013 09:35:30 +0000 (09:35 +0000)
committerDale Weiler <killfieldengine@gmail.com>
Thu, 25 Apr 2013 09:35:30 +0000 (09:35 +0000)
code.c
gmqcc.h
ir.c
ir.h
parser.c

diff --git a/code.c b/code.c
index eabc50c458a77fff4dfdc7e8b05ce82b63d3b981..b0ce2baa04aa138b24a81004257414b7ad81a3cc 100644 (file)
--- a/code.c
+++ b/code.c
  */
 #include "gmqcc.h"
 
-prog_section_statement *code_statements;
-int                    *code_linenums;
-prog_section_def       *code_defs;
-prog_section_field     *code_fields;
-prog_section_function  *code_functions;
-int                    *code_globals;
-char                   *code_chars;
-uint16_t                code_crc;
-static uint32_t         code_entfields;
-
 /* This is outrageous! */
 #define QCINT_ENTRY void*
 #define QCINT_TO_HASH_ENTRY(q) ((void*)(uintptr_t)(q))
 #define HASH_ENTRY_TO_QCINT(h) ((qcint)(uintptr_t)(h))
-static ht     code_string_cache;
-static qcint  code_string_cached_empty;
 
-void code_push_statement(prog_section_statement *stmt, int linenum)
+void code_push_statement(code_t *code, prog_section_statement *stmt, int linenum)
 {
-    vec_push(code_statements, *stmt);
-    vec_push(code_linenums,   linenum);
+    vec_push(code->statements, *stmt);
+    vec_push(code->linenums,   linenum);
 }
 
-void code_pop_statement()
+void code_pop_statement(code_t *code)
 {
-    vec_pop(code_statements);
-    vec_pop(code_linenums);
+    vec_pop(code->statements);
+    vec_pop(code->linenums);
 }
 
-void code_init() {
-    prog_section_function  empty_function  = {0,0,0,0,0,0,0,{0,0,0,0,0,0,0,0}};
-    prog_section_statement empty_statement = {0,{0},{0},{0}};
-    prog_section_def       empty_def       = {0, 0, 0};
-    int                    i               = 0;
+code_t *code_init() {
+    static prog_section_function  empty_function  = {0,0,0,0,0,0,0,{0,0,0,0,0,0,0,0}};
+    static prog_section_statement empty_statement = {0,{0},{0},{0}};
+    static prog_section_def       empty_def       = {0, 0, 0};
 
-    code_entfields = 0;
+    code_t *code       = (code_t*)mem_a(sizeof(code_t));
+    int     i          = 0;
 
-    code_string_cache = util_htnew(OPTS_OPTIMIZATION(OPTIM_OVERLAP_STRINGS) ? 0x100 : 1024);
+    memset(code, 0, sizeof(code_t));
+    code->entfields    = 0;
+    code->string_cache = util_htnew(OPTS_OPTIMIZATION(OPTIM_OVERLAP_STRINGS) ? 0x100 : 1024);
 
     /*
      * The way progs.dat is suppose to work is odd, there needs to be
      * some null (empty) statements, functions, and 28 globals
      */
     for(; i < 28; i++)
-        vec_push(code_globals, 0);
+        vec_push(code->globals, 0);
+
+    vec_push(code->chars, '\0');
+    vec_push(code->functions,  empty_function);
+
+    code_push_statement(code, &empty_statement, 0);
+
+    vec_push(code->defs,    empty_def);
+    vec_push(code->fields,  empty_def);
 
-    vec_push(code_chars, '\0');
-    vec_push(code_functions,  empty_function);
-    code_push_statement(&empty_statement, 0);
-    vec_push(code_defs,       empty_def);
-    vec_push(code_fields,     empty_def);
+    return code;
 }
 
 void *code_util_str_htgeth(hash_table_t *ht, const char *key, size_t bin);
-uint32_t code_genstring(const char *str)
+
+uint32_t code_genstring(code_t *code, const char *str)
 {
     uint32_t off;
     size_t   hash;
@@ -87,69 +82,70 @@ uint32_t code_genstring(const char *str)
         return 0;
 
     if (!*str) {
-        if (!code_string_cached_empty) {
-            code_string_cached_empty = vec_size(code_chars);
-            vec_push(code_chars, 0);
+        if (!code->string_cached_empty) {
+            code->string_cached_empty = vec_size(code->chars);
+            vec_push(code->chars, 0);
         }
-        return code_string_cached_empty;
+        return code->string_cached_empty;
     }
 
     if (OPTS_OPTIMIZATION(OPTIM_OVERLAP_STRINGS)) {
-        hash = ((unsigned char*)str)[strlen(str)-1];
-        existing = code_util_str_htgeth(code_string_cache, str, hash);
+        hash     = ((unsigned char*)str)[strlen(str)-1];
+        existing = code_util_str_htgeth(code->string_cache, str, hash);
     } else {
-        hash = util_hthash(code_string_cache, str);
-        existing = util_htgeth(code_string_cache, str, hash);
+        hash     = util_hthash(code->string_cache, str);
+        existing = util_htgeth(code->string_cache, str, hash);
     }
 
     if (existing)
         return HASH_ENTRY_TO_QCINT(existing);
 
-    off = vec_size(code_chars);
-    vec_upload(code_chars, str, strlen(str)+1);
+    off = vec_size(code->chars);
+    vec_upload(code->chars, str, strlen(str)+1);
 
-    util_htseth(code_string_cache, str, hash, QCINT_TO_HASH_ENTRY(off));
+    util_htseth(code->string_cache, str, hash, QCINT_TO_HASH_ENTRY(off));
     return off;
 }
 
-qcint code_alloc_field (size_t qcsize)
+qcint code_alloc_field (code_t *code, size_t qcsize)
 {
-    qcint pos = (qcint)code_entfields;
-    code_entfields += qcsize;
+    qcint pos = (qcint)code->entfields;
+    code->entfields += qcsize;
     return pos;
 }
 
-bool code_write(const char *filename, const char *lnofile) {
+bool code_write(code_t *code, const char *filename, const char *lnofile) {
     prog_header  code_header;
     FILE        *fp           = NULL;
     size_t       it           = 2;
 
     code_header.statements.offset = sizeof(prog_header);
-    code_header.statements.length = vec_size(code_statements);
-    code_header.defs.offset       = code_header.statements.offset + (sizeof(prog_section_statement) * vec_size(code_statements));
-    code_header.defs.length       = vec_size(code_defs);
-    code_header.fields.offset     = code_header.defs.offset       + (sizeof(prog_section_def)       * vec_size(code_defs));
-    code_header.fields.length     = vec_size(code_fields);
-    code_header.functions.offset  = code_header.fields.offset     + (sizeof(prog_section_field)     * vec_size(code_fields));
-    code_header.functions.length  = vec_size(code_functions);
-    code_header.globals.offset    = code_header.functions.offset  + (sizeof(prog_section_function)  * vec_size(code_functions));
-    code_header.globals.length    = vec_size(code_globals);
-    code_header.strings.offset    = code_header.globals.offset    + (sizeof(int32_t)                * vec_size(code_globals));
-    code_header.strings.length    = vec_size(code_chars);
+    code_header.statements.length = vec_size(code->statements);
+    code_header.defs.offset       = code_header.statements.offset + (sizeof(prog_section_statement) * vec_size(code->statements));
+    code_header.defs.length       = vec_size(code->defs);
+    code_header.fields.offset     = code_header.defs.offset       + (sizeof(prog_section_def)       * vec_size(code->defs));
+    code_header.fields.length     = vec_size(code->fields);
+    code_header.functions.offset  = code_header.fields.offset     + (sizeof(prog_section_field)     * vec_size(code->fields));
+    code_header.functions.length  = vec_size(code->functions);
+    code_header.globals.offset    = code_header.functions.offset  + (sizeof(prog_section_function)  * vec_size(code->functions));
+    code_header.globals.length    = vec_size(code->globals);
+    code_header.strings.offset    = code_header.globals.offset    + (sizeof(int32_t)                * vec_size(code->globals));
+    code_header.strings.length    = vec_size(code->chars);
     code_header.version           = 6;
+
     if (OPTS_OPTION_BOOL(OPTION_FORCECRC))
         code_header.crc16         = OPTS_OPTION_U16(OPTION_FORCED_CRC);
     else
-        code_header.crc16         = code_crc;
-    code_header.entfield          = code_entfields;
+        code_header.crc16         = code->crc;
+    code_header.entfield          = code->entfields;
 
     if (OPTS_FLAG(DARKPLACES_STRING_TABLE_BUG)) {
         util_debug("GEN", "Patching stringtable for -fdarkplaces-stringtablebug\n");
 
         /* >= + P */
-        vec_push(code_chars, '\0'); /* > */
-        vec_push(code_chars, '\0'); /* = */
-        vec_push(code_chars, '\0'); /* P */
+        vec_push(code->chars, '\0'); /* > */
+        vec_push(code->chars, '\0'); /* = */
+        vec_push(code->chars, '\0'); /* P */
     }
 
     /* ensure all data is in LE format */
@@ -162,11 +158,11 @@ bool code_write(const char *filename, const char *lnofile) {
     util_endianswap(&code_header.strings,    2, sizeof(code_header.statements.offset));
     util_endianswap(&code_header.globals,    2, sizeof(code_header.statements.offset));
     util_endianswap(&code_header.entfield,   1, sizeof(code_header.entfield));
-    util_endianswap(code_statements, vec_size(code_statements), sizeof(prog_section_statement));
-    util_endianswap(code_defs,       vec_size(code_defs),       sizeof(prog_section_def));
-    util_endianswap(code_fields,     vec_size(code_fields),     sizeof(prog_section_field));
-    util_endianswap(code_functions,  vec_size(code_functions),  sizeof(prog_section_function));
-    util_endianswap(code_globals,    vec_size(code_globals),    sizeof(int32_t));
+    util_endianswap(code->statements, vec_size(code->statements), sizeof(prog_section_statement));
+    util_endianswap(code->defs,       vec_size(code->defs),       sizeof(prog_section_def));
+    util_endianswap(code->fields,     vec_size(code->fields),     sizeof(prog_section_field));
+    util_endianswap(code->functions,  vec_size(code->functions),  sizeof(prog_section_function));
+    util_endianswap(code->globals,    vec_size(code->globals),    sizeof(int32_t));
 
     if (lnofile) {
         uint32_t version = 1;
@@ -175,17 +171,17 @@ bool code_write(const char *filename, const char *lnofile) {
         if (!fp)
             return false;
 
-        util_endianswap(&version,      1,                       sizeof(version));
-        util_endianswap(code_linenums, vec_size(code_linenums), sizeof(code_linenums[0]));
+        util_endianswap(&version,      1,                         sizeof(version));
+        util_endianswap(code->linenums, vec_size(code->linenums), sizeof(code->linenums[0]));
 
 
-        if (fs_file_write("LNOF",                          4,                                      1,                       fp) != 1 ||
-            fs_file_write(&version,                        sizeof(version),                        1,                       fp) != 1 ||
-            fs_file_write(&code_header.defs.length,        sizeof(code_header.defs.length),        1,                       fp) != 1 ||
-            fs_file_write(&code_header.globals.length,     sizeof(code_header.globals.length),     1,                       fp) != 1 ||
-            fs_file_write(&code_header.fields.length,      sizeof(code_header.fields.length),      1,                       fp) != 1 ||
-            fs_file_write(&code_header.statements.length,  sizeof(code_header.statements.length),  1,                       fp) != 1 ||
-            fs_file_write(code_linenums,                   sizeof(code_linenums[0]),               vec_size(code_linenums), fp) != vec_size(code_linenums))
+        if (fs_file_write("LNOF",                           4,                                       1,                        fp) != 1 ||
+            fs_file_write(&version,                         sizeof(version),                         1,                        fp) != 1 ||
+            fs_file_write(&code_header.defs.length,        sizeof(code_header.defs.length),        1,                        fp) != 1 ||
+            fs_file_write(&code_header.globals.length,     sizeof(code_header.globals.length),     1,                        fp) != 1 ||
+            fs_file_write(&code_header.fields.length,      sizeof(code_header.fields.length),      1,                        fp) != 1 ||
+            fs_file_write(&code_header.statements.length,  sizeof(code_header.statements.length),  1,                        fp) != 1 ||
+            fs_file_write(code->linenums,                   sizeof(code->linenums[0]),               vec_size(code->linenums), fp) != vec_size(code->linenums))
         {
             con_err("failed to write lno file\n");
         }
@@ -198,13 +194,13 @@ bool code_write(const char *filename, const char *lnofile) {
     if (!fp)
         return false;
 
-    if (1                         != fs_file_write(&code_header,    sizeof(prog_header)           , 1                        , fp) ||
-        vec_size(code_statements) != fs_file_write(code_statements, sizeof(prog_section_statement), vec_size(code_statements), fp) ||
-        vec_size(code_defs)       != fs_file_write(code_defs,       sizeof(prog_section_def)      , vec_size(code_defs)      , fp) ||
-        vec_size(code_fields)     != fs_file_write(code_fields,     sizeof(prog_section_field)    , vec_size(code_fields)    , fp) ||
-        vec_size(code_functions)  != fs_file_write(code_functions,  sizeof(prog_section_function) , vec_size(code_functions) , fp) ||
-        vec_size(code_globals)    != fs_file_write(code_globals,    sizeof(int32_t)               , vec_size(code_globals)   , fp) ||
-        vec_size(code_chars)      != fs_file_write(code_chars,      1                             , vec_size(code_chars)     , fp))
+    if (1                          != fs_file_write(&code_header,    sizeof(prog_header)           , 1                         , fp) ||
+        vec_size(code->statements) != fs_file_write(code->statements, sizeof(prog_section_statement), vec_size(code->statements), fp) ||
+        vec_size(code->defs)       != fs_file_write(code->defs,       sizeof(prog_section_def)      , vec_size(code->defs)      , fp) ||
+        vec_size(code->fields)     != fs_file_write(code->fields,     sizeof(prog_section_field)    , vec_size(code->fields)    , fp) ||
+        vec_size(code->functions)  != fs_file_write(code->functions,  sizeof(prog_section_function) , vec_size(code->functions) , fp) ||
+        vec_size(code->globals)    != fs_file_write(code->globals,    sizeof(int32_t)               , vec_size(code->globals)   , fp) ||
+        vec_size(code->chars)      != fs_file_write(code->chars,      1                             , vec_size(code->chars)     , fp))
     {
         fs_file_close(fp);
         return false;
@@ -223,37 +219,37 @@ bool code_write(const char *filename, const char *lnofile) {
 
     /* FUNCTIONS */
     util_debug("GEN", "FUNCTIONS:\n");
-    for (; it < vec_size(code_functions); it++) {
-        size_t j = code_functions[it].entry;
+    for (; it < vec_size(code->functions); it++) {
+        size_t j = code->functions[it].entry;
         util_debug("GEN", "    {.entry =% 5d, .firstlocal =% 5d, .locals =% 5d, .profile =% 5d, .name =% 5d, .file =% 5d, .nargs =% 5d, .argsize ={%d,%d,%d,%d,%d,%d,%d,%d} }\n",
-            code_functions[it].entry,
-            code_functions[it].firstlocal,
-            code_functions[it].locals,
-            code_functions[it].profile,
-            code_functions[it].name,
-            code_functions[it].file,
-            code_functions[it].nargs,
-            code_functions[it].argsize[0],
-            code_functions[it].argsize[1],
-            code_functions[it].argsize[2],
-            code_functions[it].argsize[3],
-            code_functions[it].argsize[4],
-            code_functions[it].argsize[5],
-            code_functions[it].argsize[6],
-            code_functions[it].argsize[7]
+            code->functions[it].entry,
+            code->functions[it].firstlocal,
+            code->functions[it].locals,
+            code->functions[it].profile,
+            code->functions[it].name,
+            code->functions[it].file,
+            code->functions[it].nargs,
+            code->functions[it].argsize[0],
+            code->functions[it].argsize[1],
+            code->functions[it].argsize[2],
+            code->functions[it].argsize[3],
+            code->functions[it].argsize[4],
+            code->functions[it].argsize[5],
+            code->functions[it].argsize[6],
+            code->functions[it].argsize[7]
 
         );
-        util_debug("GEN", "    NAME: %s\n", &code_chars[code_functions[it].name]);
+        util_debug("GEN", "    NAME: %s\n", &code->chars[code->functions[it].name]);
         /* Internal functions have no code */
-        if (code_functions[it].entry >= 0) {
+        if (code->functions[it].entry >= 0) {
             util_debug("GEN", "    CODE:\n");
             for (;;) {
-                if (code_statements[j].opcode != INSTR_DONE)
+                if (code->statements[j].opcode != INSTR_DONE)
                     util_debug("GEN", "        %-12s {% 5i,% 5i,% 5i}\n",
-                        asm_instr[code_statements[j].opcode].m,
-                        code_statements[j].o1.s1,
-                        code_statements[j].o2.s1,
-                        code_statements[j].o3.s1
+                        asm_instr[code->statements[j].opcode].m,
+                        code->statements[j].o1.s1,
+                        code->statements[j].o2.s1,
+                        code->statements[j].o3.s1
                     );
                 else {
                     util_debug("GEN", "        DONE  {0x00000,0x00000,0x00000}\n");
@@ -264,15 +260,17 @@ bool code_write(const char *filename, const char *lnofile) {
         }
     }
 
-    vec_free(code_statements);
-    vec_free(code_linenums);
-    vec_free(code_defs);
-    vec_free(code_fields);
-    vec_free(code_functions);
-    vec_free(code_globals);
-    vec_free(code_chars);
-    util_htdel(code_string_cache);
+    vec_free(code->statements);
+    vec_free(code->linenums);
+    vec_free(code->defs);
+    vec_free(code->fields);
+    vec_free(code->functions);
+    vec_free(code->globals);
+    vec_free(code->chars);
+
+    util_htdel(code->string_cache);
 
     fs_file_close(fp);
+    mem_d(code);
     return true;
 }
diff --git a/gmqcc.h b/gmqcc.h
index b3ba81782320d517ad4e6976416d3530fd8e6bbb..bea5cf19893fe3904bf3e7933a6bef30bc03b514 100644 (file)
--- a/gmqcc.h
+++ b/gmqcc.h
@@ -703,32 +703,38 @@ enum {
     VINSTR_NRCALL
 };
 
-/* TODO: cleanup this mess */
-extern prog_section_statement *code_statements;
-extern int                    *code_linenums;
-extern prog_section_def       *code_defs;
-extern prog_section_field     *code_fields;
-extern prog_section_function  *code_functions;
-extern int                    *code_globals;
-extern char                   *code_chars;
-extern uint16_t code_crc;
-
 /* uhh? */
 typedef float   qcfloat;
 typedef int32_t qcint;
 
+typedef struct {
+    prog_section_statement *statements;
+    int                    *linenums;
+    prog_section_def       *defs;
+    prog_section_field     *fields;
+    prog_section_function  *functions;
+    int                    *globals;
+    char                   *chars;
+    uint16_t                crc;
+    uint32_t                entfields;
+    ht                      string_cache;
+    qcint                   string_cached_empty;
+} code_t;
+
 /*
- * code_write -- writes out the compiled file
- * code_init  -- prepares the code file
+ * code_write          -- writes out the compiled file
+ * code_init           -- prepares the code file
+ * code_genstrin       -- generates string for code
+ * code_alloc_field    -- allocated a field
+ * code_push_statement -- keeps statements and linenumbers together
+ * code_pop_statement  -- keeps statements and linenumbers together 
  */
-bool     code_write       (const char *filename, const char *lno);
-void     code_init        ();
-uint32_t code_genstring   (const char *string);
-qcint    code_alloc_field (size_t qcsize);
-
-/* this function is used to keep statements and linenumbers together */
-void     code_push_statement(prog_section_statement *stmt, int linenum);
-void     code_pop_statement();
+bool      code_write         (code_t *, const char *filename, const char *lno);
+code_t   *code_init          (void);
+uint32_t  code_genstring     (code_t *, const char *string);
+qcint     code_alloc_field   (code_t *, size_t qcsize);
+void      code_push_statement(code_t *, prog_section_statement *stmt, int linenum);
+void      code_pop_statement (code_t *);
 
 /*
  * A shallow copy of a lex_file to remember where which ast node
diff --git a/ir.c b/ir.c
index 40094edfffdb9cf0febe0a36db3dd3cc157395dc..82dcb9befaf578f2c6d671a41ef88ac7fe6c3644 100644 (file)
--- a/ir.c
+++ b/ir.c
@@ -212,7 +212,7 @@ const uint16_t type_not_instr[TYPE_COUNT] = {
 
 /* protos */
 static ir_value* ir_gen_extparam_proto(ir_builder *ir);
-static void      ir_gen_extparam      (ir_builder *ir);
+static void      ir_gen_extparam      (code_t *, ir_builder *ir);
 
 /* error functions */
 
@@ -2618,9 +2618,9 @@ bool ir_function_calculate_liferanges(ir_function *self)
  *
  * Breaking conventions is annoying...
  */
-static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal);
+static bool ir_builder_gen_global(code_t *, ir_builder *self, ir_value *global, bool islocal);
 
-static bool gen_global_field(ir_value *global)
+static bool gen_global_field(code_t *code, ir_value *global)
 {
     if (global->hasvalue)
     {
@@ -2631,20 +2631,20 @@ static bool gen_global_field(ir_value *global)
         }
 
         /* copy the field's value */
-        ir_value_code_setaddr(global, vec_size(code_globals));
-        vec_push(code_globals, fld->code.fieldaddr);
+        ir_value_code_setaddr(global, vec_size(code->globals));
+        vec_push(code->globals, fld->code.fieldaddr);
         if (global->fieldtype == TYPE_VECTOR) {
-            vec_push(code_globals, fld->code.fieldaddr+1);
-            vec_push(code_globals, fld->code.fieldaddr+2);
+            vec_push(code->globals, fld->code.fieldaddr+1);
+            vec_push(code->globals, fld->code.fieldaddr+2);
         }
     }
     else
     {
-        ir_value_code_setaddr(global, vec_size(code_globals));
-        vec_push(code_globals, 0);
+        ir_value_code_setaddr(global, vec_size(code->globals));
+        vec_push(code->globals, 0);
         if (global->fieldtype == TYPE_VECTOR) {
-            vec_push(code_globals, 0);
-            vec_push(code_globals, 0);
+            vec_push(code->globals, 0);
+            vec_push(code->globals, 0);
         }
     }
     if (global->code.globaladdr < 0)
@@ -2652,7 +2652,7 @@ static bool gen_global_field(ir_value *global)
     return true;
 }
 
-static bool gen_global_pointer(ir_value *global)
+static bool gen_global_pointer(code_t *code, ir_value *global)
 {
     if (global->hasvalue)
     {
@@ -2678,20 +2678,20 @@ static bool gen_global_pointer(ir_value *global)
             return false;
         }
 
-        ir_value_code_setaddr(global, vec_size(code_globals));
-        vec_push(code_globals, target->code.globaladdr);
+        ir_value_code_setaddr(global, vec_size(code->globals));
+        vec_push(code->globals, target->code.globaladdr);
     }
     else
     {
-        ir_value_code_setaddr(global, vec_size(code_globals));
-        vec_push(code_globals, 0);
+        ir_value_code_setaddr(global, vec_size(code->globals));
+        vec_push(code->globals, 0);
     }
     if (global->code.globaladdr < 0)
         return false;
     return true;
 }
 
-static bool gen_blocks_recursive(ir_function *func, ir_block *block)
+static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *block)
 {
     prog_section_statement stmt;
     ir_instr *instr;
@@ -2702,7 +2702,7 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
     size_t    i;
 
     block->generated = true;
-    block->code_start = vec_size(code_statements);
+    block->code_start = vec_size(code->statements);
     for (i = 0; i < vec_size(block->instr); ++i)
     {
         instr = block->instr[i];
@@ -2718,15 +2718,15 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
              * yet, we generate them right here.
              */
             if (!target->generated)
-                return gen_blocks_recursive(func, target);
+                return gen_blocks_recursive(code, func, target);
 
             /* otherwise we generate a jump instruction */
             stmt.opcode = INSTR_GOTO;
-            stmt.o1.s1 = (target->code_start) - vec_size(code_statements);
+            stmt.o1.s1 = (target->code_start) - vec_size(code->statements);
             stmt.o2.s1 = 0;
             stmt.o3.s1 = 0;
             if (stmt.o1.s1 != 1)
-                code_push_statement(&stmt, instr->context.line);
+                code_push_statement(code, &stmt, instr->context.line);
 
             /* no further instructions can be in this block */
             return true;
@@ -2745,23 +2745,23 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
 
             if (ontrue->generated) {
                 stmt.opcode = INSTR_IF;
-                stmt.o2.s1 = (ontrue->code_start) - vec_size(code_statements);
+                stmt.o2.s1 = (ontrue->code_start) - vec_size(code->statements);
                 if (stmt.o2.s1 != 1)
-                    code_push_statement(&stmt, instr->context.line);
+                    code_push_statement(code, &stmt, instr->context.line);
             }
             if (onfalse->generated) {
                 stmt.opcode = INSTR_IFNOT;
-                stmt.o2.s1 = (onfalse->code_start) - vec_size(code_statements);
+                stmt.o2.s1 = (onfalse->code_start) - vec_size(code->statements);
                 if (stmt.o2.s1 != 1)
-                    code_push_statement(&stmt, instr->context.line);
+                    code_push_statement(code, &stmt, instr->context.line);
             }
             if (!ontrue->generated) {
                 if (onfalse->generated)
-                    return gen_blocks_recursive(func, ontrue);
+                    return gen_blocks_recursive(code, func, ontrue);
             }
             if (!onfalse->generated) {
                 if (ontrue->generated)
-                    return gen_blocks_recursive(func, onfalse);
+                    return gen_blocks_recursive(code, func, onfalse);
             }
             /* neither ontrue nor onfalse exist */
             stmt.opcode = INSTR_IFNOT;
@@ -2772,24 +2772,24 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
                 onfalse = ontrue;
                 ontrue = tmp;
             }
-            stidx = vec_size(code_statements);
-            code_push_statement(&stmt, instr->context.line);
+            stidx = vec_size(code->statements);
+            code_push_statement(code, &stmt, instr->context.line);
             /* on false we jump, so add ontrue-path */
-            if (!gen_blocks_recursive(func, ontrue))
+            if (!gen_blocks_recursive(code, func, ontrue))
                 return false;
             /* fixup the jump address */
-            code_statements[stidx].o2.s1 = vec_size(code_statements) - stidx;
+            code->statements[stidx].o2.s1 = vec_size(code->statements) - stidx;
             /* generate onfalse path */
             if (onfalse->generated) {
                 /* fixup the jump address */
-                code_statements[stidx].o2.s1 = (onfalse->code_start) - (stidx);
-                if (stidx+2 == vec_size(code_statements) && code_statements[stidx].o2.s1 == 1) {
-                    code_statements[stidx] = code_statements[stidx+1];
-                    if (code_statements[stidx].o1.s1 < 0)
-                        code_statements[stidx].o1.s1++;
-                    code_pop_statement();
+                code->statements[stidx].o2.s1 = (onfalse->code_start) - (stidx);
+                if (stidx+2 == vec_size(code->statements) && code->statements[stidx].o2.s1 == 1) {
+                    code->statements[stidx] = code->statements[stidx+1];
+                    if (code->statements[stidx].o1.s1 < 0)
+                        code->statements[stidx].o1.s1++;
+                    code_pop_statement(code);
                 }
-                stmt.opcode = vec_last(code_statements).opcode;
+                stmt.opcode = vec_last(code->statements).opcode;
                 if (stmt.opcode == INSTR_GOTO ||
                     stmt.opcode == INSTR_IF ||
                     stmt.opcode == INSTR_IFNOT ||
@@ -2801,21 +2801,21 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
                 }
                 /* may have been generated in the previous recursive call */
                 stmt.opcode = INSTR_GOTO;
-                stmt.o1.s1 = (onfalse->code_start) - vec_size(code_statements);
+                stmt.o1.s1 = (onfalse->code_start) - vec_size(code->statements);
                 stmt.o2.s1 = 0;
                 stmt.o3.s1 = 0;
                 if (stmt.o1.s1 != 1)
-                    code_push_statement(&stmt, instr->context.line);
+                    code_push_statement(code, &stmt, instr->context.line);
                 return true;
             }
-            else if (stidx+2 == vec_size(code_statements) && code_statements[stidx].o2.s1 == 1) {
-                code_statements[stidx] = code_statements[stidx+1];
-                if (code_statements[stidx].o1.s1 < 0)
-                    code_statements[stidx].o1.s1++;
-                code_pop_statement();
+            else if (stidx+2 == vec_size(code->statements) && code->statements[stidx].o2.s1 == 1) {
+                code->statements[stidx] = code->statements[stidx+1];
+                if (code->statements[stidx].o1.s1 < 0)
+                    code->statements[stidx].o1.s1++;
+                code_pop_statement(code);
             }
             /* if not, generate now */
-            return gen_blocks_recursive(func, onfalse);
+            return gen_blocks_recursive(code, func, onfalse);
         }
 
         if ( (instr->opcode >= INSTR_CALL0 && instr->opcode <= INSTR_CALL8)
@@ -2844,7 +2844,7 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
                     stmt.opcode = type_store_instr[param->vtype];
                 stmt.o1.u1 = ir_value_code_addr(param);
                 stmt.o2.u1 = OFS_PARM0 + 3 * p;
-                code_push_statement(&stmt, instr->context.line);
+                code_push_statement(code, &stmt, instr->context.line);
             }
             /* Now handle extparams */
             first = vec_size(instr->params);
@@ -2858,7 +2858,7 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
                     continue;
 
                 if (p-8 >= vec_size(ir->extparams))
-                    ir_gen_extparam(ir);
+                    ir_gen_extparam(code, ir);
 
                 targetparam = ir->extparams[p-8];
 
@@ -2873,7 +2873,7 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
                     stmt.opcode = type_store_instr[param->vtype];
                 stmt.o1.u1 = ir_value_code_addr(param);
                 stmt.o2.u1 = ir_value_code_addr(targetparam);
-                code_push_statement(&stmt, instr->context.line);
+                code_push_statement(code, &stmt, instr->context.line);
             }
 
             stmt.opcode = INSTR_CALL0 + vec_size(instr->params);
@@ -2882,7 +2882,7 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
             stmt.o1.u1 = ir_value_code_addr(instr->_ops[1]);
             stmt.o2.u1 = 0;
             stmt.o3.u1 = 0;
-            code_push_statement(&stmt, instr->context.line);
+            code_push_statement(code, &stmt, instr->context.line);
 
             retvalue = instr->_ops[0];
             if (retvalue && retvalue->store != store_return &&
@@ -2896,7 +2896,7 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
                 stmt.o1.u1 = OFS_RETURN;
                 stmt.o2.u1 = ir_value_code_addr(retvalue);
                 stmt.o3.u1 = 0;
-                code_push_statement(&stmt, instr->context.line);
+                code_push_statement(code, &stmt, instr->context.line);
             }
             continue;
         }
@@ -2946,12 +2946,12 @@ static bool gen_blocks_recursive(ir_function *func, ir_block *block)
             }
         }
 
-        code_push_statement(&stmt, instr->context.line);
+        code_push_statement(code, &stmt, instr->context.line);
     }
     return true;
 }
 
-static bool gen_function_code(ir_function *self)
+static bool gen_function_code(code_t *code, ir_function *self)
 {
     ir_block *block;
     prog_section_statement stmt, *retst;
@@ -2968,13 +2968,13 @@ static bool gen_function_code(ir_function *self)
     if (block->generated)
         return true;
 
-    if (!gen_blocks_recursive(self, block)) {
+    if (!gen_blocks_recursive(code, self, block)) {
         irerror(self->context, "failed to generate blocks for '%s'", self->name);
         return false;
     }
 
     /* code_write and qcvm -disasm need to know that the function ends here */
-    retst = &vec_last(code_statements);
+    retst = &vec_last(code->statements);
     if (OPTS_OPTIMIZATION(OPTIM_VOID_RETURN) &&
         self->outtype == TYPE_VOID &&
         retst->opcode == INSTR_RETURN &&
@@ -2987,12 +2987,12 @@ static bool gen_function_code(ir_function *self)
         stmt.o1.u1 = 0;
         stmt.o2.u1 = 0;
         stmt.o3.u1 = 0;
-        code_push_statement(&stmt, vec_last(code_linenums));
+        code_push_statement(code, &stmt, vec_last(code->linenums));
     }
     return true;
 }
 
-static qcint ir_builder_filestring(ir_builder *ir, const char *filename)
+static qcint ir_builder_filestring(code_t *code, ir_builder *ir, const char *filename)
 {
     /* NOTE: filename pointers are copied, we never strdup them,
      * thus we can use pointer-comparison to find the string.
@@ -3005,13 +3005,13 @@ static qcint ir_builder_filestring(ir_builder *ir, const char *filename)
             return ir->filestrings[i];
     }
 
-    str = code_genstring(filename);
+    str = code_genstring(code, filename);
     vec_push(ir->filenames, filename);
     vec_push(ir->filestrings, str);
     return str;
 }
 
-static bool gen_global_function(ir_builder *ir, ir_value *global)
+static bool gen_global_function(code_t *code, ir_builder *ir, ir_value *global)
 {
     prog_section_function fun;
     ir_function          *irfun;
@@ -3027,7 +3027,7 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
     irfun = global->constval.vfunc;
 
     fun.name    = global->code.name;
-    fun.file    = ir_builder_filestring(ir, global->context.file);
+    fun.file    = ir_builder_filestring(code, ir, global->context.file);
     fun.profile = 0; /* always 0 */
     fun.nargs   = vec_size(irfun->params);
     if (fun.nargs > 8)
@@ -3046,11 +3046,11 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
     if (irfun->builtin)
         fun.entry = irfun->builtin+1;
     else {
-        irfun->code_function_def = vec_size(code_functions);
-        fun.entry = vec_size(code_statements);
+        irfun->code_function_def = vec_size(code->functions);
+        fun.entry                = vec_size(code->statements);
     }
 
-    vec_push(code_functions, fun);
+    vec_push(code->functions, fun);
     return true;
 }
 
@@ -3066,7 +3066,7 @@ static ir_value* ir_gen_extparam_proto(ir_builder *ir)
     return global;
 }
 
-static void ir_gen_extparam(ir_builder *ir)
+static void ir_gen_extparam(code_t *code, ir_builder *ir)
 {
     prog_section_def def;
     ir_value        *global;
@@ -3076,20 +3076,22 @@ static void ir_gen_extparam(ir_builder *ir)
     else
         global = ir->extparam_protos[vec_size(ir->extparams)];
 
-    def.name = code_genstring(global->name);
-    def.type = TYPE_VECTOR;
-    def.offset = vec_size(code_globals);
+    def.name   = code_genstring(code, global->name);
+    def.type   = TYPE_VECTOR;
+    def.offset = vec_size(code->globals);
+
+    vec_push(code->defs, def);
 
-    vec_push(code_defs, def);
     ir_value_code_setaddr(global, def.offset);
-    vec_push(code_globals, 0);
-    vec_push(code_globals, 0);
-    vec_push(code_globals, 0);
+
+    vec_push(code->globals, 0);
+    vec_push(code->globals, 0);
+    vec_push(code->globals, 0);
 
     vec_push(ir->extparams, global);
 }
 
-static bool gen_function_extparam_copy(ir_function *self)
+static bool gen_function_extparam_copy(code_t *code, ir_function *self)
 {
     size_t i, ext, numparams;
 
@@ -3106,7 +3108,7 @@ static bool gen_function_extparam_copy(ir_function *self)
     for (i = 8; i < numparams; ++i) {
         ext = i - 8;
         if (ext >= vec_size(ir->extparams))
-            ir_gen_extparam(ir);
+            ir_gen_extparam(code, ir);
 
         ep = ir->extparams[ext];
 
@@ -3118,13 +3120,13 @@ static bool gen_function_extparam_copy(ir_function *self)
         }
         stmt.o1.u1 = ir_value_code_addr(ep);
         stmt.o2.u1 = ir_value_code_addr(self->locals[i]);
-        code_push_statement(&stmt, self->context.line);
+        code_push_statement(code, &stmt, self->context.line);
     }
 
     return true;
 }
 
-static bool gen_function_varargs_copy(ir_function *self)
+static bool gen_function_varargs_copy(code_t *code, ir_function *self)
 {
     size_t i, ext, numparams, maxparams;
 
@@ -3143,24 +3145,24 @@ static bool gen_function_varargs_copy(ir_function *self)
         if (i < 8) {
             stmt.o1.u1 = OFS_PARM0 + 3*i;
             stmt.o2.u1 = ir_value_code_addr(self->locals[i]);
-            code_push_statement(&stmt, self->context.line);
+            code_push_statement(code, &stmt, self->context.line);
             continue;
         }
         ext = i - 8;
         while (ext >= vec_size(ir->extparams))
-            ir_gen_extparam(ir);
+            ir_gen_extparam(code, ir);
 
         ep = ir->extparams[ext];
 
         stmt.o1.u1 = ir_value_code_addr(ep);
         stmt.o2.u1 = ir_value_code_addr(self->locals[i]);
-        code_push_statement(&stmt, self->context.line);
+        code_push_statement(code, &stmt, self->context.line);
     }
 
     return true;
 }
 
-static bool gen_function_locals(ir_builder *ir, ir_value *global)
+static bool gen_function_locals(code_t *code, ir_builder *ir, ir_value *global)
 {
     prog_section_function *def;
     ir_function           *irfun;
@@ -3168,13 +3170,13 @@ static bool gen_function_locals(ir_builder *ir, ir_value *global)
     uint32_t               firstlocal, firstglobal;
 
     irfun = global->constval.vfunc;
-    def   = code_functions + irfun->code_function_def;
+    def   = code->functions + irfun->code_function_def;
 
     if (OPTS_OPTION_BOOL(OPTION_G) ||
         !OPTS_OPTIMIZATION(OPTIM_OVERLAP_LOCALS)        ||
         (irfun->flags & IR_FLAG_MASK_NO_OVERLAP))
     {
-        firstlocal = def->firstlocal = vec_size(code_globals);
+        firstlocal = def->firstlocal = vec_size(code->globals);
     } else {
         firstlocal = def->firstlocal = ir->first_common_local;
         ++opts_optimizationcount[OPTIM_OVERLAP_LOCALS];
@@ -3182,13 +3184,13 @@ static bool gen_function_locals(ir_builder *ir, ir_value *global)
 
     firstglobal = (OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS) ? ir->first_common_globaltemp : firstlocal);
 
-    for (i = vec_size(code_globals); i < firstlocal + irfun->allocated_locals; ++i)
-        vec_push(code_globals, 0);
+    for (i = vec_size(code->globals); i < firstlocal + irfun->allocated_locals; ++i)
+        vec_push(code->globals, 0);
     for (i = 0; i < vec_size(irfun->locals); ++i) {
         ir_value *v = irfun->locals[i];
         if (v->locked || !OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS)) {
             ir_value_code_setaddr(v, firstlocal + v->code.local);
-            if (!ir_builder_gen_global(ir, irfun->locals[i], true)) {
+            if (!ir_builder_gen_global(code, ir, irfun->locals[i], true)) {
                 irerror(irfun->locals[i]->context, "failed to generate local %s", irfun->locals[i]->name);
                 return false;
             }
@@ -3209,7 +3211,7 @@ static bool gen_function_locals(ir_builder *ir, ir_value *global)
     return true;
 }
 
-static bool gen_global_function_code(ir_builder *ir, ir_value *global)
+static bool gen_global_function_code(code_t *code, ir_builder *ir, ir_value *global)
 {
     prog_section_function *fundef;
     ir_function           *irfun;
@@ -3233,29 +3235,29 @@ static bool gen_global_function_code(ir_builder *ir, ir_value *global)
         irerror(irfun->context, "`%s`: IR global wasn't generated, failed to access function-def", irfun->name);
         return false;
     }
-    fundef = &code_functions[irfun->code_function_def];
+    fundef = &code->functions[irfun->code_function_def];
 
-    fundef->entry = vec_size(code_statements);
-    if (!gen_function_locals(ir, global)) {
+    fundef->entry = vec_size(code->statements);
+    if (!gen_function_locals(code, ir, global)) {
         irerror(irfun->context, "Failed to generate locals for function %s", irfun->name);
         return false;
     }
-    if (!gen_function_extparam_copy(irfun)) {
+    if (!gen_function_extparam_copy(code, irfun)) {
         irerror(irfun->context, "Failed to generate extparam-copy code for function %s", irfun->name);
         return false;
     }
-    if (irfun->max_varargs && !gen_function_varargs_copy(irfun)) {
+    if (irfun->max_varargs && !gen_function_varargs_copy(code, irfun)) {
         irerror(irfun->context, "Failed to generate vararg-copy code for function %s", irfun->name);
         return false;
     }
-    if (!gen_function_code(irfun)) {
+    if (!gen_function_code(code, irfun)) {
         irerror(irfun->context, "Failed to generate code for function %s", irfun->name);
         return false;
     }
     return true;
 }
 
-static void gen_vector_defs(prog_section_def def, const char *name)
+static void gen_vector_defs(code_t *code, prog_section_def def, const char *name)
 {
     char  *component;
     size_t len, i;
@@ -3276,8 +3278,8 @@ static void gen_vector_defs(prog_section_def def, const char *name)
     component[len-1] = 'x';
 
     for (i = 0; i < 3; ++i) {
-        def.name = code_genstring(component);
-        vec_push(code_defs, def);
+        def.name = code_genstring(code, component);
+        vec_push(code->defs, def);
         def.offset++;
         component[len-1]++;
     }
@@ -3285,7 +3287,7 @@ static void gen_vector_defs(prog_section_def def, const char *name)
     mem_d(component);
 }
 
-static void gen_vector_fields(prog_section_field fld, const char *name)
+static void gen_vector_fields(code_t *code, prog_section_field fld, const char *name)
 {
     char  *component;
     size_t len, i;
@@ -3306,8 +3308,8 @@ static void gen_vector_fields(prog_section_field fld, const char *name)
     component[len-1] = 'x';
 
     for (i = 0; i < 3; ++i) {
-        fld.name = code_genstring(component);
-        vec_push(code_fields, fld);
+        fld.name = code_genstring(code, component);
+        vec_push(code->fields, fld);
         fld.offset++;
         component[len-1]++;
     }
@@ -3315,7 +3317,7 @@ static void gen_vector_fields(prog_section_field fld, const char *name)
     mem_d(component);
 }
 
-static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal)
+static bool ir_builder_gen_global(code_t *code, ir_builder *self, ir_value *global, bool islocal)
 {
     size_t           i;
     int32_t         *iptr;
@@ -3323,7 +3325,7 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
     bool             pushdef = opts.optimizeoff;
 
     def.type   = global->vtype;
-    def.offset = vec_size(code_globals);
+    def.offset = vec_size(code->globals);
     def.name   = 0;
     if (OPTS_OPTION_BOOL(OPTION_G) || !islocal)
     {
@@ -3339,21 +3341,21 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
         if (pushdef && global->name) {
             if (global->name[0] == '#') {
                 if (!self->str_immediate)
-                    self->str_immediate = code_genstring("IMMEDIATE");
+                    self->str_immediate = code_genstring(code, "IMMEDIATE");
                 def.name = global->code.name = self->str_immediate;
             }
             else
-                def.name = global->code.name = code_genstring(global->name);
+                def.name = global->code.name = code_genstring(code, global->name);
         }
         else
             def.name   = 0;
         if (islocal) {
             def.offset = ir_value_code_addr(global);
-            vec_push(code_defs, def);
+            vec_push(code->defs, def);
             if (global->vtype == TYPE_VECTOR)
-                gen_vector_defs(def, global->name);
+                gen_vector_defs(code, def, global->name);
             else if (global->vtype == TYPE_FIELD && global->fieldtype == TYPE_VECTOR)
-                gen_vector_defs(def, global->name);
+                gen_vector_defs(code, def, global->name);
             return true;
         }
     }
@@ -3380,102 +3382,102 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
          * Maybe this could be an -foption
          * fteqcc creates data for end_sys_* - of size 1, so let's do the same
          */
-        ir_value_code_setaddr(global, vec_size(code_globals));
-        vec_push(code_globals, 0);
+        ir_value_code_setaddr(global, vec_size(code->globals));
+        vec_push(code->globals, 0);
         /* Add the def */
-        if (pushdef) vec_push(code_defs, def);
+        if (pushdef) vec_push(code->defs, def);
         return true;
     case TYPE_POINTER:
-        if (pushdef) vec_push(code_defs, def);
-        return gen_global_pointer(global);
+        if (pushdef) vec_push(code->defs, def);
+        return gen_global_pointer(code, global);
     case TYPE_FIELD:
         if (pushdef) {
-            vec_push(code_defs, def);
+            vec_push(code->defs, def);
             if (global->fieldtype == TYPE_VECTOR)
-                gen_vector_defs(def, global->name);
+                gen_vector_defs(code, def, global->name);
         }
-        return gen_global_field(global);
+        return gen_global_field(code, global);
     case TYPE_ENTITY:
         /* fall through */
     case TYPE_FLOAT:
     {
-        ir_value_code_setaddr(global, vec_size(code_globals));
+        ir_value_code_setaddr(global, vec_size(code->globals));
         if (global->hasvalue) {
             iptr = (int32_t*)&global->constval.ivec[0];
-            vec_push(code_globals, *iptr);
+            vec_push(code->globals, *iptr);
         } else {
-            vec_push(code_globals, 0);
+            vec_push(code->globals, 0);
         }
         if (!islocal && global->cvq != CV_CONST)
             def.type |= DEF_SAVEGLOBAL;
-        if (pushdef) vec_push(code_defs, def);
+        if (pushdef) vec_push(code->defs, def);
 
         return global->code.globaladdr >= 0;
     }
     case TYPE_STRING:
     {
-        ir_value_code_setaddr(global, vec_size(code_globals));
+        ir_value_code_setaddr(global, vec_size(code->globals));
         if (global->hasvalue) {
-            vec_push(code_globals, code_genstring(global->constval.vstring));
+            vec_push(code->globals, code_genstring(code, global->constval.vstring));
         } else {
-            vec_push(code_globals, 0);
+            vec_push(code->globals, 0);
         }
         if (!islocal && global->cvq != CV_CONST)
             def.type |= DEF_SAVEGLOBAL;
-        if (pushdef) vec_push(code_defs, def);
+        if (pushdef) vec_push(code->defs, def);
         return global->code.globaladdr >= 0;
     }
     case TYPE_VECTOR:
     {
         size_t d;
-        ir_value_code_setaddr(global, vec_size(code_globals));
+        ir_value_code_setaddr(global, vec_size(code->globals));
         if (global->hasvalue) {
             iptr = (int32_t*)&global->constval.ivec[0];
-            vec_push(code_globals, iptr[0]);
+            vec_push(code->globals, iptr[0]);
             if (global->code.globaladdr < 0)
                 return false;
             for (d = 1; d < type_sizeof_[global->vtype]; ++d) {
-                vec_push(code_globals, iptr[d]);
+                vec_push(code->globals, iptr[d]);
             }
         } else {
-            vec_push(code_globals, 0);
+            vec_push(code->globals, 0);
             if (global->code.globaladdr < 0)
                 return false;
             for (d = 1; d < type_sizeof_[global->vtype]; ++d) {
-                vec_push(code_globals, 0);
+                vec_push(code->globals, 0);
             }
         }
         if (!islocal && global->cvq != CV_CONST)
             def.type |= DEF_SAVEGLOBAL;
 
         if (pushdef) {
-            vec_push(code_defs, def);
+            vec_push(code->defs, def);
             def.type &= ~DEF_SAVEGLOBAL;
-            gen_vector_defs(def, global->name);
+            gen_vector_defs(code, def, global->name);
         }
         return global->code.globaladdr >= 0;
     }
     case TYPE_FUNCTION:
-        ir_value_code_setaddr(global, vec_size(code_globals));
+        ir_value_code_setaddr(global, vec_size(code->globals));
         if (!global->hasvalue) {
-            vec_push(code_globals, 0);
+            vec_push(code->globals, 0);
             if (global->code.globaladdr < 0)
                 return false;
         } else {
-            vec_push(code_globals, vec_size(code_functions));
-            if (!gen_global_function(self, global))
+            vec_push(code->globals, vec_size(code->functions));
+            if (!gen_global_function(code, self, global))
                 return false;
         }
         if (!islocal && global->cvq != CV_CONST)
             def.type |= DEF_SAVEGLOBAL;
-        if (pushdef) vec_push(code_defs, def);
+        if (pushdef) vec_push(code->defs, def);
         return true;
     case TYPE_VARIANT:
         /* assume biggest type */
-            ir_value_code_setaddr(global, vec_size(code_globals));
-            vec_push(code_globals, 0);
+            ir_value_code_setaddr(global, vec_size(code->globals));
+            vec_push(code->globals, 0);
             for (i = 1; i < type_sizeof_[TYPE_VARIANT]; ++i)
-                vec_push(code_globals, 0);
+                vec_push(code->globals, 0);
             return true;
     default:
         /* refuse to create 'void' type or any other fancy business. */
@@ -3485,12 +3487,12 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
     }
 }
 
-static void ir_builder_prepare_field(ir_value *field)
+static GMQCC_INLINE void ir_builder_prepare_field(code_t *code, ir_value *field)
 {
-    field->code.fieldaddr = code_alloc_field(type_sizeof_[field->fieldtype]);
+    field->code.fieldaddr = code_alloc_field(code, type_sizeof_[field->fieldtype]);
 }
 
-static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
+static bool ir_builder_gen_field(code_t *code, ir_builder *self, ir_value *field)
 {
     prog_section_def def;
     prog_section_field fld;
@@ -3498,7 +3500,7 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
     (void)self;
 
     def.type   = (uint16_t)field->vtype;
-    def.offset = (uint16_t)vec_size(code_globals);
+    def.offset = (uint16_t)vec_size(code->globals);
 
     /* create a global named the same as the field */
     if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_GMQCC) {
@@ -3518,7 +3520,7 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
         memcpy(name+1, field->name, len); /* no strncpy - we used strlen above */
         name[len+1] = 0;
 
-        def.name = code_genstring(name);
+        def.name = code_genstring(code, name);
         fld.name = def.name + 1; /* we reuse that string table entry */
     } else {
         /* in plain QC, there cannot be a global with the same name,
@@ -3526,13 +3528,13 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
          * FIXME: fteqcc should create a global as well
          * check if it actually uses the same name. Probably does
          */
-        def.name = code_genstring(field->name);
+        def.name = code_genstring(code, field->name);
         fld.name = def.name;
     }
 
     field->code.name = def.name;
 
-    vec_push(code_defs, def);
+    vec_push(code->defs, def);
 
     fld.type = field->fieldtype;
 
@@ -3543,24 +3545,24 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
 
     fld.offset = field->code.fieldaddr;
 
-    vec_push(code_fields, fld);
+    vec_push(code->fields, fld);
 
-    ir_value_code_setaddr(field, vec_size(code_globals));
-    vec_push(code_globals, fld.offset);
+    ir_value_code_setaddr(field, vec_size(code->globals));
+    vec_push(code->globals, fld.offset);
     if (fld.type == TYPE_VECTOR) {
-        vec_push(code_globals, fld.offset+1);
-        vec_push(code_globals, fld.offset+2);
+        vec_push(code->globals, fld.offset+1);
+        vec_push(code->globals, fld.offset+2);
     }
 
     if (field->fieldtype == TYPE_VECTOR) {
-        gen_vector_defs(def, field->name);
-        gen_vector_fields(fld, field->name);
+        gen_vector_defs  (code, def, field->name);
+        gen_vector_fields(code, fld, field->name);
     }
 
     return field->code.globaladdr >= 0;
 }
 
-bool ir_builder_generate(ir_builder *self, const char *filename)
+bool ir_builder_generate(code_t *code, ir_builder *self, const char *filename)
 {
     prog_section_statement stmt;
     size_t i;
@@ -3570,12 +3572,12 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
 
     for (i = 0; i < vec_size(self->fields); ++i)
     {
-        ir_builder_prepare_field(self->fields[i]);
+        ir_builder_prepare_field(code, self->fields[i]);
     }
 
     for (i = 0; i < vec_size(self->globals); ++i)
     {
-        if (!ir_builder_gen_global(self, self->globals[i], false)) {
+        if (!ir_builder_gen_global(code, self, self->globals[i], false)) {
             return false;
         }
         if (self->globals[i]->vtype == TYPE_FUNCTION) {
@@ -3592,62 +3594,62 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
 
     for (i = 0; i < vec_size(self->fields); ++i)
     {
-        if (!ir_builder_gen_field(self, self->fields[i])) {
+        if (!ir_builder_gen_field(code, self, self->fields[i])) {
             return false;
         }
     }
 
     /* generate nil */
-    ir_value_code_setaddr(self->nil, vec_size(code_globals));
-    vec_push(code_globals, 0);
-    vec_push(code_globals, 0);
-    vec_push(code_globals, 0);
+    ir_value_code_setaddr(self->nil, vec_size(code->globals));
+    vec_push(code->globals, 0);
+    vec_push(code->globals, 0);
+    vec_push(code->globals, 0);
 
     /* generate global temps */
-    self->first_common_globaltemp = vec_size(code_globals);
+    self->first_common_globaltemp = vec_size(code->globals);
     for (i = 0; i < self->max_globaltemps; ++i) {
-        vec_push(code_globals, 0);
+        vec_push(code->globals, 0);
     }
     /* generate common locals */
-    self->first_common_local = vec_size(code_globals);
+    self->first_common_local = vec_size(code->globals);
     for (i = 0; i < self->max_locals; ++i) {
-        vec_push(code_globals, 0);
+        vec_push(code->globals, 0);
     }
 
     /* generate function code */
     for (i = 0; i < vec_size(self->globals); ++i)
     {
         if (self->globals[i]->vtype == TYPE_FUNCTION) {
-            if (!gen_global_function_code(self, self->globals[i])) {
+            if (!gen_global_function_code(code, self, self->globals[i])) {
                 return false;
             }
         }
     }
 
-    if (vec_size(code_globals) >= 65536) {
+    if (vec_size(code->globals) >= 65536) {
         irerror(vec_last(self->globals)->context, "This progs file would require more globals than the metadata can handle. Bailing out.");
         return false;
     }
 
     /* DP errors if the last instruction is not an INSTR_DONE. */
-    if (vec_last(code_statements).opcode != INSTR_DONE)
+    if (vec_last(code->statements).opcode != INSTR_DONE)
     {
         stmt.opcode = INSTR_DONE;
         stmt.o1.u1 = 0;
         stmt.o2.u1 = 0;
         stmt.o3.u1 = 0;
-        code_push_statement(&stmt, vec_last(code_linenums));
+        code_push_statement(code, &stmt, vec_last(code->linenums));
     }
 
     if (OPTS_OPTION_BOOL(OPTION_PP_ONLY))
         return true;
 
-    if (vec_size(code_statements) != vec_size(code_linenums)) {
+    if (vec_size(code->statements) != vec_size(code->linenums)) {
         con_err("Linecounter wrong: %lu != %lu\n",
-                (unsigned long)vec_size(code_statements),
-                (unsigned long)vec_size(code_linenums));
+                (unsigned long)vec_size(code->statements),
+                (unsigned long)vec_size(code->linenums));
     } else if (OPTS_FLAG(LNO)) {
-        char *dot;
+        char  *dot;
         size_t filelen = strlen(filename);
 
         memcpy(vec_add(lnofile, filelen+1), filename, filelen+1);
@@ -3666,7 +3668,7 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
         else
             con_out("writing '%s'\n", filename);
     }
-    if (!code_write(filename, lnofile)) {
+    if (!code_write(code, filename, lnofile)) {
         vec_free(lnofile);
         return false;
     }
diff --git a/ir.h b/ir.h
index bce85f4fb5e09fd1da578266707158698801b37b..835773afaa60f8646e2606b048d6dab47ea7c5b4 100644 (file)
--- a/ir.h
+++ b/ir.h
@@ -349,7 +349,7 @@ ir_value* ir_builder_create_field(ir_builder*, const char *name, int vtype);
 
 ir_value* ir_builder_get_va_count(ir_builder*);
 
-bool ir_builder_generate(ir_builder *self, const char *filename);
+bool ir_builder_generate(code_t *, ir_builder *self, const char *filename);
 
 void ir_builder_dump(ir_builder*, int (*oprintf)(const char*, ...));
 
index a19db282629e128dd0b9de61a150ba3385619e0b..8f9d014b8bc241672fbfd881c09fea87ea96b1ce 100644 (file)
--- a/parser.c
+++ b/parser.c
@@ -103,6 +103,9 @@ typedef struct parser_s {
 
     /* collected information */
     size_t     max_param_count;
+
+    /* code generator */
+    code_t     *code;
 } parser_t;
 
 static ast_expression * const intrinsic_debug_typestring = (ast_expression*)0x1;
@@ -5943,7 +5946,7 @@ static void generate_checksum(parser_t *parser)
     }
     crc = progdefs_crc_both(crc, "} entvars_t;\n\n");
 
-    code_crc = crc;
+    parser->code->crc = crc;
 }
 
 parser_t *parser_create()
@@ -5958,6 +5961,12 @@ parser_t *parser_create()
 
     memset(parser, 0, sizeof(*parser));
 
+    if (!(parser->code = code_init())) {
+        mem_d(parser);
+        return NULL;
+    }
+    
+
     for (i = 0; i < operator_count; ++i) {
         if (operators[i].id == opid1('=')) {
             parser->assign_op = operators+i;
@@ -6313,7 +6322,7 @@ bool parser_finish(parser_t *parser, const char *output)
 
         generate_checksum(parser);
 
-        if (!ir_builder_generate(ir, output)) {
+        if (!ir_builder_generate(parser->code, ir, output)) {
             con_out("*** failed to generate output file\n");
             ir_builder_delete(ir);
             return false;