AINSTR_END, /* array */
};
+uint16_t type_not_instr[TYPE_COUNT] = {
+ INSTR_NOT_F, /* should use I when having integer support */
+ INSTR_NOT_S,
+ INSTR_NOT_F,
+ INSTR_NOT_V,
+ INSTR_NOT_ENT,
+ INSTR_NOT_ENT,
+ INSTR_NOT_FNC,
+ INSTR_NOT_ENT, /* should use I */
+#if 0
+ INSTR_NOT_I, /* integer type */
+#else
+ INSTR_NOT_F,
+#endif
+
+ INSTR_NOT_V, /* variant, should never be accessed */
+
+ AINSTR_END, /* struct */
+ AINSTR_END, /* union */
+ AINSTR_END, /* array */
+};
+
static void irerror(lex_ctx ctx, const char *msg, ...)
{
va_list ap;
self->values = NULL;
self->locals = NULL;
- self->max_parameters = 0;
-
self->code_function_def = -1;
self->allocated_locals = 0;
if (!ir_function_calculate_liferanges(self))
return false;
-
if (!ir_function_allocate_locals(self))
return false;
return true;
self->params = NULL;
self->eid = 0;
+
+ self->likely = true;
return self;
}
bool ir_block_create_store_op(ir_block *self, int op, ir_value *target, ir_value *what)
{
- ir_instr *in = ir_instr_new(self, op);
+ ir_instr *in;
+ if (self->final) {
+ irerror(self->context, "unreachable statement (%s)", self->label);
+ return false;
+ }
+ in = ir_instr_new(self, op);
if (!in)
return false;
{
ir_instr *in;
if (self->final) {
- irerror(self->context, "block already ended (%s)", self->label);
+ irerror(self->context, "unreachable statement (%s)", self->label);
return false;
}
self->final = true;
{
ir_instr *in;
if (self->final) {
- irerror(self->context, "block already ended (%s)", self->label);
+ irerror(self->context, "unreachable statement (%s)", self->label);
return false;
}
self->final = true;
{
ir_instr *in;
if (self->final) {
- irerror(self->context, "block already ended (%s)", self->label);
+ irerror(self->context, "unreachable statement (%s)", self->label);
return false;
}
self->final = true;
{
ir_instr *in;
if (self->final) {
- irerror(self->context, "block already ended (%s)", self->label);
+ irerror(self->context, "unreachable statement (%s)", self->label);
return false;
}
self->final = true;
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;
return true;
}
+#endif
static bool ir_block_naive_phi(ir_block *self)
{
- size_t i, p, w;
+ size_t i, p; /*, w;*/
/* FIXME: optionally, create_phi can add the phis
* to a list so we don't need to loop through blocks
* - anyway: "don't optimize YET"
for (p = 0; p < vec_size(instr->phi); ++p)
{
+ ir_value *v = instr->phi[p].value;
+ ir_block *b = instr->phi[p].from;
+
+ if (v->store == store_value &&
+ vec_size(v->reads) == 1 &&
+ vec_size(v->writes) == 1)
+ {
+ /* replace the value */
+ if (!ir_instr_op(v->writes[0], 0, instr->_ops[0], true))
+ return false;
+ }
+ else
+ {
+ /* force a move instruction */
+ ir_instr *prevjump = vec_last(b->instr);
+ vec_pop(b->instr);
+ b->final = false;
+ instr->_ops[0]->store = store_global;
+ if (!ir_block_create_store(b, instr->_ops[0], v))
+ return false;
+ instr->_ops[0]->store = store_value;
+ 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;
}
}
}
+#endif
}
ir_instr_delete(instr);
}
}
/* neither ontrue nor onfalse exist */
stmt.opcode = INSTR_IFNOT;
+ if (!instr->likely) {
+ /* Honor the likelyhood hint */
+ ir_block *tmp = onfalse;
+ stmt.opcode = INSTR_IF;
+ onfalse = ontrue;
+ ontrue = tmp;
+ }
stidx = vec_size(code_statements);
vec_push(code_statements, stmt);
/* on false we jump, so add ontrue-path */
if (onfalse->generated) {
/* fixup the jump address */
code_statements[stidx].o2.s1 = (onfalse->code_start) - (stidx);
+ stmt.opcode = vec_last(code_statements).opcode;
+ if (stmt.opcode == INSTR_GOTO ||
+ stmt.opcode == INSTR_IF ||
+ stmt.opcode == INSTR_IFNOT ||
+ stmt.opcode == INSTR_RETURN ||
+ stmt.opcode == INSTR_DONE)
+ {
+ /* no use jumping from here */
+ return true;
+ }
/* may have been generated in the previous recursive call */
stmt.opcode = INSTR_GOTO;
stmt.o1.s1 = (onfalse->code_start) - vec_size(code_statements);
static bool gen_function_extparam_copy(ir_function *self)
{
- size_t i, ext;
+ size_t i, ext, numparams;
ir_builder *ir = self->owner;
ir_value *ep;
prog_section_statement stmt;
- if (!self->max_parameters)
+ numparams = vec_size(self->params);
+ if (!numparams)
return true;
stmt.opcode = INSTR_STORE_F;
stmt.o3.s1 = 0;
- for (i = 8; i < self->max_parameters; ++i) {
+ for (i = 8; i < numparams; ++i) {
ext = i - 8;
if (ext >= vec_size(ir->extparams))
ir_gen_extparam(ir);
ind[strlen(ind)-1] = 0;
}
+void ir_value_dump_string(const char *str, int (*oprintf)(const char*, ...))
+{
+ oprintf("\"");
+ for (; *str; ++str) {
+ switch (*str) {
+ case '\n': oprintf("\\n"); break;
+ case '\r': oprintf("\\r"); break;
+ case '\t': oprintf("\\t"); break;
+ case '\v': oprintf("\\v"); break;
+ case '\f': oprintf("\\f"); break;
+ case '\b': oprintf("\\b"); break;
+ case '\a': oprintf("\\a"); break;
+ case '\\': oprintf("\\\\"); break;
+ case '"': oprintf("\\\""); break;
+ default: oprintf("%c", *str); break;
+ }
+ }
+ oprintf("\"");
+}
+
void ir_value_dump(ir_value* v, int (*oprintf)(const char*, ...))
{
if (v->isconst) {
oprintf("(entity)");
break;
case TYPE_STRING:
- oprintf("\"%s\"", v->constval.vstring);
+ ir_value_dump_string(v->constval.vstring, oprintf);
break;
#if 0
case TYPE_INTEGER:
projects / xonotic / gmqcc.git / blobdiff