"<no-expression>"
};
-size_t type_sizeof_[TYPE_COUNT] = {
+static size_t type_sizeof_[TYPE_COUNT] = {
1, /* TYPE_VOID */
1, /* TYPE_STRING */
1, /* TYPE_FLOAT */
0, /* TYPE_NOESPR */
};
-uint16_t type_store_instr[TYPE_COUNT] = {
+const uint16_t type_store_instr[TYPE_COUNT] = {
INSTR_STORE_F, /* should use I when having integer support */
INSTR_STORE_S,
INSTR_STORE_F,
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] = {
+const uint16_t field_store_instr[TYPE_COUNT] = {
INSTR_STORE_FLD,
INSTR_STORE_FLD,
INSTR_STORE_FLD,
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] = {
+const uint16_t type_storep_instr[TYPE_COUNT] = {
INSTR_STOREP_F, /* should use I when having integer support */
INSTR_STOREP_S,
INSTR_STOREP_F,
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] = {
+const uint16_t type_eq_instr[TYPE_COUNT] = {
INSTR_EQ_F, /* should use I when having integer support */
INSTR_EQ_S,
INSTR_EQ_F,
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] = {
+const uint16_t type_ne_instr[TYPE_COUNT] = {
INSTR_NE_F, /* should use I when having integer support */
INSTR_NE_S,
INSTR_NE_F,
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] = {
+const uint16_t type_not_instr[TYPE_COUNT] = {
INSTR_NOT_F, /* should use I when having integer support */
- INSTR_NOT_S,
+ VINSTR_END, /* not to be used, depends on string related -f flags */
INSTR_NOT_F,
INSTR_NOT_V,
INSTR_NOT_ENT,
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->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->eid = 0;
self->is_return = false;
- self->run_id = 0;
self->living = NULL;
self->fieldtype = TYPE_VOID;
self->outtype = TYPE_VOID;
self->store = storetype;
+ self->flags = 0;
self->reads = NULL;
self->writes = NULL;
return true;
}
-static char *ir_strdup(const char *str)
-{
- if (str && !*str) {
- /* actually dup empty strings */
- char *out = (char*)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 = ir_strdup(str);
+ self->constval.vstring = util_strdupe(str);
self->hasvalue = true;
return true;
}
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)
{
* is doing something wrong.
*/
irerror(self->context, "Invalid entry block for PHI");
- abort();
+ exit(EXIT_FAILURE);
}
pe.value = v;
/* 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);
}
}
-static bool ir_block_life_propagate(ir_block *b, ir_block *prev, bool *changed);
-bool ir_function_calculate_liferanges(ir_function *self)
-{
- size_t i, s;
- bool changed;
-
- /* parameters live at 0 */
- for (i = 0; i < vec_size(self->params); ++i)
- ir_value_life_merge(self->locals[i], 0);
-
- do {
- self->run_id++;
- changed = false;
- for (i = 0; i != vec_size(self->blocks); ++i)
- {
- if (self->blocks[i]->is_return)
- {
- vec_free(self->blocks[i]->living);
- if (!ir_block_life_propagate(self->blocks[i], NULL, &changed))
- return false;
- }
- }
- } while (changed);
- if (vec_size(self->blocks)) {
- ir_block *block = self->blocks[0];
- for (i = 0; i < vec_size(block->living); ++i) {
- ir_value *v = block->living[i];
- if (v->store != store_local)
- continue;
- if (v->vtype == TYPE_VECTOR)
- continue;
- self->flags |= IR_FLAG_HAS_UNINITIALIZED;
- /* find the instruction reading from it */
- for (s = 0; s < vec_size(v->reads); ++s) {
- if (v->reads[s]->eid == v->life[0].end)
- break;
- }
- if (s < vec_size(v->reads)) {
- if (irwarning(v->context, WARN_USED_UNINITIALIZED,
- "variable `%s` may be used uninitialized in this function\n"
- " -> %s:%i",
- v->name,
- v->reads[s]->context.file, v->reads[s]->context.line)
- )
- {
- return false;
- }
- continue;
- }
- if (v->memberof) {
- ir_value *vec = v->memberof;
- for (s = 0; s < vec_size(vec->reads); ++s) {
- if (vec->reads[s]->eid == v->life[0].end)
- break;
- }
- if (s < vec_size(vec->reads)) {
- if (irwarning(v->context, WARN_USED_UNINITIALIZED,
- "variable `%s` may be used uninitialized in this function\n"
- " -> %s:%i",
- v->name,
- vec->reads[s]->context.file, vec->reads[s]->context.line)
- )
- {
- return false;
- }
- continue;
- }
- }
- if (irwarning(v->context, WARN_USED_UNINITIALIZED,
- "variable `%s` may be used uninitialized in this function", v->name))
- {
- return false;
- }
- }
- }
- return true;
-}
-
/* Local-value allocator
* After finishing creating the liferange of all values used in a function
* we can allocate their global-positions.
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;
}
return changed;
}
-static bool ir_block_life_prop_previous(ir_block* self, ir_block *prev, bool *changed)
-{
- size_t i;
-
- (void)changed;
-
- /* values which have been read in a previous iteration are now
- * in the "living" array even if the previous block doesn't use them.
- * So we have to remove whatever does not exist in the previous block.
- * They will be re-added on-read, but the liferange merge won't cause
- * a change.
- for (i = 0; i < vec_size(self->living); ++i)
- {
- if (!vec_ir_value_find(prev->living, self->living[i], NULL)) {
- vec_remove(self->living, i, 1);
- --i;
- }
- }
- */
-
- /* Whatever the previous block still has in its living set
- * must now be added to ours as well.
- */
- for (i = 0; i < vec_size(prev->living); ++i)
- {
- if (vec_ir_value_find(self->living, prev->living[i], NULL))
- continue;
- vec_push(self->living, prev->living[i]);
- /*
- irerror(self->contextt from prev: %s", self->label, prev->living[i]->_name);
- */
- }
- return true;
-}
-
-static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *changed)
+static bool ir_block_life_propagate(ir_block *self, bool *changed)
{
ir_instr *instr;
ir_value *value;
- bool tempbool;
- size_t i, o, p, mem;
+ size_t i, o, p, mem, cnt;
/* bitmasks which operands are read from or written to */
size_t read, write;
char dbg_ind[16];
dbg_ind[1] = '0';
(void)dbg_ind;
- if (prev)
- {
- if (!ir_block_life_prop_previous(self, prev, changed))
- return false;
+ vec_free(self->living);
+
+ p = vec_size(self->exits);
+ for (i = 0; i < p; ++i) {
+ ir_block *prev = self->exits[i];
+ cnt = vec_size(prev->living);
+ for (o = 0; o < cnt; ++o) {
+ if (!vec_ir_value_find(self->living, prev->living[o], NULL))
+ vec_push(self->living, prev->living[o]);
+ }
}
i = vec_size(self->instr);
/* 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 */
- tempbool = ir_block_living_add_instr(self, instr->eid-1);
- *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;
+ return true;
+}
- self->run_id = self->owner->run_id;
+bool ir_function_calculate_liferanges(ir_function *self)
+{
+ size_t i, s;
+ bool changed;
- for (i = 0; i < vec_size(self->entries); ++i)
- {
- ir_block *entry = self->entries[i];
- ir_block_life_propagate(entry, self, changed);
- }
+ /* parameters live at 0 */
+ for (i = 0; i < vec_size(self->params); ++i)
+ ir_value_life_merge(self->locals[i], 0);
+ do {
+ self->run_id++;
+ changed = false;
+ i = vec_size(self->blocks);
+ while (i--) {
+ ir_block_life_propagate(self->blocks[i], &changed);
+ }
+ } while (changed);
+
+ if (vec_size(self->blocks)) {
+ ir_block *block = self->blocks[0];
+ for (i = 0; i < vec_size(block->living); ++i) {
+ ir_value *v = block->living[i];
+ if (v->store != store_local)
+ continue;
+ if (v->vtype == TYPE_VECTOR)
+ continue;
+ self->flags |= IR_FLAG_HAS_UNINITIALIZED;
+ /* find the instruction reading from it */
+ for (s = 0; s < vec_size(v->reads); ++s) {
+ if (v->reads[s]->eid == v->life[0].end)
+ break;
+ }
+ if (s < vec_size(v->reads)) {
+ if (irwarning(v->context, WARN_USED_UNINITIALIZED,
+ "variable `%s` may be used uninitialized in this function\n"
+ " -> %s:%i",
+ v->name,
+ v->reads[s]->context.file, v->reads[s]->context.line)
+ )
+ {
+ return false;
+ }
+ continue;
+ }
+ if (v->memberof) {
+ ir_value *vec = v->memberof;
+ for (s = 0; s < vec_size(vec->reads); ++s) {
+ if (vec->reads[s]->eid == v->life[0].end)
+ break;
+ }
+ if (s < vec_size(vec->reads)) {
+ if (irwarning(v->context, WARN_USED_UNINITIALIZED,
+ "variable `%s` may be used uninitialized in this function\n"
+ " -> %s:%i",
+ v->name,
+ vec->reads[s]->context.file, vec->reads[s]->context.line)
+ )
+ {
+ return false;
+ }
+ continue;
+ }
+ }
+ if (irwarning(v->context, WARN_USED_UNINITIALIZED,
+ "variable `%s` may be used uninitialized in this function", v->name))
+ {
+ return false;
+ }
+ }
+ }
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;
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));
+ util_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 - 8;
+ while (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.offset++;
component[len-1]++;
}
+
+ mem_d(component);
}
static void gen_vector_fields(prog_section_field fld, const char *name)
fld.offset++;
component[len-1]++;
}
+
+ mem_d(component);
}
static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal)
size_t i;
int32_t *iptr;
prog_section_def def;
- bool pushdef = false;
+ bool pushdef = opts.optimizeoff;
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%s@%i ", ind, v->name, type_name[v->vtype],
+ 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%s@%i ", ind, v->name, type_name[v->vtype],
+ 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);
}
}
if (vec_size(f->blocks))
{
- oprintf("%slife passes (check): %i\n", ind, (int)f->run_id);
+ oprintf("%slife passes: %i\n", ind, (int)f->run_id);
for (i = 0; i < vec_size(f->blocks); ++i) {
- if (f->blocks[i]->run_id != f->run_id) {
- oprintf("%slife pass check fail! %i != %i\n", ind, (int)f->blocks[i]->run_id, (int)f->run_id);
- }
ir_block_dump(f->blocks[i], ind, oprintf);
}
projects / xonotic / gmqcc.git / blobdiff