X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftr_inheritance.c;h=715771d90af76be9847d815ebdaf1d0b4b7cf806;hb=f64411a2a8a4e28e70a281ac67736a1bdf996b72;hp=c0b3b73aaffad64e78e3ff0238c437c5bb3f4219;hpb=7012801102da788b13623eb0768e1acf7bf5578c;p=libfirm
diff --git a/ir/tr/tr_inheritance.c b/ir/tr/tr_inheritance.c
index c0b3b73aa..715771d90 100644
--- a/ir/tr/tr_inheritance.c
+++ b/ir/tr/tr_inheritance.c
@@ -1,9 +1,9 @@
/**
*
- * @file tp_inheritance.c
+ * @file tr_inheritance.c
*
* Project: libFIRM
- * File name: ir/tr/tp_inheritance.c
+ * File name: ir/tr/tr_inheritance.c
* Purpose: Utility routines for inheritance representation
* Author: Goetz Lindenmaier
* Modified by:
@@ -46,7 +46,7 @@ static void copy_entities_from_superclass(type *clss, void *env)
int overwritten;
type *super, *inhenttype;
entity *inhent, *thisent;
- mangle_inherited_name_func *mfunc = (mangle_inherited_name_func *)env;
+ mangle_inherited_name_func *mfunc = *(mangle_inherited_name_func **)env;
for(i = 0; i < get_class_n_supertypes(clss); i++) {
super = get_class_supertype(clss, i);
@@ -57,27 +57,28 @@ static void copy_entities_from_superclass(type *clss, void *env)
/* check whether inhent is already overwritten */
overwritten = 0;
for (k = 0; (k < get_class_n_members(clss)) && (overwritten == 0); k++) {
- thisent = get_class_member(clss, k);
- for(l = 0; l < get_entity_n_overwrites(thisent); l++) {
- if(inhent == get_entity_overwrites(thisent, l)) {
- /* overwritten - do not copy */
- overwritten = 1;
- break;
- }
- }
+ thisent = get_class_member(clss, k);
+ for(l = 0; l < get_entity_n_overwrites(thisent); l++) {
+ if(inhent == get_entity_overwrites(thisent, l)) {
+ /* overwritten - do not copy */
+ overwritten = 1;
+ break;
+ }
+ }
}
/* Inherit entity */
if (!overwritten) {
- thisent = copy_entity_own(inhent, clss);
- add_entity_overwrites(thisent, inhent);
- set_entity_peculiarity(thisent, peculiarity_inherited);
- set_entity_ld_ident(thisent, mfunc(inhent, clss));
- if (get_entity_variability(inhent) == variability_constant) {
- assert(is_atomic_entity(inhent) && /* @@@ */
- "Inheritance of constant, compound entities not implemented");
- set_entity_variability(thisent, variability_constant);
- set_atomic_ent_value(thisent, get_atomic_ent_value(inhent));
- }
+ thisent = copy_entity_own(inhent, clss);
+ add_entity_overwrites(thisent, inhent);
+ if (get_entity_peculiarity(inhent) == peculiarity_existent)
+ set_entity_peculiarity(thisent, peculiarity_inherited);
+ set_entity_ld_ident(thisent, mfunc(inhent, clss));
+ if (get_entity_variability(inhent) == variability_constant) {
+ assert(is_atomic_entity(inhent) && /* @@@ */
+ "Inheritance of constant, compound entities not implemented");
+ set_entity_variability(thisent, variability_constant);
+ set_atomic_ent_value(thisent, get_atomic_ent_value(inhent));
+ }
}
}
}
@@ -90,7 +91,7 @@ static void copy_entities_from_superclass(type *clss, void *env)
void resolve_inheritance(mangle_inherited_name_func *mfunc) {
if (!mfunc)
mfunc = default_mangle_inherited_name;
- class_walk_super2sub(copy_entities_from_superclass, NULL, (void *)mfunc);
+ class_walk_super2sub(copy_entities_from_superclass, NULL, (void *)&mfunc);
}
@@ -131,10 +132,14 @@ static void assert_valid_state(void) {
/* arrays) listing all subtypes... */
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
+typedef enum {
+ d_up = 0,
+ d_down = 1,
+} dir;
+
typedef struct {
firm_kind *kind; /* An entity or type. */
- pset *up;
- pset *down;
+ pset *directions[2];
} tr_inh_trans_tp;
/* We use this set for all types and entities. */
@@ -147,15 +152,10 @@ static int tr_inh_trans_cmp(const void *e1, const void *e2, size_t size) {
}
static INLINE unsigned int tr_inh_trans_hash(void *e) {
- void *v = (void *) ((tr_inh_trans_tp *)e)->kind;
- return HASH_PTR(v);
+ tr_inh_trans_tp *v = e;
+ return HASH_PTR(v->kind);
}
-typedef enum {
- d_up,
- d_down,
-} dir;
-
/* This always completes successfully. */
static tr_inh_trans_tp* get_firm_kind_entry(firm_kind *k) {
tr_inh_trans_tp a, *found;
@@ -165,8 +165,8 @@ static tr_inh_trans_tp* get_firm_kind_entry(firm_kind *k) {
found = set_find(tr_inh_trans_set, &a, sizeof(a), tr_inh_trans_hash(&a));
if (!found) {
- a.up = pset_new_ptr(16);
- a.down = pset_new_ptr(16);
+ a.directions[d_up] = pset_new_ptr(16);
+ a.directions[d_down] = pset_new_ptr(16);
found = set_insert(tr_inh_trans_set, &a, sizeof(a), tr_inh_trans_hash(&a));
}
return found;
@@ -177,7 +177,7 @@ static pset *get_entity_map(entity *ent, dir d) {
assert(is_entity(ent));
found = get_firm_kind_entry((firm_kind *)ent);
- return (d == d_up) ? found->up : found->down;
+ return found->directions[d];
}
/*
static void add_entity_map(entity *ent, dir d, entity *new) {
@@ -185,10 +185,7 @@ static void add_entity_map(entity *ent, dir d, entity *new) {
assert(is_entity(ent) && is_entity(new));
tr_inh_trans_tp *found = get_firm_kind_entry((firm_kind *)ent);
- if (d == d_up)
- pset_insert_ptr(found->up, new);
- else
- pset_insert_ptr(found->down, new);
+ pset_insert_ptr(found->directions[d], new);
}
*/
static pset *get_type_map(type *tp, dir d) {
@@ -196,7 +193,7 @@ static pset *get_type_map(type *tp, dir d) {
assert(is_type(tp));
found = get_firm_kind_entry((firm_kind *)tp);
- return (d == d_up) ? found->up : found->down;
+ return found->directions[d];
}
/*
static void add_type_map(type *tp, dir d, type *new) {
@@ -204,8 +201,7 @@ static void add_type_map(type *tp, dir d, type *new) {
assert(is_type(tp) && is_type(new));
found = get_firm_kind_entry((firm_kind *)tp);
- if (d == d_up) pset_insert_ptr(found->up, new);
- else pset_insert_ptr(found->down, new);
+ pset_insert_ptr(found->directions[d], new);
}
*/
@@ -260,11 +256,11 @@ static void compute_down_closure(type *tp) {
int j, n_overwrittenby = get_entity_n_overwrittenby(mem);
myset = get_entity_map(mem, d_down);
- for (j = 0; j > n_overwrittenby; ++j) {
+ for (j = 0; j < n_overwrittenby; ++j) {
entity *ov = get_entity_overwrittenby(mem, j);
subset = get_entity_map(ov, d_down);
- pset_insert_pset_ptr(myset, subset);
pset_insert_ptr(myset, ov);
+ pset_insert_pset_ptr(myset, subset);
}
}
@@ -283,7 +279,7 @@ static void compute_down_closure(type *tp) {
static void compute_up_closure(type *tp) {
pset *myset, *subset;
int i, n_subtypes, n_members, n_supertypes;
- int master_visited = get_master_type_visited();
+ unsigned long master_visited = get_master_type_visited();
assert(is_Class_type(tp));
@@ -314,7 +310,7 @@ static void compute_up_closure(type *tp) {
int j, n_overwrites = get_entity_n_overwrites(mem);
myset = get_entity_map(mem, d_up);
- for (j = 0; j > n_overwrites; ++j) {
+ for (j = 0; j < n_overwrites; ++j) {
entity *ov = get_entity_overwrites(mem, j);
subset = get_entity_map(ov, d_up);
pset_insert_pset_ptr(myset, subset);
@@ -350,17 +346,20 @@ void compute_inh_transitive_closure(void) {
type *tp = get_irp_type(i);
if (is_Class_type(tp) && type_not_visited(tp)) { /* For others there is nothing to accumulate. */
int j, n_subtypes = get_class_n_subtypes(tp);
- int has_unmarked_subtype = false;
+ int has_unmarked_subtype = 0;
assert(get_type_visited(tp) < get_master_type_visited()-1);
- for (j = 0; j < n_subtypes && !has_unmarked_subtype; ++j) {
- type *stp = get_class_subtype(tp, j);
- if (type_not_visited(stp)) has_unmarked_subtype = true;
+ for (j = 0; j < n_subtypes; ++j) {
+ type *stp = get_class_subtype(tp, j);
+ if (type_not_visited(stp)) {
+ has_unmarked_subtype = 1;
+ break;
+ }
}
/* This is a good starting point. */
if (!has_unmarked_subtype)
- compute_down_closure(tp);
+ compute_down_closure(tp);
}
}
@@ -371,17 +370,20 @@ void compute_inh_transitive_closure(void) {
type *tp = get_irp_type(i);
if (is_Class_type(tp) && type_not_visited(tp)) { /* For others there is nothing to accumulate. */
int j, n_supertypes = get_class_n_supertypes(tp);
- int has_unmarked_supertype = false;
+ int has_unmarked_supertype = 0;
assert(get_type_visited(tp) < get_master_type_visited()-1);
- for (j = 0; j < n_supertypes && !has_unmarked_supertype; ++j) {
+ for (j = 0; j < n_supertypes; ++j) {
type *stp = get_class_supertype(tp, j);
- if (type_not_visited(stp)) has_unmarked_supertype = true;
+ if (type_not_visited(stp)) {
+ has_unmarked_supertype = 1;
+ break;
+ }
}
/* This is a good starting point. */
if (!has_unmarked_supertype)
- compute_up_closure(tp);
+ compute_up_closure(tp);
}
}
@@ -393,8 +395,8 @@ void free_inh_transitive_closure(void) {
if (tr_inh_trans_set) {
tr_inh_trans_tp *elt;
for (elt = set_first(tr_inh_trans_set); elt; elt = set_next(tr_inh_trans_set)) {
- del_pset(elt->up);
- del_pset(elt->down);
+ del_pset(elt->directions[d_up]);
+ del_pset(elt->directions[d_down]);
}
del_set(tr_inh_trans_set);
tr_inh_trans_set = NULL;
@@ -466,7 +468,7 @@ entity *get_entity_trans_overwrites_next (entity *ent) {
/* ----------------------------------------------------------------------- */
/* Returns true if low is subclass of high. */
-int is_subclass_of(type *low, type *high) {
+int is_SubClass_of(type *low, type *high) {
int i, n_subtypes;
assert(is_Class_type(low) && is_Class_type(high));
@@ -482,14 +484,28 @@ int is_subclass_of(type *low, type *high) {
for (i = 0; i < n_subtypes; i++) {
type *stp = get_class_subtype(high, i);
if (low == stp) return 1;
- if (is_subclass_of(low, stp))
+ if (is_SubClass_of(low, stp))
return 1;
}
return 0;
}
-int is_superclass_of(type *high, type *low) {
- return is_subclass_of(low, high);
+
+/* Subclass check for pointers to classes.
+ *
+ * Dereferences at both types the same amount of pointer types (as
+ * many as possible). If the remaining types are both class types
+ * and subclasses, returns true, else false. Can also be called with
+ * two class types. */
+int is_SubClass_ptr_of(type *low, type *high) {
+ while (is_Pointer_type(low) && is_Pointer_type(high)) {
+ low = get_pointer_points_to_type(low);
+ high = get_pointer_points_to_type(high);
+ }
+
+ if (is_Class_type(low) && is_Class_type(high))
+ return is_SubClass_of(low, high);
+ return 0;
}
int is_overwritten_by(entity *high, entity *low) {
@@ -593,12 +609,15 @@ typedef struct ccs_env {
} ccs_env;
void verify_irn_class_cast_state(ir_node *n, void *env) {
- ccs_env *ccs = (ccs_env *)env;
+ ccs_env *ccs = (ccs_env *)env;
ir_class_cast_state this_state = ir_class_casts_any;
+ type *fromtype, *totype;
+ int ref_depth = 0;
- type *fromtype = get_irn_typeinfo_type(get_Cast_op(n));
- type *totype = get_Cast_type(n);
- int ref_depth = 0;
+ if (get_irn_op(n) != op_Cast) return;
+
+ fromtype = get_irn_typeinfo_type(get_Cast_op(n));
+ totype = get_Cast_type(n);
while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
totype = get_pointer_points_to_type(totype);
@@ -608,24 +627,36 @@ void verify_irn_class_cast_state(ir_node *n, void *env) {
if (!is_Class_type(totype)) return;
- if (is_subclass_of(totype, fromtype) ||
- is_subclass_of(fromtype, totype) ) {
+ if (is_SubClass_of(totype, fromtype) ||
+ is_SubClass_of(fromtype, totype) ) {
this_state = ir_class_casts_transitive;
- if ((get_class_supertype_index(totype, fromtype) == -1) &&
- (get_class_supertype_index(fromtype, totype) == -1) ) {
+ if ((get_class_supertype_index(totype, fromtype) != -1) ||
+ (get_class_supertype_index(fromtype, totype) != -1) ||
+ fromtype == totype) {
+ /* Das ist doch alt? Aus dem cvs aufgetaucht ...
+ if ((get_class_supertype_index(totype, fromtype) == -1) &&
+ (get_class_supertype_index(fromtype, totype) == -1) ) { */
this_state = ir_class_casts_normalized;
}
}
- assert(this_state >= ccs->expected_state &&
- "invalid state class cast state setting in graph");
+ if (!(this_state >= ccs->expected_state)) {
+ printf(" Node is "); DDMN(n);
+ printf(" totype "); DDMT(totype);
+ printf(" fromtype "); DDMT(fromtype);
+ printf(" this_state: %s, exp. state: %s\n",
+ get_class_cast_state_string(this_state),
+ get_class_cast_state_string(ccs->expected_state));
+ assert(this_state >= ccs->expected_state &&
+ "invalid state class cast state setting in graph");
+ }
if (this_state < ccs->worst_situation)
ccs->worst_situation = this_state;
}
-/** Verify that the graph meets reqirements of state set. */
+/** Verify that the graph meets requirements of state set. */
void verify_irg_class_cast_state(ir_graph *irg) {
ccs_env env;