X-Git-Url: https://git.xonotic.org/?p=xonotic%2Fgmqcc.git;a=blobdiff_plain;f=ir.c;h=5161108c80dfe6d6600d2831bb7db50bfd5b1364;hp=2cffb9d6f8238cd1971ce90142db5c4b5e61f62e;hb=3119a95a89e991e42cd52c8ce2c17ab78542c1c2;hpb=4b3e2571af85da0990d88434e0cf2613e1baf734

diff --git a/ir.c b/ir.c
index 2cffb9d..5161108 100644
--- a/ir.c
+++ b/ir.c
@@ -988,6 +988,8 @@ ir_value* ir_value_var(const char *name, int storetype, int vtype)
 
 ir_value* ir_value_vector_member(ir_value *self, unsigned int member)
 {
+    char     *name;
+    size_t    len;
     ir_value *m;
     if (member >= 3)
         return NULL;
@@ -995,9 +997,16 @@ ir_value* ir_value_vector_member(ir_value *self, unsigned int member)
     if (self->members[member])
         return self->members[member];
 
+    len = strlen(self->name);
+    name = (char*)mem_a(len + 3);
+    memcpy(name, self->name, len);
+    name[len+0] = '_';
+    name[len+1] = 'x' + member;
+    name[len+2] = '\0';
     if (self->vtype == TYPE_VECTOR)
     {
-        m = ir_value_var(self->name, self->store, TYPE_FLOAT);
+        m = ir_value_var(name, self->store, TYPE_FLOAT);
+        mem_d(name);
         if (!m)
             return NULL;
         m->context = self->context;
@@ -1009,7 +1018,8 @@ ir_value* ir_value_vector_member(ir_value *self, unsigned int member)
     {
         if (self->fieldtype != TYPE_VECTOR)
             return NULL;
-        m = ir_value_var(self->name, self->store, TYPE_FIELD);
+        m = ir_value_var(name, self->store, TYPE_FIELD);
+        mem_d(name);
         if (!m)
             return NULL;
         m->fieldtype = TYPE_FLOAT;
@@ -1350,15 +1360,19 @@ bool ir_values_overlap(const ir_value *a, const ir_value *b)
  *IR main operations
  */
 
+static bool ir_check_unreachable(ir_block *self)
+{
+    /* The IR should never have to deal with unreachable code */
+    if (!self->final/* || OPTS_FLAG(ALLOW_UNREACHABLE_CODE)*/)
+        return true;
+    irerror(self->context, "unreachable statement (%s)", self->label);
+    return false;
+}
+
 bool ir_block_create_store_op(ir_block *self, lex_ctx ctx, int op, ir_value *target, ir_value *what)
 {
     ir_instr *in;
-    if (self->final) {
-        irerror(self->context, "unreachable statement (%s)", self->label);
-        return false;
-    }
-    in = ir_instr_new(ctx, self, op);
-    if (!in)
+    if (!ir_check_unreachable(self))
         return false;
 
     if (target->store == store_value &&
@@ -1370,9 +1384,14 @@ bool ir_block_create_store_op(ir_block *self, lex_ctx ctx, int op, ir_value *tar
         return false;
     }
 
+    in = ir_instr_new(ctx, self, op);
+    if (!in)
+        return false;
+
     if (!ir_instr_op(in, 0, target, true) ||
         !ir_instr_op(in, 1, what, false))
     {
+        ir_instr_delete(in);
         return false;
     }
     vec_push(self->instr, in);
@@ -1429,18 +1448,18 @@ bool ir_block_create_storep(ir_block *self, lex_ctx ctx, ir_value *target, ir_va
 bool ir_block_create_return(ir_block *self, lex_ctx ctx, ir_value *v)
 {
     ir_instr *in;
-    if (self->final) {
-        irerror(self->context, "unreachable statement (%s)", self->label);
+    if (!ir_check_unreachable(self))
         return false;
-    }
     self->final = true;
     self->is_return = true;
     in = ir_instr_new(ctx, self, INSTR_RETURN);
     if (!in)
         return false;
 
-    if (v && !ir_instr_op(in, 0, v, false))
+    if (v && !ir_instr_op(in, 0, v, false)) {
+        ir_instr_delete(in);
         return false;
+    }
 
     vec_push(self->instr, in);
     return true;
@@ -1450,10 +1469,8 @@ bool ir_block_create_if(ir_block *self, lex_ctx ctx, ir_value *v,
                         ir_block *ontrue, ir_block *onfalse)
 {
     ir_instr *in;
-    if (self->final) {
-        irerror(self->context, "unreachable statement (%s)", self->label);
+    if (!ir_check_unreachable(self))
         return false;
-    }
     self->final = true;
     /*in = ir_instr_new(ctx, self, (v->vtype == TYPE_STRING ? INSTR_IF_S : INSTR_IF_F));*/
     in = ir_instr_new(ctx, self, VINSTR_COND);
@@ -1480,10 +1497,8 @@ bool ir_block_create_if(ir_block *self, lex_ctx ctx, ir_value *v,
 bool ir_block_create_jump(ir_block *self, lex_ctx ctx, ir_block *to)
 {
     ir_instr *in;
-    if (self->final) {
-        irerror(self->context, "unreachable statement (%s)", self->label);
+    if (!ir_check_unreachable(self))
         return false;
-    }
     self->final = true;
     in = ir_instr_new(ctx, self, VINSTR_JUMP);
     if (!in)
@@ -1500,10 +1515,8 @@ bool ir_block_create_jump(ir_block *self, lex_ctx ctx, ir_block *to)
 bool ir_block_create_goto(ir_block *self, lex_ctx ctx, ir_block *to)
 {
     ir_instr *in;
-    if (self->final) {
-        irerror(self->context, "unreachable statement (%s)", self->label);
+    if (!ir_check_unreachable(self))
         return false;
-    }
     self->final = true;
     in = ir_instr_new(ctx, self, INSTR_GOTO);
     if (!in)
@@ -1521,6 +1534,8 @@ ir_instr* ir_block_create_phi(ir_block *self, lex_ctx ctx, const char *label, in
 {
     ir_value *out;
     ir_instr *in;
+    if (!ir_check_unreachable(self))
+        return false;
     in = ir_instr_new(ctx, self, VINSTR_PHI);
     if (!in)
         return NULL;
@@ -1562,13 +1577,19 @@ void ir_phi_add(ir_instr* self, ir_block *b, ir_value *v)
 }
 
 /* call related code */
-ir_instr* ir_block_create_call(ir_block *self, lex_ctx ctx, const char *label, ir_value *func)
+ir_instr* ir_block_create_call(ir_block *self, lex_ctx ctx, const char *label, ir_value *func, bool noreturn)
 {
     ir_value *out;
     ir_instr *in;
-    in = ir_instr_new(ctx, self, INSTR_CALL0);
+    if (!ir_check_unreachable(self))
+        return false;
+    in = ir_instr_new(ctx, self, (noreturn ? VINSTR_NRCALL : INSTR_CALL0));
     if (!in)
         return NULL;
+    if (noreturn) {
+        self->final = true;
+        self->is_return = true;
+    }
     out = ir_value_out(self->owner, label, (func->outtype == TYPE_VOID) ? store_return : store_value, func->outtype);
     if (!out) {
         ir_instr_delete(in);
@@ -2169,8 +2190,24 @@ bool ir_function_calculate_liferanges(ir_function *self)
         ir_block *block = self->blocks[0];
         for (i = 0; i < vec_size(block->living); ++i) {
             ir_value *v = block->living[i];
-            if (v->memberof || v->store != store_local)
+            if (v->store != store_local)
                 continue;
+            if ((v->members[0] && v->members[1] && v->members[2])) {
+                /* all vector members have been accessed - only treat this as uninitialized
+                 * if any of them is also uninitialized.
+                 */
+                if (!vec_ir_value_find(block->living, v->members[0], NULL) &&
+                    !vec_ir_value_find(block->living, v->members[1], NULL) &&
+                    !vec_ir_value_find(block->living, v->members[2], NULL))
+                {
+                    continue;
+                }
+            }
+            if (v->memberof) {
+                /* A member is only uninitialized if the whole vector is also uninitialized */
+                if (!vec_ir_value_find(block->living, v->memberof, NULL))
+                    continue;
+            }
             if (irwarning(v->context, WARN_USED_UNINITIALIZED,
                           "variable `%s` may be used uninitialized in this function", v->name))
             {
@@ -2446,8 +2483,6 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
         for (p = 0; p < vec_size(instr->phi); ++p)
         {
             value = instr->phi[p].value;
-            if (value->memberof)
-                value = value->memberof;
             if (!vec_ir_value_find(self->living, value, NULL))
                 vec_push(self->living, value);
         }
@@ -2456,8 +2491,6 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
         for (p = 0; p < vec_size(instr->params); ++p)
         {
             value = instr->params[p];
-            if (value->memberof)
-                value = value->memberof;
             if (!vec_ir_value_find(self->living, value, NULL))
                 vec_push(self->living, value);
         }
@@ -2485,8 +2518,6 @@ 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
@@ -2691,7 +2722,8 @@ tailcall:
             stmt.o1.s1 = (target->code_start) - vec_size(code_statements);
             stmt.o2.s1 = 0;
             stmt.o3.s1 = 0;
-            code_push_statement(&stmt, instr->context.line);
+            if (stmt.o1.s1 != 1)
+                code_push_statement(&stmt, instr->context.line);
 
             /* no further instructions can be in this block */
             return true;
@@ -2711,12 +2743,14 @@ tailcall:
             if (ontrue->generated) {
                 stmt.opcode = INSTR_IF;
                 stmt.o2.s1 = (ontrue->code_start) - vec_size(code_statements);
-                code_push_statement(&stmt, instr->context.line);
+                if (stmt.o2.s1 != 1)
+                    code_push_statement(&stmt, instr->context.line);
             }
             if (onfalse->generated) {
                 stmt.opcode = INSTR_IFNOT;
                 stmt.o2.s1 = (onfalse->code_start) - vec_size(code_statements);
-                code_push_statement(&stmt, instr->context.line);
+                if (stmt.o2.s1 != 1)
+                    code_push_statement(&stmt, instr->context.line);
             }
             if (!ontrue->generated) {
                 if (onfalse->generated) {
@@ -2750,6 +2784,12 @@ tailcall:
             if (onfalse->generated) {
                 /* fixup the jump address */
                 code_statements[stidx].o2.s1 = (onfalse->code_start) - (stidx);
+                if (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();
+                }
                 stmt.opcode = vec_last(code_statements).opcode;
                 if (stmt.opcode == INSTR_GOTO ||
                     stmt.opcode == INSTR_IF ||
@@ -2765,15 +2805,24 @@ tailcall:
                 stmt.o1.s1 = (onfalse->code_start) - vec_size(code_statements);
                 stmt.o2.s1 = 0;
                 stmt.o3.s1 = 0;
-                code_push_statement(&stmt, instr->context.line);
+                if (stmt.o1.s1 != 1)
+                    code_push_statement(&stmt, instr->context.line);
                 return true;
             }
+            else if (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();
+            }
             /* if not, generate now */
             block = onfalse;
             goto tailcall;
         }
 
-        if (instr->opcode >= INSTR_CALL0 && instr->opcode <= INSTR_CALL8) {
+        if ( (instr->opcode >= INSTR_CALL0 && instr->opcode <= INSTR_CALL8)
+           || instr->opcode == VINSTR_NRCALL)
+        {
             /* Trivial call translation:
              * copy all params to OFS_PARM*
              * if the output's storetype is not store_return,
@@ -2929,8 +2978,8 @@ static bool gen_function_code(ir_function *self)
         return false;
     }
 
-    /* otherwise code_write crashes since it debug-prints functions until AINSTR_END */
-    stmt.opcode = AINSTR_END;
+    /* code_write and qcvm -disasm need to know that the function ends here */
+    stmt.opcode = INSTR_DONE;
     stmt.o1.u1 = 0;
     stmt.o2.u1 = 0;
     stmt.o3.u1 = 0;
@@ -3145,6 +3194,62 @@ static bool gen_global_function_code(ir_builder *ir, ir_value *global)
     return true;
 }
 
+static void gen_vector_defs(prog_section_def def, const char *name)
+{
+    char  *component;
+    size_t len, i;
+
+    if (!name || OPTS_FLAG(SINGLE_VECTOR_DEFS))
+        return;
+
+    def.type = TYPE_FLOAT;
+
+    len = strlen(name);
+
+    component = (char*)mem_a(len+3);
+    memcpy(component, name, len);
+    len += 2;
+    component[len-0] = 0;
+    component[len-2] = '_';
+
+    component[len-1] = 'x';
+
+    for (i = 0; i < 3; ++i) {
+        def.name = code_genstring(component);
+        vec_push(code_defs, def);
+        def.offset++;
+        component[len-1]++;
+    }
+}
+
+static void gen_vector_fields(prog_section_field fld, const char *name)
+{
+    char  *component;
+    size_t len, i;
+
+    if (!name || OPTS_FLAG(SINGLE_VECTOR_DEFS))
+        return;
+
+    fld.type = TYPE_FLOAT;
+
+    len = strlen(name);
+
+    component = (char*)mem_a(len+3);
+    memcpy(component, name, len);
+    len += 2;
+    component[len-0] = 0;
+    component[len-2] = '_';
+
+    component[len-1] = 'x';
+
+    for (i = 0; i < 3; ++i) {
+        fld.name = code_genstring(component);
+        vec_push(code_fields, fld);
+        fld.offset++;
+        component[len-1]++;
+    }
+}
+
 static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal)
 {
     size_t           i;
@@ -3196,6 +3301,7 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
         return gen_global_pointer(global);
     case TYPE_FIELD:
         vec_push(code_defs, def);
+        gen_vector_defs(def, global->name);
         return gen_global_field(global);
     case TYPE_ENTITY:
         /* fall through */
@@ -3207,9 +3313,9 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
             vec_push(code_globals, *iptr);
         } else {
             vec_push(code_globals, 0);
-            if (!islocal)
-                def.type |= DEF_SAVEGLOBAL;
         }
+        if (!islocal && global->cvq != CV_CONST)
+            def.type |= DEF_SAVEGLOBAL;
         vec_push(code_defs, def);
 
         return global->code.globaladdr >= 0;
@@ -3221,9 +3327,9 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
             vec_push(code_globals, code_genstring(global->constval.vstring));
         } else {
             vec_push(code_globals, 0);
-            if (!islocal)
-                def.type |= DEF_SAVEGLOBAL;
         }
+        if (!islocal && global->cvq != CV_CONST)
+            def.type |= DEF_SAVEGLOBAL;
         vec_push(code_defs, def);
         return global->code.globaladdr >= 0;
     }
@@ -3236,23 +3342,23 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
             vec_push(code_globals, iptr[0]);
             if (global->code.globaladdr < 0)
                 return false;
-            for (d = 1; d < type_sizeof[global->vtype]; ++d)
-            {
+            for (d = 1; d < type_sizeof[global->vtype]; ++d) {
                 vec_push(code_globals, iptr[d]);
             }
         } else {
             vec_push(code_globals, 0);
             if (global->code.globaladdr < 0)
                 return false;
-            for (d = 1; d < type_sizeof[global->vtype]; ++d)
-            {
+            for (d = 1; d < type_sizeof[global->vtype]; ++d) {
                 vec_push(code_globals, 0);
             }
-            if (!islocal)
-                def.type |= DEF_SAVEGLOBAL;
         }
+        if (!islocal && global->cvq != CV_CONST)
+            def.type |= DEF_SAVEGLOBAL;
 
         vec_push(code_defs, def);
+        def.type &= ~DEF_SAVEGLOBAL;
+        gen_vector_defs(def, global->name);
         return global->code.globaladdr >= 0;
     }
     case TYPE_FUNCTION:
@@ -3265,9 +3371,9 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool isloc
             vec_push(code_globals, vec_size(code_functions));
             if (!gen_global_function(self, global))
                 return false;
-            if (!islocal)
-                def.type |= DEF_SAVEGLOBAL;
         }
+        if (!islocal && global->cvq != CV_CONST)
+            def.type |= DEF_SAVEGLOBAL;
         vec_push(code_defs, def);
         return true;
     case TYPE_VARIANT:
@@ -3352,6 +3458,11 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
         vec_push(code_globals, fld.offset+2);
     }
 
+    if (field->fieldtype == TYPE_VECTOR) {
+        gen_vector_defs(def, field->name);
+        gen_vector_fields(fld, field->name);
+    }
+
     return field->code.globaladdr >= 0;
 }
 
@@ -3397,15 +3508,15 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
         return false;
     }
 
-    /* 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;
-    code_push_statement(&stmt, vec_last(code_linenums));
+    /* DP errors if the last instruction is not an 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));
+    }
 
     if (opts.pp_only)
         return true;
@@ -3446,8 +3557,8 @@ bool ir_builder_generate(ir_builder *self, const char *filename)
 
 #define IND_BUFSZ 1024
 
-#ifdef WIN32
-# define strncat(dst, src, sz) strncat_s(dst, sz, src, _TRUNCATE)
+#ifdef _MSC_VER
+#   define strncat(dst, src, sz) strncat_s(dst, sz, src, _TRUNCATE)
 #endif
 
 const char *qc_opname(int op)
@@ -3581,7 +3692,7 @@ void ir_instr_dump(ir_instr *in, char *ind,
         if (in->_ops[1] || in->_ops[2])
             oprintf(" <- ");
     }
-    if (in->opcode == INSTR_CALL0) {
+    if (in->opcode == INSTR_CALL0 || in->opcode == VINSTR_NRCALL) {
         oprintf("CALL%i\t", vec_size(in->params));
     } else
         oprintf("%s\t", qc_opname(in->opcode));