BugFix: allow method entities to be initialized by an const_initializer.

[libfirm] / ir / tr / type.c

diff --git a/ir/tr/type.c b/ir/tr/type.c
index 91b52eb..9114ff9 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;
 }
 
@@ -144,7 +145,7 @@ ir_type *new_type(const tp_op *type_op, ir_mode *mode, type_dbg_info *db)
        res->kind       = k_type;
        res->type_op    = type_op;
        res->mode       = mode;
-       res->visibility = visibility_external_allocated;
+       res->visibility = ir_visibility_external;
        res->flags      = tf_none;
        res->size       = 0;
        res->align      = 0;
@@ -365,7 +366,6 @@ void set_type_state(ir_type *tp, ir_type_state state)
                case tpo_struct:
                        for (i = 0; i < get_struct_n_members(tp); i++) {
                                assert(get_entity_offset(get_struct_member(tp, i)) > -1);
-                               assert((get_entity_allocation(get_struct_member(tp, i)) == allocation_automatic));
                        }
                        break;
                case tpo_union:
@@ -561,7 +561,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;
@@ -597,7 +597,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);
 
@@ -692,12 +692,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;
@@ -952,7 +952,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;
@@ -971,18 +971,6 @@ void set_class_type_info(ir_type *clss, ir_entity *ent)
                ent->repr_class = clss;
 }
 
-const char *get_peculiarity_name(ir_peculiarity p)
-{
-#define X(a)    case a: return #a
-       switch (p) {
-       X(peculiarity_description);
-       X(peculiarity_inherited);
-       X(peculiarity_existent);
-       }
-#undef X
-       return "invalid peculiarity";
-}
-
 ir_peculiarity get_class_peculiarity(const ir_type *clss)
 {
        assert(clss && (clss->type_op == type_class));
@@ -1059,7 +1047,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;
 }
 
@@ -1067,6 +1056,7 @@ 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);
@@ -1151,7 +1141,7 @@ void remove_struct_member(ir_type *strct, ir_entity *member)
        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;
@@ -1186,10 +1176,10 @@ void set_struct_size(ir_type *tp, unsigned size)
  * @param len     number of fields
  * @param tps     array of field types with length len
  */
-static ir_type *build_value_type(int len, tp_ent_pair *tps)
+static ir_type *build_value_type(char const* name, int len, tp_ent_pair *tps)
 {
        int i;
-       ir_type *res = new_type_struct(NULL);
+       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);
@@ -1348,9 +1338,8 @@ ir_entity *get_method_value_param_ent(ir_type *method, int pos)
 
        if (!method->attr.ma.value_params) {
                /* parameter value type not created yet, build */
-               method->attr.ma.value_params
-                       = build_value_type(get_method_n_params(method),
-                                          method->attr.ma.params);
+               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
@@ -1419,9 +1408,8 @@ ir_entity *get_method_value_res_ent(ir_type *method, int pos)
 
        if (!method->attr.ma.value_ress) {
                /* result value type not created yet, build */
-               method->attr.ma.value_ress
-                       = build_value_type(get_method_n_ress(method),
-                                          method->attr.ma.res_type);
+               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
@@ -1617,7 +1605,7 @@ void remove_union_member(ir_type *uni, ir_entity *member)
        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;
@@ -2240,6 +2228,43 @@ void set_default_size(ir_type *tp, unsigned size)
        tp->size = size;
 }
 
+void default_layout_compound_type(ir_type *type)
+{
+       int i;
+       int 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)
 {