X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ir.c;h=47b9adc7798125536cf83969e61468da5068c2c8;hb=5022f716dcaefdc8b1e6fe45f1ecb8865921d9ec;hp=00411a6f09a9b6ad2b49c201b4a5b9a36ac864f3;hpb=9420c01538223dc977060087e5026642cb3fbe2f;p=xonotic%2Fgmqcc.git diff --git a/ir.c b/ir.c index 00411a6..47b9adc 100644 --- a/ir.c +++ b/ir.c @@ -172,11 +172,6 @@ ir_builder* ir_builder_new(const char *modulename) return NULL; } - /* globals which always exist */ - - /* for now we give it a vector size */ - ir_builder_create_global(self, "OFS_RETURN", TYPE_VARIANT); - return self; } @@ -641,6 +636,7 @@ ir_value* ir_value_var(const char *name, int storetype, int vtype) self->members[0] = NULL; self->members[1] = NULL; self->members[2] = NULL; + self->memberof = NULL; MEM_VECTOR_INIT(self, life); return self; @@ -684,6 +680,7 @@ ir_value* ir_value_vector_member(ir_value *self, unsigned int member) return NULL; } + m->memberof = self; return m; } @@ -1815,6 +1812,7 @@ bool ir_function_calculate_liferanges(ir_function *self) { if (self->blocks[i]->is_return) { + self->blocks[i]->living_count = 0; if (!ir_block_life_propagate(self->blocks[i], NULL, &changed)) return false; } @@ -1824,7 +1822,7 @@ bool ir_function_calculate_liferanges(ir_function *self) ir_block *block = self->blocks[0]; for (i = 0; i < block->living_count; ++i) { ir_value *v = block->living[i]; - if (v->name[0] == '#' || v->name[0] == '%') + if (v->memberof || v->store != store_local) continue; if (irwarning(v->context, WARN_USED_UNINITIALIZED, "variable `%s` may be used uninitialized in this function", v->name)) @@ -2086,6 +2084,8 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change for (p = 0; p < instr->phi_count; ++p) { value = instr->phi[p].value; + if (value->memberof) + value = value->memberof; if (!ir_block_living_find(self, value, NULL) && !ir_block_living_add(self, value)) { @@ -2097,6 +2097,8 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change for (p = 0; p < instr->params_count; ++p) { value = instr->params[p]; + if (value->memberof) + value = value->memberof; if (!ir_block_living_find(self, value, NULL) && !ir_block_living_add(self, value)) { @@ -2107,6 +2109,19 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change /* 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 */ for (o = 0; o < 3; ++o) { @@ -2114,6 +2129,8 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change continue; value = instr->_ops[o]; + if (value->memberof) + value = value->memberof; /* We only care about locals */ /* we also calculate parameter liferanges so that locals @@ -2554,7 +2571,6 @@ static bool gen_global_function(ir_builder *ir, ir_value *global) } fun.firstlocal = code_globals_elements; - fun.locals = irfun->allocated_locals + irfun->locals_count; local_var_end = fun.firstlocal; for (i = 0; i < irfun->locals_count; ++i) { @@ -2579,6 +2595,8 @@ static bool gen_global_function(ir_builder *ir, ir_value *global) code_globals_add(0); } + fun.locals = code_globals_elements - fun.firstlocal; + if (irfun->builtin) fun.entry = irfun->builtin; else { @@ -2595,6 +2613,13 @@ static bool gen_global_function_code(ir_builder *ir, ir_value *global) ir_function *irfun; irfun = global->constval.vfunc; + if (!irfun) { + irwarning(global->context, WARN_IMPLICIT_FUNCTION_POINTER, + "function `%s` has no body and in QC implicitly becomes a function-pointer", global->name); + /* this was a function pointer, don't generate code for those */ + return true; + } + if (irfun->builtin) return true; @@ -2624,6 +2649,28 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global) switch (global->vtype) { + case TYPE_VOID: + if (!strcmp(global->name, "end_sys_globals")) { + /* TODO: remember this point... all the defs before this one + * should be checksummed and added to progdefs.h when we generate it. + */ + } + else if (!strcmp(global->name, "end_sys_fields")) { + /* TODO: same as above but for entity-fields rather than globsl + */ + } + else + irwarning(global->context, WARN_VOID_VARIABLES, "unrecognized variable of type void `%s`", + global->name); + /* I'd argue setting it to 0 is sufficient, but maybe some depend on knowing how far + * the system fields actually go? Though the engine knows this anyway... + * Maybe this could be an -foption + */ + ir_value_code_setaddr(global, def.offset); + /* Add the def */ + if (code_defs_add(def) < 0) + return false; + return true; case TYPE_POINTER: if (code_defs_add(def) < 0) return false; @@ -2688,9 +2735,14 @@ static bool ir_builder_gen_global(ir_builder *self, ir_value *global) case TYPE_FUNCTION: if (code_defs_add(def) < 0) return false; - ir_value_code_setaddr(global, code_globals_elements); - code_globals_add(code_functions_elements); - return gen_global_function(self, global); + if (!global->isconst) { + ir_value_code_setaddr(global, code_globals_add(0)); + return global->code.globaladdr >= 0; + } else { + ir_value_code_setaddr(global, code_globals_elements); + code_globals_add(code_functions_elements); + return gen_global_function(self, global); + } case TYPE_VARIANT: /* assume biggest type */ ir_value_code_setaddr(global, code_globals_add(0)); @@ -2775,20 +2827,21 @@ static bool ir_builder_gen_field(ir_builder *self, ir_value *field) bool ir_builder_generate(ir_builder *self, const char *filename) { + prog_section_statement stmt; size_t i; code_init(); - for (i = 0; i < self->fields_count; ++i) + for (i = 0; i < self->globals_count; ++i) { - if (!ir_builder_gen_field(self, self->fields[i])) { + if (!ir_builder_gen_global(self, self->globals[i])) { return false; } } - for (i = 0; i < self->globals_count; ++i) + for (i = 0; i < self->fields_count; ++i) { - if (!ir_builder_gen_global(self, self->globals[i])) { + if (!ir_builder_gen_field(self, self->fields[i])) { return false; } } @@ -2803,6 +2856,17 @@ bool ir_builder_generate(ir_builder *self, const char *filename) } } + /* DP errors if the last instruction is not an INSTR_DONE + * and for debugging purposes we add an additional AINSTR_END + * to the end of functions, so here it goes: + */ + stmt.opcode = INSTR_DONE; + stmt.o1.u1 = 0; + stmt.o2.u1 = 0; + stmt.o3.u1 = 0; + if (code_statements_add(stmt) < 0) + return false; + printf("writing '%s'...\n", filename); return code_write(filename); } @@ -2872,6 +2936,25 @@ void ir_function_dump(ir_function *f, char *ind, oprintf("\n"); } } + oprintf("%sliferanges:\n", ind); + for (i = 0; i < f->locals_count; ++i) { + size_t l; + ir_value *v = f->locals[i]; + oprintf("%s\t%s: unique ", ind, v->name); + for (l = 0; l < v->life_count; ++l) { + oprintf("[%i,%i] ", v->life[l].start, v->life[l].end); + } + oprintf("\n"); + } + for (i = 0; i < f->values_count; ++i) { + size_t l; + ir_value *v = f->values[i]; + oprintf("%s\t%s: @%i ", ind, v->name, (int)v->code.local); + for (l = 0; l < v->life_count; ++l) { + oprintf("[%i,%i] ", v->life[l].start, v->life[l].end); + } + oprintf("\n"); + } if (f->blocks_count) { oprintf("%slife passes (check): %i\n", ind, (int)f->run_id); @@ -2960,6 +3043,12 @@ void ir_instr_dump(ir_instr *in, char *ind, } if (in->bops[1]) oprintf("%s[%s]", comma, in->bops[1]->label); + if (in->params_count) { + oprintf("\tparams: "); + for (i = 0; i != in->params_count; ++i) { + oprintf("%s, ", in->params[i]->name); + } + } oprintf("\n"); ind[strlen(ind)-1] = 0; } @@ -2973,7 +3062,7 @@ void ir_value_dump(ir_value* v, int (*oprintf)(const char*, ...)) oprintf("(void)"); break; case TYPE_FUNCTION: - oprintf("(function)"); + oprintf("fn:%s", v->name); break; case TYPE_FLOAT: oprintf("%g", v->constval.vfloat);