+
+/**
+ * Lazy construction of value argument / result representation.
+ * Constructs a struct type and its member. The types of the members
+ * are passed in the argument list.
+ *
+ * @param name name of the type constructed
+ * @param len number of fields
+ * @param tps array of field types with length len
+ */
+static ir_type *build_value_type(char const* name, size_t len, tp_ent_pair *tps)
+{
+ 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 = 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;
+ tps[i].ent = new_entity(res, id, elt_type);
+ set_entity_allocation(tps[i].ent, allocation_parameter);
+ }
+ return res;
+}
+
+ir_type *new_d_type_method(size_t n_param, size_t n_res, type_dbg_info *db)
+{
+ ir_type *res;
+
+ assert((get_mode_size_bits(mode_P_code) % 8 == 0) && "unorthodox modes not implemented");
+ res = new_type(type_method, mode_P_code, db);
+ res->flags |= tf_layout_fixed;
+ res->size = get_mode_size_bytes(mode_P_code);
+ res->attr.ma.n_params = n_param;
+ res->attr.ma.params = XMALLOCNZ(tp_ent_pair, n_param);
+ 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.variadicity = variadicity_non_variadic;
+ res->attr.ma.additional_properties = mtp_no_property;
+ hook_new_type(res);
+ return res;
+}
+
+ir_type *new_type_method(size_t n_param, size_t n_res)
+{
+ return new_d_type_method(n_param, n_res, NULL);
+}
+
+ir_type *clone_type_method(ir_type *tp)
+{
+ ir_type *res;
+ ir_mode *mode;
+ size_t n_params;
+ size_t n_res;
+ type_dbg_info *db;
+
+ assert(is_Method_type(tp));
+
+ mode = tp->mode;
+ n_params = tp->attr.ma.n_params;
+ n_res = tp->attr.ma.n_res;
+ db = tp->dbi;
+
+ res = new_type(type_method, mode, db);
+
+ res->flags = tp->flags;
+ res->assoc_type = tp->assoc_type;
+ res->size = tp->size;
+ res->attr.ma.n_params = n_params;
+ res->attr.ma.params = XMALLOCN(tp_ent_pair, n_params);
+ memcpy(res->attr.ma.params, tp->attr.ma.params, n_params * sizeof(res->attr.ma.params[0]));
+ res->attr.ma.value_params = tp->attr.ma.value_params;
+ 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.variadicity = tp->attr.ma.variadicity;
+ 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);
+ return res;
+}
+
+void free_method_entities(ir_type *method)
+{
+ (void) method;
+ assert(method && (method->type_op == type_method));
+}
+
+void free_method_attrs(ir_type *method)
+{
+ assert(method && (method->type_op == type_method));
+ free(method->attr.ma.params);
+ free(method->attr.ma.res_type);
+ /* cannot free it yet, type could be cloned ...
+ if (method->attr.ma.value_params) {
+ free_type_entities(method->attr.ma.value_params);
+ free_type(method->attr.ma.value_params);
+ }
+ */
+}
+
+size_t (get_method_n_params)(const ir_type *method)
+{
+ return _get_method_n_params(method);
+}
+
+ir_type *get_method_param_type(ir_type *method, size_t pos)
+{
+ ir_type *res;
+ assert(method->type_op == type_method);
+ assert(pos < get_method_n_params(method));
+ res = method->attr.ma.params[pos].tp;
+ assert(res != NULL && "empty method param type");
+ return res;
+}
+
+void set_method_param_type(ir_type *method, size_t pos, ir_type *tp)
+{
+ assert(method->type_op == type_method);
+ assert(pos < get_method_n_params(method));
+ method->attr.ma.params[pos].tp = tp;
+ /* If information constructed set pass-by-value representation. */
+ if (method->attr.ma.value_params) {
+ assert(get_method_n_params(method) == get_struct_n_members(method->attr.ma.value_params));
+ set_entity_type(get_struct_member(method->attr.ma.value_params, pos), tp);
+ }
+}
+
+ir_entity *get_method_value_param_ent(ir_type *method, size_t pos)
+{
+ assert(method && (method->type_op == type_method));
+ assert(pos < get_method_n_params(method));
+
+ if (!method->attr.ma.value_params) {
+ /* parameter value type not created yet, build */
+ method->attr.ma.value_params = build_value_type("<value param>",
+ get_method_n_params(method), method->attr.ma.params);
+ }
+ /*
+ * build_value_type() sets the method->attr.ma.value_params type as default if
+ * no type is set!
+ */
+ assert((get_entity_type(method->attr.ma.params[pos].ent) != method->attr.ma.value_params)
+ && "param type not yet set");
+ return method->attr.ma.params[pos].ent;
+}
+
+void set_method_value_param_type(ir_type *method, ir_type *tp)
+{
+ size_t i;
+ size_t n;
+
+ assert(method && (method->type_op == type_method));
+ assert(is_value_param_type(tp));
+ assert(get_method_n_params(method) == get_struct_n_members(tp));
+
+ method->attr.ma.value_params = tp;
+
+ n = get_struct_n_members(tp);
+ for (i = 0; i < n; i++) {
+ ir_entity *ent = get_struct_member(tp, i);
+ method->attr.ma.params[i].ent = ent;
+ }
+}
+
+ir_type *get_method_value_param_type(const ir_type *method)
+{
+ assert(method && (method->type_op == type_method));
+ return method->attr.ma.value_params;
+}
+
+size_t (get_method_n_ress)(const ir_type *method)
+{
+ return _get_method_n_ress(method);
+}
+
+ir_type *get_method_res_type(ir_type *method, size_t pos)
+{
+ ir_type *res;
+ assert(method->type_op == type_method);
+ assert(pos < get_method_n_ress(method));
+ res = method->attr.ma.res_type[pos].tp;
+ assert(res != NULL && "empty method return type");
+ return res;
+}
+
+void set_method_res_type(ir_type *method, size_t pos, ir_type *tp)
+{
+ assert(method->type_op == type_method);
+ assert(pos < get_method_n_ress(method));
+ /* set the result ir_type */
+ method->attr.ma.res_type[pos].tp = tp;
+ /* If information constructed set pass-by-value representation. */
+}
+
+const char *get_variadicity_name(ir_variadicity vari)
+{
+#define X(a) case a: return #a
+ switch (vari) {
+ X(variadicity_non_variadic);
+ X(variadicity_variadic);
+ default:
+ return "BAD VALUE";
+ }
+#undef X
+}
+
+ir_variadicity get_method_variadicity(const ir_type *method)
+{
+ assert(method && (method->type_op == type_method));
+ return method->attr.ma.variadicity;
+}
+
+void set_method_variadicity(ir_type *method, ir_variadicity vari)
+{
+ assert(method && (method->type_op == type_method));
+ method->attr.ma.variadicity = vari;
+}
+
+mtp_additional_properties (get_method_additional_properties)(const ir_type *method)
+{
+ return _get_method_additional_properties(method);
+}
+
+void (set_method_additional_properties)(ir_type *method, mtp_additional_properties mask)
+{
+ _set_method_additional_properties(method, mask);
+}
+
+void (add_method_additional_properties)(ir_type *method,
+ mtp_additional_properties flag)
+{
+ _add_method_additional_properties(method, flag);
+}
+
+unsigned (get_method_calling_convention)(const ir_type *method)
+{
+ return _get_method_calling_convention(method);
+}
+
+void (set_method_calling_convention)(ir_type *method, unsigned cc_mask)
+{
+ _set_method_calling_convention(method, cc_mask);
+}
+
+unsigned get_method_n_regparams(ir_type *method)
+{
+ unsigned cc = get_method_calling_convention(method);
+ assert(IS_FASTCALL(cc));
+
+ return cc & ~cc_bits;
+}
+
+void set_method_n_regparams(ir_type *method, unsigned n_regs)
+{
+ unsigned cc = get_method_calling_convention(method);
+ assert(IS_FASTCALL(cc));
+
+ set_method_calling_convention(method, (cc & cc_bits) | (n_regs & ~cc_bits));
+}
+
+int (is_Method_type)(const ir_type *method)
+{
+ return _is_method_type(method);
+}
+
+
+ir_type *new_d_type_union(ident *name, type_dbg_info *db)
+{
+ ir_type *res = new_type(type_union, NULL, db);
+ res->name = name;
+
+ res->attr.ua.members = NEW_ARR_F(ir_entity *, 0);
+ hook_new_type(res);
+ return res;
+}
+
+ir_type *new_type_union(ident *name)
+{
+ return new_d_type_union(name, NULL);
+}
+
+void free_union_entities(ir_type *uni)
+{
+ size_t i;
+ assert(uni && (uni->type_op == type_union));
+ /* 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)
+{
+ assert(uni && (uni->type_op == type_union));
+ DEL_ARR_F(uni->attr.ua.members);
+}
+
+ident *get_union_ident(const ir_type *uni)
+{
+ assert(uni->type_op == type_union);
+ return uni->name;
+}
+
+const char *get_union_name(const ir_type *uni)
+{
+ if (get_union_ident(uni) == NULL)
+ return NULL;
+ return get_id_str(get_union_ident(uni));
+}
+
+size_t get_union_n_members(const ir_type *uni)
+{
+ assert(uni->type_op == type_union);
+ return ARR_LEN(uni->attr.ua.members);
+}
+
+static void add_union_member(ir_type *uni, ir_entity *member)
+{
+ assert(uni->type_op == type_union);
+ assert(uni != get_entity_type(member) && "recursive type");
+ ARR_APP1(ir_entity *, uni->attr.ua.members, member);
+}
+
+ir_entity *get_union_member(const ir_type *uni, size_t pos)
+{
+ assert(uni->type_op == type_union);
+ assert(pos < get_union_n_members(uni));
+ return uni->attr.ua.members[pos];
+}
+
+size_t get_union_member_index(const ir_type *uni, ir_entity *mem)
+{
+ size_t i, n;
+ assert(uni && (uni->type_op == type_union));
+ for (i = 0, n = get_union_n_members(uni); i < n; ++i) {
+ if (get_union_member(uni, i) == mem)
+ return i;
+ }
+ return (size_t)-1;
+}
+
+static void remove_union_member(ir_type *uni, ir_entity *member)
+{
+ size_t i;
+ assert(uni && (uni->type_op == type_union));
+ for (i = 0; i < ARR_LEN(uni->attr.ua.members); ++i) {
+ if (uni->attr.ua.members[i] == member) {
+ for (; i < ARR_LEN(uni->attr.ua.members) - 1; i++)
+ uni->attr.ua.members[i] = uni->attr.ua.members[i+1];
+ ARR_SETLEN(ir_entity*, uni->attr.ua.members, ARR_LEN(uni->attr.ua.members) - 1);
+ break;
+ }
+ }
+}
+
+int (is_Union_type)(const ir_type *uni)
+{
+ return _is_union_type(uni);
+}
+
+void set_union_size(ir_type *tp, unsigned size)
+{
+ tp->size = size;
+}
+
+
+
+ir_type *new_d_type_array(size_t n_dimensions, ir_type *element_type,
+ type_dbg_info *db)
+{
+ ir_type *res;
+ size_t i;
+ ir_node *unk;
+ ir_graph *irg = get_const_code_irg();
+
+ assert(!is_Method_type(element_type));
+
+ res = new_type(type_array, NULL, db);
+ 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(size_t, n_dimensions);
+
+ unk = new_r_Unknown(irg, mode_Iu);
+ for (i = 0; i < n_dimensions; i++) {
+ res->attr.aa.lower_bound[i] =
+ res->attr.aa.upper_bound[i] = unk;
+ res->attr.aa.order[i] = i;
+ }
+
+ res->attr.aa.element_type = element_type;
+ res->attr.aa.element_ent
+ = new_entity(NULL, new_id_from_chars("elem_ent", 8), element_type);
+ res->attr.aa.element_ent->owner = res;
+
+ hook_new_type(res);
+ return res;
+}
+
+ir_type *new_type_array(size_t n_dimensions, ir_type *element_type)
+{
+ return new_d_type_array(n_dimensions, element_type, NULL);
+}
+
+void free_array_automatic_entities(ir_type *array)
+{
+ assert(array && (array->type_op == type_array));
+ free_entity(get_array_element_entity(array));
+}
+
+void free_array_entities(ir_type *array)
+{
+ (void) array;
+ assert(array->type_op == type_array);
+}
+
+void free_array_attrs(ir_type *array)
+{
+ assert(array->type_op == type_array);
+ free(array->attr.aa.lower_bound);
+ free(array->attr.aa.upper_bound);
+ free(array->attr.aa.order);
+}
+
+/* manipulate private fields of array ir_type */
+size_t get_array_n_dimensions(const ir_type *array)
+{
+ assert(array->type_op == type_array);
+ return array->attr.aa.n_dimensions;
+}
+
+void set_array_bounds(ir_type *array, size_t dimension, ir_node *lower_bound,
+ ir_node *upper_bound)
+{
+ assert(array && (array->type_op == type_array));
+ assert(lower_bound && "lower_bound node may not be NULL.");
+ assert(upper_bound && "upper_bound node may not be NULL.");
+ assert(dimension < array->attr.aa.n_dimensions);
+ array->attr.aa.lower_bound[dimension] = lower_bound;
+ array->attr.aa.upper_bound[dimension] = upper_bound;
+}
+
+void set_array_bounds_int(ir_type *array, size_t dimension, int lower_bound,
+ int upper_bound)
+{
+ ir_graph *irg = get_const_code_irg();
+ set_array_bounds(array, dimension,
+ new_r_Const_long(irg, mode_Iu, lower_bound),
+ new_r_Const_long(irg, mode_Iu, upper_bound));
+}
+
+void set_array_lower_bound(ir_type *array, size_t dimension,
+ ir_node *lower_bound)
+{
+ assert(array && (array->type_op == type_array));
+ assert(lower_bound && "lower_bound node may not be NULL.");
+ array->attr.aa.lower_bound[dimension] = lower_bound;
+}
+
+void set_array_lower_bound_int(ir_type *array, size_t dimension, int lower_bound)
+{
+ ir_graph *irg = get_const_code_irg();
+ set_array_lower_bound(array, dimension,
+ new_r_Const_long(irg, mode_Iu, lower_bound));
+}
+
+void set_array_upper_bound(ir_type *array, size_t dimension, ir_node *upper_bound)
+{
+ assert(array && (array->type_op == type_array));
+ assert(upper_bound && "upper_bound node may not be NULL.");
+ array->attr.aa.upper_bound[dimension] = upper_bound;
+}
+
+void set_array_upper_bound_int(ir_type *array, size_t dimension, int upper_bound)
+{
+ ir_graph *irg = get_const_code_irg();
+ set_array_upper_bound(array, dimension,
+ new_r_Const_long(irg, mode_Iu, upper_bound));
+}
+
+int has_array_lower_bound(const ir_type *array, size_t dimension)
+{
+ assert(array && (array->type_op == type_array));
+ return !is_Unknown(array->attr.aa.lower_bound[dimension]);
+}
+
+ir_node *get_array_lower_bound(const ir_type *array, size_t dimension)
+{
+ assert(array && (array->type_op == type_array));
+ return array->attr.aa.lower_bound[dimension];
+}
+
+long get_array_lower_bound_int(const ir_type *array, size_t dimension)
+{
+ ir_node *node;
+ assert(array && (array->type_op == type_array));
+ node = array->attr.aa.lower_bound[dimension];
+ assert(is_Const(node));
+ return get_tarval_long(get_Const_tarval(node));
+}
+
+int has_array_upper_bound(const ir_type *array, size_t dimension)
+{
+ assert(array && (array->type_op == type_array));
+ return !is_Unknown(array->attr.aa.upper_bound[dimension]);
+}
+
+ir_node *get_array_upper_bound(const ir_type *array, size_t dimension)
+{
+ assert(array && (array->type_op == type_array));
+ return array->attr.aa.upper_bound[dimension];
+}
+
+long get_array_upper_bound_int(const ir_type *array, size_t dimension)
+{
+ ir_node *node;
+ assert(array && (array->type_op == type_array));
+ node = array->attr.aa.upper_bound[dimension];
+ assert(is_Const(node));
+ return get_tarval_long(get_Const_tarval(node));
+}
+
+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;
+}
+
+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, size_t order)
+{
+ size_t dim;
+
+ assert(array->type_op == type_array);
+
+ for (dim = 0; dim < array->attr.aa.n_dimensions; ++dim) {
+ if (array->attr.aa.order[dim] == order)
+ return dim;
+ }
+ return (size_t)-1;
+}
+
+void set_array_element_type(ir_type *array, ir_type *tp)
+{
+ assert(array && (array->type_op == type_array));
+ assert(!is_Method_type(tp));
+ array->attr.aa.element_type = tp;
+}
+
+ir_type *get_array_element_type(const ir_type *array)
+{
+ assert(array && (array->type_op == type_array));
+ return array->attr.aa.element_type;
+}
+
+void set_array_element_entity(ir_type *array, ir_entity *ent)
+{
+ assert(array && (array->type_op == type_array));
+ assert((get_entity_type(ent)->type_op != type_method));
+ array->attr.aa.element_ent = ent;
+ array->attr.aa.element_type = get_entity_type(ent);
+}
+
+ir_entity *get_array_element_entity(const ir_type *array)
+{
+ assert(array && (array->type_op == type_array));
+ return array->attr.aa.element_ent;
+}
+
+int (is_Array_type)(const ir_type *array)
+{
+ return _is_array_type(array);
+}
+
+void set_array_size(ir_type *tp, unsigned size)
+{
+ /* FIXME: Here we should make some checks with the element type size */
+ tp->size = size;
+}
+
+
+ir_type *new_d_type_enumeration(ident *name, size_t n_enums, type_dbg_info *db)
+{
+ ir_type *res;
+
+ res = new_type(type_enumeration, NULL, db);
+ res->name = name;
+ res->attr.ea.enumer = NEW_ARR_F(ir_enum_const, n_enums);
+ hook_new_type(res);
+ return res;
+}
+
+ir_type *new_type_enumeration(ident *name, size_t n_enums)
+{
+ return new_d_type_enumeration(name, n_enums, NULL);
+}
+
+void free_enumeration_entities(ir_type *enumeration)
+{
+ (void) enumeration;
+ assert(enumeration->type_op == type_enumeration);
+}
+
+void free_enumeration_attrs(ir_type *enumeration)
+{
+ assert(enumeration->type_op == type_enumeration);
+ DEL_ARR_F(enumeration->attr.ea.enumer);
+}
+
+ident *get_enumeration_ident(const ir_type *enumeration)
+{
+ assert(enumeration->type_op == type_enumeration);
+ return enumeration->name;
+}
+
+const char *get_enumeration_name(const ir_type *enumeration)
+{
+ if (get_enumeration_ident(enumeration) == NULL)
+ return NULL;
+ return get_id_str(get_enumeration_ident(enumeration));
+}
+
+size_t get_enumeration_n_enums(const ir_type *enumeration)
+{
+ assert(enumeration->type_op == type_enumeration);
+ return ARR_LEN(enumeration->attr.ea.enumer);
+}
+
+void set_enumeration_const(ir_type *enumeration, size_t pos, ident *nameid,
+ ir_tarval *con)
+{
+ assert(pos < ARR_LEN(enumeration->attr.ea.enumer));
+ enumeration->attr.ea.enumer[pos].nameid = nameid;
+ enumeration->attr.ea.enumer[pos].value = con;
+ enumeration->attr.ea.enumer[pos].owner = enumeration;
+}
+
+ir_enum_const *get_enumeration_const(const ir_type *enumeration, size_t pos)
+{
+ assert(enumeration->type_op == type_enumeration);
+ assert(pos < get_enumeration_n_enums(enumeration));
+ return &enumeration->attr.ea.enumer[pos];
+}
+
+ir_type *get_enumeration_owner(const ir_enum_const *enum_cnst)
+{
+ return enum_cnst->owner;
+}
+
+void set_enumeration_value(ir_enum_const *enum_cnst, ir_tarval *con)
+{
+ enum_cnst->value = con;
+}
+
+ir_tarval *get_enumeration_value(const ir_enum_const *enum_cnst)
+{
+ return enum_cnst->value;
+}
+
+void set_enumeration_nameid(ir_enum_const *enum_cnst, ident *id)
+{
+ enum_cnst->nameid = id;
+}
+
+ident *get_enumeration_const_nameid(const ir_enum_const *enum_cnst)
+{
+ return enum_cnst->nameid;
+}
+
+const char *get_enumeration_const_name(const ir_enum_const *enum_cnst)
+{
+ return get_id_str(enum_cnst->nameid);
+}
+
+int (is_Enumeration_type)(const ir_type *enumeration)
+{
+ return _is_enumeration_type(enumeration);
+}
+
+void set_enumeration_mode(ir_type *tp, ir_mode *mode)
+{
+ assert(mode_is_int(mode) && "Modes of enumerations must be integers");
+ /* For pointer and enumeration size depends on the mode, but only byte size allowed. */
+ assert((get_mode_size_bits(mode) % 8) == 0 && "unorthodox modes not implemented");
+
+ tp->size = get_mode_size_bytes(mode);
+ tp->mode = mode;
+}
+
+
+
+ir_type *new_d_type_pointer(ir_type *points_to, type_dbg_info *db)
+{
+ ir_type *res;
+ ir_mode *mode;
+
+ if (is_Method_type(points_to) || is_code_type(points_to)) {
+ mode = mode_P_code;
+ } else {
+ mode = mode_P_data;
+ }
+
+ res = new_type(type_pointer, mode, db);
+ res->attr.pa.points_to = points_to;
+ assert((get_mode_size_bits(res->mode) % 8 == 0) && "unorthodox modes not implemented");
+ res->size = get_mode_size_bytes(res->mode);
+ res->flags |= tf_layout_fixed;
+ hook_new_type(res);
+ return res;
+}
+
+ir_type *new_type_pointer(ir_type *points_to)
+{
+ return new_d_type_pointer(points_to, NULL);
+}
+
+void free_pointer_entities(ir_type *pointer)
+{
+ (void) pointer;
+ assert(pointer && (pointer->type_op == type_pointer));
+}
+
+void free_pointer_attrs(ir_type *pointer)
+{
+ (void) pointer;
+ assert(pointer && (pointer->type_op == type_pointer));
+}
+
+void set_pointer_points_to_type(ir_type *pointer, ir_type *tp)
+{
+ assert(pointer && (pointer->type_op == type_pointer));
+ pointer->attr.pa.points_to = tp;
+}
+
+ir_type *get_pointer_points_to_type(const ir_type *pointer)
+{
+ assert(pointer && (pointer->type_op == type_pointer));
+ return pointer->attr.pa.points_to;
+}
+
+int (is_Pointer_type)(const ir_type *pointer)
+{
+ return _is_pointer_type(pointer);
+}
+
+void set_pointer_mode(ir_type *tp, ir_mode *mode)
+{
+ assert(mode_is_reference(mode) && "Modes of pointers must be references");
+ /* For pointer and enumeration size depends on the mode, but only byte size allowed. */
+ assert((get_mode_size_bits(mode) & 7) == 0 && "unorthodox modes not implemented");
+
+ tp->size = get_mode_size_bytes(mode);
+ tp->mode = mode;
+}
+
+ir_type *find_pointer_type_to_type(ir_type *tp)
+{
+ size_t i, n = get_irp_n_types();
+ for (i = 0; i < n; ++i) {
+ ir_type *found = get_irp_type(i);
+ if (is_Pointer_type(found) && get_pointer_points_to_type(found) == tp)
+ return (found);
+ }
+ return firm_unknown_type;
+}
+
+
+
+ir_type *new_d_type_primitive(ir_mode *mode, type_dbg_info *db)
+{
+ ir_type *res = new_type(type_primitive, mode, db);
+ res->size = get_mode_size_bytes(mode);
+ res->flags |= tf_layout_fixed;
+ res->attr.ba.base_type = NULL;
+ hook_new_type(res);
+ return res;
+}
+
+ir_type *new_type_primitive(ir_mode *mode)
+{
+ return new_d_type_primitive(mode, NULL);
+}
+
+int (is_Primitive_type)(const ir_type *primitive)
+{
+ return _is_primitive_type(primitive);
+}
+
+void set_primitive_mode(ir_type *tp, ir_mode *mode)
+{
+ /* Modes of primitives must be data */
+ assert(mode_is_data(mode));
+
+ /* For primitive size depends on the mode. */
+ tp->size = get_mode_size_bytes(mode);
+ tp->mode = mode;
+}
+
+ir_type *get_primitive_base_type(const ir_type *tp)
+{
+ assert(is_Primitive_type(tp));
+ return tp->attr.ba.base_type;
+}
+
+void set_primitive_base_type(ir_type *tp, ir_type *base_tp)
+{
+ assert(is_Primitive_type(tp));
+ tp->attr.ba.base_type = base_tp;
+}
+
+
+
+int (is_atomic_type)(const ir_type *tp)
+{
+ return _is_atomic_type(tp);
+}
+
+size_t get_compound_n_members(const ir_type *tp)
+{
+ const tp_op *op = get_type_tpop(tp);
+ return op->ops.get_n_members(tp);
+}
+
+ir_entity *get_compound_member(const ir_type *tp, size_t pos)
+{
+ const tp_op *op = get_type_tpop(tp);
+ return op->ops.get_member(tp, pos);
+}
+
+size_t get_compound_member_index(const ir_type *tp, ir_entity *member)
+{
+ const tp_op *op = get_type_tpop(tp);
+ return op->ops.get_member_index(tp, member);
+}
+
+int is_compound_type(const ir_type *tp)
+{
+ assert(tp->kind == k_type);
+ return tp->type_op->flags & TP_OP_FLAG_COMPOUND;
+}
+
+ident *get_compound_ident(const ir_type *tp)
+{
+ assert(is_compound_type(tp));
+ return tp->name;
+}
+
+const char *get_compound_name(const ir_type *tp)
+{
+ if (get_compound_ident(tp) == NULL)
+ return NULL;
+ return get_id_str(get_compound_ident(tp));
+}
+
+void remove_compound_member(ir_type *compound, ir_entity *entity)
+{
+ switch (get_type_tpop_code(compound)) {
+ case tpo_class: remove_class_member(compound, entity); break;
+ case tpo_struct: remove_struct_member(compound, entity); break;
+ case tpo_union: remove_union_member(compound, entity); break;
+ default:
+ panic("argument for remove_compound_member not a compound type");
+ }
+}
+
+void add_compound_member(ir_type *compound, ir_entity *entity)
+{
+ switch (get_type_tpop_code(compound)) {
+ case tpo_class: add_class_member(compound, entity); break;
+ case tpo_struct: add_struct_member(compound, entity); break;
+ case tpo_union: add_union_member(compound, entity); break;
+ default:
+ panic("argument for add_compound_member not a compound type");
+ }
+}
+
+
+
+int is_code_type(const ir_type *tp)
+{
+ assert(tp && tp->kind == k_type);
+ return tp->type_op == tpop_code;
+}
+
+int is_frame_type(const ir_type *tp)
+{
+ return tp->flags & tf_frame_type;
+}
+
+int is_value_param_type(const ir_type *tp)
+{
+ return tp->flags & tf_value_param_type;
+}
+
+ir_type *new_type_value(void)
+{
+ ir_type *res = new_type_struct(new_id_from_str("<value_type>"));
+
+ res->flags |= tf_value_param_type;
+
+ /* Remove type from type list. Must be treated differently than other types. */
+ remove_irp_type(res);
+
+ return res;
+}
+
+ir_type *new_type_frame(void)
+{
+ ir_type *res = new_type_class(new_id_from_str("<frame_type>"));
+
+ res->flags |= tf_frame_type;
+
+ /* Remove type from type list. Must be treated differently than other types. */
+ remove_irp_type(res);
+
+ /* It is not possible to derive from the frame type. Set the final flag. */
+ set_class_final(res, 1);
+
+ return res;
+}
+
+ir_type *clone_frame_type(ir_type *type)
+{
+ ir_type *res;
+ size_t i, n;
+
+ assert(is_frame_type(type));
+ /* the entity link resource should be allocated if this function is called */
+ assert(irp_resources_reserved(irp) & IR_RESOURCE_ENTITY_LINK);
+
+ res = new_type_frame();
+ for (i = 0, n = get_class_n_members(type); i < n; ++i) {
+ ir_entity *ent = get_class_member(type, i);
+ ir_entity *nent = copy_entity_own(ent, res);
+ set_entity_link(ent, nent);
+ set_entity_link(nent, ent);
+ }
+ return res;
+}
+
+void set_default_size(ir_type *tp, unsigned size)
+{
+ tp->size = size;
+}
+
+void default_layout_compound_type(ir_type *type)
+{
+ size_t i;
+ size_t n = get_compound_n_members(type);
+ int size = 0;
+ unsigned align_all = 1;
+
+ for (i = 0; i < n; ++i) {
+ ir_entity *entity = get_compound_member(type, i);
+ ir_type *entity_type = get_entity_type(entity);
+ unsigned align;
+ unsigned misalign;
+
+ if (is_Method_type(entity_type))
+ continue;
+
+ assert(get_type_state(entity_type) == layout_fixed);
+ align = get_type_alignment_bytes(entity_type);
+ align_all = align > align_all ? align : align_all;
+ misalign = (align ? size % align : 0);
+ size += (misalign ? align - misalign : 0);
+
+ set_entity_offset(entity, size);
+ if (!is_Union_type(type)) {
+ size += get_type_size_bytes(entity_type);
+ }
+ }
+ if (align_all > 0 && size % align_all) {
+ size += align_all - (size % align_all);
+ }
+ if (align_all > get_type_alignment_bytes(type)) {
+ set_type_alignment_bytes(type, align_all);
+ }
+ set_type_size_bytes(type, size);
+ set_type_state(type, layout_fixed);
+}
+
+ir_entity *frame_alloc_area(ir_type *frame_type, int size, unsigned alignment,
+ int at_start)
+{
+ ir_entity *area;
+ ir_type *tp;
+ ident *name;
+ char buf[32];
+ unsigned frame_align;
+ int offset, frame_size;
+ static unsigned area_cnt = 0;
+ static ir_type *a_byte = NULL;
+
+ assert(is_frame_type(frame_type));
+ assert(get_type_state(frame_type) == layout_fixed);
+ assert(get_type_alignment_bytes(frame_type) > 0);
+ set_type_state(frame_type, layout_undefined);
+
+ if (! a_byte)
+ a_byte = new_type_primitive(mode_Bu);
+
+ snprintf(buf, sizeof(buf), "area%u", area_cnt++);
+ name = new_id_from_str(buf);
+
+ /* align the size */
+ frame_align = get_type_alignment_bytes(frame_type);
+ size = (size + frame_align - 1) & ~(frame_align - 1);
+
+ tp = new_type_array(1, a_byte);
+ set_array_bounds_int(tp, 0, 0, size);
+ set_type_alignment_bytes(tp, alignment);
+
+ frame_size = get_type_size_bytes(frame_type);
+ if (at_start) {
+ size_t i, n;
+ /* fix all offsets so far */
+ 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);
+ }
+ /* calculate offset and new type size */
+ offset = 0;
+ frame_size += size;
+
+ /* increase size to match alignment... */
+ if (alignment > frame_align) {
+ frame_align = alignment;
+ set_type_alignment_bytes(frame_type, frame_align);
+ frame_size = (frame_size + frame_align - 1) & ~(frame_align - 1);
+ }
+ } else {
+ /* calculate offset and new type size */
+ offset = (frame_size + alignment - 1) & ~(alignment - 1);
+ frame_size = offset + size;
+ }
+
+ area = new_entity(frame_type, name, tp);
+ set_entity_offset(area, offset);
+ set_type_size_bytes(frame_type, frame_size);
+
+ /* mark this entity as compiler generated */
+ set_entity_compiler_generated(area, 1);
+
+ set_type_state(frame_type, layout_fixed);
+ return area;
+}
+
+void ir_print_type(char *buffer, size_t buffer_size, const ir_type *type)
+{
+ ident *id;
+ int p;
+ type_dbg_info *tdbgi = get_type_dbg_info(type);
+ if (tdbgi != NULL) {
+ ir_retrieve_type_dbg_info(buffer, buffer_size, tdbgi);
+ return;
+ }
+
+ /* we have to construct some name... */
+ switch (get_type_tpop_code(type)) {
+ case tpo_uninitialized:
+ break;
+ case tpo_code:
+ snprintf(buffer, buffer_size, "code");
+ return;
+
+ case tpo_class:
+ id = get_class_ident(type);
+ snprintf(buffer, buffer_size, "class '%s'", get_id_str(id));
+ return;
+
+ case tpo_struct:
+ id = get_struct_ident(type);
+ snprintf(buffer, buffer_size, "struct '%s'", get_id_str(id));
+ return;
+
+ case tpo_union:
+ id = get_union_ident(type);
+ snprintf(buffer, buffer_size, "union '%s'", get_id_str(id));
+ return;
+
+ case tpo_enumeration:
+ id = get_enumeration_ident(type);
+ snprintf(buffer, buffer_size, "enumeration '%s'", get_id_str(id));
+ return;
+
+ case tpo_unknown:
+ snprintf(buffer, buffer_size, "unknown type");
+ return;
+
+ case tpo_pointer:
+ p = snprintf(buffer, buffer_size, "pointer to ");
+ buffer += p;
+ buffer_size -= p;
+ ir_print_type(buffer, buffer_size, get_pointer_points_to_type(type));
+ return;
+
+ case tpo_array:
+ p = snprintf(buffer, buffer_size, "array of ");
+ buffer += p;
+ buffer_size -= p;
+ ir_print_type(buffer, buffer_size, get_array_element_type(type));
+ return;
+
+ case tpo_primitive:
+ id = get_mode_ident(get_type_mode(type));
+ snprintf(buffer, buffer_size, "%s", get_id_str(id));
+ return;
+
+ case tpo_none:
+ snprintf(buffer, buffer_size, "none");
+ return;
+ case tpo_method:
+ /* TODO: we should print argument and return types here... */
+ snprintf(buffer, buffer_size, "method type");
+ return;
+ }
+ snprintf(buffer, buffer_size, "invalid type");