return firm_unknown_type;
}
-/* Suffixes added to types used for pass-by-value representations. */
-static ident *value_params_suffix = NULL;
-static ident *value_ress_suffix = NULL;
-
void ir_init_type(void)
{
- value_params_suffix = new_id_from_str(VALUE_PARAMS_SUFFIX);
- value_ress_suffix = new_id_from_str(VALUE_RESS_SUFFIX);
-
/* construct none and unknown type. */
firm_none_type = new_type(tpop_none, mode_BAD, NULL);
set_type_size_bytes(firm_none_type, 0);
free_type(firm_unknown_type);
firm_unknown_type = NULL;
}
- value_params_suffix = NULL;
- value_ress_suffix = NULL;
}
/** the global type visited flag */
else if (is_Array_type(tp))
align = get_type_alignment_bytes(get_array_element_type(tp));
else if (is_compound_type(tp)) {
- int i, n = get_compound_n_members(tp);
+ size_t i, n = get_compound_n_members(tp);
align = 0;
for (i = 0; i < n; ++i) {
if (tp != get_glob_type()) {
size_t n_mem = get_class_n_members(tp);
for (i = 0; i < n_mem; i++) {
- assert(get_entity_offset(get_class_member(tp, i)) > -1);
- /* TR ??
- assert(is_Method_type(get_entity_type(get_class_member(tp, i))) ||
- (get_entity_allocation(get_class_member(tp, i)) == allocation_automatic));
- */
+ ir_entity *entity = get_class_member(tp, i);
+ if (is_Method_type(get_entity_type(entity)))
+ continue;
+ assert(get_entity_offset(entity) > -1);
}
}
break;
}
break;
case tpo_union:
- /* ?? */
break;
case tpo_array:
- /* ??
- Check order?
- Assure that only innermost dimension is dynamic? */
break;
case tpo_enumeration: {
#ifndef NDEBUG
break;
}
default: break;
- } /* switch (tp) */
+ }
}
if (state == layout_fixed)
tp->flags |= tf_layout_fixed;
if (get_method_calling_convention(typ1) !=
get_method_calling_convention(typ2)) return 0;
- if (get_method_variadicity(typ1) == variadicity_non_variadic) {
- n_param1 = get_method_n_params(typ1);
- n_param2 = get_method_n_params(typ2);
- } else {
- n_param1 = get_method_first_variadic_param_index(typ1);
- n_param2 = get_method_first_variadic_param_index(typ2);
- }
+ n_param1 = get_method_n_params(typ1);
+ n_param2 = get_method_n_params(typ2);
if (n_param1 != n_param2) return 0;
if (get_method_calling_convention(st) !=
get_method_calling_convention(lt)) return 0;
- if (get_method_variadicity(st) == variadicity_non_variadic) {
- n_param1 = get_method_n_params(st);
- n_param2 = get_method_n_params(lt);
- } else {
- n_param1 = get_method_first_variadic_param_index(st);
- n_param2 = get_method_first_variadic_param_index(lt);
- }
+ n_param1 = get_method_n_params(st);
+ n_param2 = get_method_n_params(lt);
if (n_param1 != n_param2) return 0;
ir_type *new_type_class(ident *name)
{
- return new_d_type_class (name, NULL);
+ return new_d_type_class(name, NULL);
}
void free_class_entities(ir_type *clss)
{
- int i;
+ size_t i;
assert(clss && (clss->type_op == type_class));
- for (i = get_class_n_members(clss) - 1; i >= 0; --i)
- free_entity(get_class_member(clss, i));
+ /* we must iterate backward here */
+ for (i = get_class_n_members(clss); i > 0;)
+ free_entity(get_class_member(clss, --i));
/* do NOT free the type info here. It belongs to another class */
}
if (get_class_member(clss, i) == mem)
return i;
}
- return (size_t)-1;
+ return INVALID_MEMBER_INDEX;
}
ir_entity *(get_class_member)(const ir_type *clss, size_t pos)
ir_entity *get_class_member_by_name(ir_type *clss, ident *name)
{
- int i, n_mem;
+ size_t i, n_mem;
assert(clss && (clss->type_op == type_class));
n_mem = get_class_n_members(clss);
for (i = 0; i < n_mem; ++i) {
ir_entity *mem = get_class_member(clss, i);
- if (get_entity_ident(mem) == name) return mem;
+ if (get_entity_ident(mem) == name)
+ return mem;
}
return NULL;
}
void free_struct_entities(ir_type *strct)
{
- int i;
+ size_t i;
assert(strct && (strct->type_op == type_struct));
- for (i = get_struct_n_members(strct)-1; i >= 0; --i)
- free_entity(get_struct_member(strct, i));
+ /* we must iterate backward here */
+ for (i = get_struct_n_members(strct); i > 0;)
+ free_entity(get_struct_member(strct, --i));
}
void free_struct_attrs(ir_type *strct)
* @param len number of fields
* @param tps array of field types with length len
*/
-static ir_type *build_value_type(char const* name, int len, tp_ent_pair *tps)
+static ir_type *build_value_type(char const* name, size_t len, tp_ent_pair *tps)
{
- int i;
+ size_t i;
ir_type *res = new_type_struct(new_id_from_str(name));
res->flags |= tf_value_param_type;
/* Remove type from type list. Must be treated differently than other types. */
remove_irp_type(res);
- for (i = 0; i < len; i++) {
- ident *id = tps[i].param_name;
+ for (i = 0; i < len; ++i) {
+ ident *id = new_id_from_str("elt");
/* use res as default if corresponding type is not yet set. */
ir_type *elt_type = tps[i].tp ? tps[i].tp : res;
-
- /* use the parameter name if specified */
- if (id == NULL) {
- id = new_id_from_str("elt");
- }
tps[i].ent = new_entity(res, id, elt_type);
set_entity_allocation(tps[i].ent, allocation_parameter);
}
res->attr.ma.value_params = NULL;
res->attr.ma.n_res = n_res;
res->attr.ma.res_type = XMALLOCNZ(tp_ent_pair, n_res);
- res->attr.ma.value_ress = NULL;
res->attr.ma.variadicity = variadicity_non_variadic;
- res->attr.ma.first_variadic_param = -1;
res->attr.ma.additional_properties = mtp_no_property;
hook_new_type(res);
return res;
res->attr.ma.n_res = n_res;
res->attr.ma.res_type = XMALLOCN(tp_ent_pair, n_res);
memcpy(res->attr.ma.res_type, tp->attr.ma.res_type, n_res * sizeof(res->attr.ma.res_type[0]));
- res->attr.ma.value_ress = tp->attr.ma.value_ress;
res->attr.ma.variadicity = tp->attr.ma.variadicity;
- res->attr.ma.first_variadic_param = tp->attr.ma.first_variadic_param;
res->attr.ma.additional_properties = tp->attr.ma.additional_properties;
res->attr.ma.irg_calling_conv = tp->attr.ma.irg_calling_conv;
hook_new_type(res);
free_type(method->attr.ma.value_params);
}
*/
- if (method->attr.ma.value_ress) {
- free_type_entities(method->attr.ma.value_ress);
- free_type(method->attr.ma.value_ress);
- }
}
size_t (get_method_n_params)(const ir_type *method)
}
}
-ident *get_method_param_ident(ir_type *method, size_t pos)
-{
- assert(method->type_op == type_method);
- assert(pos < get_method_n_params(method));
- return method->attr.ma.params[pos].param_name;
-}
-
-const char *get_method_param_name(ir_type *method, size_t pos)
-{
- ident *id = get_method_param_ident(method, pos);
- return id ? get_id_str(id) : NULL;
-}
-
-void set_method_param_ident(ir_type *method, size_t pos, ident *id)
-{
- assert(method->type_op == type_method);
- assert(pos < get_method_n_params(method));
- method->attr.ma.params[pos].param_name = id;
-}
-
ir_entity *get_method_value_param_ent(ir_type *method, size_t pos)
{
assert(method && (method->type_op == type_method));
/* set the result ir_type */
method->attr.ma.res_type[pos].tp = tp;
/* If information constructed set pass-by-value representation. */
- if (method->attr.ma.value_ress) {
- assert(get_method_n_ress(method) == get_struct_n_members(method->attr.ma.value_ress));
- set_entity_type(get_struct_member(method->attr.ma.value_ress, pos), tp);
- }
-}
-
-ir_entity *get_method_value_res_ent(ir_type *method, size_t pos)
-{
- assert(method->type_op == type_method);
- assert(pos < get_method_n_ress(method));
-
- if (!method->attr.ma.value_ress) {
- /* result value type not created yet, build */
- method->attr.ma.value_ress = build_value_type("<value result>",
- get_method_n_ress(method), method->attr.ma.res_type);
- }
- /*
- * build_value_type() sets the method->attr.ma.value_ress type as default if
- * no type is set!
- */
- assert((get_entity_type(method->attr.ma.res_type[pos].ent) != method->attr.ma.value_ress)
- && "result type not yet set");
-
- return method->attr.ma.res_type[pos].ent;
-}
-
-ir_type *get_method_value_res_type(const ir_type *method)
-{
- assert(method->type_op == type_method);
- return method->attr.ma.value_ress;
}
const char *get_variadicity_name(ir_variadicity vari)
method->attr.ma.variadicity = vari;
}
-size_t get_method_first_variadic_param_index(const ir_type *method)
-{
- assert(method->type_op == type_method);
-
- if (method->attr.ma.variadicity == variadicity_non_variadic)
- return (size_t)-1;
-
- if (method->attr.ma.first_variadic_param == (size_t)-1)
- return get_method_n_params(method);
- return method->attr.ma.first_variadic_param;
-}
-
-void set_method_first_variadic_param_index(ir_type *method, size_t index)
-{
- assert(method->type_op == type_method);
- assert(index <= get_method_n_params(method));
-
- method->attr.ma.first_variadic_param = index;
-}
-
mtp_additional_properties (get_method_additional_properties)(const ir_type *method)
{
return _get_method_additional_properties(method);
void free_union_entities(ir_type *uni)
{
- int i;
+ size_t i;
assert(uni && (uni->type_op == type_union));
- for (i = get_union_n_members(uni) - 1; i >= 0; --i)
- free_entity(get_union_member(uni, i));
+ /* we must iterate backward here */
+ for (i = get_union_n_members(uni); i > 0;)
+ free_entity(get_union_member(uni, --i));
}
-void free_union_attrs (ir_type *uni)
+void free_union_attrs(ir_type *uni)
{
assert(uni && (uni->type_op == type_union));
DEL_ARR_F(uni->attr.ua.members);
-ir_type *new_d_type_array(int n_dimensions, ir_type *element_type,
+ir_type *new_d_type_array(size_t n_dimensions, ir_type *element_type,
type_dbg_info *db)
{
ir_type *res;
- int i;
+ size_t i;
ir_node *unk;
ir_graph *irg = get_const_code_irg();
res->attr.aa.n_dimensions = n_dimensions;
res->attr.aa.lower_bound = XMALLOCNZ(ir_node*, n_dimensions);
res->attr.aa.upper_bound = XMALLOCNZ(ir_node*, n_dimensions);
- res->attr.aa.order = XMALLOCNZ(int, n_dimensions);
+ res->attr.aa.order = XMALLOCNZ(size_t, n_dimensions);
unk = new_r_Unknown(irg, mode_Iu);
for (i = 0; i < n_dimensions; i++) {
return res;
}
-ir_type *new_type_array(int n_dimensions, ir_type *element_type)
+ir_type *new_type_array(size_t n_dimensions, ir_type *element_type)
{
return new_d_type_array(n_dimensions, element_type, NULL);
}
return get_tarval_long(get_Const_tarval(node));
}
-void set_array_order(ir_type *array, size_t dimension, int order)
+void set_array_order(ir_type *array, size_t dimension, size_t order)
{
assert(array && (array->type_op == type_array));
array->attr.aa.order[dimension] = order;
}
-int get_array_order(const ir_type *array, size_t dimension)
+size_t get_array_order(const ir_type *array, size_t dimension)
{
assert(array && (array->type_op == type_array));
return array->attr.aa.order[dimension];
}
-size_t find_array_dimension(const ir_type *array, int order)
+size_t find_array_dimension(const ir_type *array, size_t order)
{
size_t dim;
return tp->flags & tf_value_param_type;
}
-int is_lowered_type(const ir_type *tp)
-{
- return tp->flags & tf_lowered_type;
-}
-
ir_type *new_type_value(void)
{
ir_type *res = new_type_struct(new_id_from_str("<value_type>"));
ir_type *clone_frame_type(ir_type *type)
{
ir_type *res;
- int i, n;
+ size_t i, n;
assert(is_frame_type(type));
/* the entity link resource should be allocated if this function is called */
return res;
}
-void set_lowered_type(ir_type *tp, ir_type *lowered_type)
-{
- assert(is_type(tp) && is_type(lowered_type));
- lowered_type->flags |= tf_lowered_type;
- tp->assoc_type = lowered_type;
- lowered_type->assoc_type = tp;
-}
-
-ir_type *get_associated_type(const ir_type *tp)
-{
- return tp->assoc_type;
-}
-
void set_default_size(ir_type *tp, unsigned size)
{
tp->size = size;
ident *name;
char buf[32];
unsigned frame_align;
- int i, offset, frame_size;
+ int offset, frame_size;
static unsigned area_cnt = 0;
static ir_type *a_byte = NULL;
frame_size = get_type_size_bytes(frame_type);
if (at_start) {
+ size_t i, n;
/* fix all offsets so far */
- for (i = get_class_n_members(frame_type) - 1; i >= 0; --i) {
+ for (i = 0, n = get_class_n_members(frame_type); i < n; ++i) {
ir_entity *ent = get_class_member(frame_type, i);
set_entity_offset(ent, get_entity_offset(ent) + size);