"field",
"function",
"pointer",
-#if 0
"integer",
-#endif
- "variant"
+ "variant",
+ "struct",
+ "union",
+ "array"
};
size_t type_sizeof[TYPE_COUNT] = {
1, /* TYPE_FIELD */
1, /* TYPE_FUNCTION */
1, /* TYPE_POINTER */
-#if 0
1, /* TYPE_INTEGER */
-#endif
3, /* TYPE_VARIANT */
+ 0, /* TYPE_STRUCT */
+ 0, /* TYPE_UNION */
+ 0, /* TYPE_ARRAY */
};
uint16_t type_store_instr[TYPE_COUNT] = {
INSTR_STORE_ENT, /* should use I */
#if 0
INSTR_STORE_I, /* integer type */
+#else
+ INSTR_STORE_F,
#endif
INSTR_STORE_V, /* variant, should never be accessed */
+
+ AINSTR_END, /* struct */
+ AINSTR_END, /* union */
+ AINSTR_END, /* array */
+};
+
+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 */
+#else
+ INSTR_STORE_FLD,
+#endif
+
+ INSTR_STORE_V, /* variant, should never be accessed */
+
+ AINSTR_END, /* struct */
+ AINSTR_END, /* union */
+ AINSTR_END, /* array */
};
uint16_t type_storep_instr[TYPE_COUNT] = {
INSTR_STOREP_ENT, /* should use I */
#if 0
INSTR_STOREP_ENT, /* integer type */
+#else
+ INSTR_STOREP_F,
#endif
INSTR_STOREP_V, /* variant, should never be accessed */
+
+ AINSTR_END, /* struct */
+ AINSTR_END, /* union */
+ AINSTR_END, /* array */
};
uint16_t type_eq_instr[TYPE_COUNT] = {
INSTR_EQ_E, /* should use I */
#if 0
INSTR_EQ_I,
+#else
+ INSTR_EQ_F,
#endif
INSTR_EQ_V, /* variant, should never be accessed */
+
+ AINSTR_END, /* struct */
+ AINSTR_END, /* union */
+ AINSTR_END, /* array */
};
uint16_t type_ne_instr[TYPE_COUNT] = {
INSTR_NE_E, /* should use I */
#if 0
INSTR_NE_I,
+#else
+ INSTR_NE_F,
#endif
INSTR_NE_V, /* variant, should never be accessed */
+
+ AINSTR_END, /* struct */
+ AINSTR_END, /* union */
+ AINSTR_END, /* array */
};
MEM_VEC_FUNCTIONS(ir_value_vector, ir_value*, v)
*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;
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) {
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;
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_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;
case TYPE_INTEGER: op = INSTR_LOAD_I; break;
#endif
default:
+ irerror(self->context, "invalid type for ir_block_create_load_from_ent: %s", type_name[outype]);
return NULL;
}
if (l == r) {
switch (l) {
default:
+ irerror(self->context, "invalid type for ir_block_create_add: %s", type_name[l]);
return NULL;
case TYPE_FLOAT:
op = INSTR_ADD_F;
op = INSTR_ADD_IF;
else
#endif
+ {
+ irerror(self->context, "invalid type for ir_block_create_add: %s", type_name[l]);
return NULL;
+ }
}
return ir_block_create_binop(self, label, op, left, right);
}
switch (l) {
default:
+ irerror(self->context, "invalid type for ir_block_create_sub: %s", type_name[l]);
return NULL;
case TYPE_FLOAT:
op = INSTR_SUB_F;
op = INSTR_SUB_IF;
else
#endif
+ {
+ irerror(self->context, "invalid type for ir_block_create_sub: %s", type_name[l]);
return NULL;
+ }
}
return ir_block_create_binop(self, label, op, left, right);
}
switch (l) {
default:
+ irerror(self->context, "invalid type for ir_block_create_mul: %s", type_name[l]);
return NULL;
case TYPE_FLOAT:
op = INSTR_MUL_F;
else if ( (l == TYPE_INTEGER && r == TYPE_FLOAT) )
op = INSTR_MUL_IF;
#endif
- else
+ else {
+ irerror(self->context, "invalid type for ir_block_create_mul: %s", type_name[l]);
return NULL;
+ }
}
return ir_block_create_binop(self, label, op, left, right);
}
switch (l) {
default:
+ irerror(self->context, "invalid type for ir_block_create_div: %s", type_name[l]);
return NULL;
case TYPE_FLOAT:
op = INSTR_DIV_F;
op = INSTR_DIV_IF;
else
#endif
+ {
+ irerror(self->context, "invalid type for ir_block_create_div: %s", type_name[l]);
return NULL;
+ }
}
return ir_block_create_binop(self, label, op, left, right);
}
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;
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));
{
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;
#ifdef WIN32
# define strncat(dst, src, sz) strncat_s(dst, sz, src, _TRUNCATE)
-#else
-# define strncat strncat
#endif
const char *qc_opname(int op)