X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ir.c;h=f273f1c34cff8cce52f34021e5ca8e6a8e238c02;hb=0c06f9f6500e95a18c45de5b5dd84eac1e2592d7;hp=4e8060757ef70dd8fd276226088c615c5de9d250;hpb=22e6b8558b3b60d9924b802786499ef8d6af671f;p=xonotic%2Fgmqcc.git

diff --git a/ir.c b/ir.c
index 4e80607..f273f1c 100644
--- a/ir.c
+++ b/ir.c
@@ -41,8 +41,6 @@ const char *type_name[TYPE_COUNT] = {
 #if 0
     "integer",
 #endif
-    "quaternion",
-    "matrix",
     "variant"
 };
 
@@ -58,9 +56,7 @@ size_t type_sizeof[TYPE_COUNT] = {
 #if 0
     1, /* TYPE_INTEGER  */
 #endif
-    4, /* TYPE_QUATERNION */
-    16, /* TYPE_MATRIX */
-    16, /* TYPE_VARIANT  */
+    3, /* TYPE_VARIANT  */
 };
 
 uint16_t type_store_instr[TYPE_COUNT] = {
@@ -75,10 +71,8 @@ uint16_t type_store_instr[TYPE_COUNT] = {
 #if 0
     INSTR_STORE_I, /* integer type */
 #endif
-    INSTR_STORE_Q,
-    INSTR_STORE_M,
 
-    INSTR_STORE_M, /* variant, should never be accessed */
+    INSTR_STORE_V, /* variant, should never be accessed */
 };
 
 uint16_t type_storep_instr[TYPE_COUNT] = {
@@ -93,10 +87,8 @@ uint16_t type_storep_instr[TYPE_COUNT] = {
 #if 0
     INSTR_STOREP_ENT, /* integer type */
 #endif
-    INSTR_STOREP_Q,
-    INSTR_STOREP_M,
 
-    INSTR_STOREP_M, /* variant, should never be accessed */
+    INSTR_STOREP_V, /* variant, should never be accessed */
 };
 
 MEM_VEC_FUNCTIONS(ir_value_vector, ir_value*, v)
@@ -115,6 +107,7 @@ ir_builder* ir_builder_new(const char *modulename)
 
     MEM_VECTOR_INIT(self, functions);
     MEM_VECTOR_INIT(self, globals);
+    MEM_VECTOR_INIT(self, fields);
     self->name = NULL;
     if (!ir_builder_set_name(self, modulename)) {
         mem_d(self);
@@ -130,6 +123,7 @@ ir_builder* ir_builder_new(const char *modulename)
 }
 
 MEM_VEC_FUNCTIONS(ir_builder, ir_value*, globals)
+MEM_VEC_FUNCTIONS(ir_builder, ir_value*, fields)
 MEM_VEC_FUNCTIONS(ir_builder, ir_function*, functions)
 
 void ir_builder_delete(ir_builder* self)
@@ -143,7 +137,11 @@ void ir_builder_delete(ir_builder* self)
     for (i = 0; i != self->globals_count; ++i) {
         ir_value_delete(self->globals[i]);
     }
-    MEM_VECTOR_CLEAR(self, globals);
+    MEM_VECTOR_CLEAR(self, fields);
+    for (i = 0; i != self->fields_count; ++i) {
+        ir_value_delete(self->fields[i]);
+    }
+    MEM_VECTOR_CLEAR(self, fields);
     mem_d(self);
 }
 
@@ -224,6 +222,33 @@ ir_value* ir_builder_create_global(ir_builder *self, const char *name, int vtype
     return ve;
 }
 
+ir_value* ir_builder_get_field(ir_builder *self, const char *name)
+{
+    size_t i;
+    for (i = 0; i < self->fields_count; ++i) {
+        if (!strcmp(self->fields[i]->name, name))
+            return self->fields[i];
+    }
+    return NULL;
+}
+
+
+ir_value* ir_builder_create_field(ir_builder *self, const char *name, int vtype)
+{
+    ir_value *ve = ir_builder_get_field(self, name);
+    if (ve) {
+        return NULL;
+    }
+
+    ve = ir_value_var(name, store_global, TYPE_FIELD);
+    ve->fieldtype = vtype;
+    if (!ir_builder_fields_add(self, ve)) {
+        ir_value_delete(ve);
+        return NULL;
+    }
+    return ve;
+}
+
 /***********************************************************************
  *IR Function
  */
@@ -516,6 +541,21 @@ 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)
+{
+    self->code.globaladdr = gaddr;
+    if (self->members[0]) self->members[0]->code.globaladdr = gaddr;
+    if (self->members[1]) self->members[1]->code.globaladdr = gaddr;
+    if (self->members[2]) self->members[2]->code.globaladdr = gaddr;
+}
+
+int32_t ir_value_code_addr(const ir_value *self)
+{
+    if (self->store == store_return)
+        return OFS_RETURN + self->code.addroffset;
+    return self->code.globaladdr + self->code.addroffset;
+}
+
 ir_value* ir_value_var(const char *name, int storetype, int vtype)
 {
     ir_value *self;
@@ -538,6 +578,48 @@ ir_value* ir_value_var(const char *name, int storetype, int vtype)
     MEM_VECTOR_INIT(self, life);
     return self;
 }
+
+ir_value* ir_value_vector_member(ir_value *self, unsigned int member)
+{
+    ir_value *m;
+    if (member >= 3)
+        return NULL;
+
+    if (self->members[member])
+        return self->members[member];
+
+    if (self->vtype == TYPE_VECTOR)
+    {
+        m = ir_value_var(self->name, self->store, TYPE_FLOAT);
+        if (!m)
+            return NULL;
+        m->context = self->context;
+
+        self->members[member] = m;
+        m->code.addroffset = member;
+    }
+    else if (self->vtype == TYPE_FIELD)
+    {
+        if (self->fieldtype != TYPE_VECTOR)
+            return NULL;
+        m = ir_value_var(self->name, self->store, TYPE_FIELD);
+        if (!m)
+            return NULL;
+        m->fieldtype = TYPE_FLOAT;
+        m->context = self->context;
+
+        self->members[member] = m;
+        m->code.addroffset = member;
+    }
+    else
+    {
+        printf("invalid member access on %s\n", self->name);
+        return NULL;
+    }
+
+    return m;
+}
+
 MEM_VEC_FUNCTIONS(ir_value, ir_life_entry_t, life)
 MEM_VEC_FUNCTIONS_ALL(ir_value, ir_instr*, reads)
 MEM_VEC_FUNCTIONS_ALL(ir_value, ir_instr*, writes)
@@ -557,6 +639,7 @@ ir_value* ir_value_out(ir_function *owner, const char *name, int storetype, int
 
 void ir_value_delete(ir_value* self)
 {
+    size_t i;
     if (self->name)
         mem_d((void*)self->name);
     if (self->isconst)
@@ -564,6 +647,10 @@ void ir_value_delete(ir_value* self)
         if (self->vtype == TYPE_STRING)
             mem_d((void*)self->constval.vstring);
     }
+    for (i = 0; i < 3; ++i) {
+        if (self->members[i])
+            ir_value_delete(self->members[i]);
+    }
     MEM_VECTOR_CLEAR(self, reads);
     MEM_VECTOR_CLEAR(self, writes);
     MEM_VECTOR_CLEAR(self, life);
@@ -604,20 +691,11 @@ bool ir_value_set_vector(ir_value *self, vector v)
     return true;
 }
 
-bool ir_value_set_quaternion(ir_value *self, quaternion v)
+bool ir_value_set_field(ir_value *self, ir_value *fld)
 {
-    if (self->vtype != TYPE_QUATERNION)
+    if (self->vtype != TYPE_FIELD)
         return false;
-    memcpy(&self->constval.vquat, v, sizeof(self->constval.vquat));
-    self->isconst = true;
-    return true;
-}
-
-bool ir_value_set_matrix(ir_value *self, matrix v)
-{
-    if (self->vtype != TYPE_MATRIX)
-        return false;
-    memcpy(&self->constval.vmat, v, sizeof(self->constval.vmat));
+    self->constval.vpointer = fld;
     self->isconst = true;
     return true;
 }
@@ -873,22 +951,26 @@ bool ir_values_overlap(const ir_value *a, const ir_value *b)
 
 bool ir_block_create_store_op(ir_block *self, int op, ir_value *target, ir_value *what)
 {
-    if (target->store == store_value) {
+    ir_instr *in = ir_instr_new(self, op);
+    if (!in)
+        return false;
+
+    if (target->store == store_value &&
+        (op < INSTR_STOREP_F || op > INSTR_STOREP_FNC))
+    {
         fprintf(stderr, "cannot store to an SSA value\n");
         fprintf(stderr, "trying to store: %s <- %s\n", target->name, what->name);
+        fprintf(stderr, "instruction: %s\n", asm_instr[op].m);
         return false;
-    } else {
-        ir_instr *in = ir_instr_new(self, op);
-        if (!in)
-            return false;
-        if (!ir_instr_op(in, 0, target, true) ||
-            !ir_instr_op(in, 1, what, false)  ||
-            !ir_block_instr_add(self, in) )
-        {
-            return false;
-        }
-        return true;
     }
+
+    if (!ir_instr_op(in, 0, target, true) ||
+        !ir_instr_op(in, 1, what, false)  ||
+        !ir_block_instr_add(self, in) )
+    {
+        return false;
+    }
+    return true;
 }
 
 bool ir_block_create_store(ir_block *self, ir_value *target, ir_value *what)
@@ -908,6 +990,11 @@ bool ir_block_create_store(ir_block *self, ir_value *target, ir_value *what)
 #endif
         op = type_store_instr[vtype];
 
+    if (OPTS_FLAG(ADJUST_VECTOR_FIELDS)) {
+        if (op == INSTR_STORE_FLD && what->fieldtype == TYPE_VECTOR)
+            op = INSTR_STORE_V;
+    }
+
     return ir_block_create_store_op(self, op, target, what);
 }
 
@@ -925,6 +1012,11 @@ bool ir_block_create_storep(ir_block *self, ir_value *target, ir_value *what)
     vtype = what->vtype;
 
     op = type_storep_instr[vtype];
+    if (OPTS_FLAG(ADJUST_VECTOR_FIELDS)) {
+        if (op == INSTR_STOREP_FLD && what->fieldtype == TYPE_VECTOR)
+            op = INSTR_STOREP_V;
+    }
+
     return ir_block_create_store_op(self, op, target, what);
 }
 
@@ -1284,6 +1376,8 @@ on_error:
 
 ir_value* ir_block_create_fieldaddress(ir_block *self, const char *label, ir_value *ent, ir_value *field)
 {
+    ir_value *v;
+
     /* Support for various pointer types todo if so desired */
     if (ent->vtype != TYPE_ENTITY)
         return NULL;
@@ -1291,7 +1385,9 @@ ir_value* ir_block_create_fieldaddress(ir_block *self, const char *label, ir_val
     if (field->vtype != TYPE_FIELD)
         return NULL;
 
-    return ir_block_create_general_instr(self, label, INSTR_ADDRESS, ent, field, TYPE_POINTER);
+    v = ir_block_create_general_instr(self, label, INSTR_ADDRESS, ent, field, TYPE_POINTER);
+    v->fieldtype = field->fieldtype;
+    return v;
 }
 
 ir_value* ir_block_create_load_from_ent(ir_block *self, const char *label, ir_value *ent, ir_value *field, int outype)
@@ -1315,8 +1411,6 @@ ir_value* ir_block_create_load_from_ent(ir_block *self, const char *label, ir_va
         case TYPE_POINTER: op = INSTR_LOAD_I;   break;
         case TYPE_INTEGER: op = INSTR_LOAD_I;   break;
 #endif
-        case TYPE_QUATERNION: op = INSTR_LOAD_Q; break;
-        case TYPE_MATRIX:     op = INSTR_LOAD_M; break;
         default:
             return NULL;
     }
@@ -1420,22 +1514,12 @@ ir_value* ir_block_create_mul(ir_block *self,
             case TYPE_VECTOR:
                 op = INSTR_MUL_V;
                 break;
-            case TYPE_QUATERNION:
-                op = INSTR_MUL_Q;
-                break;
-            case TYPE_MATRIX:
-                op = INSTR_MUL_M;
-                break;
         }
     } else {
         if ( (l == TYPE_VECTOR && r == TYPE_FLOAT) )
             op = INSTR_MUL_VF;
         else if ( (l == TYPE_FLOAT && r == TYPE_VECTOR) )
             op = INSTR_MUL_FV;
-        else if ( (l == TYPE_QUATERNION && r == TYPE_FLOAT) )
-            op = INSTR_MUL_QF;
-        else if ( (l == TYPE_MATRIX && r == TYPE_FLOAT) )
-            op = INSTR_MUL_MF;
 #if 0
         else if ( (l == TYPE_VECTOR && r == TYPE_INTEGER) )
             op = INSTR_MUL_VI;
@@ -2101,25 +2185,19 @@ static bool gen_global_field(ir_value *global)
         }
 
         /* copy the field's value */
-        global->code.globaladdr = code_globals_add(code_globals_data[fld->code.globaladdr]);
+        ir_value_code_setaddr(global, code_globals_add(code_globals_data[fld->code.globaladdr]));
+        if (global->fieldtype == TYPE_VECTOR) {
+            code_globals_add(code_globals_data[fld->code.globaladdr]+1);
+            code_globals_add(code_globals_data[fld->code.globaladdr]+2);
+        }
     }
     else
     {
-        prog_section_field fld;
-
-        fld.name = global->code.name;
-        fld.offset = code_fields_elements;
-        fld.type = global->fieldtype;
-
-        if (fld.type == TYPE_VOID) {
-            printf("Field is missing a type: %s\n", global->name);
-            return false;
+        ir_value_code_setaddr(global, code_globals_add(0));
+        if (global->fieldtype == TYPE_VECTOR) {
+            code_globals_add(0);
+            code_globals_add(0);
         }
-
-        if (code_fields_add(fld) < 0)
-            return false;
-
-        global->code.globaladdr = code_globals_add(fld.offset);
     }
     if (global->code.globaladdr < 0)
         return false;
@@ -2152,11 +2230,11 @@ static bool gen_global_pointer(ir_value *global)
             return false;
         }
 
-        global->code.globaladdr = code_globals_add(target->code.globaladdr);
+        ir_value_code_setaddr(global, code_globals_add(target->code.globaladdr));
     }
     else
     {
-        global->code.globaladdr = code_globals_add(0);
+        ir_value_code_setaddr(global, code_globals_add(0));
     }
     if (global->code.globaladdr < 0)
         return false;
@@ -2214,7 +2292,7 @@ tailcall:
              * come first: eg. optimize IFs without ELSE...
              */
 
-            stmt.o1.u1 = instr->_ops[0]->code.globaladdr;
+            stmt.o1.u1 = ir_value_code_addr(instr->_ops[0]);
             stmt.o2.u1 = 0;
             stmt.o3.s1 = 0;
 
@@ -2293,7 +2371,7 @@ tailcall:
                 stmt.o3.u1 = 0;
 
                 stmt.opcode = type_store_instr[param->vtype];
-                stmt.o1.u1 = param->code.globaladdr;
+                stmt.o1.u1 = ir_value_code_addr(param);
                 stmt.o2.u1 = OFS_PARM0 + 3 * p;
                 if (code_statements_add(stmt) < 0)
                     return false;
@@ -2301,7 +2379,7 @@ tailcall:
             stmt.opcode = INSTR_CALL0 + instr->params_count;
             if (stmt.opcode > INSTR_CALL8)
                 stmt.opcode = INSTR_CALL8;
-            stmt.o1.u1 = instr->_ops[1]->code.globaladdr;
+            stmt.o1.u1 = ir_value_code_addr(instr->_ops[1]);
             stmt.o2.u1 = 0;
             stmt.o3.u1 = 0;
             if (code_statements_add(stmt) < 0)
@@ -2313,7 +2391,7 @@ tailcall:
                 /* not to be kept in OFS_RETURN */
                 stmt.opcode = type_store_instr[retvalue->vtype];
                 stmt.o1.u1 = OFS_RETURN;
-                stmt.o2.u1 = retvalue->code.globaladdr;
+                stmt.o2.u1 = ir_value_code_addr(retvalue);
                 stmt.o3.u1 = 0;
                 if (code_statements_add(stmt) < 0)
                     return false;
@@ -2333,21 +2411,23 @@ tailcall:
 
         /* This is the general order of operands */
         if (instr->_ops[0])
-            stmt.o3.u1 = instr->_ops[0]->code.globaladdr;
+            stmt.o3.u1 = ir_value_code_addr(instr->_ops[0]);
 
         if (instr->_ops[1])
-            stmt.o1.u1 = instr->_ops[1]->code.globaladdr;
+            stmt.o1.u1 = ir_value_code_addr(instr->_ops[1]);
 
         if (instr->_ops[2])
-            stmt.o2.u1 = instr->_ops[2]->code.globaladdr;
+            stmt.o2.u1 = ir_value_code_addr(instr->_ops[2]);
 
         if (stmt.opcode == INSTR_RETURN || stmt.opcode == INSTR_DONE)
         {
             stmt.o1.u1 = stmt.o3.u1;
             stmt.o3.u1 = 0;
         }
-        else if (stmt.opcode >= INSTR_STORE_F &&
-                 stmt.opcode <= INSTR_STORE_FNC)
+        else if ((stmt.opcode >= INSTR_STORE_F &&
+                  stmt.opcode <= INSTR_STORE_FNC) ||
+                 (stmt.opcode >= INSTR_STOREP_F &&
+                  stmt.opcode <= INSTR_STOREP_FNC))
         {
             /* 2-operand instructions with A -> B */
             stmt.o2.u1 = stmt.o3.u1;
@@ -2439,7 +2519,7 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
     {
         /* generate code.globaladdr for ssa values */
         ir_value *v = irfun->values[i];
-        v->code.globaladdr = local_var_end + v->code.local;
+        ir_value_code_setaddr(v, local_var_end + v->code.local);
     }
     for (i = 0; i < irfun->locals_count; ++i) {
         /* fill the locals with zeros */
@@ -2488,9 +2568,9 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
 
         if (global->isconst) {
             iptr = (int32_t*)&global->constval.vfloat;
-            global->code.globaladdr = code_globals_add(*iptr);
+            ir_value_code_setaddr(global, code_globals_add(*iptr));
         } else
-            global->code.globaladdr = code_globals_add(0);
+            ir_value_code_setaddr(global, code_globals_add(0));
 
         return global->code.globaladdr >= 0;
     }
@@ -2499,14 +2579,12 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
         if (code_defs_add(def) < 0)
             return false;
         if (global->isconst)
-            global->code.globaladdr = code_globals_add(code_cachedstring(global->constval.vstring));
+            ir_value_code_setaddr(global, code_globals_add(code_cachedstring(global->constval.vstring)));
         else
-            global->code.globaladdr = code_globals_add(0);
+            ir_value_code_setaddr(global, code_globals_add(0));
         return global->code.globaladdr >= 0;
     }
     case TYPE_VECTOR:
-    case TYPE_QUATERNION:
-    case TYPE_MATRIX:
     {
         size_t d;
         if (code_defs_add(def) < 0)
@@ -2514,7 +2592,7 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
 
         if (global->isconst) {
             iptr = (int32_t*)&global->constval.vvec;
-            global->code.globaladdr = code_globals_add(iptr[0]);
+            ir_value_code_setaddr(global, code_globals_add(iptr[0]));
             if (global->code.globaladdr < 0)
                 return false;
             for (d = 1; d < type_sizeof[global->vtype]; ++d)
@@ -2523,7 +2601,7 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
                     return false;
             }
         } else {
-            global->code.globaladdr = code_globals_add(0);
+            ir_value_code_setaddr(global, code_globals_add(0));
             if (global->code.globaladdr < 0)
                 return false;
             for (d = 1; d < type_sizeof[global->vtype]; ++d)
@@ -2537,12 +2615,12 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
     case TYPE_FUNCTION:
         if (code_defs_add(def) < 0)
             return false;
-        global->code.globaladdr = code_globals_elements;
+        ir_value_code_setaddr(global, code_globals_elements);
         code_globals_add(code_functions_elements);
         return gen_global_function(self, global);
     case TYPE_VARIANT:
         /* assume biggest type */
-            global->code.globaladdr = code_globals_add(0);
+            ir_value_code_setaddr(global, code_globals_add(0));
             for (i = 1; i < type_sizeof[TYPE_VARIANT]; ++i)
                 code_globals_add(0);
             return true;
@@ -2553,12 +2631,87 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
     }
 }
 
+static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
+{
+    prog_section_def def;
+    prog_section_field fld;
+
+    def.type   = field->vtype;
+    def.offset = code_globals_elements;
+
+    /* create a global named the same as the field */
+    if (opts_standard == COMPILER_GMQCC) {
+        /* in our standard, the global gets a dot prefix */
+        size_t len = strlen(field->name);
+        char name[1024];
+
+        /* we really don't want to have to allocate this, and 1024
+         * bytes is more than enough for a variable/field name
+         */
+        if (len+2 >= sizeof(name)) {
+            printf("invalid field name size: %u\n", (unsigned int)len);
+            return false;
+        }
+
+        name[0] = '.';
+        strcpy(name+1, field->name); /* no strncpy - we used strlen above */
+        name[len+1] = 0;
+
+        def.name = code_genstring(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,
+         * and so we also name the global the same.
+         * FIXME: fteqcc should create a global as well
+         * check if it actually uses the same name. Probably does
+         */
+        def.name = code_genstring(field->name);
+        fld.name = def.name;
+    }
+
+    field->code.name = def.name;
+
+    if (code_defs_add(def) < 0)
+        return false;
+
+    fld.type = field->fieldtype;
+
+    if (fld.type == TYPE_VOID) {
+        printf("field is missing a type: %s - don't know its size\n", field->name);
+        return false;
+    }
+
+    fld.offset = code_alloc_field(type_sizeof[field->fieldtype]);
+
+    if (code_fields_add(fld) < 0)
+        return false;
+
+    ir_value_code_setaddr(field, code_globals_elements);
+    if (!code_globals_add(fld.offset))
+        return false;
+    if (fld.type == TYPE_VECTOR) {
+        if (!code_globals_add(fld.offset+1))
+            return false;
+        if (!code_globals_add(fld.offset+2))
+            return false;
+    }
+
+    return field->code.globaladdr >= 0;
+}
+
 bool ir_builder_generate(ir_builder *self, const char *filename)
 {
     size_t i;
 
     code_init();
 
+    for (i = 0; i < self->fields_count; ++i)
+    {
+        if (!ir_builder_gen_field(self, self->fields[i])) {
+            return false;
+        }
+    }
+
     for (i = 0; i < self->globals_count; ++i)
     {
         if (!ir_builder_gen_global(self, self->globals[i])) {
@@ -2591,176 +2744,183 @@ const char *qc_opname(int op)
 
 void ir_builder_dump(ir_builder *b, int (*oprintf)(const char*, ...))
 {
-	size_t i;
-	char indent[IND_BUFSZ];
-	indent[0] = '\t';
-	indent[1] = 0;
-
-	oprintf("module %s\n", b->name);
-	for (i = 0; i < b->globals_count; ++i)
-	{
-		oprintf("global ");
-		if (b->globals[i]->isconst)
-			oprintf("%s = ", b->globals[i]->name);
-		ir_value_dump(b->globals[i], oprintf);
-		oprintf("\n");
-	}
-	for (i = 0; i < b->functions_count; ++i)
-		ir_function_dump(b->functions[i], indent, oprintf);
-	oprintf("endmodule %s\n", b->name);
+    size_t i;
+    char indent[IND_BUFSZ];
+    indent[0] = '\t';
+    indent[1] = 0;
+
+    oprintf("module %s\n", b->name);
+    for (i = 0; i < b->globals_count; ++i)
+    {
+        oprintf("global ");
+        if (b->globals[i]->isconst)
+            oprintf("%s = ", b->globals[i]->name);
+        ir_value_dump(b->globals[i], oprintf);
+        oprintf("\n");
+    }
+    for (i = 0; i < b->functions_count; ++i)
+        ir_function_dump(b->functions[i], indent, oprintf);
+    oprintf("endmodule %s\n", b->name);
 }
 
 void ir_function_dump(ir_function *f, char *ind,
                       int (*oprintf)(const char*, ...))
 {
-	size_t i;
-	if (f->builtin != 0) {
-	    oprintf("%sfunction %s = builtin %i\n", ind, f->name, -f->builtin);
-	    return;
-	}
-	oprintf("%sfunction %s\n", ind, f->name);
-	strncat(ind, "\t", IND_BUFSZ);
-	if (f->locals_count)
-	{
-		oprintf("%s%i locals:\n", ind, (int)f->locals_count);
-		for (i = 0; i < f->locals_count; ++i) {
-			oprintf("%s\t", ind);
-			ir_value_dump(f->locals[i], oprintf);
-			oprintf("\n");
-		}
-	}
-	if (f->blocks_count)
-	{
-		oprintf("%slife passes (check): %i\n", ind, (int)f->run_id);
-		for (i = 0; i < f->blocks_count; ++i) {
-		    if (f->blocks[i]->run_id != f->run_id) {
-		        oprintf("%slife pass check fail! %i != %i\n", ind, (int)f->blocks[i]->run_id, (int)f->run_id);
-		    }
-			ir_block_dump(f->blocks[i], ind, oprintf);
-		}
-
-	}
-	ind[strlen(ind)-1] = 0;
-	oprintf("%sendfunction %s\n", ind, f->name);
+    size_t i;
+    if (f->builtin != 0) {
+        oprintf("%sfunction %s = builtin %i\n", ind, f->name, -f->builtin);
+        return;
+    }
+    oprintf("%sfunction %s\n", ind, f->name);
+    strncat(ind, "\t", IND_BUFSZ);
+    if (f->locals_count)
+    {
+        oprintf("%s%i locals:\n", ind, (int)f->locals_count);
+        for (i = 0; i < f->locals_count; ++i) {
+            oprintf("%s\t", ind);
+            ir_value_dump(f->locals[i], oprintf);
+            oprintf("\n");
+        }
+    }
+    if (f->blocks_count)
+    {
+        oprintf("%slife passes (check): %i\n", ind, (int)f->run_id);
+        for (i = 0; i < f->blocks_count; ++i) {
+            if (f->blocks[i]->run_id != f->run_id) {
+                oprintf("%slife pass check fail! %i != %i\n", ind, (int)f->blocks[i]->run_id, (int)f->run_id);
+            }
+            ir_block_dump(f->blocks[i], ind, oprintf);
+        }
+
+    }
+    ind[strlen(ind)-1] = 0;
+    oprintf("%sendfunction %s\n", ind, f->name);
 }
 
 void ir_block_dump(ir_block* b, char *ind,
                    int (*oprintf)(const char*, ...))
 {
-	size_t i;
-	oprintf("%s:%s\n", ind, b->label);
-	strncat(ind, "\t", IND_BUFSZ);
+    size_t i;
+    oprintf("%s:%s\n", ind, b->label);
+    strncat(ind, "\t", IND_BUFSZ);
 
-	for (i = 0; i < b->instr_count; ++i)
-		ir_instr_dump(b->instr[i], ind, oprintf);
-	ind[strlen(ind)-1] = 0;
+    for (i = 0; i < b->instr_count; ++i)
+        ir_instr_dump(b->instr[i], ind, oprintf);
+    ind[strlen(ind)-1] = 0;
 }
 
 void dump_phi(ir_instr *in, char *ind,
               int (*oprintf)(const char*, ...))
 {
-	size_t i;
-	oprintf("%s <- phi ", in->_ops[0]->name);
-	for (i = 0; i < in->phi_count; ++i)
-	{
-		oprintf("([%s] : %s) ", in->phi[i].from->label,
-		                        in->phi[i].value->name);
-	}
-	oprintf("\n");
+    size_t i;
+    oprintf("%s <- phi ", in->_ops[0]->name);
+    for (i = 0; i < in->phi_count; ++i)
+    {
+        oprintf("([%s] : %s) ", in->phi[i].from->label,
+                                in->phi[i].value->name);
+    }
+    oprintf("\n");
 }
 
 void ir_instr_dump(ir_instr *in, char *ind,
                        int (*oprintf)(const char*, ...))
 {
-	size_t i;
-	const char *comma = NULL;
-
-	oprintf("%s (%i) ", ind, (int)in->eid);
-
-	if (in->opcode == VINSTR_PHI) {
-		dump_phi(in, ind, oprintf);
-		return;
-	}
-
-	strncat(ind, "\t", IND_BUFSZ);
-
-	if (in->_ops[0] && (in->_ops[1] || in->_ops[2])) {
-		ir_value_dump(in->_ops[0], oprintf);
-		if (in->_ops[1] || in->_ops[2])
-			oprintf(" <- ");
-	}
-	oprintf("%s\t", qc_opname(in->opcode));
-	if (in->_ops[0] && !(in->_ops[1] || in->_ops[2])) {
-		ir_value_dump(in->_ops[0], oprintf);
-		comma = ",\t";
-	}
-	else
-	{
-		for (i = 1; i != 3; ++i) {
-			if (in->_ops[i]) {
-				if (comma)
-					oprintf(comma);
-				ir_value_dump(in->_ops[i], oprintf);
-				comma = ",\t";
-			}
-		}
-	}
-	if (in->bops[0]) {
-		if (comma)
-			oprintf(comma);
-		oprintf("[%s]", in->bops[0]->label);
-		comma = ",\t";
-	}
-	if (in->bops[1])
-		oprintf("%s[%s]", comma, in->bops[1]->label);
-	oprintf("\n");
-	ind[strlen(ind)-1] = 0;
+    size_t i;
+    const char *comma = NULL;
+
+    oprintf("%s (%i) ", ind, (int)in->eid);
+
+    if (in->opcode == VINSTR_PHI) {
+        dump_phi(in, ind, oprintf);
+        return;
+    }
+
+    strncat(ind, "\t", IND_BUFSZ);
+
+    if (in->_ops[0] && (in->_ops[1] || in->_ops[2])) {
+        ir_value_dump(in->_ops[0], oprintf);
+        if (in->_ops[1] || in->_ops[2])
+            oprintf(" <- ");
+    }
+    if (in->opcode == INSTR_CALL0) {
+        oprintf("CALL%i\t", in->params_count);
+    } else
+        oprintf("%s\t", qc_opname(in->opcode));
+
+    if (in->_ops[0] && !(in->_ops[1] || in->_ops[2])) {
+        ir_value_dump(in->_ops[0], oprintf);
+        comma = ",\t";
+    }
+    else
+    {
+        for (i = 1; i != 3; ++i) {
+            if (in->_ops[i]) {
+                if (comma)
+                    oprintf(comma);
+                ir_value_dump(in->_ops[i], oprintf);
+                comma = ",\t";
+            }
+        }
+    }
+    if (in->bops[0]) {
+        if (comma)
+            oprintf(comma);
+        oprintf("[%s]", in->bops[0]->label);
+        comma = ",\t";
+    }
+    if (in->bops[1])
+        oprintf("%s[%s]", comma, in->bops[1]->label);
+    oprintf("\n");
+    ind[strlen(ind)-1] = 0;
 }
 
 void ir_value_dump(ir_value* v, int (*oprintf)(const char*, ...))
 {
-	if (v->isconst) {
-		switch (v->vtype) {
-		    default:
-			case TYPE_VOID:
-				oprintf("(void)");
-				break;
-			case TYPE_FLOAT:
-				oprintf("%g", v->constval.vfloat);
-				break;
-			case TYPE_VECTOR:
-				oprintf("'%g %g %g'",
-				        v->constval.vvec.x,
-				        v->constval.vvec.y,
-				        v->constval.vvec.z);
-				break;
-			case TYPE_ENTITY:
-				oprintf("(entity)");
-				break;
-			case TYPE_STRING:
-				oprintf("\"%s\"", v->constval.vstring);
-				break;
+    if (v->isconst) {
+        switch (v->vtype) {
+            default:
+            case TYPE_VOID:
+                oprintf("(void)");
+                break;
+            case TYPE_FUNCTION:
+                oprintf("(function)");
+                break;
+            case TYPE_FLOAT:
+                oprintf("%g", v->constval.vfloat);
+                break;
+            case TYPE_VECTOR:
+                oprintf("'%g %g %g'",
+                        v->constval.vvec.x,
+                        v->constval.vvec.y,
+                        v->constval.vvec.z);
+                break;
+            case TYPE_ENTITY:
+                oprintf("(entity)");
+                break;
+            case TYPE_STRING:
+                oprintf("\"%s\"", v->constval.vstring);
+                break;
 #if 0
-			case TYPE_INTEGER:
-				oprintf("%i", v->constval.vint);
-				break;
+            case TYPE_INTEGER:
+                oprintf("%i", v->constval.vint);
+                break;
 #endif
-			case TYPE_POINTER:
-				oprintf("&%s",
-					v->constval.vpointer->name);
-				break;
-		}
-	} else {
-		oprintf("%s", v->name);
-	}
+            case TYPE_POINTER:
+                oprintf("&%s",
+                    v->constval.vpointer->name);
+                break;
+        }
+    } else {
+        oprintf("%s", v->name);
+    }
 }
 
 void ir_value_dump_life(ir_value *self, int (*oprintf)(const char*,...))
 {
-	size_t i;
-	oprintf("Life of %s:\n", self->name);
-	for (i = 0; i < self->life_count; ++i)
-	{
-		oprintf(" + [%i, %i]\n", self->life[i].start, self->life[i].end);
-	}
+    size_t i;
+    oprintf("Life of %s:\n", self->name);
+    for (i = 0; i < self->life_count; ++i)
+    {
+        oprintf(" + [%i, %i]\n", self->life[i].start, self->life[i].end);
+    }
 }