/*
- * 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.
*
* @author Goetz Lindenmaier
* @version $Id$
*/
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include "config.h"
-#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. */
/* ----------------------------------------------------------------------- */
-ident *default_mangle_inherited_name(ir_entity *super, ir_type *clss) {
- return mangle_u(new_id_from_str("inh"), mangle_u(get_type_ident(clss), get_entity_ident(super)));
+ident *default_mangle_inherited_name(const ir_entity *super, const ir_type *clss) {
+ return id_mangle_u(new_id_from_str("inh"), id_mangle_u(get_class_ident(clss), get_entity_ident(super)));
}
/** Replicates all entities in all super classes that are not overwritten
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) {
+ if (get_entity_linkage(inhent) & IR_LINKAGE_CONSTANT) {
assert(is_atomic_entity(inhent) && /* @@@ */
"Inheritance of constant, compound entities not implemented");
- set_entity_variability(thisent, variability_constant);
+ add_entity_linkage(thisent, IR_LINKAGE_CONSTANT);
set_atomic_ent_value(thisent, get_atomic_ent_value(inhent));
}
}
} 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;
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);
-}
-*/
/**
static void compute_down_closure(ir_type *tp) {
pset *myset, *subset;
int i, n_subtypes, n_members, n_supertypes;
- unsigned long master_visited = get_master_type_visited();
+ ir_visited_t master_visited = get_master_type_visited();
assert(is_Class_type(tp));
static void compute_up_closure(ir_type *tp) {
pset *myset, *subset;
int i, n_subtypes, n_members, n_supertypes;
- unsigned long master_visited = get_master_type_visited();
+ ir_visited_t master_visited = get_master_type_visited();
assert(is_Class_type(tp));
free_inh_transitive_closure();
/* The 'down' relation */
+ irp_reserve_resources(irp, IR_RESOURCE_TYPE_VISITED);
inc_master_type_visited(); /* Inc twice: one if on stack, second if values computed. */
inc_master_type_visited();
for (i = 0; i < n_types; ++i) {
}
irp->inh_trans_closure_state = inh_transitive_closure_valid;
+ irp_free_resources(irp, IR_RESOURCE_TYPE_VISITED);
}
/** Free memory occupied by the transitive closure information. */
/* - 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));
}
/** 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. */
/* ----------------------------------------------------------------------- */
*
* Returns the dynamically referenced entity if the static entity and the
* dynamic type are given.
- * Search downwards in overwritten tree. */
+ * Search downwards in overwritten tree.
+ */
ir_entity *resolve_ent_polymorphy(ir_type *dynamic_class, ir_entity *static_ent) {
ir_entity *res;
assert(static_ent && is_entity(static_ent));
/* - State handling. ----------------------------------------- */
void set_irg_class_cast_state(ir_graph *irg, ir_class_cast_state s) {
- if (get_irp_class_cast_state() > s) set_irp_class_cast_state(s);
+ if (get_irp_class_cast_state() > s)
+ set_irp_class_cast_state(s);
irg->class_cast_state = s;
}
-ir_class_cast_state get_irg_class_cast_state(ir_graph *irg) {
+ir_class_cast_state get_irg_class_cast_state(const ir_graph *irg) {
return irg->class_cast_state;
}
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;
}
return irp->class_cast_state;
}
-char *get_class_cast_state_string(ir_class_cast_state s) {
+const char *get_class_cast_state_string(ir_class_cast_state s) {
#define X(a) case a: return #a
switch(s) {
X(ir_class_casts_any);
ir_class_cast_state worst_situation;
} ccs_env;
-void verify_irn_class_cast_state(ir_node *n, void *env) {
+/**
+ * Walker: check Casts.
+ */
+static void verify_irn_class_cast_state(ir_node *n, void *env) {
ccs_env *ccs = (ccs_env *)env;
ir_class_cast_state this_state = ir_class_casts_any;
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);
}
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 &&
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)));
}
}
projects / libfirm / blobdiff