X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ir.c;h=5e885872876327ea17a9325b79a4a527800d9d67;hp=a124bd1fa60e1c608a276780812f321cfdc8a594;hb=b39a748984064f4eea79a082caa1fe1151f20622;hpb=2058ce69a4b4e0d380aa3eb5ad4e08a9a4df7368

diff --git a/ir.c b/ir.c
index a124bd1..5e88587 100644
--- a/ir.c
+++ b/ir.c
@@ -1,6 +1,7 @@
 /*
  * Copyright (C) 2012, 2013
  *     Wolfgang Bumiller
+ *     Dale Weiler
  *
  * Permission is hereby granted, free of charge, to any person obtaining a copy of
  * this software and associated documentation files (the "Software"), to deal in
@@ -22,6 +23,7 @@
  */
 #include <stdlib.h>
 #include <string.h>
+
 #include "gmqcc.h"
 #include "ir.h"
 
@@ -211,9 +213,31 @@ const uint16_t type_not_instr[TYPE_COUNT] = {
 };
 
 /* protos */
-static ir_value* ir_gen_extparam_proto(ir_builder *ir);
-static void      ir_gen_extparam      (code_t *, ir_builder *ir);
-
+static ir_value*       ir_value_var(const char *name, int st, int vtype);
+static bool            ir_value_set_name(ir_value*, const char *name);
+static void            ir_value_dump(ir_value*, int (*oprintf)(const char*,...));
+
+static ir_value*       ir_gen_extparam_proto(ir_builder *ir);
+static void            ir_gen_extparam      (ir_builder *ir);
+
+static bool            ir_builder_set_name(ir_builder *self, const char *name);
+
+static ir_function*    ir_function_new(struct ir_builder_s *owner, int returntype);
+static bool            ir_function_set_name(ir_function*, const char *name);
+static void            ir_function_delete(ir_function*);
+static void            ir_function_dump(ir_function*, char *ind, int (*oprintf)(const char*,...));
+
+static ir_value*       ir_block_create_general_instr(ir_block *self, lex_ctx, const char *label,
+                                        int op, ir_value *a, ir_value *b, int outype);
+static void            ir_block_delete(ir_block*);
+static ir_block*       ir_block_new(struct ir_function_s *owner, const char *label);
+static bool GMQCC_WARN ir_block_create_store(ir_block*, lex_ctx, ir_value *target, ir_value *what);
+static bool            ir_block_set_label(ir_block*, const char *label);
+static void            ir_block_dump(ir_block*, char *ind, int (*oprintf)(const char*,...));
+
+static bool            ir_instr_op(ir_instr*, int op, ir_value *value, bool writing);
+static void            ir_instr_delete(ir_instr*);
+static void            ir_instr_dump(ir_instr* in, char *ind, int (*oprintf)(const char*,...));
 /* error functions */
 
 static void irerror(lex_ctx ctx, const char *msg, ...)
@@ -238,7 +262,7 @@ static bool irwarning(lex_ctx ctx, int warntype, const char *fmt, ...)
  * Vector utility functions
  */
 
-bool GMQCC_WARN vec_ir_value_find(ir_value **vec, const ir_value *what, size_t *idx)
+static bool GMQCC_WARN vec_ir_value_find(ir_value **vec, const ir_value *what, size_t *idx)
 {
     size_t i;
     size_t len = vec_size(vec);
@@ -251,7 +275,7 @@ bool GMQCC_WARN vec_ir_value_find(ir_value **vec, const ir_value *what, size_t *
     return false;
 }
 
-bool GMQCC_WARN vec_ir_block_find(ir_block **vec, ir_block *what, size_t *idx)
+static bool GMQCC_WARN vec_ir_block_find(ir_block **vec, ir_block *what, size_t *idx)
 {
     size_t i;
     size_t len = vec_size(vec);
@@ -264,7 +288,7 @@ bool GMQCC_WARN vec_ir_block_find(ir_block **vec, ir_block *what, size_t *idx)
     return false;
 }
 
-bool GMQCC_WARN vec_ir_instr_find(ir_instr **vec, ir_instr *what, size_t *idx)
+static bool GMQCC_WARN vec_ir_instr_find(ir_instr **vec, ir_instr *what, size_t *idx)
 {
     size_t i;
     size_t len = vec_size(vec);
@@ -321,6 +345,7 @@ ir_builder* ir_builder_new(const char *modulename)
     self->nil->cvq = CV_CONST;
 
     self->reserved_va_count = NULL;
+    self->code              = code_init();
 
     return self;
 }
@@ -340,6 +365,7 @@ void ir_builder_delete(ir_builder* self)
         ir_value_delete(self->extparams[i]);
     }
     vec_free(self->extparams);
+    vec_free(self->extparam_protos);
     for (i = 0; i != vec_size(self->globals); ++i) {
         ir_value_delete(self->globals[i]);
     }
@@ -351,6 +377,8 @@ void ir_builder_delete(ir_builder* self)
     vec_free(self->fields);
     vec_free(self->filenames);
     vec_free(self->filestrings);
+
+    code_cleanup(self->code);
     mem_d(self);
 }
 
@@ -362,7 +390,7 @@ bool ir_builder_set_name(ir_builder *self, const char *name)
     return !!self->name;
 }
 
-ir_function* ir_builder_get_function(ir_builder *self, const char *name)
+static ir_function* ir_builder_get_function(ir_builder *self, const char *name)
 {
     return (ir_function*)util_htget(self->htfunctions, name);
 }
@@ -397,7 +425,7 @@ ir_function* ir_builder_create_function(ir_builder *self, const char *name, int
     return fn;
 }
 
-ir_value* ir_builder_get_global(ir_builder *self, const char *name)
+static ir_value* ir_builder_get_global(ir_builder *self, const char *name)
 {
     return (ir_value*)util_htget(self->htglobals, name);
 }
@@ -427,7 +455,7 @@ ir_value* ir_builder_get_va_count(ir_builder *self)
     return (self->reserved_va_count = ir_builder_create_global(self, "reserved:va_count", TYPE_FLOAT));
 }
 
-ir_value* ir_builder_get_field(ir_builder *self, const char *name)
+static ir_value* ir_builder_get_field(ir_builder *self, const char *name)
 {
     return (ir_value*)util_htget(self->htfields, name);
 }
@@ -451,10 +479,10 @@ ir_value* ir_builder_create_field(ir_builder *self, const char *name, int vtype)
  *IR Function
  */
 
-bool ir_function_naive_phi(ir_function*);
-void ir_function_enumerate(ir_function*);
-bool ir_function_calculate_liferanges(ir_function*);
-bool ir_function_allocate_locals(ir_function*);
+static bool ir_function_naive_phi(ir_function*);
+static void ir_function_enumerate(ir_function*);
+static bool ir_function_calculate_liferanges(ir_function*);
+static bool ir_function_allocate_locals(ir_function*);
 
 ir_function* ir_function_new(ir_builder* owner, int outtype)
 {
@@ -551,7 +579,7 @@ void ir_function_delete(ir_function *self)
     mem_d(self);
 }
 
-void ir_function_collect_value(ir_function *self, ir_value *v)
+static void ir_function_collect_value(ir_function *self, ir_value *v)
 {
     vec_push(self->values, v);
 }
@@ -574,7 +602,7 @@ static bool instr_is_operation(uint16_t op)
              (op >= INSTR_CALL0  && op <= INSTR_CALL8) );
 }
 
-bool ir_function_pass_peephole(ir_function *self)
+static bool ir_function_pass_peephole(ir_function *self)
 {
     size_t b;
 
@@ -690,7 +718,7 @@ bool ir_function_pass_peephole(ir_function *self)
     return true;
 }
 
-bool ir_function_pass_tailrecursion(ir_function *self)
+static bool ir_function_pass_tailrecursion(ir_function *self)
 {
     size_t b, p;
 
@@ -926,7 +954,7 @@ bool ir_block_set_label(ir_block *self, const char *name)
  *IR Instructions
  */
 
-ir_instr* ir_instr_new(lex_ctx ctx, ir_block* owner, int op)
+static ir_instr* ir_instr_new(lex_ctx ctx, ir_block* owner, int op)
 {
     ir_instr *self;
     self = (ir_instr*)mem_a(sizeof(*self));
@@ -958,7 +986,7 @@ static void ir_instr_delete_quick(ir_instr *self)
     mem_d(self);
 }
 
-void ir_instr_delete(ir_instr *self)
+static void ir_instr_delete(ir_instr *self)
 {
     size_t i;
     /* The following calls can only delete from
@@ -989,7 +1017,7 @@ void ir_instr_delete(ir_instr *self)
     mem_d(self);
 }
 
-bool ir_instr_op(ir_instr *self, int op, ir_value *v, bool writing)
+static bool ir_instr_op(ir_instr *self, int op, ir_value *v, bool writing)
 {
     if (self->_ops[op]) {
         size_t idx;
@@ -1012,7 +1040,7 @@ bool ir_instr_op(ir_instr *self, int op, ir_value *v, bool writing)
  *IR Value
  */
 
-void ir_value_code_setaddr(ir_value *self, int32_t gaddr)
+static void ir_value_code_setaddr(ir_value *self, int32_t gaddr)
 {
     self->code.globaladdr = gaddr;
     if (self->members[0]) self->members[0]->code.globaladdr = gaddr;
@@ -1020,7 +1048,7 @@ void ir_value_code_setaddr(ir_value *self, int32_t gaddr)
     if (self->members[2]) self->members[2]->code.globaladdr = gaddr;
 }
 
-int32_t ir_value_code_addr(const ir_value *self)
+static int32_t ir_value_code_addr(const ir_value *self)
 {
     if (self->store == store_return)
         return OFS_RETURN + self->code.addroffset;
@@ -1133,7 +1161,7 @@ static GMQCC_INLINE size_t ir_value_sizeof(const ir_value *self)
     return type_sizeof_[self->vtype];
 }
 
-ir_value* ir_value_out(ir_function *owner, const char *name, int storetype, int vtype)
+static ir_value* ir_value_out(ir_function *owner, const char *name, int storetype, int vtype)
 {
     ir_value *v = ir_value_var(name, storetype, vtype);
     if (!v)
@@ -1240,7 +1268,7 @@ bool ir_value_lives(ir_value *self, size_t at)
     return false;
 }
 
-bool ir_value_life_insert(ir_value *self, size_t idx, ir_life_entry_t e)
+static bool ir_value_life_insert(ir_value *self, size_t idx, ir_life_entry_t e)
 {
     size_t k;
     vec_push(self->life, e);
@@ -1250,7 +1278,7 @@ bool ir_value_life_insert(ir_value *self, size_t idx, ir_life_entry_t e)
     return true;
 }
 
-bool ir_value_life_merge(ir_value *self, size_t s)
+static bool ir_value_life_merge(ir_value *self, size_t s)
 {
     size_t i;
     const size_t vs = vec_size(self->life);
@@ -1313,7 +1341,7 @@ bool ir_value_life_merge(ir_value *self, size_t s)
     return ir_value_life_insert(self, i, new_entry);
 }
 
-bool ir_value_life_merge_into(ir_value *self, const ir_value *other)
+static bool ir_value_life_merge_into(ir_value *self, const ir_value *other)
 {
     size_t i, myi;
 
@@ -1387,7 +1415,7 @@ bool ir_value_life_merge_into(ir_value *self, const ir_value *other)
     return true;
 }
 
-bool ir_values_overlap(const ir_value *a, const ir_value *b)
+static bool ir_values_overlap(const ir_value *a, const ir_value *b)
 {
     /* For any life entry in A see if it overlaps with
      * any life entry in B.
@@ -1483,7 +1511,7 @@ bool ir_block_create_store_op(ir_block *self, lex_ctx ctx, int op, ir_value *tar
     return true;
 }
 
-bool ir_block_create_store(ir_block *self, lex_ctx ctx, ir_value *target, ir_value *what)
+static bool ir_block_create_store(ir_block *self, lex_ctx ctx, ir_value *target, ir_value *what)
 {
     int op = 0;
     int vtype;
@@ -1772,14 +1800,33 @@ ir_value* ir_block_create_binop(ir_block *self, lex_ctx ctx,
             ot = TYPE_POINTER;
             break;
 #endif
+    /*
+     * after the following default case, the value of opcode can never
+     * be 1, 2, 3, 4, 5, 6, 7, 8, 9, 62, 63, 64, 65
+     */
         default:
             /* ranges: */
             /* boolean operations result in floats */
+            
+            /*
+             * opcode >= 10 takes true branch opcode is at least 10
+             * opcode <= 23 takes false branch opcode is at least 24
+             */
             if (opcode >= INSTR_EQ_F && opcode <= INSTR_GT)
                 ot = TYPE_FLOAT;
+                
+            /* 
+             * At condition "opcode <= 23", the value of "opcode" must be 
+             * at least 24.
+             * At condition "opcode <= 23", the value of "opcode" cannot be
+             * equal to any of {1, 2, 3, 4, 5, 6, 7, 8, 9, 62, 63, 64, 65}.
+             * The condition "opcode <= 23" cannot be true.
+             * 
+             * Thus ot=2 (TYPE_FLOAT) can never be true
+             */
+#if 0
             else if (opcode >= INSTR_LE && opcode <= INSTR_GT)
                 ot = TYPE_FLOAT;
-#if 0
             else if (opcode >= INSTR_LE_I && opcode <= INSTR_EQ_FI)
                 ot = TYPE_FLOAT;
 #endif
@@ -1826,7 +1873,7 @@ ir_value* ir_block_create_unary(ir_block *self, lex_ctx ctx,
     return ir_block_create_general_instr(self, ctx, label, opcode, operand, NULL, ot);
 }
 
-ir_value* ir_block_create_general_instr(ir_block *self, lex_ctx ctx, const char *label,
+static ir_value* ir_block_create_general_instr(ir_block *self, lex_ctx ctx, const char *label,
                                         int op, ir_value *a, ir_value *b, int outype)
 {
     ir_instr *instr;
@@ -2537,7 +2584,8 @@ bool ir_function_calculate_liferanges(ir_function *self)
 
     /* parameters live at 0 */
     for (i = 0; i < vec_size(self->params); ++i)
-        ir_value_life_merge(self->locals[i], 0);
+        if (!ir_value_life_merge(self->locals[i], 0))
+            compile_error(self->context, "internal error: failed value-life merging");
 
     do {
         self->run_id++;
@@ -2618,7 +2666,7 @@ bool ir_function_calculate_liferanges(ir_function *self)
  *
  * Breaking conventions is annoying...
  */
-static bool ir_builder_gen_global(code_t *, ir_builder *self, ir_value *global, bool islocal);
+static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal);
 
 static bool gen_global_field(code_t *code, ir_value *global)
 {
@@ -2858,7 +2906,7 @@ static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *bloc
                     continue;
 
                 if (p-8 >= vec_size(ir->extparams))
-                    ir_gen_extparam(code, ir);
+                    ir_gen_extparam(ir);
 
                 targetparam = ir->extparams[p-8];
 
@@ -2992,7 +3040,7 @@ static bool gen_function_code(code_t *code, ir_function *self)
     return true;
 }
 
-static qcint ir_builder_filestring(code_t *code, ir_builder *ir, const char *filename)
+static qcint ir_builder_filestring(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 +3053,13 @@ static qcint ir_builder_filestring(code_t *code, ir_builder *ir, const char *fil
             return ir->filestrings[i];
     }
 
-    str = code_genstring(code, filename);
+    str = code_genstring(ir->code, filename);
     vec_push(ir->filenames, filename);
     vec_push(ir->filestrings, str);
     return str;
 }
 
-static bool gen_global_function(code_t *code, ir_builder *ir, ir_value *global)
+static bool gen_global_function(ir_builder *ir, ir_value *global)
 {
     prog_section_function fun;
     ir_function          *irfun;
@@ -3027,7 +3075,7 @@ static bool gen_global_function(code_t *code, ir_builder *ir, ir_value *global)
     irfun = global->constval.vfunc;
 
     fun.name    = global->code.name;
-    fun.file    = ir_builder_filestring(code, ir, global->context.file);
+    fun.file    = ir_builder_filestring(ir, global->context.file);
     fun.profile = 0; /* always 0 */
     fun.nargs   = vec_size(irfun->params);
     if (fun.nargs > 8)
@@ -3046,11 +3094,11 @@ static bool gen_global_function(code_t *code, 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(ir->code->functions);
+        fun.entry                = vec_size(ir->code->statements);
     }
 
-    vec_push(code->functions, fun);
+    vec_push(ir->code->functions, fun);
     return true;
 }
 
@@ -3066,7 +3114,7 @@ static ir_value* ir_gen_extparam_proto(ir_builder *ir)
     return global;
 }
 
-static void ir_gen_extparam(code_t *code, ir_builder *ir)
+static void ir_gen_extparam(ir_builder *ir)
 {
     prog_section_def def;
     ir_value        *global;
@@ -3076,17 +3124,17 @@ static void ir_gen_extparam(code_t *code, ir_builder *ir)
     else
         global = ir->extparam_protos[vec_size(ir->extparams)];
 
-    def.name   = code_genstring(code, global->name);
+    def.name   = code_genstring(ir->code, global->name);
     def.type   = TYPE_VECTOR;
-    def.offset = vec_size(code->globals);
+    def.offset = vec_size(ir->code->globals);
 
-    vec_push(code->defs, def);
+    vec_push(ir->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(ir->code->globals, 0);
+    vec_push(ir->code->globals, 0);
+    vec_push(ir->code->globals, 0);
 
     vec_push(ir->extparams, global);
 }
@@ -3108,7 +3156,7 @@ static bool gen_function_extparam_copy(code_t *code, ir_function *self)
     for (i = 8; i < numparams; ++i) {
         ext = i - 8;
         if (ext >= vec_size(ir->extparams))
-            ir_gen_extparam(code, ir);
+            ir_gen_extparam(ir);
 
         ep = ir->extparams[ext];
 
@@ -3150,7 +3198,7 @@ static bool gen_function_varargs_copy(code_t *code, ir_function *self)
         }
         ext = i - 8;
         while (ext >= vec_size(ir->extparams))
-            ir_gen_extparam(code, ir);
+            ir_gen_extparam(ir);
 
         ep = ir->extparams[ext];
 
@@ -3162,7 +3210,7 @@ static bool gen_function_varargs_copy(code_t *code, ir_function *self)
     return true;
 }
 
-static bool gen_function_locals(code_t *code, ir_builder *ir, ir_value *global)
+static bool gen_function_locals(ir_builder *ir, ir_value *global)
 {
     prog_section_function *def;
     ir_function           *irfun;
@@ -3170,13 +3218,13 @@ static bool gen_function_locals(code_t *code, ir_builder *ir, ir_value *global)
     uint32_t               firstlocal, firstglobal;
 
     irfun = global->constval.vfunc;
-    def   = code->functions + irfun->code_function_def;
+    def   = ir->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(ir->code->globals);
     } else {
         firstlocal = def->firstlocal = ir->first_common_local;
         ++opts_optimizationcount[OPTIM_OVERLAP_LOCALS];
@@ -3184,13 +3232,13 @@ static bool gen_function_locals(code_t *code, 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(ir->code->globals); i < firstlocal + irfun->allocated_locals; ++i)
+        vec_push(ir->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(code, ir, irfun->locals[i], true)) {
+            if (!ir_builder_gen_global(ir, irfun->locals[i], true)) {
                 irerror(irfun->locals[i]->context, "failed to generate local %s", irfun->locals[i]->name);
                 return false;
             }
@@ -3211,7 +3259,7 @@ static bool gen_function_locals(code_t *code, ir_builder *ir, ir_value *global)
     return true;
 }
 
-static bool gen_global_function_code(code_t *code, ir_builder *ir, ir_value *global)
+static bool gen_global_function_code(ir_builder *ir, ir_value *global)
 {
     prog_section_function *fundef;
     ir_function           *irfun;
@@ -3235,22 +3283,22 @@ static bool gen_global_function_code(code_t *code, ir_builder *ir, ir_value *glo
         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 = &ir->code->functions[irfun->code_function_def];
 
-    fundef->entry = vec_size(code->statements);
-    if (!gen_function_locals(code, ir, global)) {
+    fundef->entry = vec_size(ir->code->statements);
+    if (!gen_function_locals(ir, global)) {
         irerror(irfun->context, "Failed to generate locals for function %s", irfun->name);
         return false;
     }
-    if (!gen_function_extparam_copy(code, irfun)) {
+    if (!gen_function_extparam_copy(ir->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(code, irfun)) {
+    if (irfun->max_varargs && !gen_function_varargs_copy(ir->code, irfun)) {
         irerror(irfun->context, "Failed to generate vararg-copy code for function %s", irfun->name);
         return false;
     }
-    if (!gen_function_code(code, irfun)) {
+    if (!gen_function_code(ir->code, irfun)) {
         irerror(irfun->context, "Failed to generate code for function %s", irfun->name);
         return false;
     }
@@ -3317,7 +3365,7 @@ static void gen_vector_fields(code_t *code, prog_section_field fld, const char *
     mem_d(component);
 }
 
-static bool ir_builder_gen_global(code_t *code, ir_builder *self, ir_value *global, bool islocal)
+static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal)
 {
     size_t           i;
     int32_t         *iptr;
@@ -3325,7 +3373,7 @@ static bool ir_builder_gen_global(code_t *code, ir_builder *self, ir_value *glob
     bool             pushdef = opts.optimizeoff;
 
     def.type   = global->vtype;
-    def.offset = vec_size(code->globals);
+    def.offset = vec_size(self->code->globals);
     def.name   = 0;
     if (OPTS_OPTION_BOOL(OPTION_G) || !islocal)
     {
@@ -3341,21 +3389,21 @@ static bool ir_builder_gen_global(code_t *code, ir_builder *self, ir_value *glob
         if (pushdef && global->name) {
             if (global->name[0] == '#') {
                 if (!self->str_immediate)
-                    self->str_immediate = code_genstring(code, "IMMEDIATE");
+                    self->str_immediate = code_genstring(self->code, "IMMEDIATE");
                 def.name = global->code.name = self->str_immediate;
             }
             else
-                def.name = global->code.name = code_genstring(code, global->name);
+                def.name = global->code.name = code_genstring(self->code, global->name);
         }
         else
             def.name   = 0;
         if (islocal) {
             def.offset = ir_value_code_addr(global);
-            vec_push(code->defs, def);
+            vec_push(self->code->defs, def);
             if (global->vtype == TYPE_VECTOR)
-                gen_vector_defs(code, def, global->name);
+                gen_vector_defs(self->code, def, global->name);
             else if (global->vtype == TYPE_FIELD && global->fieldtype == TYPE_VECTOR)
-                gen_vector_defs(code, def, global->name);
+                gen_vector_defs(self->code, def, global->name);
             return true;
         }
     }
@@ -3382,103 +3430,103 @@ static bool ir_builder_gen_global(code_t *code, ir_builder *self, ir_value *glob
          * 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(self->code->globals));
+        vec_push(self->code->globals, 0);
         /* Add the def */
-        if (pushdef) vec_push(code->defs, def);
+        if (pushdef) vec_push(self->code->defs, def);
         return true;
     case TYPE_POINTER:
-        if (pushdef) vec_push(code->defs, def);
-        return gen_global_pointer(code, global);
+        if (pushdef) vec_push(self->code->defs, def);
+        return gen_global_pointer(self->code, global);
     case TYPE_FIELD:
         if (pushdef) {
-            vec_push(code->defs, def);
+            vec_push(self->code->defs, def);
             if (global->fieldtype == TYPE_VECTOR)
-                gen_vector_defs(code, def, global->name);
+                gen_vector_defs(self->code, def, global->name);
         }
-        return gen_global_field(code, global);
+        return gen_global_field(self->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(self->code->globals));
         if (global->hasvalue) {
             iptr = (int32_t*)&global->constval.ivec[0];
-            vec_push(code->globals, *iptr);
+            vec_push(self->code->globals, *iptr);
         } else {
-            vec_push(code->globals, 0);
+            vec_push(self->code->globals, 0);
         }
         if (!islocal && global->cvq != CV_CONST)
             def.type |= DEF_SAVEGLOBAL;
-        if (pushdef) vec_push(code->defs, def);
+        if (pushdef) vec_push(self->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(self->code->globals));
         if (global->hasvalue) {
-            uint32_t load = code_genstring(code, global->constval.vstring);
-            vec_push(code->globals, load);
+            uint32_t load = code_genstring(self->code, global->constval.vstring);
+            vec_push(self->code->globals, load);
         } else {
-            vec_push(code->globals, 0);
+            vec_push(self->code->globals, 0);
         }
         if (!islocal && global->cvq != CV_CONST)
             def.type |= DEF_SAVEGLOBAL;
-        if (pushdef) vec_push(code->defs, def);
+        if (pushdef) vec_push(self->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(self->code->globals));
         if (global->hasvalue) {
             iptr = (int32_t*)&global->constval.ivec[0];
-            vec_push(code->globals, iptr[0]);
+            vec_push(self->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(self->code->globals, iptr[d]);
             }
         } else {
-            vec_push(code->globals, 0);
+            vec_push(self->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(self->code->globals, 0);
             }
         }
         if (!islocal && global->cvq != CV_CONST)
             def.type |= DEF_SAVEGLOBAL;
 
         if (pushdef) {
-            vec_push(code->defs, def);
+            vec_push(self->code->defs, def);
             def.type &= ~DEF_SAVEGLOBAL;
-            gen_vector_defs(code, def, global->name);
+            gen_vector_defs(self->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(self->code->globals));
         if (!global->hasvalue) {
-            vec_push(code->globals, 0);
+            vec_push(self->code->globals, 0);
             if (global->code.globaladdr < 0)
                 return false;
         } else {
-            vec_push(code->globals, vec_size(code->functions));
-            if (!gen_global_function(code, self, global))
+            vec_push(self->code->globals, vec_size(self->code->functions));
+            if (!gen_global_function(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(self->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(self->code->globals));
+            vec_push(self->code->globals, 0);
             for (i = 1; i < type_sizeof_[TYPE_VARIANT]; ++i)
-                vec_push(code->globals, 0);
+                vec_push(self->code->globals, 0);
             return true;
     default:
         /* refuse to create 'void' type or any other fancy business. */
@@ -3493,7 +3541,7 @@ static GMQCC_INLINE void ir_builder_prepare_field(code_t *code, ir_value *field)
     field->code.fieldaddr = code_alloc_field(code, type_sizeof_[field->fieldtype]);
 }
 
-static bool ir_builder_gen_field(code_t *code, ir_builder *self, ir_value *field)
+static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
 {
     prog_section_def def;
     prog_section_field fld;
@@ -3501,7 +3549,7 @@ static bool ir_builder_gen_field(code_t *code, 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(self->code->globals);
 
     /* create a global named the same as the field */
     if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_GMQCC) {
@@ -3521,7 +3569,7 @@ static bool ir_builder_gen_field(code_t *code, 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(code, name);
+        def.name = code_genstring(self->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,
@@ -3529,13 +3577,13 @@ static bool ir_builder_gen_field(code_t *code, 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(code, field->name);
+        def.name = code_genstring(self->code, field->name);
         fld.name = def.name;
     }
 
     field->code.name = def.name;
 
-    vec_push(code->defs, def);
+    vec_push(self->code->defs, def);
 
     fld.type = field->fieldtype;
 
@@ -3546,39 +3594,37 @@ static bool ir_builder_gen_field(code_t *code, ir_builder *self, ir_value *field
 
     fld.offset = field->code.fieldaddr;
 
-    vec_push(code->fields, fld);
+    vec_push(self->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(self->code->globals));
+    vec_push(self->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(self->code->globals, fld.offset+1);
+        vec_push(self->code->globals, fld.offset+2);
     }
 
     if (field->fieldtype == TYPE_VECTOR) {
-        gen_vector_defs  (code, def, field->name);
-        gen_vector_fields(code, fld, field->name);
+        gen_vector_defs  (self->code, def, field->name);
+        gen_vector_fields(self->code, fld, field->name);
     }
 
     return field->code.globaladdr >= 0;
 }
 
-bool ir_builder_generate(code_t *code, ir_builder *self, const char *filename)
+bool ir_builder_generate(ir_builder *self, const char *filename)
 {
     prog_section_statement stmt;
     size_t i;
     char  *lnofile = NULL;
 
-    code_init();
-
     for (i = 0; i < vec_size(self->fields); ++i)
     {
-        ir_builder_prepare_field(code, self->fields[i]);
+        ir_builder_prepare_field(self->code, self->fields[i]);
     }
 
     for (i = 0; i < vec_size(self->globals); ++i)
     {
-        if (!ir_builder_gen_global(code, self, self->globals[i], false)) {
+        if (!ir_builder_gen_global(self, self->globals[i], false)) {
             return false;
         }
         if (self->globals[i]->vtype == TYPE_FUNCTION) {
@@ -3595,60 +3641,60 @@ bool ir_builder_generate(code_t *code, ir_builder *self, const char *filename)
 
     for (i = 0; i < vec_size(self->fields); ++i)
     {
-        if (!ir_builder_gen_field(code, self, self->fields[i])) {
+        if (!ir_builder_gen_field(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(self->code->globals));
+    vec_push(self->code->globals, 0);
+    vec_push(self->code->globals, 0);
+    vec_push(self->code->globals, 0);
 
     /* generate global temps */
-    self->first_common_globaltemp = vec_size(code->globals);
+    self->first_common_globaltemp = vec_size(self->code->globals);
     for (i = 0; i < self->max_globaltemps; ++i) {
-        vec_push(code->globals, 0);
+        vec_push(self->code->globals, 0);
     }
     /* generate common locals */
-    self->first_common_local = vec_size(code->globals);
+    self->first_common_local = vec_size(self->code->globals);
     for (i = 0; i < self->max_locals; ++i) {
-        vec_push(code->globals, 0);
+        vec_push(self->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(code, self, self->globals[i])) {
+            if (!gen_global_function_code(self, self->globals[i])) {
                 return false;
             }
         }
     }
 
-    if (vec_size(code->globals) >= 65536) {
+    if (vec_size(self->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(self->code->statements).opcode != INSTR_DONE)
     {
         stmt.opcode = INSTR_DONE;
         stmt.o1.u1 = 0;
         stmt.o2.u1 = 0;
         stmt.o3.u1 = 0;
-        code_push_statement(code, &stmt, vec_last(code->linenums));
+        code_push_statement(self->code, &stmt, vec_last(self->code->linenums));
     }
 
     if (OPTS_OPTION_BOOL(OPTION_PP_ONLY))
         return true;
 
-    if (vec_size(code->statements) != vec_size(code->linenums)) {
+    if (vec_size(self->code->statements) != vec_size(self->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(self->code->statements),
+                (unsigned long)vec_size(self->code->linenums));
     } else if (OPTS_FLAG(LNO)) {
         char  *dot;
         size_t filelen = strlen(filename);
@@ -3669,7 +3715,7 @@ bool ir_builder_generate(code_t *code, ir_builder *self, const char *filename)
         else
             con_out("writing '%s'\n", filename);
     }
-    if (!code_write(code, filename, lnofile)) {
+    if (!code_write(self->code, filename, lnofile)) {
         vec_free(lnofile);
         return false;
     }
@@ -3687,7 +3733,7 @@ bool ir_builder_generate(code_t *code, ir_builder *self, const char *filename)
 #   define strncat(dst, src, sz) strncat_s(dst, sz, src, _TRUNCATE)
 #endif
 
-const char *qc_opname(int op)
+static const char *qc_opname(int op)
 {
     if (op < 0) return "<INVALID>";
     if (op < (int)( sizeof(asm_instr) / sizeof(asm_instr[0]) ))
@@ -3734,7 +3780,7 @@ void ir_function_dump(ir_function *f, char *ind,
         return;
     }
     oprintf("%sfunction %s\n", ind, f->name);
-    strncat(ind, "\t", IND_BUFSZ);
+    strncat(ind, "\t", IND_BUFSZ-1);
     if (vec_size(f->locals))
     {
         oprintf("%s%i locals:\n", ind, (int)vec_size(f->locals));
@@ -3830,7 +3876,7 @@ void ir_block_dump(ir_block* b, char *ind,
 {
     size_t i;
     oprintf("%s:%s\n", ind, b->label);
-    strncat(ind, "\t", IND_BUFSZ);
+    strncat(ind, "\t", IND_BUFSZ-1);
 
     if (b->instr && b->instr[0])
         oprintf("%s (%i) [entry]\n", ind, (int)(b->instr[0]->eid-1));
@@ -3839,7 +3885,7 @@ void ir_block_dump(ir_block* b, char *ind,
     ind[strlen(ind)-1] = 0;
 }
 
-void dump_phi(ir_instr *in, int (*oprintf)(const char*, ...))
+static void dump_phi(ir_instr *in, int (*oprintf)(const char*, ...))
 {
     size_t i;
     oprintf("%s <- phi ", in->_ops[0]->name);
@@ -3864,7 +3910,7 @@ void ir_instr_dump(ir_instr *in, char *ind,
         return;
     }
 
-    strncat(ind, "\t", IND_BUFSZ);
+    strncat(ind, "\t", IND_BUFSZ-1);
 
     if (in->_ops[0] && (in->_ops[1] || in->_ops[2])) {
         ir_value_dump(in->_ops[0], oprintf);
@@ -3909,7 +3955,7 @@ void ir_instr_dump(ir_instr *in, char *ind,
     ind[strlen(ind)-1] = 0;
 }
 
-void ir_value_dump_string(const char *str, int (*oprintf)(const char*, ...))
+static void ir_value_dump_string(const char *str, int (*oprintf)(const char*, ...))
 {
     oprintf("\"");
     for (; *str; ++str) {