"<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 */
static ir_value* ir_gen_extparam_proto(ir_builder *ir);
-static void ir_gen_extparam (ir_builder *ir);
+static void ir_gen_extparam (code_t *, ir_builder *ir);
/* error functions */
self->eid = 0;
self->is_return = false;
- self->run_id = 0;
self->living = 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;
}
* is doing something wrong.
*/
irerror(self->context, "Invalid entry block for PHI");
- abort();
+ exit(EXIT_FAILURE);
}
pe.value = v;
++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.
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;
}
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;
- 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);
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;
}
*
* Breaking conventions is annoying...
*/
-static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal);
+static bool ir_builder_gen_global(code_t *, ir_builder *self, ir_value *global, bool islocal);
-static bool gen_global_field(ir_value *global)
+static bool gen_global_field(code_t *code, ir_value *global)
{
if (global->hasvalue)
{
}
/* copy the field's value */
- ir_value_code_setaddr(global, vec_size(code_globals));
- vec_push(code_globals, fld->code.fieldaddr);
+ ir_value_code_setaddr(global, vec_size(code->globals));
+ vec_push(code->globals, fld->code.fieldaddr);
if (global->fieldtype == TYPE_VECTOR) {
- vec_push(code_globals, fld->code.fieldaddr+1);
- vec_push(code_globals, fld->code.fieldaddr+2);
+ vec_push(code->globals, fld->code.fieldaddr+1);
+ vec_push(code->globals, fld->code.fieldaddr+2);
}
}
else
{
- ir_value_code_setaddr(global, vec_size(code_globals));
- vec_push(code_globals, 0);
+ ir_value_code_setaddr(global, vec_size(code->globals));
+ vec_push(code->globals, 0);
if (global->fieldtype == TYPE_VECTOR) {
- vec_push(code_globals, 0);
- vec_push(code_globals, 0);
+ vec_push(code->globals, 0);
+ vec_push(code->globals, 0);
}
}
if (global->code.globaladdr < 0)
return true;
}
-static bool gen_global_pointer(ir_value *global)
+static bool gen_global_pointer(code_t *code, ir_value *global)
{
if (global->hasvalue)
{
return false;
}
- ir_value_code_setaddr(global, vec_size(code_globals));
- vec_push(code_globals, target->code.globaladdr);
+ ir_value_code_setaddr(global, vec_size(code->globals));
+ vec_push(code->globals, target->code.globaladdr);
}
else
{
- ir_value_code_setaddr(global, vec_size(code_globals));
- vec_push(code_globals, 0);
+ ir_value_code_setaddr(global, vec_size(code->globals));
+ vec_push(code->globals, 0);
}
if (global->code.globaladdr < 0)
return false;
return true;
}
-static bool gen_blocks_recursive(ir_function *func, ir_block *block)
+static bool gen_blocks_recursive(code_t *code, ir_function *func, ir_block *block)
{
prog_section_statement stmt;
ir_instr *instr;
size_t i;
block->generated = true;
- block->code_start = vec_size(code_statements);
+ block->code_start = vec_size(code->statements);
for (i = 0; i < vec_size(block->instr); ++i)
{
instr = block->instr[i];
* yet, we generate them right here.
*/
if (!target->generated)
- return gen_blocks_recursive(func, target);
+ return gen_blocks_recursive(code, func, target);
/* otherwise we generate a jump instruction */
stmt.opcode = INSTR_GOTO;
- stmt.o1.s1 = (target->code_start) - vec_size(code_statements);
+ stmt.o1.s1 = (target->code_start) - vec_size(code->statements);
stmt.o2.s1 = 0;
stmt.o3.s1 = 0;
if (stmt.o1.s1 != 1)
- code_push_statement(&stmt, instr->context.line);
+ code_push_statement(code, &stmt, instr->context.line);
/* no further instructions can be in this block */
return true;
if (ontrue->generated) {
stmt.opcode = INSTR_IF;
- stmt.o2.s1 = (ontrue->code_start) - vec_size(code_statements);
+ stmt.o2.s1 = (ontrue->code_start) - vec_size(code->statements);
if (stmt.o2.s1 != 1)
- code_push_statement(&stmt, instr->context.line);
+ code_push_statement(code, &stmt, instr->context.line);
}
if (onfalse->generated) {
stmt.opcode = INSTR_IFNOT;
- stmt.o2.s1 = (onfalse->code_start) - vec_size(code_statements);
+ stmt.o2.s1 = (onfalse->code_start) - vec_size(code->statements);
if (stmt.o2.s1 != 1)
- code_push_statement(&stmt, instr->context.line);
+ code_push_statement(code, &stmt, instr->context.line);
}
if (!ontrue->generated) {
if (onfalse->generated)
- return gen_blocks_recursive(func, ontrue);
+ return gen_blocks_recursive(code, func, ontrue);
}
if (!onfalse->generated) {
if (ontrue->generated)
- return gen_blocks_recursive(func, onfalse);
+ return gen_blocks_recursive(code, func, onfalse);
}
/* neither ontrue nor onfalse exist */
stmt.opcode = INSTR_IFNOT;
onfalse = ontrue;
ontrue = tmp;
}
- stidx = vec_size(code_statements);
- code_push_statement(&stmt, instr->context.line);
+ stidx = vec_size(code->statements);
+ code_push_statement(code, &stmt, instr->context.line);
/* on false we jump, so add ontrue-path */
- if (!gen_blocks_recursive(func, ontrue))
+ if (!gen_blocks_recursive(code, func, ontrue))
return false;
/* fixup the jump address */
- code_statements[stidx].o2.s1 = vec_size(code_statements) - stidx;
+ code->statements[stidx].o2.s1 = vec_size(code->statements) - stidx;
/* generate onfalse path */
if (onfalse->generated) {
/* fixup the jump address */
- code_statements[stidx].o2.s1 = (onfalse->code_start) - (stidx);
- 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();
+ code->statements[stidx].o2.s1 = (onfalse->code_start) - (stidx);
+ 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(code);
}
- stmt.opcode = vec_last(code_statements).opcode;
+ stmt.opcode = vec_last(code->statements).opcode;
if (stmt.opcode == INSTR_GOTO ||
stmt.opcode == INSTR_IF ||
stmt.opcode == INSTR_IFNOT ||
}
/* may have been generated in the previous recursive call */
stmt.opcode = INSTR_GOTO;
- stmt.o1.s1 = (onfalse->code_start) - vec_size(code_statements);
+ stmt.o1.s1 = (onfalse->code_start) - vec_size(code->statements);
stmt.o2.s1 = 0;
stmt.o3.s1 = 0;
if (stmt.o1.s1 != 1)
- code_push_statement(&stmt, instr->context.line);
+ code_push_statement(code, &stmt, instr->context.line);
return true;
}
- 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();
+ 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(code);
}
/* if not, generate now */
- return gen_blocks_recursive(func, onfalse);
+ return gen_blocks_recursive(code, func, onfalse);
}
if ( (instr->opcode >= INSTR_CALL0 && instr->opcode <= INSTR_CALL8)
stmt.opcode = type_store_instr[param->vtype];
stmt.o1.u1 = ir_value_code_addr(param);
stmt.o2.u1 = OFS_PARM0 + 3 * p;
- code_push_statement(&stmt, instr->context.line);
+ code_push_statement(code, &stmt, instr->context.line);
}
/* Now handle extparams */
first = vec_size(instr->params);
continue;
if (p-8 >= vec_size(ir->extparams))
- ir_gen_extparam(ir);
+ ir_gen_extparam(code, ir);
targetparam = ir->extparams[p-8];
stmt.opcode = type_store_instr[param->vtype];
stmt.o1.u1 = ir_value_code_addr(param);
stmt.o2.u1 = ir_value_code_addr(targetparam);
- code_push_statement(&stmt, instr->context.line);
+ code_push_statement(code, &stmt, instr->context.line);
}
stmt.opcode = INSTR_CALL0 + vec_size(instr->params);
stmt.o1.u1 = ir_value_code_addr(instr->_ops[1]);
stmt.o2.u1 = 0;
stmt.o3.u1 = 0;
- code_push_statement(&stmt, instr->context.line);
+ code_push_statement(code, &stmt, instr->context.line);
retvalue = instr->_ops[0];
if (retvalue && retvalue->store != store_return &&
stmt.o1.u1 = OFS_RETURN;
stmt.o2.u1 = ir_value_code_addr(retvalue);
stmt.o3.u1 = 0;
- code_push_statement(&stmt, instr->context.line);
+ code_push_statement(code, &stmt, instr->context.line);
}
continue;
}
}
}
- code_push_statement(&stmt, instr->context.line);
+ code_push_statement(code, &stmt, instr->context.line);
}
return true;
}
-static bool gen_function_code(ir_function *self)
+static bool gen_function_code(code_t *code, ir_function *self)
{
ir_block *block;
prog_section_statement stmt, *retst;
if (block->generated)
return true;
- if (!gen_blocks_recursive(self, block)) {
+ if (!gen_blocks_recursive(code, self, block)) {
irerror(self->context, "failed to generate blocks for '%s'", self->name);
return false;
}
/* code_write and qcvm -disasm need to know that the function ends here */
- retst = &vec_last(code_statements);
+ retst = &vec_last(code->statements);
if (OPTS_OPTIMIZATION(OPTIM_VOID_RETURN) &&
self->outtype == TYPE_VOID &&
retst->opcode == INSTR_RETURN &&
stmt.o1.u1 = 0;
stmt.o2.u1 = 0;
stmt.o3.u1 = 0;
- code_push_statement(&stmt, vec_last(code_linenums));
+ code_push_statement(code, &stmt, vec_last(code->linenums));
}
return true;
}
-static qcint ir_builder_filestring(ir_builder *ir, const char *filename)
+static qcint ir_builder_filestring(code_t *code, ir_builder *ir, const char *filename)
{
/* NOTE: filename pointers are copied, we never strdup them,
* thus we can use pointer-comparison to find the string.
return ir->filestrings[i];
}
- str = code_genstring(filename);
+ str = code_genstring(code, filename);
vec_push(ir->filenames, filename);
vec_push(ir->filestrings, str);
return str;
}
-static bool gen_global_function(ir_builder *ir, ir_value *global)
+static bool gen_global_function(code_t *code, ir_builder *ir, ir_value *global)
{
prog_section_function fun;
ir_function *irfun;
irfun = global->constval.vfunc;
fun.name = global->code.name;
- fun.file = ir_builder_filestring(ir, global->context.file);
+ fun.file = ir_builder_filestring(code, ir, global->context.file);
fun.profile = 0; /* always 0 */
fun.nargs = vec_size(irfun->params);
if (fun.nargs > 8)
if (irfun->builtin)
fun.entry = irfun->builtin+1;
else {
- irfun->code_function_def = vec_size(code_functions);
- fun.entry = vec_size(code_statements);
+ irfun->code_function_def = vec_size(code->functions);
+ fun.entry = vec_size(code->statements);
}
- vec_push(code_functions, fun);
+ vec_push(code->functions, fun);
return true;
}
ir_value *global;
char name[128];
- snprintf(name, sizeof(name), "EXTPARM#%i", (int)(vec_size(ir->extparam_protos)));
+ 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 global;
}
-static void ir_gen_extparam(ir_builder *ir)
+static void ir_gen_extparam(code_t *code, ir_builder *ir)
{
prog_section_def def;
ir_value *global;
else
global = ir->extparam_protos[vec_size(ir->extparams)];
- def.name = code_genstring(global->name);
- def.type = TYPE_VECTOR;
- def.offset = vec_size(code_globals);
+ def.name = code_genstring(code, global->name);
+ def.type = TYPE_VECTOR;
+ def.offset = vec_size(code->globals);
+
+ vec_push(code->defs, def);
- vec_push(code_defs, def);
ir_value_code_setaddr(global, def.offset);
- vec_push(code_globals, 0);
- vec_push(code_globals, 0);
- vec_push(code_globals, 0);
+
+ vec_push(code->globals, 0);
+ vec_push(code->globals, 0);
+ vec_push(code->globals, 0);
vec_push(ir->extparams, global);
}
-static bool gen_function_extparam_copy(ir_function *self)
+static bool gen_function_extparam_copy(code_t *code, ir_function *self)
{
size_t i, ext, numparams;
for (i = 8; i < numparams; ++i) {
ext = i - 8;
if (ext >= vec_size(ir->extparams))
- ir_gen_extparam(ir);
+ ir_gen_extparam(code, 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);
+ code_push_statement(code, &stmt, self->context.line);
}
return true;
}
-static bool gen_function_varargs_copy(ir_function *self)
+static bool gen_function_varargs_copy(code_t *code, ir_function *self)
{
size_t i, ext, numparams, maxparams;
stmt.o3.s1 = 0;
maxparams = numparams + self->max_varargs;
for (i = numparams; i < maxparams; ++i) {
- if (i <= 8) {
+ 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);
+ code_push_statement(code, &stmt, self->context.line);
continue;
}
- ext = i - 9;
- if (ext >= vec_size(ir->extparams))
- ir_gen_extparam(ir);
+ ext = i - 8;
+ while (ext >= vec_size(ir->extparams))
+ ir_gen_extparam(code, 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);
+ code_push_statement(code, &stmt, self->context.line);
}
return true;
}
-static bool gen_function_locals(ir_builder *ir, ir_value *global)
+static bool gen_function_locals(code_t *code, ir_builder *ir, ir_value *global)
{
prog_section_function *def;
ir_function *irfun;
uint32_t firstlocal, firstglobal;
irfun = global->constval.vfunc;
- def = code_functions + irfun->code_function_def;
+ def = code->functions + irfun->code_function_def;
- if (opts.g || !OPTS_OPTIMIZATION(OPTIM_OVERLAP_LOCALS) || (irfun->flags & IR_FLAG_MASK_NO_OVERLAP))
- firstlocal = def->firstlocal = vec_size(code_globals);
- else {
+ 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 {
firstlocal = def->firstlocal = ir->first_common_local;
++opts_optimizationcount[OPTIM_OVERLAP_LOCALS];
}
firstglobal = (OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS) ? ir->first_common_globaltemp : firstlocal);
- for (i = vec_size(code_globals); i < firstlocal + irfun->allocated_locals; ++i)
- vec_push(code_globals, 0);
+ for (i = vec_size(code->globals); i < firstlocal + irfun->allocated_locals; ++i)
+ vec_push(code->globals, 0);
for (i = 0; i < vec_size(irfun->locals); ++i) {
ir_value *v = irfun->locals[i];
if (v->locked || !OPTS_OPTIMIZATION(OPTIM_GLOBAL_TEMPS)) {
ir_value_code_setaddr(v, firstlocal + v->code.local);
- if (!ir_builder_gen_global(ir, irfun->locals[i], true)) {
+ if (!ir_builder_gen_global(code, ir, irfun->locals[i], true)) {
irerror(irfun->locals[i]->context, "failed to generate local %s", irfun->locals[i]->name);
return false;
}
return true;
}
-static bool gen_global_function_code(ir_builder *ir, ir_value *global)
+static bool gen_global_function_code(code_t *code, ir_builder *ir, ir_value *global)
{
prog_section_function *fundef;
ir_function *irfun;
irerror(irfun->context, "`%s`: IR global wasn't generated, failed to access function-def", irfun->name);
return false;
}
- fundef = &code_functions[irfun->code_function_def];
+ fundef = &code->functions[irfun->code_function_def];
- fundef->entry = vec_size(code_statements);
- if (!gen_function_locals(ir, global)) {
+ fundef->entry = vec_size(code->statements);
+ if (!gen_function_locals(code, ir, global)) {
irerror(irfun->context, "Failed to generate locals for function %s", irfun->name);
return false;
}
- if (!gen_function_extparam_copy(irfun)) {
+ if (!gen_function_extparam_copy(code, irfun)) {
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)) {
+ if (irfun->max_varargs && !gen_function_varargs_copy(code, irfun)) {
irerror(irfun->context, "Failed to generate vararg-copy code for function %s", irfun->name);
return false;
}
- if (!gen_function_code(irfun)) {
+ if (!gen_function_code(code, irfun)) {
irerror(irfun->context, "Failed to generate code for function %s", irfun->name);
return false;
}
return true;
}
-static void gen_vector_defs(prog_section_def def, const char *name)
+static void gen_vector_defs(code_t *code, prog_section_def def, const char *name)
{
char *component;
size_t len, i;
component[len-1] = 'x';
for (i = 0; i < 3; ++i) {
- def.name = code_genstring(component);
- vec_push(code_defs, def);
+ def.name = code_genstring(code, component);
+ vec_push(code->defs, def);
def.offset++;
component[len-1]++;
}
+
+ mem_d(component);
}
-static void gen_vector_fields(prog_section_field fld, const char *name)
+static void gen_vector_fields(code_t *code, prog_section_field fld, const char *name)
{
char *component;
size_t len, i;
component[len-1] = 'x';
for (i = 0; i < 3; ++i) {
- fld.name = code_genstring(component);
- vec_push(code_fields, fld);
+ fld.name = code_genstring(code, component);
+ vec_push(code->fields, fld);
fld.offset++;
component[len-1]++;
}
+
+ mem_d(component);
}
-static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal)
+static bool ir_builder_gen_global(code_t *code, 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.offset = vec_size(code->globals);
def.name = 0;
- if (opts.g || !islocal)
+ if (OPTS_OPTION_BOOL(OPTION_G) || !islocal)
{
pushdef = true;
if (pushdef && global->name) {
if (global->name[0] == '#') {
if (!self->str_immediate)
- self->str_immediate = code_genstring("IMMEDIATE");
+ self->str_immediate = code_genstring(code, "IMMEDIATE");
def.name = global->code.name = self->str_immediate;
}
else
- def.name = global->code.name = code_genstring(global->name);
+ def.name = global->code.name = code_genstring(code, global->name);
}
else
def.name = 0;
if (islocal) {
def.offset = ir_value_code_addr(global);
- vec_push(code_defs, def);
+ vec_push(code->defs, def);
if (global->vtype == TYPE_VECTOR)
- gen_vector_defs(def, global->name);
+ gen_vector_defs(code, def, global->name);
else if (global->vtype == TYPE_FIELD && global->fieldtype == TYPE_VECTOR)
- gen_vector_defs(def, global->name);
+ gen_vector_defs(code, def, global->name);
return true;
}
}
* Maybe this could be an -foption
* fteqcc creates data for end_sys_* - of size 1, so let's do the same
*/
- ir_value_code_setaddr(global, vec_size(code_globals));
- vec_push(code_globals, 0);
+ ir_value_code_setaddr(global, vec_size(code->globals));
+ vec_push(code->globals, 0);
/* Add the def */
- if (pushdef) vec_push(code_defs, def);
+ if (pushdef) vec_push(code->defs, def);
return true;
case TYPE_POINTER:
- if (pushdef) vec_push(code_defs, def);
- return gen_global_pointer(global);
+ if (pushdef) vec_push(code->defs, def);
+ return gen_global_pointer(code, global);
case TYPE_FIELD:
if (pushdef) {
- vec_push(code_defs, def);
+ vec_push(code->defs, def);
if (global->fieldtype == TYPE_VECTOR)
- gen_vector_defs(def, global->name);
+ gen_vector_defs(code, def, global->name);
}
- return gen_global_field(global);
+ return gen_global_field(code, global);
case TYPE_ENTITY:
/* fall through */
case TYPE_FLOAT:
{
- ir_value_code_setaddr(global, vec_size(code_globals));
+ ir_value_code_setaddr(global, vec_size(code->globals));
if (global->hasvalue) {
iptr = (int32_t*)&global->constval.ivec[0];
- vec_push(code_globals, *iptr);
+ vec_push(code->globals, *iptr);
} else {
- vec_push(code_globals, 0);
+ vec_push(code->globals, 0);
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
- if (pushdef) vec_push(code_defs, def);
+ if (pushdef) vec_push(code->defs, def);
return global->code.globaladdr >= 0;
}
case TYPE_STRING:
{
- ir_value_code_setaddr(global, vec_size(code_globals));
+ ir_value_code_setaddr(global, vec_size(code->globals));
if (global->hasvalue) {
- vec_push(code_globals, code_genstring(global->constval.vstring));
+ vec_push(code->globals, code_genstring(code, global->constval.vstring));
} else {
- vec_push(code_globals, 0);
+ vec_push(code->globals, 0);
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
- if (pushdef) vec_push(code_defs, def);
+ if (pushdef) vec_push(code->defs, def);
return global->code.globaladdr >= 0;
}
case TYPE_VECTOR:
{
size_t d;
- ir_value_code_setaddr(global, vec_size(code_globals));
+ ir_value_code_setaddr(global, vec_size(code->globals));
if (global->hasvalue) {
iptr = (int32_t*)&global->constval.ivec[0];
- vec_push(code_globals, iptr[0]);
+ vec_push(code->globals, iptr[0]);
if (global->code.globaladdr < 0)
return false;
for (d = 1; d < type_sizeof_[global->vtype]; ++d) {
- vec_push(code_globals, iptr[d]);
+ vec_push(code->globals, iptr[d]);
}
} else {
- vec_push(code_globals, 0);
+ vec_push(code->globals, 0);
if (global->code.globaladdr < 0)
return false;
for (d = 1; d < type_sizeof_[global->vtype]; ++d) {
- vec_push(code_globals, 0);
+ vec_push(code->globals, 0);
}
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
if (pushdef) {
- vec_push(code_defs, def);
+ vec_push(code->defs, def);
def.type &= ~DEF_SAVEGLOBAL;
- gen_vector_defs(def, global->name);
+ gen_vector_defs(code, def, global->name);
}
return global->code.globaladdr >= 0;
}
case TYPE_FUNCTION:
- ir_value_code_setaddr(global, vec_size(code_globals));
+ ir_value_code_setaddr(global, vec_size(code->globals));
if (!global->hasvalue) {
- vec_push(code_globals, 0);
+ vec_push(code->globals, 0);
if (global->code.globaladdr < 0)
return false;
} else {
- vec_push(code_globals, vec_size(code_functions));
- if (!gen_global_function(self, global))
+ vec_push(code->globals, vec_size(code->functions));
+ if (!gen_global_function(code, self, global))
return false;
}
if (!islocal && global->cvq != CV_CONST)
def.type |= DEF_SAVEGLOBAL;
- if (pushdef) vec_push(code_defs, def);
+ if (pushdef) vec_push(code->defs, def);
return true;
case TYPE_VARIANT:
/* assume biggest type */
- ir_value_code_setaddr(global, vec_size(code_globals));
- vec_push(code_globals, 0);
+ ir_value_code_setaddr(global, vec_size(code->globals));
+ vec_push(code->globals, 0);
for (i = 1; i < type_sizeof_[TYPE_VARIANT]; ++i)
- vec_push(code_globals, 0);
+ vec_push(code->globals, 0);
return true;
default:
/* refuse to create 'void' type or any other fancy business. */
}
}
-static void ir_builder_prepare_field(ir_value *field)
+static GMQCC_INLINE void ir_builder_prepare_field(code_t *code, ir_value *field)
{
- field->code.fieldaddr = code_alloc_field(type_sizeof_[field->fieldtype]);
+ field->code.fieldaddr = code_alloc_field(code, type_sizeof_[field->fieldtype]);
}
-static bool ir_builder_gen_field(ir_builder *self, ir_value *field)
+static bool ir_builder_gen_field(code_t *code, ir_builder *self, ir_value *field)
{
prog_section_def def;
prog_section_field fld;
(void)self;
def.type = (uint16_t)field->vtype;
- def.offset = (uint16_t)vec_size(code_globals);
+ 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];
memcpy(name+1, field->name, len); /* no strncpy - we used strlen above */
name[len+1] = 0;
- def.name = code_genstring(name);
+ def.name = code_genstring(code, name);
fld.name = def.name + 1; /* we reuse that string table entry */
} else {
/* in plain QC, there cannot be a global with the same name,
* FIXME: fteqcc should create a global as well
* check if it actually uses the same name. Probably does
*/
- def.name = code_genstring(field->name);
+ def.name = code_genstring(code, field->name);
fld.name = def.name;
}
field->code.name = def.name;
- vec_push(code_defs, def);
+ vec_push(code->defs, def);
fld.type = field->fieldtype;
fld.offset = field->code.fieldaddr;
- vec_push(code_fields, fld);
+ vec_push(code->fields, fld);
- ir_value_code_setaddr(field, vec_size(code_globals));
- vec_push(code_globals, fld.offset);
+ ir_value_code_setaddr(field, vec_size(code->globals));
+ vec_push(code->globals, fld.offset);
if (fld.type == TYPE_VECTOR) {
- vec_push(code_globals, fld.offset+1);
- vec_push(code_globals, fld.offset+2);
+ vec_push(code->globals, fld.offset+1);
+ vec_push(code->globals, fld.offset+2);
}
if (field->fieldtype == TYPE_VECTOR) {
- gen_vector_defs(def, field->name);
- gen_vector_fields(fld, field->name);
+ gen_vector_defs (code, def, field->name);
+ gen_vector_fields(code, fld, field->name);
}
return field->code.globaladdr >= 0;
}
-bool ir_builder_generate(ir_builder *self, const char *filename)
+bool ir_builder_generate(code_t *code, ir_builder *self, const char *filename)
{
prog_section_statement stmt;
size_t i;
for (i = 0; i < vec_size(self->fields); ++i)
{
- ir_builder_prepare_field(self->fields[i]);
+ ir_builder_prepare_field(code, self->fields[i]);
}
for (i = 0; i < vec_size(self->globals); ++i)
{
- if (!ir_builder_gen_global(self, self->globals[i], false)) {
+ if (!ir_builder_gen_global(code, self, self->globals[i], false)) {
return false;
}
if (self->globals[i]->vtype == TYPE_FUNCTION) {
for (i = 0; i < vec_size(self->fields); ++i)
{
- if (!ir_builder_gen_field(self, self->fields[i])) {
+ if (!ir_builder_gen_field(code, self, self->fields[i])) {
return false;
}
}
/* generate nil */
- ir_value_code_setaddr(self->nil, vec_size(code_globals));
- vec_push(code_globals, 0);
- vec_push(code_globals, 0);
- vec_push(code_globals, 0);
+ ir_value_code_setaddr(self->nil, vec_size(code->globals));
+ vec_push(code->globals, 0);
+ vec_push(code->globals, 0);
+ vec_push(code->globals, 0);
/* generate global temps */
- self->first_common_globaltemp = vec_size(code_globals);
+ self->first_common_globaltemp = vec_size(code->globals);
for (i = 0; i < self->max_globaltemps; ++i) {
- vec_push(code_globals, 0);
+ vec_push(code->globals, 0);
}
/* generate common locals */
- self->first_common_local = vec_size(code_globals);
+ self->first_common_local = vec_size(code->globals);
for (i = 0; i < self->max_locals; ++i) {
- vec_push(code_globals, 0);
+ vec_push(code->globals, 0);
}
/* generate function code */
for (i = 0; i < vec_size(self->globals); ++i)
{
if (self->globals[i]->vtype == TYPE_FUNCTION) {
- if (!gen_global_function_code(self, self->globals[i])) {
+ if (!gen_global_function_code(code, self, self->globals[i])) {
return false;
}
}
}
- if (vec_size(code_globals) >= 65536) {
+ if (vec_size(code->globals) >= 65536) {
irerror(vec_last(self->globals)->context, "This progs file would require more globals than the metadata can handle. Bailing out.");
return false;
}
/* DP errors if the last instruction is not an INSTR_DONE. */
- if (vec_last(code_statements).opcode != 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));
+ code_push_statement(code, &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)) {
+ if (vec_size(code->statements) != vec_size(code->linenums)) {
con_err("Linecounter wrong: %lu != %lu\n",
- (unsigned long)vec_size(code_statements),
- (unsigned long)vec_size(code_linenums));
+ (unsigned long)vec_size(code->statements),
+ (unsigned long)vec_size(code->linenums));
} else if (OPTS_FLAG(LNO)) {
- char *dot;
+ char *dot;
size_t filelen = strlen(filename);
memcpy(vec_add(lnofile, filelen+1), filename, filelen+1);
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
con_out("writing '%s'\n", filename);
}
- if (!code_write(filename, lnofile)) {
+ if (!code_write(code, filename, lnofile)) {
vec_free(lnofile);
return false;
}
}
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