X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ir.c;h=47b9adc7798125536cf83969e61468da5068c2c8;hb=412446f42ebade78b38153d93f0135b15a48f01e;hp=0a6a8dae555691091c7c202a13368fc7e46602e1;hpb=14210a62ef7ff1529f93b5c050553049e1bedd4a;p=xonotic%2Fgmqcc.git

diff --git a/ir.c b/ir.c
index 0a6a8da..47b9adc 100644
--- a/ir.c
+++ b/ir.c
@@ -133,6 +133,24 @@ static void irerror(lex_ctx ctx, const char *msg, ...)
     va_end(ap);
 }
 
+static bool irwarning(lex_ctx ctx, int warntype, const char *fmt, ...)
+{
+	va_list ap;
+	int lvl = LVL_WARNING;
+
+    if (!OPTS_WARN(warntype))
+        return false;
+
+    if (opts_werror)
+	    lvl = LVL_ERROR;
+
+	va_start(ap, fmt);
+    vprintmsg(lvl, ctx.file, ctx.line, "warning", fmt, ap);
+	va_end(ap);
+
+	return opts_werror;
+}
+
 /***********************************************************************
  *IR Builder
  */
@@ -154,11 +172,6 @@ ir_builder* ir_builder_new(const char *modulename)
         return NULL;
     }
 
-    /* globals which always exist */
-
-    /* for now we give it a vector size */
-    ir_builder_create_global(self, "OFS_RETURN", TYPE_VARIANT);
-
     return self;
 }
 
@@ -421,7 +434,7 @@ ir_value* ir_function_create_local(ir_function *self, const char *name, int vtyp
     if (param &&
         self->locals_count &&
         self->locals[self->locals_count-1]->store != store_param) {
-        irerror(self->context, "cannot add parameters after adding locals\n");
+        irerror(self->context, "cannot add parameters after adding locals");
         return NULL;
     }
 
@@ -623,6 +636,7 @@ ir_value* ir_value_var(const char *name, int storetype, int vtype)
     self->members[0] = NULL;
     self->members[1] = NULL;
     self->members[2] = NULL;
+    self->memberof = NULL;
 
     MEM_VECTOR_INIT(self, life);
     return self;
@@ -662,10 +676,11 @@ ir_value* ir_value_vector_member(ir_value *self, unsigned int member)
     }
     else
     {
-        irerror(self->context, "invalid member access on %s\n", self->name);
+        irerror(self->context, "invalid member access on %s", self->name);
         return NULL;
     }
 
+    m->memberof = self;
     return m;
 }
 
@@ -749,11 +764,22 @@ bool ir_value_set_field(ir_value *self, ir_value *fld)
     return true;
 }
 
+static char *ir_strdup(const char *str)
+{
+    if (str && !*str) {
+        /* actually dup empty strings */
+        char *out = mem_a(1);
+        *out = 0;
+        return out;
+    }
+    return util_strdup(str);
+}
+
 bool ir_value_set_string(ir_value *self, const char *str)
 {
     if (self->vtype != TYPE_STRING)
         return false;
-    self->constval.vstring = util_strdup(str);
+    self->constval.vstring = ir_strdup(str);
     self->isconst = true;
     return true;
 }
@@ -959,13 +985,8 @@ bool ir_values_overlap(const ir_value *a, const ir_value *b)
         /* check if the entries overlap, for that,
          * both must start before the other one ends.
          */
-#if defined(LIFE_RANGE_WITHOUT_LAST_READ)
-        if (la->start <= lb->end &&
-            lb->start <= la->end)
-#else
-        if (la->start <  lb->end &&
-            lb->start <  la->end)
-#endif
+        if (la->start < lb->end &&
+            lb->start < la->end)
         {
             return true;
         }
@@ -1007,9 +1028,9 @@ bool ir_block_create_store_op(ir_block *self, int op, ir_value *target, ir_value
     if (target->store == store_value &&
         (op < INSTR_STOREP_F || op > INSTR_STOREP_FNC))
     {
-        irerror(self->context, "cannot store to an SSA value\n");
-        irerror(self->context, "trying to store: %s <- %s\n", target->name, what->name);
-        irerror(self->context, "instruction: %s\n", asm_instr[op].m);
+        irerror(self->context, "cannot store to an SSA value");
+        irerror(self->context, "trying to store: %s <- %s", target->name, what->name);
+        irerror(self->context, "instruction: %s", asm_instr[op].m);
         return false;
     }
 
@@ -1073,7 +1094,7 @@ bool ir_block_create_return(ir_block *self, ir_value *v)
 {
     ir_instr *in;
     if (self->final) {
-        irerror(self->context, "block already ended (%s)\n", self->label);
+        irerror(self->context, "block already ended (%s)", self->label);
         return false;
     }
     self->final = true;
@@ -1095,7 +1116,7 @@ bool ir_block_create_if(ir_block *self, ir_value *v,
 {
     ir_instr *in;
     if (self->final) {
-        irerror(self->context, "block already ended (%s)\n", self->label);
+        irerror(self->context, "block already ended (%s)", self->label);
         return false;
     }
     self->final = true;
@@ -1129,7 +1150,7 @@ bool ir_block_create_jump(ir_block *self, ir_block *to)
 {
     ir_instr *in;
     if (self->final) {
-        irerror(self->context, "block already ended (%s)\n", self->label);
+        irerror(self->context, "block already ended (%s)", self->label);
         return false;
     }
     self->final = true;
@@ -1153,7 +1174,7 @@ bool ir_block_create_goto(ir_block *self, ir_block *to)
 {
     ir_instr *in;
     if (self->final) {
-        irerror(self->context, "block already ended (%s)\n", self->label);
+        irerror(self->context, "block already ended (%s)", self->label);
         return false;
     }
     self->final = true;
@@ -1211,7 +1232,7 @@ bool ir_phi_add(ir_instr* self, ir_block *b, ir_value *v)
         /* Must not be possible to cause this, otherwise the AST
          * is doing something wrong.
          */
-        irerror(self->context, "Invalid entry block for PHI\n");
+        irerror(self->context, "Invalid entry block for PHI");
         abort();
     }
 
@@ -1791,11 +1812,25 @@ bool ir_function_calculate_liferanges(ir_function *self)
         {
             if (self->blocks[i]->is_return)
             {
+                self->blocks[i]->living_count = 0;
                 if (!ir_block_life_propagate(self->blocks[i], NULL, &changed))
                     return false;
             }
         }
     } while (changed);
+    if (self->blocks_count) {
+        ir_block *block = self->blocks[0];
+        for (i = 0; i < block->living_count; ++i) {
+            ir_value *v = block->living[i];
+            if (v->memberof || v->store != store_local)
+                continue;
+            if (irwarning(v->context, WARN_USED_UNINITIALIZED,
+                          "variable `%s` may be used uninitialized in this function", v->name))
+            {
+                return false;
+            }
+        }
+    }
     return true;
 }
 
@@ -1982,7 +2017,7 @@ static bool ir_block_living_add_instr(ir_block *self, size_t eid)
         tempbool = ir_value_life_merge(self->living[i], eid);
         /* debug
         if (tempbool)
-            irerror(self->context, "block_living_add_instr() value instruction added %s: %i\n", self->living[i]->_name, (int)eid);
+            irerror(self->context, "block_living_add_instr() value instruction added %s: %i", self->living[i]->_name, (int)eid);
         */
         changed = changed || tempbool;
     }
@@ -2017,7 +2052,7 @@ static bool ir_block_life_prop_previous(ir_block* self, ir_block *prev, bool *ch
         if (!ir_block_living_add(self, prev->living[i]))
             return false;
         /*
-        irerror(self->contextt from prev: %s\n", self->label, prev->living[i]->_name);
+        irerror(self->contextt from prev: %s", self->label, prev->living[i]->_name);
         */
     }
     return true;
@@ -2031,17 +2066,9 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
     size_t i, o, p;
     /* bitmasks which operands are read from or written to */
     size_t read, write;
-#if defined(LIFE_RANGE_WITHOUT_LAST_READ)
-    size_t rd;
-    new_reads_t new_reads;
-#endif
     char dbg_ind[16] = { '#', '0' };
     (void)dbg_ind;
 
-#if defined(LIFE_RANGE_WITHOUT_LAST_READ)
-    MEM_VECTOR_INIT(&new_reads, v);
-#endif
-
     if (prev)
     {
         if (!ir_block_life_prop_previous(self, prev, changed))
@@ -2057,43 +2084,44 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
         for (p = 0; p < instr->phi_count; ++p)
         {
             value = instr->phi[p].value;
-#if ! defined(LIFE_RANGE_WITHOUT_LAST_READ)
+            if (value->memberof)
+                value = value->memberof;
             if (!ir_block_living_find(self, value, NULL) &&
                 !ir_block_living_add(self, value))
             {
-                goto on_error;
-            }
-#else
-            if (!new_reads_t_v_find(&new_reads, value, NULL))
-            {
-                if (!new_reads_t_v_add(&new_reads, value))
-                    goto on_error;
+                return false;
             }
-#endif
         }
 
         /* call params are read operands too */
         for (p = 0; p < instr->params_count; ++p)
         {
             value = instr->params[p];
-#if ! defined(LIFE_RANGE_WITHOUT_LAST_READ)
+            if (value->memberof)
+                value = value->memberof;
             if (!ir_block_living_find(self, value, NULL) &&
                 !ir_block_living_add(self, value))
             {
-                goto on_error;
-            }
-#else
-            if (!new_reads_t_v_find(&new_reads, value, NULL))
-            {
-                if (!new_reads_t_v_add(&new_reads, value))
-                    goto on_error;
+                return false;
             }
-#endif
         }
 
         /* See which operands are read and write operands */
         ir_op_read_write(instr->opcode, &read, &write);
 
+        if (instr->opcode == INSTR_MUL_VF)
+        {
+            /* the float source will get an additional lifetime */
+            tempbool = ir_value_life_merge(instr->_ops[2], instr->eid+1);
+            *changed = *changed || tempbool;
+        }
+        else if (instr->opcode == INSTR_MUL_FV)
+        {
+            /* the float source will get an additional lifetime */
+            tempbool = ir_value_life_merge(instr->_ops[1], instr->eid+1);
+            *changed = *changed || tempbool;
+        }
+
         /* Go through the 3 main operands */
         for (o = 0; o < 3; ++o)
         {
@@ -2101,6 +2129,8 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
                 continue;
 
             value = instr->_ops[o];
+            if (value->memberof)
+                value = value->memberof;
 
             /* We only care about locals */
             /* we also calculate parameter liferanges so that locals
@@ -2113,20 +2143,11 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
             /* read operands */
             if (read & (1<<o))
             {
-#if ! defined(LIFE_RANGE_WITHOUT_LAST_READ)
                 if (!ir_block_living_find(self, value, NULL) &&
                     !ir_block_living_add(self, value))
                 {
-                    goto on_error;
-                }
-#else
-                /* fprintf(stderr, "read: %s\n", value->_name); */
-                if (!new_reads_t_v_find(&new_reads, value, NULL))
-                {
-                    if (!new_reads_t_v_add(&new_reads, value))
-                        goto on_error;
+                    return false;
                 }
-#endif
             }
 
             /* write operands */
@@ -2138,13 +2159,7 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
             {
                 size_t idx;
                 bool in_living = ir_block_living_find(self, value, &idx);
-#if defined(LIFE_RANGE_WITHOUT_LAST_READ)
-                size_t readidx;
-                bool in_reads = new_reads_t_v_find(&new_reads, value, &readidx);
-                if (!in_living && !in_reads)
-#else
                 if (!in_living)
-#endif
                 {
                     /* If the value isn't alive it hasn't been read before... */
                     /* TODO: See if the warning can be emitted during parsing or AST processing
@@ -2173,16 +2188,8 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
                     */
                     *changed = *changed || tempbool;
                     /* Then remove */
-#if ! defined(LIFE_RANGE_WITHOUT_LAST_READ)
                     if (!ir_block_living_remove(self, idx))
-                        goto on_error;
-#else
-                    if (in_reads)
-                    {
-                        if (!new_reads_t_v_remove(&new_reads, readidx))
-                            goto on_error;
-                    }
-#endif
+                        return false;
                 }
             }
         }
@@ -2191,21 +2198,6 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
         /*fprintf(stderr, "living added values\n");*/
         *changed = *changed || tempbool;
 
-#if defined(LIFE_RANGE_WITHOUT_LAST_READ)
-        /* new reads: */
-        for (rd = 0; rd < new_reads.v_count; ++rd)
-        {
-            if (!ir_block_living_find(self, new_reads.v[rd], NULL)) {
-                if (!ir_block_living_add(self, new_reads.v[rd]))
-                    goto on_error;
-            }
-            if (!i && !self->entries_count) {
-                /* fix the top */
-                *changed = *changed || ir_value_life_merge(new_reads.v[rd], instr->eid);
-            }
-        }
-        MEM_VECTOR_CLEAR(&new_reads, v);
-#endif
     }
 
     if (self->run_id == self->owner->run_id)
@@ -2220,11 +2212,6 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
     }
 
     return true;
-on_error:
-#if defined(LIFE_RANGE_WITHOUT_LAST_READ)
-    MEM_VECTOR_CLEAR(&new_reads, v);
-#endif
-    return false;
 }
 
 /***********************************************************************
@@ -2250,7 +2237,7 @@ static bool gen_global_field(ir_value *global)
     {
         ir_value *fld = global->constval.vpointer;
         if (!fld) {
-            irerror(global->context, "Invalid field constant with no field: %s\n", global->name);
+            irerror(global->context, "Invalid field constant with no field: %s", global->name);
             return false;
         }
 
@@ -2263,7 +2250,7 @@ static bool gen_global_field(ir_value *global)
          * for functions... might as well support that here.
          */
         if (!fld->code.globaladdr) {
-            irerror(global->context, "FIXME: Relocation support\n");
+            irerror(global->context, "FIXME: Relocation support");
             return false;
         }
 
@@ -2293,7 +2280,7 @@ static bool gen_global_pointer(ir_value *global)
     {
         ir_value *target = global->constval.vpointer;
         if (!target) {
-            irerror(global->context, "Invalid pointer constant: %s\n", global->name);
+            irerror(global->context, "Invalid pointer constant: %s", global->name);
             /* NULL pointers are pointing to the NULL constant, which also
              * sits at address 0, but still has an ir_value for itself.
              */
@@ -2309,7 +2296,7 @@ static bool gen_global_pointer(ir_value *global)
             /* FIXME: Check for the constant nullptr ir_value!
              * because then code.globaladdr being 0 is valid.
              */
-            irerror(global->context, "FIXME: Relocation support\n");
+            irerror(global->context, "FIXME: Relocation support");
             return false;
         }
 
@@ -2342,7 +2329,7 @@ tailcall:
         instr = block->instr[i];
 
         if (instr->opcode == VINSTR_PHI) {
-            irerror(block->context, "cannot generate virtual instruction (phi)\n");
+            irerror(block->context, "cannot generate virtual instruction (phi)");
             return false;
         }
 
@@ -2483,7 +2470,7 @@ tailcall:
         }
 
         if (instr->opcode == INSTR_STATE) {
-            irerror(block->context, "TODO: state instruction\n");
+            irerror(block->context, "TODO: state instruction");
             return false;
         }
 
@@ -2532,7 +2519,7 @@ static bool gen_function_code(ir_function *self)
      * for now. Dead blocks will not be translated obviously.
      */
     if (!self->blocks_count) {
-        irerror(self->context, "Function '%s' declared without body.\n", self->name);
+        irerror(self->context, "Function '%s' declared without body.", self->name);
         return false;
     }
 
@@ -2541,7 +2528,7 @@ static bool gen_function_code(ir_function *self)
         return true;
 
     if (!gen_blocks_recursive(self, block)) {
-        irerror(self->context, "failed to generate blocks for '%s'\n", self->name);
+        irerror(self->context, "failed to generate blocks for '%s'", self->name);
         return false;
     }
 
@@ -2565,7 +2552,7 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
 
     if (!global->isconst || (!global->constval.vfunc))
     {
-        irerror(global->context, "Invalid state of function-global: not constant: %s\n", global->name);
+        irerror(global->context, "Invalid state of function-global: not constant: %s", global->name);
         return false;
     }
 
@@ -2584,7 +2571,6 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
     }
 
     fun.firstlocal = code_globals_elements;
-    fun.locals     = irfun->allocated_locals + irfun->locals_count;
 
     local_var_end = fun.firstlocal;
     for (i = 0; i < irfun->locals_count; ++i) {
@@ -2609,6 +2595,8 @@ static bool gen_global_function(ir_builder *ir, ir_value *global)
         code_globals_add(0);
     }
 
+    fun.locals = code_globals_elements - fun.firstlocal;
+
     if (irfun->builtin)
         fun.entry = irfun->builtin;
     else {
@@ -2625,6 +2613,13 @@ static bool gen_global_function_code(ir_builder *ir, ir_value *global)
     ir_function           *irfun;
 
     irfun = global->constval.vfunc;
+    if (!irfun) {
+        irwarning(global->context, WARN_IMPLICIT_FUNCTION_POINTER,
+                  "function `%s` has no body and in QC implicitly becomes a function-pointer", global->name);
+        /* this was a function pointer, don't generate code for those */
+        return true;
+    }
+
     if (irfun->builtin)
         return true;
 
@@ -2654,6 +2649,28 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
 
     switch (global->vtype)
     {
+    case TYPE_VOID:
+        if (!strcmp(global->name, "end_sys_globals")) {
+            /* TODO: remember this point... all the defs before this one
+             * should be checksummed and added to progdefs.h when we generate it.
+             */
+        }
+        else if (!strcmp(global->name, "end_sys_fields")) {
+            /* TODO: same as above but for entity-fields rather than globsl
+             */
+        }
+        else
+            irwarning(global->context, WARN_VOID_VARIABLES, "unrecognized variable of type void `%s`",
+                      global->name);
+        /* I'd argue setting it to 0 is sufficient, but maybe some depend on knowing how far
+         * the system fields actually go? Though the engine knows this anyway...
+         * Maybe this could be an -foption
+         */
+        ir_value_code_setaddr(global, def.offset);
+        /* Add the def */
+        if (code_defs_add(def) < 0)
+            return false;
+        return true;
     case TYPE_POINTER:
         if (code_defs_add(def) < 0)
             return false;
@@ -2718,9 +2735,14 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
     case TYPE_FUNCTION:
         if (code_defs_add(def) < 0)
             return false;
-        ir_value_code_setaddr(global, code_globals_elements);
-        code_globals_add(code_functions_elements);
-        return gen_global_function(self, global);
+        if (!global->isconst) {
+            ir_value_code_setaddr(global, code_globals_add(0));
+            return global->code.globaladdr >= 0;
+        } else {
+            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 */
             ir_value_code_setaddr(global, code_globals_add(0));
@@ -2729,7 +2751,8 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global)
             return true;
     default:
         /* refuse to create 'void' type or any other fancy business. */
-        irerror(global->context, "Invalid type for global variable %s\n", global->name);
+        irerror(global->context, "Invalid type for global variable `%s`: %s",
+                global->name, type_name[global->vtype]);
         return false;
     }
 }
@@ -2752,7 +2775,7 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
          * bytes is more than enough for a variable/field name
          */
         if (len+2 >= sizeof(name)) {
-            irerror(field->context, "invalid field name size: %u\n", (unsigned int)len);
+            irerror(field->context, "invalid field name size: %u", (unsigned int)len);
             return false;
         }
 
@@ -2780,7 +2803,7 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
     fld.type = field->fieldtype;
 
     if (fld.type == TYPE_VOID) {
-        irerror(field->context, "field is missing a type: %s - don't know its size\n", field->name);
+        irerror(field->context, "field is missing a type: %s - don't know its size", field->name);
         return false;
     }
 
@@ -2804,20 +2827,21 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
 
 bool ir_builder_generate(ir_builder *self, const char *filename)
 {
+    prog_section_statement stmt;
     size_t i;
 
     code_init();
 
-    for (i = 0; i < self->fields_count; ++i)
+    for (i = 0; i < self->globals_count; ++i)
     {
-        if (!ir_builder_gen_field(self, self->fields[i])) {
+        if (!ir_builder_gen_global(self, self->globals[i])) {
             return false;
         }
     }
 
-    for (i = 0; i < self->globals_count; ++i)
+    for (i = 0; i < self->fields_count; ++i)
     {
-        if (!ir_builder_gen_global(self, self->globals[i])) {
+        if (!ir_builder_gen_field(self, self->fields[i])) {
             return false;
         }
     }
@@ -2832,6 +2856,17 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
         }
     }
 
+    /* DP errors if the last instruction is not an INSTR_DONE
+     * and for debugging purposes we add an additional AINSTR_END
+     * to the end of functions, so here it goes:
+     */
+    stmt.opcode = INSTR_DONE;
+    stmt.o1.u1 = 0;
+    stmt.o2.u1 = 0;
+    stmt.o3.u1 = 0;
+    if (code_statements_add(stmt) < 0)
+        return false;
+
     printf("writing '%s'...\n", filename);
     return code_write(filename);
 }
@@ -2901,6 +2936,25 @@ void ir_function_dump(ir_function *f, char *ind,
             oprintf("\n");
         }
     }
+    oprintf("%sliferanges:\n", ind);
+    for (i = 0; i < f->locals_count; ++i) {
+        size_t l;
+        ir_value *v = f->locals[i];
+        oprintf("%s\t%s: unique ", ind, v->name);
+        for (l = 0; l < v->life_count; ++l) {
+            oprintf("[%i,%i] ", v->life[l].start, v->life[l].end);
+        }
+        oprintf("\n");
+    }
+    for (i = 0; i < f->values_count; ++i) {
+        size_t l;
+        ir_value *v = f->values[i];
+        oprintf("%s\t%s: @%i ", ind, v->name, (int)v->code.local);
+        for (l = 0; l < v->life_count; ++l) {
+            oprintf("[%i,%i] ", v->life[l].start, v->life[l].end);
+        }
+        oprintf("\n");
+    }
     if (f->blocks_count)
     {
         oprintf("%slife passes (check): %i\n", ind, (int)f->run_id);
@@ -2989,6 +3043,12 @@ void ir_instr_dump(ir_instr *in, char *ind,
     }
     if (in->bops[1])
         oprintf("%s[%s]", comma, in->bops[1]->label);
+    if (in->params_count) {
+        oprintf("\tparams: ");
+        for (i = 0; i != in->params_count; ++i) {
+            oprintf("%s, ", in->params[i]->name);
+        }
+    }
     oprintf("\n");
     ind[strlen(ind)-1] = 0;
 }
@@ -3002,7 +3062,7 @@ void ir_value_dump(ir_value* v, int (*oprintf)(const char*, ...))
                 oprintf("(void)");
                 break;
             case TYPE_FUNCTION:
-                oprintf("(function)");
+                oprintf("fn:%s", v->name);
                 break;
             case TYPE_FLOAT:
                 oprintf("%g", v->constval.vfloat);