convopt: fix potential bug with modulo shifts, improve cost calculation for optimizab...

[libfirm] / ir / tr / type.c

diff --git a/ir/tr/type.c b/ir/tr/type.c
index e8f2e56..f5db17b 100644 (file)
--- a/ir/tr/type.c
+++ b/ir/tr/type.c
@@ -81,15 +81,8 @@ ir_type *get_unknown_type(void)
        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);
@@ -120,8 +113,6 @@ void ir_finish_type(void)
                free_type(firm_unknown_type);
                firm_unknown_type = NULL;
        }
-       value_params_suffix = NULL;
-       value_ress_suffix = NULL;
 }
 
 /** the global type visited flag */
@@ -1169,15 +1160,10 @@ static ir_type *build_value_type(char const* name, size_t len, tp_ent_pair *tps)
        /* 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;
+               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);
        }
@@ -1197,7 +1183,6 @@ ir_type *new_d_type_method(size_t n_param, size_t n_res, type_dbg_info *db)
        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.additional_properties = mtp_no_property;
        hook_new_type(res);
@@ -1236,7 +1221,6 @@ ir_type *clone_type_method(ir_type *tp)
        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.additional_properties = tp->attr.ma.additional_properties;
        res->attr.ma.irg_calling_conv      = tp->attr.ma.irg_calling_conv;
@@ -1261,10 +1245,6 @@ void free_method_attrs(ir_type *method)
                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)
@@ -1294,26 +1274,6 @@ void set_method_param_type(ir_type *method, size_t pos, ir_type *tp)
        }
 }
 
-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));
@@ -1379,36 +1339,6 @@ void set_method_res_type(ir_type *method, size_t pos, ir_type *tp)
        /* 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)
@@ -1583,11 +1513,11 @@ void set_union_size(ir_type *tp, unsigned size)
 
 
 
-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();
 
@@ -1597,7 +1527,7 @@ ir_type *new_d_type_array(int n_dimensions, ir_type *element_type,
        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++) {
@@ -1615,7 +1545,7 @@ ir_type *new_d_type_array(int n_dimensions, ir_type *element_type,
        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);
 }
@@ -1738,19 +1668,19 @@ long get_array_upper_bound_int(const ir_type *array, size_t dimension)
        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;
 
@@ -2115,11 +2045,6 @@ int is_value_param_type(const ir_type *tp)
        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>"));
@@ -2166,19 +2091,6 @@ ir_type *clone_frame_type(ir_type *type)
        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;