X-Git-Url: https://git.xonotic.org/?a=blobdiff_plain;f=ir.c;h=47b9adc7798125536cf83969e61468da5068c2c8;hb=5022f716dcaefdc8b1e6fe45f1ecb8865921d9ec;hp=f60b6496facbe0f5b7a87f21ff083780ace96160;hpb=211b11f1547b0e71eba034ca5260d8952a44a305;p=xonotic%2Fgmqcc.git diff --git a/ir.c b/ir.c index f60b649..47b9adc 100644 --- a/ir.c +++ b/ir.c @@ -133,6 +133,24 @@ static void irerror(lex_ctx ctx, const char *msg, ...) va_end(ap); } +static bool irwarning(lex_ctx ctx, int warntype, const char *fmt, ...) +{ + va_list ap; + int lvl = LVL_WARNING; + + if (!OPTS_WARN(warntype)) + return false; + + if (opts_werror) + lvl = LVL_ERROR; + + va_start(ap, fmt); + vprintmsg(lvl, ctx.file, ctx.line, "warning", fmt, ap); + va_end(ap); + + return opts_werror; +} + /*********************************************************************** *IR Builder */ @@ -154,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; } @@ -623,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; @@ -666,6 +680,7 @@ ir_value* ir_value_vector_member(ir_value *self, unsigned int member) return NULL; } + m->memberof = self; return m; } @@ -970,13 +985,8 @@ bool ir_values_overlap(const ir_value *a, const ir_value *b) /* check if the entries overlap, for that, * both must start before the other one ends. */ -#if defined(LIFE_RANGE_WITHOUT_LAST_READ) - if (la->start <= lb->end && - lb->start <= la->end) -#else - if (la->start < lb->end && - lb->start < la->end) -#endif + if (la->start < lb->end && + lb->start < la->end) { return true; } @@ -1802,11 +1812,25 @@ 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; } } } while (changed); + if (self->blocks_count) { + ir_block *block = self->blocks[0]; + for (i = 0; i < block->living_count; ++i) { + ir_value *v = block->living[i]; + 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)) + { + return false; + } + } + } return true; } @@ -2042,17 +2066,9 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change size_t i, o, p; /* bitmasks which operands are read from or written to */ size_t read, write; -#if defined(LIFE_RANGE_WITHOUT_LAST_READ) - size_t rd; - new_reads_t new_reads; -#endif char dbg_ind[16] = { '#', '0' }; (void)dbg_ind; -#if defined(LIFE_RANGE_WITHOUT_LAST_READ) - MEM_VECTOR_INIT(&new_reads, v); -#endif - if (prev) { if (!ir_block_life_prop_previous(self, prev, changed)) @@ -2068,43 +2084,44 @@ 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 ! defined(LIFE_RANGE_WITHOUT_LAST_READ) + if (value->memberof) + value = value->memberof; if (!ir_block_living_find(self, value, NULL) && !ir_block_living_add(self, value)) { - goto on_error; - } -#else - if (!new_reads_t_v_find(&new_reads, value, NULL)) - { - if (!new_reads_t_v_add(&new_reads, value)) - goto on_error; + return false; } -#endif } /* call params are read operands too */ for (p = 0; p < instr->params_count; ++p) { value = instr->params[p]; -#if ! defined(LIFE_RANGE_WITHOUT_LAST_READ) + if (value->memberof) + value = value->memberof; if (!ir_block_living_find(self, value, NULL) && !ir_block_living_add(self, value)) { - goto on_error; - } -#else - if (!new_reads_t_v_find(&new_reads, value, NULL)) - { - if (!new_reads_t_v_add(&new_reads, value)) - goto on_error; + return false; } -#endif } /* 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) { @@ -2112,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 @@ -2124,20 +2143,11 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change /* read operands */ if (read & (1<_name); */ - if (!new_reads_t_v_find(&new_reads, value, NULL)) - { - if (!new_reads_t_v_add(&new_reads, value)) - goto on_error; + return false; } -#endif } /* write operands */ @@ -2149,13 +2159,7 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change { size_t idx; bool in_living = ir_block_living_find(self, value, &idx); -#if defined(LIFE_RANGE_WITHOUT_LAST_READ) - size_t readidx; - bool in_reads = new_reads_t_v_find(&new_reads, value, &readidx); - if (!in_living && !in_reads) -#else if (!in_living) -#endif { /* If the value isn't alive it hasn't been read before... */ /* TODO: See if the warning can be emitted during parsing or AST processing @@ -2184,16 +2188,8 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change */ *changed = *changed || tempbool; /* Then remove */ -#if ! defined(LIFE_RANGE_WITHOUT_LAST_READ) if (!ir_block_living_remove(self, idx)) - goto on_error; -#else - if (in_reads) - { - if (!new_reads_t_v_remove(&new_reads, readidx)) - goto on_error; - } -#endif + return false; } } } @@ -2202,21 +2198,6 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change /*fprintf(stderr, "living added values\n");*/ *changed = *changed || tempbool; -#if defined(LIFE_RANGE_WITHOUT_LAST_READ) - /* new reads: */ - for (rd = 0; rd < new_reads.v_count; ++rd) - { - if (!ir_block_living_find(self, new_reads.v[rd], NULL)) { - if (!ir_block_living_add(self, new_reads.v[rd])) - goto on_error; - } - if (!i && !self->entries_count) { - /* fix the top */ - *changed = *changed || ir_value_life_merge(new_reads.v[rd], instr->eid); - } - } - MEM_VECTOR_CLEAR(&new_reads, v); -#endif } if (self->run_id == self->owner->run_id) @@ -2231,11 +2212,6 @@ static bool ir_block_life_propagate(ir_block *self, ir_block *prev, bool *change } return true; -on_error: -#if defined(LIFE_RANGE_WITHOUT_LAST_READ) - MEM_VECTOR_CLEAR(&new_reads, v); -#endif - return false; } /*********************************************************************** @@ -2595,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) { @@ -2620,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 { @@ -2636,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; @@ -2665,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; @@ -2729,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)); @@ -2816,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; } } @@ -2844,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); } @@ -2913,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); @@ -3001,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; } @@ -3014,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);