X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftr_inheritance.c;h=f1c7d9c40bf744ef6dd82c79bd51f641066ef9f5;hb=87b6a945e992229095254b628b932ebd40114f0a;hp=525ef5ee6f105fd594e434cad47873d45004aa1d;hpb=1a26f4853c07d1ecd68a097409dd602edfe29eff;p=libfirm

diff --git a/ir/tr/tr_inheritance.c b/ir/tr/tr_inheritance.c
index 525ef5ee6..f1c7d9c40 100644
--- a/ir/tr/tr_inheritance.c
+++ b/ir/tr/tr_inheritance.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2011 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -50,7 +50,10 @@ ident *default_mangle_inherited_name(const ir_entity *super, const ir_type *clss
     by an entity of this class. */
 static void copy_entities_from_superclass(ir_type *clss, void *env)
 {
-	int i, j, k, l;
+	size_t i;
+	size_t j;
+	size_t k;
+	size_t l;
 	int overwritten;
 	ir_type *super, *inhenttype;
 	ir_entity *inhent, *thisent;
@@ -163,8 +166,8 @@ static set *tr_inh_trans_set = NULL;
  */
 static int tr_inh_trans_cmp(const void *e1, const void *e2, size_t size)
 {
-	const tr_inh_trans_tp *ef1 = e1;
-	const tr_inh_trans_tp *ef2 = e2;
+	const tr_inh_trans_tp *ef1 = (const tr_inh_trans_tp*)e1;
+	const tr_inh_trans_tp *ef2 = (const tr_inh_trans_tp*)e2;
 	(void) size;
 
 	return ef1->kind != ef2->kind;
@@ -186,11 +189,11 @@ static tr_inh_trans_tp *get_firm_kind_entry(const firm_kind *k)
 
 	if (!tr_inh_trans_set) tr_inh_trans_set = new_set(tr_inh_trans_cmp, 128);
 
-	found = set_find(tr_inh_trans_set, &a, sizeof(a), tr_inh_trans_hash(&a));
+	found = (tr_inh_trans_tp*)set_find(tr_inh_trans_set, &a, sizeof(a), tr_inh_trans_hash(&a));
 	if (!found) {
 		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));
+		found = (tr_inh_trans_tp*)set_insert(tr_inh_trans_set, &a, sizeof(a), tr_inh_trans_hash(&a));
 	}
 	return found;
 }
@@ -233,7 +236,7 @@ static pset *get_type_map(const ir_type *tp, dir d)
 static void compute_down_closure(ir_type *tp)
 {
 	pset *myset, *subset;
-	int i, n_subtypes, n_members, n_supertypes;
+	size_t i, n_subtypes, n_members, n_supertypes;
 	ir_visited_t master_visited = get_master_type_visited();
 
 	assert(is_Class_type(tp));
@@ -262,7 +265,7 @@ static void compute_down_closure(ir_type *tp)
 	n_members = get_class_n_members(tp);
 	for (i = 0; i < n_members; ++i) {
 		ir_entity *mem = get_class_member(tp, i);
-		int j, n_overwrittenby = get_entity_n_overwrittenby(mem);
+		size_t j, n_overwrittenby = get_entity_n_overwrittenby(mem);
 
 		myset = get_entity_map(mem, d_down);
 		for (j = 0; j < n_overwrittenby; ++j) {
@@ -288,7 +291,7 @@ static void compute_down_closure(ir_type *tp)
 static void compute_up_closure(ir_type *tp)
 {
 	pset *myset, *subset;
-	int i, n_subtypes, n_members, n_supertypes;
+	size_t i, n_subtypes, n_members, n_supertypes;
 	ir_visited_t master_visited = get_master_type_visited();
 
 	assert(is_Class_type(tp));
@@ -317,7 +320,7 @@ static void compute_up_closure(ir_type *tp)
 	n_members = get_class_n_members(tp);
 	for (i = 0; i < n_members; ++i) {
 		ir_entity *mem = get_class_member(tp, i);
-		int j, n_overwrites = get_entity_n_overwrites(mem);
+		size_t j, n_overwrites = get_entity_n_overwrites(mem);
 
 		myset = get_entity_map(mem, d_up);
 		for (j = 0; j < n_overwrites; ++j) {
@@ -347,7 +350,7 @@ static void compute_up_closure(ir_type *tp)
  *  transitive closure.    */
 void compute_inh_transitive_closure(void)
 {
-	int i, n_types = get_irp_n_types();
+	size_t i, n_types = get_irp_n_types();
 	free_inh_transitive_closure();
 
 	/* The 'down' relation */
@@ -357,7 +360,7 @@ void compute_inh_transitive_closure(void)
 	for (i = 0; i < n_types; ++i) {
 		ir_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);
+			size_t j, n_subtypes = get_class_n_subtypes(tp);
 			int has_unmarked_subtype = 0;
 
 			assert(get_type_visited(tp) < get_master_type_visited()-1);
@@ -381,7 +384,7 @@ void compute_inh_transitive_closure(void)
 	for (i = 0; i < n_types; ++i) {
 		ir_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);
+			size_t j, n_supertypes = get_class_n_supertypes(tp);
 			int has_unmarked_supertype = 0;
 
 			assert(get_type_visited(tp) < get_master_type_visited()-1);
@@ -408,7 +411,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)) {
+		for (elt = (tr_inh_trans_tp*)set_first(tr_inh_trans_set); elt != NULL;
+		     elt = (tr_inh_trans_tp*)set_next(tr_inh_trans_set)) {
 			del_pset(elt->directions[d_up]);
 			del_pset(elt->directions[d_down]);
 		}
@@ -423,13 +427,13 @@ void free_inh_transitive_closure(void)
 ir_type *get_class_trans_subtype_first(const ir_type *tp)
 {
 	assert_valid_state();
-	return pset_first(get_type_map(tp, d_down));
+	return (ir_type*)pset_first(get_type_map(tp, d_down));
 }
 
 ir_type *get_class_trans_subtype_next(const ir_type *tp)
 {
 	assert_valid_state();
-	return pset_next(get_type_map(tp, d_down));
+	return (ir_type*)pset_next(get_type_map(tp, d_down));
 }
 
 int is_class_trans_subtype(const ir_type *tp, const ir_type *subtp)
@@ -443,13 +447,13 @@ int is_class_trans_subtype(const ir_type *tp, const ir_type *subtp)
 ir_type *get_class_trans_supertype_first(const ir_type *tp)
 {
 	assert_valid_state();
-	return pset_first(get_type_map(tp, d_up));
+	return (ir_type*)pset_first(get_type_map(tp, d_up));
 }
 
 ir_type *get_class_trans_supertype_next(const ir_type *tp)
 {
 	assert_valid_state();
-	return pset_next(get_type_map(tp, d_up));
+	return (ir_type*)pset_next(get_type_map(tp, d_up));
 }
 
 /* - overwrittenby ------------------------------------------------------- */
@@ -457,13 +461,13 @@ ir_type *get_class_trans_supertype_next(const ir_type *tp)
 ir_entity *get_entity_trans_overwrittenby_first(const ir_entity *ent)
 {
 	assert_valid_state();
-	return pset_first(get_entity_map(ent, d_down));
+	return (ir_entity*)pset_first(get_entity_map(ent, d_down));
 }
 
 ir_entity *get_entity_trans_overwrittenby_next(const ir_entity *ent)
 {
 	assert_valid_state();
-	return pset_next(get_entity_map(ent, d_down));
+	return (ir_entity*)pset_next(get_entity_map(ent, d_down));
 }
 
 /* - overwrites ---------------------------------------------------------- */
@@ -473,13 +477,13 @@ ir_entity *get_entity_trans_overwrittenby_next(const ir_entity *ent)
 ir_entity *get_entity_trans_overwrites_first(const ir_entity *ent)
 {
 	assert_valid_state();
-	return pset_first(get_entity_map(ent, d_up));
+	return (ir_entity*)pset_first(get_entity_map(ent, d_up));
 }
 
 ir_entity *get_entity_trans_overwrites_next(const ir_entity *ent)
 {
 	assert_valid_state();
-	return pset_next(get_entity_map(ent, d_up));
+	return (ir_entity*)pset_next(get_entity_map(ent, d_up));
 }
 
 
@@ -490,7 +494,7 @@ ir_entity *get_entity_trans_overwrites_next(const ir_entity *ent)
 /** Returns true if low is subclass of high. */
 static int check_is_SubClass_of(ir_type *low, ir_type *high)
 {
-	int i, n_subtypes;
+	size_t i, n_subtypes;
 
 	/* depth first search from high downwards. */
 	n_subtypes = get_class_n_subtypes(high);
@@ -538,7 +542,7 @@ int is_SubClass_ptr_of(ir_type *low, ir_type *high)
 
 int is_overwritten_by(ir_entity *high, ir_entity *low)
 {
-	int i, n_overwrittenby;
+	size_t i, n_overwrittenby;
 	assert(is_entity(low) && is_entity(high));
 
 	if (get_irp_inh_transitive_closure_state() == inh_transitive_closure_valid) {
@@ -567,9 +571,14 @@ int is_overwritten_by(ir_entity *high, ir_entity *low)
  */
 static ir_entity *do_resolve_ent_polymorphy(ir_type *dynamic_class, ir_entity *static_ent)
 {
-	int i, n_overwrittenby;
+	size_t i, n_overwrittenby;
 
-	if (get_entity_owner(static_ent) == dynamic_class) return static_ent;
+	ir_type *owner = get_entity_owner(static_ent);
+	if (owner == dynamic_class) return static_ent;
+
+	// if the owner of the static_ent already is more special than the dynamic
+	// type to check against - stop here.
+	if (! is_SubClass_of(dynamic_class, owner)) return NULL;
 
 	n_overwrittenby = get_entity_n_overwrittenby(static_ent);
 	for (i = 0; i < n_overwrittenby; ++i) {
@@ -577,7 +586,9 @@ static ir_entity *do_resolve_ent_polymorphy(ir_type *dynamic_class, ir_entity *s
 		ent = do_resolve_ent_polymorphy(dynamic_class, ent);
 		if (ent) return ent;
 	}
-	return NULL;
+
+	// No further specialization of static_ent has been found
+	return static_ent;
 }
 
 /* Resolve polymorphy in the inheritance relation.
@@ -620,8 +631,8 @@ ir_class_cast_state get_irg_class_cast_state(const ir_graph *irg)
 void set_irp_class_cast_state(ir_class_cast_state s)
 {
 #ifndef NDEBUG
-	int i;
-	for (i = get_irp_n_irgs() - 1; i >= 0; --i)
+	size_t i, n;
+	for (i = 0, n = get_irp_n_irgs(); i < n; ++i)
 		assert(get_irg_class_cast_state(get_irp_irg(i)) >= s);
 #endif
 	irp->class_cast_state = s;
@@ -676,14 +687,11 @@ static 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)   ) {
+		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) != (size_t)-1) ||
+		    (get_class_supertype_index(fromtype, totype) != (size_t)-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;
 		}
 	}