X-Git-Url: https://de.git.xonotic.org/?a=blobdiff_plain;f=ir.c;h=ad86914e5feb6144876c31be9062f663e00d998b;hb=531fbaf28c9147a5d34ae0c3c522a3898d4b7744;hp=bd8f12fb20f79a1d2a72ec4ec6b6d9aea981fb13;hpb=2a4ea74a975b0d5bcea1fcc96711115bb34373d8;p=xonotic%2Fgmqcc.git

diff --git a/ir.c b/ir.c
index bd8f12f..ad86914 100644
--- a/ir.c
+++ b/ir.c
@@ -485,7 +485,7 @@ ir_function* ir_function_new(ir_builder* owner, int outtype)
     self->values = NULL;
     self->locals = NULL;
 
-    self->max_varargs = NULL;
+    self->max_varargs = 0;
 
     self->code_function_def = -1;
     self->allocated_locals = 0;
@@ -600,6 +600,13 @@ bool ir_function_pass_peephole(ir_function *self)
                 if (!instr_is_operation(oper->opcode))
                     continue;
 
+                if (OPTS_FLAG(LEGACY_VECTOR_MATHS)) {
+                    if (oper->opcode == INSTR_MUL_VF && oper->_ops[2]->memberof == oper->_ops[1])
+                        continue;
+                    if (oper->opcode == INSTR_MUL_FV && oper->_ops[1]->memberof == oper->_ops[2])
+                        continue;
+                }
+
                 value = oper->_ops[0];
 
                 /* only do it for SSA values */
@@ -1258,12 +1265,13 @@ bool ir_value_life_insert(ir_value *self, size_t idx, ir_life_entry_t e)
 bool ir_value_life_merge(ir_value *self, size_t s)
 {
     size_t i;
+    const size_t vs = vec_size(self->life);
     ir_life_entry_t *life = NULL;
     ir_life_entry_t *before = NULL;
     ir_life_entry_t new_entry;
 
     /* Find the first range >= s */
-    for (i = 0; i < vec_size(self->life); ++i)
+    for (i = 0; i < vs; ++i)
     {
         before = life;
         life = &self->life[i];
@@ -1271,7 +1279,7 @@ bool ir_value_life_merge(ir_value *self, size_t s)
             break;
     }
     /* nothing found? append */
-    if (i == vec_size(self->life)) {
+    if (i == vs) {
         ir_life_entry_t e;
         if (life && life->end+1 == s)
         {
@@ -2204,7 +2212,7 @@ bool ir_function_allocate_locals(ir_function *self)
     for (i = 0; i < vec_size(self->locals); ++i)
     {
         v = self->locals[i];
-        if (!OPTS_OPTIMIZATION(OPTIM_LOCAL_TEMPS)) {
+        if ((self->flags & IR_FLAG_MASK_NO_LOCAL_TEMPS) || !OPTS_OPTIMIZATION(OPTIM_LOCAL_TEMPS)) {
             v->locked      = true;
             v->unique_life = true;
         }
@@ -2249,18 +2257,22 @@ bool ir_function_allocate_locals(ir_function *self)
                     irerror(call->context, "internal error: unlocked parameter %s not found", v->name);
                     goto error;
                 }
-
                 ++opts_optimizationcount[OPTIM_CALL_STORES];
                 v->callparam = true;
                 if (param < 8)
                     ir_value_code_setaddr(v, OFS_PARM0 + 3*param);
                 else {
+                    size_t nprotos = vec_size(self->owner->extparam_protos);
                     ir_value *ep;
                     param -= 8;
-                    if (vec_size(self->owner->extparam_protos) <= param)
-                        ep = ir_gen_extparam_proto(self->owner);
-                    else
+                    if (nprotos > param)
                         ep = self->owner->extparam_protos[param];
+                    else
+                    {
+                        ep = ir_gen_extparam_proto(self->owner);
+                        while (++nprotos <= param)
+                            ep = ir_gen_extparam_proto(self->owner);
+                    }
                     ir_instr_op(v->writes[0], 0, ep, true);
                     call->params[param+8] = ep;
                 }
@@ -2310,8 +2322,6 @@ bool ir_function_allocate_locals(ir_function *self)
     /* Locals need to know their new position */
     for (i = 0; i < vec_size(self->locals); ++i) {
         v = self->locals[i];
-        if (i >= vec_size(self->params) && !vec_size(v->life))
-            continue;
         if (v->locked || !opt_gt)
             v->code.local = lockalloc.positions[v->code.local];
         else
@@ -2320,8 +2330,6 @@ bool ir_function_allocate_locals(ir_function *self)
     /* Take over the actual slot positions on values */
     for (i = 0; i < vec_size(self->values); ++i) {
         v = self->values[i];
-        if (!vec_size(v->life))
-            continue;
         if (v->locked || !opt_gt)
             v->code.local = lockalloc.positions[v->code.local];
         else
@@ -2389,13 +2397,13 @@ static void ir_op_read_write(int op, size_t *read, size_t *write)
 
 static bool ir_block_living_add_instr(ir_block *self, size_t eid)
 {
-    size_t i;
-    bool changed = false;
-    bool tempbool;
-    for (i = 0; i != vec_size(self->living); ++i)
+    size_t       i;
+    const size_t vs = vec_size(self->living);
+    bool         changed = false;
+    for (i = 0; i != vs; ++i)
     {
-        tempbool = ir_value_life_merge(self->living[i], eid);
-        changed = changed || tempbool;
+        if (ir_value_life_merge(self->living[i], eid))
+            changed = true;
     }
     return changed;
 }
@@ -2453,7 +2461,6 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
 {
     ir_instr *instr;
     ir_value *value;
-    bool  tempbool;
     size_t i, o, p, mem;
     /* bitmasks which operands are read from or written to */
     size_t read, write;
@@ -2513,23 +2520,23 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
                      * since this function is run multiple times.
                      */
                     /* con_err( "Value only written %s\n", value->name); */
-                    tempbool = ir_value_life_merge(value, instr->eid);
-                    *changed = *changed || tempbool;
+                    if (ir_value_life_merge(value, instr->eid))
+                        *changed = true;
                 } else {
                     /* since 'living' won't contain it
                      * anymore, merge the value, since
                      * (A) doesn't.
                      */
-                    tempbool = ir_value_life_merge(value, instr->eid);
-                    *changed = *changed || tempbool;
+                    if (ir_value_life_merge(value, instr->eid))
+                        *changed = true;
                     /* Then remove */
                     vec_remove(self->living, idx, 1);
                 }
                 /* Removing a vector removes all members */
                 for (mem = 0; mem < 3; ++mem) {
                     if (value->members[mem] && vec_ir_value_find(self->living, value->members[mem], &idx)) {
-                        tempbool = ir_value_life_merge(value->members[mem], instr->eid);
-                        *changed = *changed || tempbool;
+                        if (ir_value_life_merge(value->members[mem], instr->eid))
+                            *changed = true;
                         vec_remove(self->living, idx, 1);
                     }
                 }
@@ -2541,8 +2548,8 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
                             break;
                     }
                     if (mem == 3 && vec_ir_value_find(self->living, value, &idx)) {
-                        tempbool = ir_value_life_merge(value, instr->eid);
-                        *changed = *changed || tempbool;
+                        if (ir_value_life_merge(value, instr->eid))
+                            *changed = true;
                         vec_remove(self->living, idx, 1);
                     }
                 }
@@ -2558,7 +2565,7 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
             if (value->memberof && ir_value_life_merge(value->memberof, instr->eid+1))
                 *changed = true;
         }
-        else if (instr->opcode == INSTR_MUL_FV)
+        else if (instr->opcode == INSTR_MUL_FV || instr->opcode == INSTR_LOAD_V)
         {
             value = instr->_ops[1];
             /* the float source will get an additional lifetime */
@@ -2633,13 +2640,12 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change
         }
 
         /* (A) */
-        tempbool = ir_block_living_add_instr(self, instr->eid);
-        /*con_err( "living added values\n");*/
-        *changed = *changed || tempbool;
+        if (ir_block_living_add_instr(self, instr->eid))
+            *changed = true;
     }
     /* the "entry" instruction ID */
-    tempbool = ir_block_living_add_instr(self, self->entry_id);
-    *changed = *changed || tempbool;
+    if (ir_block_living_add_instr(self, self->entry_id))
+        *changed = true;
 
     if (self->run_id == self->owner->run_id)
         return true;
@@ -3111,7 +3117,7 @@ static ir_value* ir_gen_extparam_proto(ir_builder *ir)
     ir_value *global;
     char      name[128];
 
-    snprintf(name, sizeof(name), "EXTPARM#%i", (int)(vec_size(ir->extparam_protos)+8));
+    snprintf(name, sizeof(name), "EXTPARM#%i", (int)(vec_size(ir->extparam_protos)));
     global = ir_value_var(name, store_global, TYPE_VECTOR);
 
     vec_push(ir->extparam_protos, global);
@@ -3176,6 +3182,42 @@ static bool gen_function_extparam_copy(ir_function *self)
     return true;
 }
 
+static bool gen_function_varargs_copy(ir_function *self)
+{
+    size_t i, ext, numparams, maxparams;
+
+    ir_builder *ir = self->owner;
+    ir_value   *ep;
+    prog_section_statement stmt;
+
+    numparams = vec_size(self->params);
+    if (!numparams)
+        return true;
+
+    stmt.opcode = INSTR_STORE_V;
+    stmt.o3.s1 = 0;
+    maxparams = numparams + self->max_varargs;
+    for (i = numparams; i < maxparams; ++i) {
+        if (i <= 8) {
+            stmt.o1.u1 = OFS_PARM0 + 3*i;
+            stmt.o2.u1 = ir_value_code_addr(self->locals[i]);
+            code_push_statement(&stmt, self->context.line);
+            continue;
+        }
+        ext = i - 9;
+        if (ext >= vec_size(ir->extparams))
+            ir_gen_extparam(ir);
+
+        ep = ir->extparams[ext];
+
+        stmt.o1.u1 = ir_value_code_addr(ep);
+        stmt.o2.u1 = ir_value_code_addr(self->locals[i]);
+        code_push_statement(&stmt, self->context.line);
+    }
+
+    return true;
+}
+
 static bool gen_function_locals(ir_builder *ir, ir_value *global)
 {
     prog_section_function *def;
@@ -3257,6 +3299,10 @@ static bool gen_global_function_code(ir_builder *ir, ir_value *global)
         irerror(irfun->context, "Failed to generate extparam-copy code for function %s", irfun->name);
         return false;
     }
+    if (irfun->max_varargs && !gen_function_varargs_copy(irfun)) {
+        irerror(irfun->context, "Failed to generate vararg-copy code for function %s", irfun->name);
+        return false;
+    }
     if (!gen_function_code(irfun)) {
         irerror(irfun->context, "Failed to generate code for function %s", irfun->name);
         return false;