/*
- * Copyright (C) 2012
+ * Copyright (C) 2012, 2013
* Wolfgang Bumiller
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of
"union",
"array",
- "nil"
+ "nil",
+ "<no-expression>"
};
size_t type_sizeof_[TYPE_COUNT] = {
0, /* TYPE_UNION */
0, /* TYPE_ARRAY */
0, /* TYPE_NIL */
+ 0, /* TYPE_NOESPR */
};
uint16_t type_store_instr[TYPE_COUNT] = {
INSTR_STORE_V, /* variant, should never be accessed */
- AINSTR_END, /* struct */
- AINSTR_END, /* union */
- AINSTR_END, /* array */
- AINSTR_END, /* nil */
+ 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 */
+ 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 */
+ 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 */
+ 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 */
+ 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 */
+ VINSTR_END, /* struct */
+ VINSTR_END, /* union */
+ VINSTR_END, /* array */
+ VINSTR_END, /* nil */
+ VINSTR_END, /* noexpr */
};
/* protos */
self->nil = ir_value_var("nil", store_value, TYPE_NIL);
self->nil->cvq = CV_CONST;
+ self->reserved_va_count = NULL;
+
return self;
}
return ve;
}
+ir_value* ir_builder_get_va_count(ir_builder *self)
+{
+ if (self->reserved_va_count)
+ return self->reserved_va_count;
+ return (self->reserved_va_count = ir_builder_create_global(self, "reserved:va_count", TYPE_FLOAT));
+}
+
ir_value* ir_builder_get_field(ir_builder *self, const char *name)
{
return (ir_value*)util_htget(self->htfields, name);
self->values = NULL;
self->locals = NULL;
+ self->max_varargs = 0;
+
self->code_function_def = -1;
self->allocated_locals = 0;
self->globaltemps = 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 */
self->fieldtype = TYPE_VOID;
self->outtype = TYPE_VOID;
self->store = storetype;
+ self->flags = 0;
self->reads = NULL;
self->writes = NULL;
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)
{
return true;
}
-#if 0
-static bool ir_naive_phi_emit_store(ir_block *block, size_t iid, ir_value *old, ir_value *what)
-{
- ir_instr *instr;
- size_t i;
-
- /* create a store */
- if (!ir_block_create_store(block, old, what))
- return false;
-
- /* we now move it up */
- instr = vec_last(block->instr);
- for (i = vec_size(block->instr)-1; i > iid; --i)
- block->instr[i] = block->instr[i-1];
- block->instr[i] = instr;
-
- return true;
-}
-#endif
-
static bool ir_block_naive_phi(ir_block *self)
{
size_t i, p; /*, w;*/
vec_push(b->instr, prevjump);
b->final = true;
}
-
-#if 0
- ir_value *v = instr->phi[p].value;
- for (w = 0; w < vec_size(v->writes); ++w) {
- ir_value *old;
-
- if (!v->writes[w]->_ops[0])
- continue;
-
- /* When the write was to a global, we have to emit a mov */
- old = v->writes[w]->_ops[0];
-
- /* The original instruction now writes to the PHI target local */
- if (v->writes[w]->_ops[0] == v)
- v->writes[w]->_ops[0] = instr->_ops[0];
-
- if (old->store != store_value && old->store != store_local && old->store != store_param)
- {
- /* If it originally wrote to a global we need to store the value
- * there as welli
- */
- if (!ir_naive_phi_emit_store(self, i+1, old, v))
- return false;
- if (i+1 < vec_size(self->instr))
- instr = self->instr[i+1];
- else
- instr = NULL;
- /* In case I forget and access instr later, it'll be NULL
- * when it's a problem, to make sure we crash, rather than accessing
- * invalid data.
- */
- }
- else
- {
- /* If it didn't, we can replace all reads by the phi target now. */
- size_t r;
- for (r = 0; r < vec_size(old->reads); ++r)
- {
- size_t op;
- ir_instr *ri = old->reads[r];
- for (op = 0; op < vec_size(ri->phi); ++op) {
- if (ri->phi[op].value == old)
- ri->phi[op].value = v;
- }
- for (op = 0; op < 3; ++op) {
- if (ri->_ops[op] == old)
- ri->_ops[op] = v;
- }
- }
- }
- }
-#endif
}
ir_instr_delete(instr);
}
void ir_function_enumerate(ir_function *self)
{
size_t i;
- size_t instruction_id = 1;
+ size_t instruction_id = 0;
for (i = 0; i < vec_size(self->blocks); ++i)
{
+ /* each block now gets an additional "entry" instruction id
+ * we can use to avoid point-life issues
+ */
+ self->blocks[i]->entry_id = instruction_id;
+ ++instruction_id;
+
self->blocks[i]->eid = i;
self->blocks[i]->run_id = 0;
ir_block_enumerate(self->blocks[i], &instruction_id);
size_t a;
ir_value *slot;
+ if (v->unique_life)
+ return function_allocator_alloc(alloc, v);
+
for (a = 0; a < vec_size(alloc->locals); ++a)
{
/* if it's reserved for a unique liferange: skip */
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;
}
break;
else
v->locked = true; /* lock parameters locals */
- if (!function_allocator_alloc((v->locked || !opt_gt ? &lockalloc : &globalloc), self->locals[i]))
+ if (!function_allocator_alloc((v->locked || !opt_gt ? &lockalloc : &globalloc), v))
goto error;
}
for (; i < vec_size(self->locals); ++i)
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;
}
bool changed = false;
for (i = 0; i != vec_size(self->living); ++i)
{
- if (!self->living[i]->locked)
+ if (!self->living[i]->locked) {
+ self->living[i]->locked = true;
changed = true;
- self->living[i]->locked = 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;
/* 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
* writes first, then reads
*/
* 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 (instr->opcode == INSTR_MUL_VF)
+ {
+ value = instr->_ops[2];
+ /* the float source will get an additional lifetime */
+ if (ir_value_life_merge(value, instr->eid+1))
+ *changed = true;
+ if (value->memberof && ir_value_life_merge(value->memberof, instr->eid+1))
+ *changed = true;
+ }
+ else if (instr->opcode == INSTR_MUL_FV || instr->opcode == INSTR_LOAD_V)
+ {
+ value = instr->_ops[1];
+ /* the float source will get an additional lifetime */
+ if (ir_value_life_merge(value, instr->eid+1))
+ *changed = true;
+ if (value->memberof && ir_value_life_merge(value->memberof, instr->eid+1))
+ *changed = true;
+ }
+
for (o = 0; o < 3; ++o)
{
if (!instr->_ops[o]) /* no such operand */
}
/* (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 */
+ if (ir_block_living_add_instr(self, self->entry_id))
+ *changed = true;
if (self->run_id == self->owner->run_id)
return true;
size_t stidx;
size_t i;
-tailcall:
block->generated = true;
block->code_start = vec_size(code_statements);
for (i = 0; i < vec_size(block->instr); ++i)
/* for uncoditional jumps, if the target hasn't been generated
* yet, we generate them right here.
*/
- if (!target->generated) {
- block = target;
- goto tailcall;
- }
+ if (!target->generated)
+ return gen_blocks_recursive(func, target);
/* otherwise we generate a jump instruction */
stmt.opcode = INSTR_GOTO;
code_push_statement(&stmt, instr->context.line);
}
if (!ontrue->generated) {
- if (onfalse->generated) {
- block = ontrue;
- goto tailcall;
- }
+ if (onfalse->generated)
+ return gen_blocks_recursive(func, ontrue);
}
if (!onfalse->generated) {
- if (ontrue->generated) {
- block = onfalse;
- goto tailcall;
- }
+ if (ontrue->generated)
+ return gen_blocks_recursive(func, onfalse);
}
/* neither ontrue nor onfalse exist */
stmt.opcode = INSTR_IFNOT;
if (onfalse->generated) {
/* fixup the jump address */
code_statements[stidx].o2.s1 = (onfalse->code_start) - (stidx);
- if (code_statements[stidx].o2.s1 == 1) {
+ if (stidx+2 == vec_size(code_statements) && 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_push_statement(&stmt, instr->context.line);
return true;
}
- else if (code_statements[stidx].o2.s1 == 1) {
+ else if (stidx+2 == vec_size(code_statements) && 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;
+ return gen_blocks_recursive(func, onfalse);
}
if ( (instr->opcode >= INSTR_CALL0 && instr->opcode <= INSTR_CALL8)
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;
if (OPTS_OPTIMIZATION(OPTIM_STRIP_CONSTANT_NAMES) &&
+ !(global->flags & IR_FLAG_INCLUDE_DEF) &&
(global->name[0] == '#' || global->cvq == CV_CONST))
{
pushdef = false;
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
oprintf("endmodule %s\n", b->name);
}
+static const char *storenames[] = {
+ "[global]", "[local]", "[param]", "[value]", "[return]"
+};
+
void ir_function_dump(ir_function *f, char *ind,
int (*oprintf)(const char*, ...))
{
attr = "unique ";
else if (v->locked)
attr = "locked ";
- oprintf("%s\t%s: %s %s@%i ", ind, v->name, type_name[v->vtype], attr, (int)v->code.local);
+ oprintf("%s\t%s: %s %s %s%s@%i ", ind, v->name, type_name[v->vtype],
+ storenames[v->store],
+ attr, (v->callparam ? "callparam " : ""),
+ (int)v->code.local);
+ if (!v->life)
+ oprintf("[null]");
for (l = 0; l < vec_size(v->life); ++l) {
oprintf("[%i,%i] ", v->life[l].start, v->life[l].end);
}
ir_value *vm = v->members[m];
if (!vm)
continue;
- if (vm->unique_life && vm->locked)
- attr = "unique,locked ";
- else if (vm->unique_life)
- attr = "unique ";
- else if (vm->locked)
- attr = "locked ";
- oprintf("%s\t%s: %s@%i ", ind, vm->name, attr, (int)vm->code.local);
+ oprintf("%s\t%s: @%i ", ind, vm->name, (int)vm->code.local);
for (l = 0; l < vec_size(vm->life); ++l) {
oprintf("[%i,%i] ", vm->life[l].start, vm->life[l].end);
}
attr = "unique ";
else if (v->locked)
attr = "locked ";
- oprintf("%s\t%s: %s %s@%i ", ind, v->name, type_name[v->vtype], attr, (int)v->code.local);
+ oprintf("%s\t%s: %s %s %s%s@%i ", ind, v->name, type_name[v->vtype],
+ storenames[v->store],
+ attr, (v->callparam ? "callparam " : ""),
+ (int)v->code.local);
+ if (!v->life)
+ oprintf("[null]");
for (l = 0; l < vec_size(v->life); ++l) {
oprintf("[%i,%i] ", v->life[l].start, v->life[l].end);
}
oprintf("%s:%s\n", ind, b->label);
strncat(ind, "\t", IND_BUFSZ);
+ if (b->instr && b->instr[0])
+ oprintf("%s (%i) [entry]\n", ind, (int)(b->instr[0]->eid-1));
for (i = 0; i < vec_size(b->instr); ++i)
ir_instr_dump(b->instr[i], ind, oprintf);
ind[strlen(ind)-1] = 0;
projects / xonotic / gmqcc.git / blobdiff