Mostly reverted r27894, removed usage of unreachable.

[libfirm] / ir / tr / type.c

diff --git a/ir/tr/type.c b/ir/tr/type.c
index ab81082..8f252f8 100644 (file)
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -76,7 +76,8 @@ ir_type *get_code_type(void)
 }
 
 ir_type *firm_unknown_type;
-ir_type *get_unknown_type(void) {
+ir_type *get_unknown_type(void)
+{
        return firm_unknown_type;
 }
 
@@ -84,17 +85,8 @@ ir_type *get_unknown_type(void) {
 static ident *value_params_suffix = NULL;
 static ident *value_ress_suffix = NULL;
 
-/** The default calling convention for method types. */
-static unsigned default_cc_mask;
-
-unsigned get_default_cc_mask(void)
+void ir_init_type(void)
 {
-       return default_cc_mask;
-}
-
-void firm_init_type(unsigned def_cc_mask)
-{
-       default_cc_mask     = def_cc_mask;
        value_params_suffix = new_id_from_str(VALUE_PARAMS_SUFFIX);
        value_ress_suffix   = new_id_from_str(VALUE_RESS_SUFFIX);
 
@@ -114,6 +106,24 @@ void firm_init_type(unsigned def_cc_mask)
        remove_irp_type(firm_unknown_type);
 }
 
+void ir_finish_type(void)
+{
+       if (firm_none_type != NULL) {
+               free_type(firm_none_type);
+               firm_none_type = NULL;
+       }
+       if (firm_code_type != NULL) {
+               free_type(firm_code_type);
+               firm_code_type = NULL;
+       }
+       if (firm_unknown_type != NULL) {
+               free_type(firm_unknown_type);
+               firm_unknown_type = NULL;
+       }
+       value_params_suffix = NULL;
+       value_ress_suffix = NULL;
+}
+
 /** the global type visited flag */
 ir_visited_t firm_type_visited;
 
@@ -377,7 +387,7 @@ void set_type_state(ir_type *tp, ir_type_state state)
                        break;
                case tpo_enumeration:
 #ifndef NDEBUG
-                       assert(get_type_mode != NULL);
+                       assert(get_type_mode(tp) != NULL);
                        for (i = get_enumeration_n_enums(tp) - 1; i >= 0; --i) {
                                ir_enum_const *ec = get_enumeration_const(tp, i);
                                tarval        *tv = get_enumeration_value(ec);
@@ -560,7 +570,7 @@ int equal_type(ir_type *typ1, ir_type *typ2)
                        return 0;
                if (!equal_type(get_array_element_type(typ1), get_array_element_type(typ2)))
                        return 0;
-               for(i = 0; i < get_array_n_dimensions(typ1); i++) {
+               for (i = 0; i < get_array_n_dimensions(typ1); i++) {
                        if (get_array_lower_bound(typ1, i) != get_array_lower_bound(typ2, i) ||
                                get_array_upper_bound(typ1, i) != get_array_upper_bound(typ2, i))
                                return 0;
@@ -596,7 +606,7 @@ int smaller_type(ir_type *st, ir_type *lt)
        if (get_type_tpop_code(st) != get_type_tpop_code(lt))
                return 0;
 
-       switch(get_type_tpop_code(st)) {
+       switch (get_type_tpop_code(st)) {
        case tpo_class:
                return is_SubClass_of(st, lt);
 
@@ -691,12 +701,12 @@ int smaller_type(ir_type *st, ir_type *lt)
                            get_type_size_bytes(set) != get_type_size_bytes(let))
                                return 0;
                }
-               for(i = 0; i < get_array_n_dimensions(st); i++) {
+               for (i = 0; i < get_array_n_dimensions(st); i++) {
                        if (get_array_lower_bound(lt, i))
-                               if(get_array_lower_bound(st, i) != get_array_lower_bound(lt, i))
+                               if (get_array_lower_bound(st, i) != get_array_lower_bound(lt, i))
                                        return 0;
                                if (get_array_upper_bound(lt, i))
-                                       if(get_array_upper_bound(st, i) != get_array_upper_bound(lt, i))
+                                       if (get_array_upper_bound(st, i) != get_array_upper_bound(lt, i))
                                                return 0;
                }
        } break;
@@ -775,7 +785,7 @@ const char *get_class_name(const ir_type *clss)
        return get_id_str(get_class_ident(clss));
 }
 
-void add_class_member(ir_type *clss, ir_entity *member)
+static void add_class_member(ir_type *clss, ir_entity *member)
 {
        assert(clss && (clss->type_op == type_class));
        assert(clss != get_entity_type(member) && "recursive type");
@@ -833,7 +843,7 @@ void set_class_members(ir_type *clss, ir_entity **members, int arity)
        }
 }
 
-void remove_class_member(ir_type *clss, ir_entity *member)
+static void remove_class_member(ir_type *clss, ir_entity *member)
 {
        int i;
        assert(clss && (clss->type_op == type_class));
@@ -951,7 +961,7 @@ void remove_class_supertype(ir_type *clss, ir_type *supertype)
        assert(clss && (clss->type_op == type_class));
        for (i = 0; i < (ARR_LEN(clss->attr.ca.supertypes)); i++)
                if (clss->attr.ca.supertypes[i] == supertype) {
-                       for(; i < (ARR_LEN(clss->attr.ca.supertypes))-1; i++)
+                       for (; i < (ARR_LEN(clss->attr.ca.supertypes))-1; i++)
                                clss->attr.ca.supertypes[i] = clss->attr.ca.supertypes[i+1];
                        ARR_SETLEN(ir_entity*, clss->attr.ca.supertypes, ARR_LEN(clss->attr.ca.supertypes) - 1);
                        break;
@@ -1046,7 +1056,8 @@ void set_class_mode(ir_type *tp, ir_mode *mode)
        tp->mode = mode;
 }
 
-void set_class_size(ir_type *tp, unsigned size) {
+void set_class_size(ir_type *tp, unsigned size)
+{
        tp->size = size;
 }
 
@@ -1054,7 +1065,6 @@ void set_class_size(ir_type *tp, unsigned size) {
 ir_type *new_d_type_struct(ident *name, type_dbg_info *db)
 {
        ir_type *res = new_type(type_struct, NULL, db);
-       assert(name != NULL);
        res->name = name;
 
        res->attr.sa.members = NEW_ARR_F(ir_entity *, 0);
@@ -1100,7 +1110,7 @@ int get_struct_n_members(const ir_type *strct)
        return ARR_LEN(strct->attr.sa.members);
 }
 
-void add_struct_member(ir_type *strct, ir_entity *member)
+static void add_struct_member(ir_type *strct, ir_entity *member)
 {
        assert(strct && (strct->type_op == type_struct));
        assert(get_type_tpop(get_entity_type(member)) != type_method);
@@ -1133,13 +1143,13 @@ void set_struct_member(ir_type *strct, int pos, ir_entity *member)
        strct->attr.sa.members[pos] = member;
 }
 
-void remove_struct_member(ir_type *strct, ir_entity *member)
+static void remove_struct_member(ir_type *strct, ir_entity *member)
 {
        int i;
        assert(strct && (strct->type_op == type_struct));
        for (i = 0; i < (ARR_LEN (strct->attr.sa.members)); i++)
                if (strct->attr.sa.members[i] == member) {
-                       for(; i < (ARR_LEN (strct->attr.sa.members))-1; i++)
+                       for (; i < (ARR_LEN (strct->attr.sa.members))-1; i++)
                                strct->attr.sa.members[i] = strct->attr.sa.members[i+1];
                        ARR_SETLEN(ir_entity*, strct->attr.sa.members, ARR_LEN(strct->attr.sa.members) - 1);
                        break;
@@ -1214,7 +1224,6 @@ ir_type *new_d_type_method(int n_param, int n_res, type_dbg_info *db)
        res->attr.ma.variadicity          = variadicity_non_variadic;
        res->attr.ma.first_variadic_param = -1;
        res->attr.ma.additional_properties = mtp_no_property;
-       res->attr.ma.irg_calling_conv     = default_cc_mask;
        hook_new_type(res);
        return res;
 }
@@ -1565,7 +1574,7 @@ int get_union_n_members(const ir_type *uni)
        return ARR_LEN(uni->attr.ua.members);
 }
 
-void add_union_member(ir_type *uni, ir_entity *member)
+static void add_union_member(ir_type *uni, ir_entity *member)
 {
        assert(uni && (uni->type_op == type_union));
        assert(uni != get_entity_type(member) && "recursive type");
@@ -1597,13 +1606,13 @@ void set_union_member(ir_type *uni, int pos, ir_entity *member)
        uni->attr.ua.members[pos] = member;
 }
 
-void remove_union_member(ir_type *uni, ir_entity *member)
+static void remove_union_member(ir_type *uni, ir_entity *member)
 {
        int 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++)
+                       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;
@@ -1649,7 +1658,10 @@ ir_type *new_d_type_array(int n_dimensions, ir_type *element_type,
        current_ir_graph = rem;
 
        res->attr.aa.element_type = element_type;
-       new_entity(res, new_id_from_chars("elem_ent", 8), 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;
 }
@@ -2141,6 +2153,30 @@ const char *get_compound_name(const ir_type *tp)
        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);