X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Ftr%2Ftr_inheritance.c;h=bceae17d6e9b760f18824019cadb938cce8354a1;hb=f4e5f09589f68012dbd8007389366dd992f7a7c5;hp=b8aabd7fe2a875676bbc21b9454423526c49eeef;hpb=02a879a0c7b7fc0873d5637e633d188856048abc;p=libfirm

diff --git a/ir/tr/tr_inheritance.c b/ir/tr/tr_inheritance.c
index b8aabd7fe..bceae17d6 100644
--- a/ir/tr/tr_inheritance.c
+++ b/ir/tr/tr_inheritance.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -27,17 +27,17 @@
 # include "config.h"
 #endif
 
-#include "type.h"
-#include "entity.h"
-#include "typewalk.h"
+#include "debug.h"
+#include "typerep.h"
 #include "irgraph_t.h"
 #include "irprog_t.h"
+#include "irprintf.h"
 #include "pset.h"
 #include "set.h"
-#include "mangle.h"
 #include "irgwalk.h"
 #include "irflag.h"
 
+DEBUG_ONLY(static firm_dbg_module_t *dbg);
 
 /* ----------------------------------------------------------------------- */
 /* Resolve implicit inheritance.                                           */
@@ -147,26 +147,33 @@ typedef enum {
 } dir;
 
 typedef struct {
-	firm_kind *kind;   /* An entity or type. */
+	const firm_kind *kind;   /**< An entity or type. */
 	pset *directions[2];
 } tr_inh_trans_tp;
 
 /* We use this set for all types and entities.  */
 static set *tr_inh_trans_set = NULL;
 
+/**
+ * Compare two tr_inh_trans_tp entries.
+ */
 static int tr_inh_trans_cmp(const void *e1, const void *e2, size_t size) {
-	tr_inh_trans_tp *ef1 = (tr_inh_trans_tp *)e1;
-	tr_inh_trans_tp *ef2 = (tr_inh_trans_tp *)e2;
-	return (ef1->kind != ef2->kind);
+	const tr_inh_trans_tp *ef1 = e1;
+	const tr_inh_trans_tp *ef2 = e2;
+	(void) size;
+
+	return ef1->kind != ef2->kind;
 }
 
-static INLINE unsigned int tr_inh_trans_hash(void *e) {
-	tr_inh_trans_tp *v = e;
+/**
+ * calculate the hash value of an tr_inh_trans_tp
+ */
+static INLINE unsigned int tr_inh_trans_hash(const tr_inh_trans_tp *v) {
 	return HASH_PTR(v->kind);
 }
 
 /* This always completes successfully. */
-static tr_inh_trans_tp* get_firm_kind_entry(firm_kind *k) {
+static tr_inh_trans_tp *get_firm_kind_entry(const firm_kind *k) {
 	tr_inh_trans_tp a, *found;
 	a.kind = k;
 
@@ -181,38 +188,21 @@ static tr_inh_trans_tp* get_firm_kind_entry(firm_kind *k) {
 	return found;
 }
 
-static pset *get_entity_map(ir_entity *ent, dir d) {
+static pset *get_entity_map(const ir_entity *ent, dir d) {
 	tr_inh_trans_tp *found;
 
 	assert(is_entity(ent));
-	found = get_firm_kind_entry((firm_kind *)ent);
+	found = get_firm_kind_entry((const firm_kind *)ent);
 	return found->directions[d];
 }
-/*
-static void  add_entity_map(ir_entity *ent, dir d, ir_entity *new) {
-	tr_inh_trans_tp *found;
 
-	assert(is_entity(ent) && is_entity(new));
-	tr_inh_trans_tp *found = get_firm_kind_entry((firm_kind *)ent);
-	pset_insert_ptr(found->directions[d], new);
-}
-*/
-static pset *get_type_map(ir_type *tp, dir d) {
+static pset *get_type_map(const ir_type *tp, dir d) {
 	tr_inh_trans_tp *found;
 
 	assert(is_type(tp));
-	found = get_firm_kind_entry((firm_kind *)tp);
+	found = get_firm_kind_entry((const firm_kind *)tp);
 	return found->directions[d];
 }
-/*
-static void  add_type_map(ir_type *tp, dir d, type *new) {
-	tr_inh_trans_tp *found;
-
-	assert(is_type(tp) && is_type(new));
-	found = get_firm_kind_entry((firm_kind *)tp);
-	pset_insert_ptr(found->directions[d], new);
-}
-*/
 
 
 /**
@@ -415,41 +405,41 @@ void free_inh_transitive_closure(void) {
 
 /* - subtype ------------------------------------------------------------- */
 
-ir_type *get_class_trans_subtype_first(ir_type *tp) {
+ir_type *get_class_trans_subtype_first(const ir_type *tp) {
 	assert_valid_state();
 	return pset_first(get_type_map(tp, d_down));
 }
 
-ir_type *get_class_trans_subtype_next (ir_type *tp) {
+ir_type *get_class_trans_subtype_next(const ir_type *tp) {
 	assert_valid_state();
 	return pset_next(get_type_map(tp, d_down));
 }
 
-int is_class_trans_subtype (ir_type *tp, ir_type *subtp) {
+int is_class_trans_subtype(const ir_type *tp, const ir_type *subtp) {
 	assert_valid_state();
 	return (pset_find_ptr(get_type_map(tp, d_down), subtp) != NULL);
 }
 
 /* - supertype ----------------------------------------------------------- */
 
-ir_type *get_class_trans_supertype_first(ir_type *tp) {
+ir_type *get_class_trans_supertype_first(const ir_type *tp) {
 	assert_valid_state();
 	return pset_first(get_type_map(tp, d_up));
 }
 
-ir_type *get_class_trans_supertype_next (ir_type *tp) {
+ir_type *get_class_trans_supertype_next(const ir_type *tp) {
 	assert_valid_state();
 	return pset_next(get_type_map(tp, d_up));
 }
 
 /* - overwrittenby ------------------------------------------------------- */
 
-ir_entity *get_entity_trans_overwrittenby_first(ir_entity *ent) {
+ir_entity *get_entity_trans_overwrittenby_first(const ir_entity *ent) {
 	assert_valid_state();
 	return pset_first(get_entity_map(ent, d_down));
 }
 
-ir_entity *get_entity_trans_overwrittenby_next (ir_entity *ent) {
+ir_entity *get_entity_trans_overwrittenby_next(const ir_entity *ent) {
 	assert_valid_state();
 	return pset_next(get_entity_map(ent, d_down));
 }
@@ -458,20 +448,17 @@ ir_entity *get_entity_trans_overwrittenby_next (ir_entity *ent) {
 
 
 /** Iterate over all transitive overwritten entities. */
-ir_entity *get_entity_trans_overwrites_first(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));
 }
 
-ir_entity *get_entity_trans_overwrites_next (ir_entity *ent) {
+ir_entity *get_entity_trans_overwrites_next(const ir_entity *ent) {
 	assert_valid_state();
 	return pset_next(get_entity_map(ent, d_up));
 }
 
 
-
-
-
 /* ----------------------------------------------------------------------- */
 /* Classify pairs of types/entities in the inheritance relations.          */
 /* ----------------------------------------------------------------------- */
@@ -597,9 +584,11 @@ ir_class_cast_state get_irg_class_cast_state(ir_graph *irg) {
 }
 
 void set_irp_class_cast_state(ir_class_cast_state s) {
+#ifndef NDEBUG
 	int i;
-	for (i = 0; i < get_irp_n_irgs(); ++i)
+	for (i = get_irp_n_irgs() - 1; i >= 0; --i)
 		assert(get_irg_class_cast_state(get_irp_irg(i)) >= s);
+#endif
 	irp->class_cast_state = s;
 }
 
@@ -632,7 +621,7 @@ void verify_irn_class_cast_state(ir_node *n, void *env) {
 	ir_type             *fromtype, *totype;
 	int                 ref_depth = 0;
 
-	if (get_irn_op(n) != op_Cast) return;
+	if (!is_Cast(n)) return;
 
 	fromtype = get_irn_typeinfo_type(get_Cast_op(n));
 	totype   = get_Cast_type(n);
@@ -659,10 +648,10 @@ void verify_irn_class_cast_state(ir_node *n, void *env) {
 	}
 
 	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",
+		ir_printf("  Node is %+F\n", n);
+		ir_printf("    totype   %+F\n", totype);
+		ir_printf("    fromtype %+F\n", fromtype);
+		ir_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 &&
@@ -673,21 +662,22 @@ void verify_irn_class_cast_state(ir_node *n, void *env) {
 		ccs->worst_situation = this_state;
 }
 
-
 /** Verify that the graph meets requirements of state set. */
 void verify_irg_class_cast_state(ir_graph *irg) {
 	ccs_env env;
 
+	FIRM_DBG_REGISTER(dbg, "firm.tr.inheritance");
+
 	env.expected_state  = get_irg_class_cast_state(irg);
 	env.worst_situation = ir_class_casts_normalized;
 
 	irg_walk_graph(irg, NULL, verify_irn_class_cast_state, &env);
 
-	if ((env.worst_situation > env.expected_state) && get_firm_verbosity()) {
-		printf("Note:  class cast state is set lower than reqired in graph\n       ");
-		DDMG(irg);
-		printf("       state is %s, reqired is %s\n",
+	if ((env.worst_situation > env.expected_state)) {
+		DB((dbg, LEVEL_1, "Note:  class cast state is set lower than reqired "
+		    "in graph \n\t%+F\n", irg));
+		DB((dbg, LEVEL_1, "       state is %s, reqired is %s\n",
 			get_class_cast_state_string(env.expected_state),
-			get_class_cast_state_string(env.worst_situation));
+			get_class_cast_state_string(env.worst_situation)));
 	}
 }