INSTR_STORE_V, /* variant, should never be accessed */
};
+uint16_t field_store_instr[TYPE_COUNT] = {
+ INSTR_STORE_FLD,
+ INSTR_STORE_FLD,
+ INSTR_STORE_FLD,
+ INSTR_STORE_V,
+ INSTR_STORE_FLD,
+ INSTR_STORE_FLD,
+ INSTR_STORE_FLD,
+ INSTR_STORE_FLD,
+#if 0
+ INSTR_STORE_FLD, /* integer type */
+#endif
+
+ INSTR_STORE_V, /* variant, should never be accessed */
+};
+
uint16_t type_storep_instr[TYPE_COUNT] = {
INSTR_STOREP_F, /* should use I when having integer support */
INSTR_STOREP_S,
*IR Builder
*/
+static void ir_block_delete_quick(ir_block* self);
+static void ir_instr_delete_quick(ir_instr *self);
+static void ir_function_delete_quick(ir_function *self);
+
ir_builder* ir_builder_new(const char *modulename)
{
ir_builder* self;
MEM_VECTOR_INIT(self, functions);
MEM_VECTOR_INIT(self, globals);
MEM_VECTOR_INIT(self, fields);
+ MEM_VECTOR_INIT(self, filenames);
+ MEM_VECTOR_INIT(self, filestrings);
+ self->str_immediate = 0;
self->name = NULL;
if (!ir_builder_set_name(self, modulename)) {
mem_d(self);
return self;
}
-MEM_VEC_FUNCTIONS(ir_builder, ir_value*, globals)
-MEM_VEC_FUNCTIONS(ir_builder, ir_value*, fields)
+MEM_VEC_FUNCTIONS(ir_builder, ir_value*, globals)
+MEM_VEC_FUNCTIONS(ir_builder, ir_value*, fields)
MEM_VEC_FUNCTIONS(ir_builder, ir_function*, functions)
+MEM_VEC_FUNCTIONS(ir_builder, const char*, filenames)
+MEM_VEC_FUNCTIONS(ir_builder, qcint, filestrings)
void ir_builder_delete(ir_builder* self)
{
size_t i;
mem_d((void*)self->name);
for (i = 0; i != self->functions_count; ++i) {
- ir_function_delete(self->functions[i]);
+ ir_function_delete_quick(self->functions[i]);
}
MEM_VECTOR_CLEAR(self, functions);
for (i = 0; i != self->globals_count; ++i) {
ir_value_delete(self->fields[i]);
}
MEM_VECTOR_CLEAR(self, fields);
+ MEM_VECTOR_CLEAR(self, filenames);
+ MEM_VECTOR_CLEAR(self, filestrings);
mem_d(self);
}
return !!self->name;
}
+static void ir_function_delete_quick(ir_function *self)
+{
+ size_t i;
+ mem_d((void*)self->name);
+
+ for (i = 0; i != self->blocks_count; ++i)
+ ir_block_delete_quick(self->blocks[i]);
+ MEM_VECTOR_CLEAR(self, blocks);
+
+ MEM_VECTOR_CLEAR(self, params);
+
+ for (i = 0; i != self->values_count; ++i)
+ ir_value_delete(self->values[i]);
+ MEM_VECTOR_CLEAR(self, values);
+
+ for (i = 0; i != self->locals_count; ++i)
+ ir_value_delete(self->locals[i]);
+ MEM_VECTOR_CLEAR(self, locals);
+
+ /* self->value is deleted by the builder */
+
+ mem_d(self);
+}
+
void ir_function_delete(ir_function *self)
{
size_t i;
memset(self, 0, sizeof(*self));
self->label = NULL;
- if (!ir_block_set_label(self, name)) {
+ if (name && !ir_block_set_label(self, name)) {
mem_d(self);
return NULL;
}
MEM_VEC_FUNCTIONS_ALL(ir_block, ir_block*, exits)
MEM_VEC_FUNCTIONS_ALL(ir_block, ir_value*, living)
+static void ir_block_delete_quick(ir_block* self)
+{
+ size_t i;
+ if (self->label) mem_d(self->label);
+ for (i = 0; i != self->instr_count; ++i)
+ ir_instr_delete_quick(self->instr[i]);
+ MEM_VECTOR_CLEAR(self, instr);
+ MEM_VECTOR_CLEAR(self, entries);
+ MEM_VECTOR_CLEAR(self, exits);
+ MEM_VECTOR_CLEAR(self, living);
+ mem_d(self);
+}
+
void ir_block_delete(ir_block* self)
{
size_t i;
- mem_d(self->label);
+ if (self->label) mem_d(self->label);
for (i = 0; i != self->instr_count; ++i)
ir_instr_delete(self->instr[i]);
MEM_VECTOR_CLEAR(self, instr);
MEM_VEC_FUNCTIONS(ir_instr, ir_phi_entry_t, phi)
MEM_VEC_FUNCTIONS(ir_instr, ir_value*, params)
+static void ir_instr_delete_quick(ir_instr *self)
+{
+ MEM_VECTOR_CLEAR(self, phi);
+ MEM_VECTOR_CLEAR(self, params);
+ mem_d(self);
+}
+
void ir_instr_delete(ir_instr *self)
{
size_t i;
self->context.file = "<@no context>";
self->context.line = 0;
self->name = NULL;
- ir_value_set_name(self, name);
+ if (name && !ir_value_set_name(self, name)) {
+ irerror(self->context, "out of memory");
+ mem_d(self);
+ return NULL;
+ }
memset(&self->constval, 0, sizeof(self->constval));
memset(&self->code, 0, sizeof(self->code));
mem_d(self);
}
-void ir_value_set_name(ir_value *self, const char *name)
+bool ir_value_set_name(ir_value *self, const char *name)
{
if (self->name)
mem_d((void*)self->name);
self->name = util_strdup(name);
+ return !!self->name;
}
bool ir_value_set_float(ir_value *self, float f)
}
if (life->start < entry->start &&
- life->end >= entry->start)
+ life->end+1 >= entry->start)
{
/* starts earlier and overlaps */
entry->start = life->start;
}
- if (life->end > entry->end &&
- life->start-1 <= entry->end)
+ if (life->end > entry->end &&
+ life->start <= entry->end+1)
{
/* ends later and overlaps */
entry->end = life->end;
*
* Breaking conventions is annoying...
*/
-static bool ir_builder_gen_global(ir_builder *self, ir_value *global);
+static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal);
static bool gen_global_field(ir_value *global)
{
stmt.opcode = INSTR_STORE_F;
stmt.o3.u1 = 0;
- stmt.opcode = type_store_instr[param->vtype];
+ if (param->vtype == TYPE_FIELD)
+ stmt.opcode = field_store_instr[param->fieldtype];
+ else
+ stmt.opcode = type_store_instr[param->vtype];
stmt.o1.u1 = ir_value_code_addr(param);
stmt.o2.u1 = OFS_PARM0 + 3 * p;
if (code_statements_add(stmt) < 0)
if (retvalue && retvalue->store != store_return && retvalue->life_count)
{
/* not to be kept in OFS_RETURN */
- stmt.opcode = type_store_instr[retvalue->vtype];
+ if (retvalue->vtype == TYPE_FIELD)
+ stmt.opcode = field_store_instr[retvalue->vtype];
+ else
+ stmt.opcode = type_store_instr[retvalue->vtype];
stmt.o1.u1 = OFS_RETURN;
stmt.o2.u1 = ir_value_code_addr(retvalue);
stmt.o3.u1 = 0;
return true;
}
+static qcint ir_builder_filestring(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.
+ */
+ size_t i;
+ qcint str;
+
+ for (i = 0; i < ir->filenames_count; ++i) {
+ if (ir->filenames[i] == filename)
+ return ir->filestrings[i];
+ }
+
+ str = code_genstring(filename);
+ if (!ir_builder_filenames_add(ir, filename))
+ return 0;
+ if (!ir_builder_filestrings_add(ir, str))
+ ir->filenames_count--;
+ return str;
+}
+
static bool gen_global_function(ir_builder *ir, ir_value *global)
{
prog_section_function fun;
irfun = global->constval.vfunc;
fun.name = global->code.name;
- fun.file = code_cachedstring(global->context.file);
+ fun.file = ir_builder_filestring(ir, global->context.file);
fun.profile = 0; /* always 0 */
fun.nargs = irfun->params_count;
local_var_end = fun.firstlocal;
for (i = 0; i < irfun->locals_count; ++i) {
- if (!ir_builder_gen_global(ir, irfun->locals[i])) {
+ if (!ir_builder_gen_global(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 ir_builder_gen_global(ir_builder *self, ir_value *global)
+static bool ir_builder_gen_global(ir_builder *self, ir_value *global, bool islocal)
{
size_t i;
int32_t *iptr;
def.type = global->vtype;
def.offset = code_globals_elements;
- def.name = global->code.name = code_genstring(global->name);
+
+ if (global->name) {
+ if (global->name[0] == '#') {
+ if (!self->str_immediate)
+ self->str_immediate = code_genstring("IMMEDIATE");
+ def.name = global->code.name = self->str_immediate;
+ }
+ else
+ def.name = global->code.name = code_genstring(global->name);
+ }
+ else
+ def.name = 0;
switch (global->vtype)
{
case TYPE_FLOAT:
{
if (global->isconst) {
- iptr = (int32_t*)&global->constval.vfloat;
+ iptr = (int32_t*)&global->constval.ivec[0];
ir_value_code_setaddr(global, code_globals_add(*iptr));
} else {
ir_value_code_setaddr(global, code_globals_add(0));
- def.type |= DEF_SAVEGLOBAL;
+ if (!islocal)
+ def.type |= DEF_SAVEGLOBAL;
}
if (code_defs_add(def) < 0)
return false;
case TYPE_STRING:
{
if (global->isconst)
- ir_value_code_setaddr(global, code_globals_add(code_cachedstring(global->constval.vstring)));
+ ir_value_code_setaddr(global, code_globals_add(code_genstring(global->constval.vstring)));
else {
ir_value_code_setaddr(global, code_globals_add(0));
- def.type |= DEF_SAVEGLOBAL;
+ if (!islocal)
+ def.type |= DEF_SAVEGLOBAL;
}
if (code_defs_add(def) < 0)
return false;
{
size_t d;
if (global->isconst) {
- iptr = (int32_t*)&global->constval.vvec;
+ iptr = (int32_t*)&global->constval.ivec[0];
ir_value_code_setaddr(global, code_globals_add(iptr[0]));
if (global->code.globaladdr < 0)
return false;
if (code_globals_add(0) < 0)
return false;
}
- def.type |= DEF_SAVEGLOBAL;
+ if (!islocal)
+ def.type |= DEF_SAVEGLOBAL;
}
if (code_defs_add(def) < 0)
code_globals_add(code_functions_elements);
if (!gen_global_function(self, global))
return false;
- def.type |= DEF_SAVEGLOBAL;
+ if (!islocal)
+ def.type |= DEF_SAVEGLOBAL;
}
if (code_defs_add(def) < 0)
return false;
for (i = 0; i < self->globals_count; ++i)
{
- if (!ir_builder_gen_global(self, self->globals[i])) {
+ if (!ir_builder_gen_global(self, self->globals[i], false)) {
return false;
}
}
#ifdef WIN32
# define strncat(dst, src, sz) strncat_s(dst, sz, src, _TRUNCATE)
-#else
-# define strncat strncat
#endif
const char *qc_opname(int op)
}
}
-void ir_value_dump_life(ir_value *self, int (*oprintf)(const char*,...))
+void ir_value_dump_life(const ir_value *self, int (*oprintf)(const char*,...))
{
size_t i;
- oprintf("Life of %s:\n", self->name);
+ oprintf("Life of %12s:", self->name);
for (i = 0; i < self->life_count; ++i)
{
oprintf(" + [%i, %i]\n", self->life[i].start, self->life[i].end);
projects / xonotic / gmqcc.git / blobdiff