INSTR_STORE_V, /* variant, should never be accessed */
- AINSTR_END, /* struct */
- AINSTR_END, /* union */
- AINSTR_END, /* array */
- AINSTR_END, /* nil */
- AINSTR_END, /* noexpr */
+ VINSTR_END, /* struct */
+ VINSTR_END, /* union */
+ VINSTR_END, /* array */
+ VINSTR_END, /* nil */
+ VINSTR_END, /* noexpr */
};
uint16_t field_store_instr[TYPE_COUNT] = {
INSTR_STORE_V, /* variant, should never be accessed */
- AINSTR_END, /* struct */
- AINSTR_END, /* union */
- AINSTR_END, /* array */
- AINSTR_END, /* nil */
- AINSTR_END, /* noexpr */
+ VINSTR_END, /* struct */
+ VINSTR_END, /* union */
+ VINSTR_END, /* array */
+ VINSTR_END, /* nil */
+ VINSTR_END, /* noexpr */
};
uint16_t type_storep_instr[TYPE_COUNT] = {
INSTR_STOREP_V, /* variant, should never be accessed */
- AINSTR_END, /* struct */
- AINSTR_END, /* union */
- AINSTR_END, /* array */
- AINSTR_END, /* nil */
- AINSTR_END, /* noexpr */
+ VINSTR_END, /* struct */
+ VINSTR_END, /* union */
+ VINSTR_END, /* array */
+ VINSTR_END, /* nil */
+ VINSTR_END, /* noexpr */
};
uint16_t type_eq_instr[TYPE_COUNT] = {
INSTR_EQ_V, /* variant, should never be accessed */
- AINSTR_END, /* struct */
- AINSTR_END, /* union */
- AINSTR_END, /* array */
- AINSTR_END, /* nil */
- AINSTR_END, /* noexpr */
+ VINSTR_END, /* struct */
+ VINSTR_END, /* union */
+ VINSTR_END, /* array */
+ VINSTR_END, /* nil */
+ VINSTR_END, /* noexpr */
};
uint16_t type_ne_instr[TYPE_COUNT] = {
INSTR_NE_V, /* variant, should never be accessed */
- AINSTR_END, /* struct */
- AINSTR_END, /* union */
- AINSTR_END, /* array */
- AINSTR_END, /* nil */
- AINSTR_END, /* noexpr */
+ VINSTR_END, /* struct */
+ VINSTR_END, /* union */
+ VINSTR_END, /* array */
+ VINSTR_END, /* nil */
+ VINSTR_END, /* noexpr */
};
uint16_t type_not_instr[TYPE_COUNT] = {
INSTR_NOT_V, /* variant, should never be accessed */
- AINSTR_END, /* struct */
- AINSTR_END, /* union */
- AINSTR_END, /* array */
- AINSTR_END, /* nil */
- AINSTR_END, /* noexpr */
+ VINSTR_END, /* struct */
+ VINSTR_END, /* union */
+ VINSTR_END, /* array */
+ VINSTR_END, /* nil */
+ VINSTR_END, /* noexpr */
};
/* protos */
self->values = NULL;
self->locals = NULL;
- self->max_varargs = NULL;
+ self->max_varargs = 0;
self->code_function_def = -1;
self->allocated_locals = 0;
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 */
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];
break;
}
/* nothing found? append */
- if (i == vec_size(self->life)) {
+ if (i == vs) {
ir_life_entry_t e;
if (life && life->end+1 == s)
{
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;
}
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;
}
/* 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
/* 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
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;
}
{
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;
* 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);
}
}
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);
}
}
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 */
}
/* (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;
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);
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;
irfun = global->constval.vfunc;
def = code_functions + irfun->code_function_def;
- if (opts.g || !OPTS_OPTIMIZATION(OPTIM_OVERLAP_LOCALS) || (irfun->flags & IR_FLAG_MASK_NO_OVERLAP))
+ 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);
- else {
+ } else {
firstlocal = def->firstlocal = ir->first_common_local;
++opts_optimizationcount[OPTIM_OVERLAP_LOCALS];
}
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;
def.type = global->vtype;
def.offset = vec_size(code_globals);
def.name = 0;
- if (opts.g || !islocal)
+ if (OPTS_OPTION_BOOL(OPTION_G) || !islocal)
{
pushdef = true;
def.offset = (uint16_t)vec_size(code_globals);
/* create a global named the same as the field */
- if (opts.standard == COMPILER_GMQCC) {
+ if (OPTS_OPTION_U32(OPTION_STANDARD) == COMPILER_GMQCC) {
/* in our standard, the global gets a dot prefix */
size_t len = strlen(field->name);
char name[1024];
code_push_statement(&stmt, vec_last(code_linenums));
}
- if (opts.pp_only)
+ if (OPTS_OPTION_BOOL(OPTION_PP_ONLY))
return true;
if (vec_size(code_statements) != vec_size(code_linenums)) {
memcpy(vec_add(lnofile, 5), ".lno", 5);
}
- if (!opts.quiet) {
+ if (!OPTS_OPTION_BOOL(OPTION_QUIET)) {
if (lnofile)
con_out("writing '%s' and '%s'...\n", filename, lnofile);
else