- fixed type_or_ent type: get rod of casts

[r20678]

diff --git a/include/libfirm/typerep.h b/include/libfirm/typerep.h
index 6c01a9d..40ab36b 100644 (file)
--- a/include/libfirm/typerep.h
+++ b/include/libfirm/typerep.h
@@ -2565,7 +2565,7 @@ typedef union {
  * @param tore    points to the visited type or entity
  * @param env     free environment pointer
  */
-typedef void type_walk_func(type_or_ent *tore, void *env);
+typedef void type_walk_func(type_or_ent tore, void *env);
 
 /**  The class walk function
  *

diff --git a/ir/ana/rta.c b/ir/ana/rta.c
index d323592..2024337 100644 (file)
--- a/ir/ana/rta.c
+++ b/ir/ana/rta.c
@@ -451,10 +451,10 @@ void rta_init (int do_verbose)
  * Changes the peculiarity of entities that represents
  * dead graphs to peculiarity_description.
  */
-static void make_entity_to_description(type_or_ent *tore, void *env) {
+static void make_entity_to_description(type_or_ent tore, void *env) {
   (void) env;
-  if (get_kind(tore) == k_entity) {
-    ir_entity *ent = (ir_entity *)tore;
+  if (is_entity(tore.ent)) {
+    ir_entity *ent = tore.ent;
 
     if ((is_Method_type(get_entity_type(ent)))                        &&
         (get_entity_peculiarity(ent) != peculiarity_description)      &&

diff --git a/ir/be/bestabs.c b/ir/be/bestabs.c
index e522a55..9a0a6eb 100644 (file)
--- a/ir/be/bestabs.c
+++ b/ir/be/bestabs.c
@@ -469,13 +469,13 @@ static void gen_method_type(wenv_t *env, ir_type *tp) {
  * type-walker: generate declaration for simple types,
  * put all other types on a wait queue
  */
-static void walk_type(type_or_ent *tore, void *ctx)
+static void walk_type(type_or_ent tore, void *ctx)
 {
        wenv_t *env = ctx;
        ir_type  *tp;
 
-       if (get_kind(tore) == k_type) {
-               tp = (ir_type *)tore;
+       if (is_type(tore.typ)) {
+               tp = tore.typ;
 
                /* ignore the unknown type */
                if (tp == firm_unknown_type)

diff --git a/ir/common/firmwalk.c b/ir/common/firmwalk.c
index 418dd32..ff02992 100644 (file)
--- a/ir/common/firmwalk.c
+++ b/ir/common/firmwalk.c
@@ -229,21 +229,21 @@ void *get_firm_walk_link(void *thing)
  *  @param env Environment pointer (currently unused)
  */
 static
-void fw_collect_tore(type_or_ent *tore, void *env)
+void fw_collect_tore(type_or_ent tore, void *env)
 {
   ir_type *tp;
   ir_entity *ent;
 
-  switch (get_kind(tore)) {
+  switch (get_kind(tore.ent)) {
   case k_entity:
-    ent = (ir_entity *)tore;
+    ent = tore.ent;
     /*  append entity to list */
     set_entity_link(ent, NULL);
     if (!pmap_contains(entity_map, ent))
       pmap_insert(entity_map, ent, env);
     break;
   case k_type:
-    tp = (ir_type *)tore;
+    tp = tore.typ;
 
     /*  append type to list */
     set_type_link(tp, NULL);

diff --git a/ir/debug/debugger.c b/ir/debug/debugger.c
index c4c375d..c5cc2fb 100644 (file)
--- a/ir/debug/debugger.c
+++ b/ir/debug/debugger.c
@@ -765,26 +765,25 @@ typedef struct find_env {
 /**
  * Type-walker: Find an entity with given number.
  */
-static void check_ent_nr(type_or_ent *tore, void *ctx) {
-       ir_entity *ent = (ir_entity *)tore;
+static void check_ent_nr(type_or_ent tore, void *ctx) {
        find_env_t *env = ctx;
 
-       if (is_entity(ent))
-               if (get_entity_nr(ent) == env->u.nr) {
-                       env->res = ent;
+       if (is_entity(tore.ent)) {
+               if (get_entity_nr(tore.ent) == env->u.nr) {
+                       env->res = tore.ent;
                }
+       }
 }  /* check_ent_nr */
 
 /**
  * Type-walker: Find an entity with given name.
  */
-static void check_ent_name(type_or_ent *tore, void *ctx) {
-       ir_entity *ent = (ir_entity *)tore;
+static void check_ent_name(type_or_ent tore, void *ctx) {
        find_env_t *env = ctx;
 
-       if (is_entity(ent))
-               if (strcmp(get_entity_name(ent), env->u.name) == 0) {
-                       env->res = ent;
+       if (is_entity(tore.ent))
+               if (strcmp(get_entity_name(tore.ent), env->u.name) == 0) {
+                       env->res = tore.ent;
                }
 }  /* check_ent_name */
 
@@ -843,11 +842,11 @@ static void show_by_name(type_or_ent *tore, void *env) {
 /**
  * Search methods for a ldname.
  */
-static void show_by_ldname(type_or_ent *tore, void *env) {
+static void show_by_ldname(type_or_ent tore, void *env) {
        ident *id = (ident *)env;
 
-       if (is_entity(tore)) {
-               ir_entity *ent = (ir_entity *)tore;
+       if (is_entity(tore.ent)) {
+               ir_entity *ent = tore.ent;
 
                if (is_method_entity(ent)) {
                        if (get_entity_ld_ident(ent) == id) {

diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c
index dc43bec..c96bdb8 100644 (file)
--- a/ir/ir/irdump.c
+++ b/ir/ir/irdump.c
@@ -2042,15 +2042,15 @@ static void dump_enum_item(FILE *F, ir_type *tp, int pos)
 
 /* dumps a type or entity and it's edges. */
 static void
-dump_type_info(type_or_ent *tore, void *env) {
+dump_type_info(type_or_ent tore, void *env) {
        FILE *F = env;
        int i = 0;  /* to shutup gcc */
 
        /* dump this type or entity */
 
-       switch (get_kind(tore)) {
+       switch (get_kind(tore.ent)) {
        case k_entity: {
-               ir_entity *ent = (ir_entity *)tore;
+               ir_entity *ent = tore.ent;
                ir_node *value;
                /* The node */
                dump_entity_node(F, ent, 0);
@@ -2092,7 +2092,7 @@ dump_type_info(type_or_ent *tore, void *env) {
                break;
        }
        case k_type: {
-               ir_type *tp = (ir_type *)tore;
+               ir_type *tp = tore.typ;
                dump_type_node(F, tp);
                /* and now the edges */
                switch (get_type_tpop_code(tp)) {
@@ -2159,17 +2159,18 @@ typedef struct _h_env {
  * If env->dump_ent dumps entities of classes and overwrites edges.
  */
 static void
-dump_class_hierarchy_node(type_or_ent *tore, void *ctx) {
+dump_class_hierarchy_node(type_or_ent tore, void *ctx) {
        h_env_t *env = ctx;
        FILE *F = env->f;
        int i = 0;  /* to shutup gcc */
 
        /* dump this type or entity */
-       switch (get_kind(tore)) {
+       switch (get_kind(tore.ent)) {
        case k_entity: {
-               ir_entity *ent = (ir_entity *)tore;
+               ir_entity *ent = tore.ent;
                if (get_entity_owner(ent) == get_glob_type()) break;
-               if (!is_Method_type(get_entity_type(ent))) break;  /* GL */
+               if (!is_Method_type(get_entity_type(ent)))
+                       break;  /* GL */
                if (env->dump_ent && is_Class_type(get_entity_owner(ent))) {
                        /* The node */
                        dump_entity_node(F, ent, 0);
@@ -2181,8 +2182,9 @@ dump_class_hierarchy_node(type_or_ent *tore, void *ctx) {
                break;
        }
        case k_type: {
-               ir_type *tp = (ir_type *)tore;
-               if (tp == get_glob_type()) break;
+               ir_type *tp = tore.typ;
+               if (tp == get_glob_type())
+                       break;
                switch (get_type_tpop_code(tp)) {
                case tpo_class:
                        dump_type_node(F, tp);

diff --git a/ir/lower/lower_calls.c b/ir/lower/lower_calls.c
index b8d0de4..8c9fc67 100644 (file)
--- a/ir/lower/lower_calls.c
+++ b/ir/lower/lower_calls.c
@@ -808,14 +808,14 @@ static int must_be_lowered(const lower_params_t *lp, ir_type *tp) {
  * type-walker: lower all method types of entities
  * and points-to types.
  */
-static void lower_method_types(type_or_ent *tore, void *env)
+static void lower_method_types(type_or_ent tore, void *env)
 {
        const lower_params_t *lp = env;
        ir_type *tp;
 
        /* fix method entities */
-       if (is_entity(tore)) {
-               ir_entity *ent = (ir_entity *)tore;
+       if (is_entity(tore.ent)) {
+               ir_entity *ent = tore.ent;
                tp = get_entity_type(ent);
 
                if (must_be_lowered(lp, tp)) {
@@ -823,7 +823,7 @@ static void lower_method_types(type_or_ent *tore, void *env)
                        set_entity_type(ent, tp);
                }
        } else {
-               tp = (ir_type *)tore;
+               tp = tore.typ;
 
                /* fix pointer to methods */
                if (is_Pointer_type(tp)) {

diff --git a/ir/opt/ircgopt.c b/ir/opt/ircgopt.c
index b462fc6..17baa91 100644 (file)
--- a/ir/opt/ircgopt.c
+++ b/ir/opt/ircgopt.c
@@ -63,9 +63,9 @@ static void collect_call(ir_node *node, void *env) {
  * Type walker, set the peculiarity of entities which graphs
  * gets removed to peculiarity_description.
  */
-static void make_entity_to_description(type_or_ent *tore, void *env) {
-       if (get_kind(tore) == k_entity) {
-               ir_entity *ent = (ir_entity *)tore;
+static void make_entity_to_description(type_or_ent tore, void *env) {
+       if (is_entity(tore.ent)) {
+               ir_entity *ent = tore.ent;
 
                if ((is_Method_type(get_entity_type(ent)))                        &&
                        (get_entity_peculiarity(ent) != peculiarity_description)      &&

diff --git a/ir/tr/trvrfy.c b/ir/tr/trvrfy.c
index ae2bc4a..d3024a3 100644 (file)
--- a/ir/tr/trvrfy.c
+++ b/ir/tr/trvrfy.c
@@ -417,14 +417,14 @@ int check_entity(ir_entity *ent) {
 /*
  * check types and entities
  */
-static void check_tore(type_or_ent *tore, void *env) {
+static void check_tore(type_or_ent tore, void *env) {
        int *res = env;
-       assert(tore);
-       if (is_type(tore)) {
-               *res = check_type((ir_type *)tore);
+       assert(tore.ent);
+       if (is_type(tore.typ)) {
+               *res = check_type(tore.typ);
        } else {
-               assert(is_entity(tore));
-               *res = check_entity((ir_entity *)tore);
+               assert(is_entity(tore.ent));
+               *res = check_entity(tore.ent);
        }
 }
 

diff --git a/ir/tr/type_finalization.c b/ir/tr/type_finalization.c
index ede6aff..8e8899d 100644 (file)
--- a/ir/tr/type_finalization.c
+++ b/ir/tr/type_finalization.c
@@ -36,11 +36,11 @@
 
 DEBUG_ONLY(static firm_dbg_module_t *dbg;)
 
-static void do_finalization(type_or_ent *tore, void *env) {
+static void do_finalization(type_or_ent tore, void *env) {
        ir_type *glob_tp = env;
 
-       if (is_type(tore)) {
-               ir_type *cls = (ir_type *)tore;
+       if (is_type(tore.typ)) {
+               ir_type *cls = tore.typ;
 
                if (! is_Class_type(cls) || cls == glob_tp)
                        return;
@@ -55,7 +55,7 @@ static void do_finalization(type_or_ent *tore, void *env) {
                                get_type_name(cls)));
                }
        } else {
-               ir_entity *ent = (ir_entity *)tore;
+               ir_entity *ent = tore.ent;
                ir_type *owner;
 
                if (is_entity_final(ent))

diff --git a/ir/tr/typewalk.c b/ir/tr/typewalk.c
index 5ac0c35..6369474 100644 (file)
--- a/ir/tr/typewalk.c
+++ b/ir/tr/typewalk.c
@@ -90,25 +90,28 @@ static void walk_initializer(ir_initializer_t *initializer,
  * Main walker: walks over all used types/entities of a
  * type entity.
  */
-static void do_type_walk(type_or_ent *tore,
+static void do_type_walk(type_or_ent tore,
                          type_walk_func *pre,
                          type_walk_func *post,
                          void *env)
 {
-       int       i, n_types, n_mem;
-       ir_entity *ent = NULL;
-       ir_type   *tp = NULL;
-       ir_node   *n;
+       int         i, n_types, n_mem;
+       ir_entity   *ent = NULL;
+       ir_type     *tp = NULL;
+       ir_node     *n;
+       type_or_ent cont;
 
        /* marked? */
-       switch (get_kind(tore)) {
+       switch (get_kind(tore.ent)) {
        case k_entity:
-               ent = (ir_entity *)tore;
-               if (entity_visited(ent)) return;
+               ent = tore.ent;
+               if (entity_visited(ent))
+                       return;
                break;
        case k_type:
-               tp = skip_tid((ir_type *)tore);
-               if (type_visited(tp)) return;
+               tp = skip_tid(tore.typ);
+               if (type_visited(tp))
+                       return;
                break;
        default:
                break;
@@ -119,11 +122,13 @@ static void do_type_walk(type_or_ent *tore,
                pre(tore, env);
 
        /* iterate */
-       switch (get_kind(tore)) {
+       switch (get_kind(tore.ent)) {
        case k_entity:
                mark_entity_visited(ent);
-               do_type_walk((type_or_ent *)get_entity_owner(ent), pre, post, env);
-               do_type_walk((type_or_ent *)get_entity_type(ent), pre, post, env);
+               cont.typ = get_entity_owner(ent);
+               do_type_walk(cont, pre, post, env);
+               cont.typ = get_entity_type(ent);
+               do_type_walk(cont, pre, post, env);
 
                if (get_entity_variability(ent) != variability_uninitialized) {
                        /* walk over the value types */
@@ -147,45 +152,56 @@ static void do_type_walk(type_or_ent *tore,
 
                case tpo_class:
                        n_types = get_class_n_supertypes(tp);
-                       for (i = 0; i < n_types; ++i)
-                               do_type_walk((type_or_ent *)get_class_supertype(tp, i), pre, post, env);
-
+                       for (i = 0; i < n_types; ++i) {
+                               cont.typ = get_class_supertype(tp, i);
+                               do_type_walk(cont, pre, post, env);
+                       }
                        n_mem = get_class_n_members(tp);
-                       for (i = 0; i < n_mem; ++i)
-                               do_type_walk((type_or_ent *)get_class_member(tp, i), pre, post, env);
-
+                       for (i = 0; i < n_mem; ++i) {
+                               cont.ent = get_class_member(tp, i);
+                               do_type_walk(cont, pre, post, env);
+                       }
                        n_types = get_class_n_subtypes(tp);
-                       for (i = 0; i < n_types; ++i)
-                               do_type_walk((type_or_ent *)get_class_subtype(tp, i), pre, post, env);
+                       for (i = 0; i < n_types; ++i) {
+                               cont.typ = get_class_subtype(tp, i);
+                               do_type_walk(cont, pre, post, env);
+                       }
                        break;
 
                case tpo_struct:
                        n_mem = get_struct_n_members(tp);
-                       for (i = 0; i < n_mem; ++i)
-                               do_type_walk((type_or_ent *)get_struct_member(tp, i), pre, post, env);
+                       for (i = 0; i < n_mem; ++i) {
+                               cont.ent = get_struct_member(tp, i);
+                               do_type_walk(cont, pre, post, env);
+                       }
                        break;
 
                case tpo_method:
                        n_mem = get_method_n_params(tp);
-                       for (i = 0; i < n_mem; ++i)
-                               do_type_walk((type_or_ent *)get_method_param_type(tp, i), pre, post, env);
-
+                       for (i = 0; i < n_mem; ++i) {
+                               cont.typ = get_method_param_type(tp, i);
+                               do_type_walk(cont, pre, post, env);
+                       }
                        n_mem = get_method_n_ress(tp);
-                       for (i = 0; i < n_mem; ++i)
-                               do_type_walk((type_or_ent *)get_method_res_type(tp, i), pre, post, env);
+                       for (i = 0; i < n_mem; ++i) {
+                               cont.typ = get_method_res_type(tp, i);
+                               do_type_walk(cont, pre, post, env);
+                       }
                        break;
 
                case tpo_union:
                        n_mem = get_union_n_members(tp);
-                       for (i = 0; i < n_mem; ++i)
-                               do_type_walk((type_or_ent *)get_union_member(tp, i), pre, post, env);
+                       for (i = 0; i < n_mem; ++i) {
+                               cont.ent = get_union_member(tp, i);
+                               do_type_walk(cont, pre, post, env);
+                       }
                        break;
 
                case tpo_array:
-                       do_type_walk((type_or_ent *)get_array_element_type(tp),
-                               pre, post, env);
-                       do_type_walk((type_or_ent *)get_array_element_entity(tp),
-                               pre, post, env);
+                       cont.typ = get_array_element_type(tp);
+                       do_type_walk(cont, pre, post, env);
+                       cont.ent = get_array_element_entity(tp);
+                       do_type_walk(cont, pre, post, env);
                        break;
 
                case tpo_enumeration:
@@ -193,8 +209,8 @@ static void do_type_walk(type_or_ent *tore,
                        break;
 
                case tpo_pointer:
-                       do_type_walk((type_or_ent *)get_pointer_points_to_type(tp),
-                               pre, post, env);
+                       cont.typ = get_pointer_points_to_type(tp);
+                       do_type_walk(cont, pre, post, env);
                        break;
 
                case tpo_primitive:
@@ -226,17 +242,16 @@ static void do_type_walk(type_or_ent *tore,
 static void irn_type_walker(
   ir_node *node, type_walk_func *pre, type_walk_func *post, void *env)
 {
-       ir_entity *ent;
-       ir_type *tp;
+       type_or_ent cont;
 
        assert(node);
 
-       ent = get_irn_entity_attr(node);
-       if (ent)
-               do_type_walk((type_or_ent *)ent, pre, post, env);
-       tp  = get_irn_type_attr(node);
-       if (tp)
-               do_type_walk((type_or_ent *)tp, pre, post, env);
+       cont.ent = get_irn_entity_attr(node);
+       if (cont.ent)
+               do_type_walk(cont, pre, post, env);
+       cont.typ = get_irn_type_attr(node);
+       if (cont.typ)
+               do_type_walk(cont, pre, post, env);
 }
 
 /**  Check whether node contains types or entities as an attribute.
@@ -256,13 +271,16 @@ static void start_type_walk(ir_node *node, void *ctx) {
 
 /* walker: walks over all types */
 void type_walk(type_walk_func *pre, type_walk_func *post, void *env) {
-       int i, n_types = get_irp_n_types();
+       int         i, n_types = get_irp_n_types();
+       type_or_ent cont;
 
        inc_master_type_visited();
        for (i = 0; i < n_types; ++i) {
-               do_type_walk((type_or_ent *)get_irp_type(i), pre, post, env);
+               cont.typ = get_irp_type(i);
+               do_type_walk(cont, pre, post, env);
        }
-       do_type_walk((type_or_ent *)get_glob_type(), pre, post, env);
+       cont.typ = get_glob_type();
+       do_type_walk(cont, pre, post, env);
 }
 
 void type_walk_irg(ir_graph *irg,
@@ -274,6 +292,7 @@ void type_walk_irg(ir_graph *irg,
        /* this is needed to pass the parameters to the walker that actually
           walks the type information */
        type_walk_env type_env;
+       type_or_ent   cont;
 
        type_env.pre  = pre;
        type_env.post = post;
@@ -281,10 +300,10 @@ void type_walk_irg(ir_graph *irg,
 
        current_ir_graph = irg;
 
-       /* We walk over the irg to find all irnodes that contain an attribute
+       /* We walk over the irg to find all IR-nodes that contain an attribute
           with type information.  If we find one we call a type walker to
           touch the reachable type information.
-          The same type can be referenced by several irnodes.  To avoid
+          The same type can be referenced by several IR-nodes.  To avoid
           repeated visits of the same type node we must decrease the
           type visited flag for each walk.  This is done in start_type_walk().
           Here we initially increase the flag.  We only call do_type_walk that does
@@ -293,58 +312,64 @@ void type_walk_irg(ir_graph *irg,
        inc_master_type_visited();
        irg_walk(get_irg_end(irg), start_type_walk, NULL, &type_env);
 
-       do_type_walk((type_or_ent *)get_irg_entity(irg), pre, post, env);
+       cont.ent = get_irg_entity(irg);
+       do_type_walk(cont, pre, post, env);
 
-       do_type_walk((type_or_ent *)get_irg_frame_type(irg), pre, post, env);
+       cont.typ = get_irg_frame_type(irg);
+       do_type_walk(cont, pre, post, env);
 
        current_ir_graph = rem;
        return;
 }
 
-static void type_walk_s2s_2(type_or_ent *tore,
+static void type_walk_s2s_2(type_or_ent tore,
                             type_walk_func *pre,
                             type_walk_func *post,
                             void *env)
 {
-       int i, n;
+       type_or_ent cont;
+       int         i, n;
 
        /* marked? */
-       switch (get_kind(tore)) {
+       switch (get_kind(tore.ent)) {
        case k_entity:
-               if (entity_visited((ir_entity *)tore)) return;
+               if (entity_visited(tore.ent)) return;
                break;
        case k_type:
-               if (type_id == get_type_tpop((ir_type*)tore)) {
-                       type_walk_s2s_2((type_or_ent *)skip_tid((ir_type *)tore), pre, post, env);
+               if (type_id == get_type_tpop(tore.typ)) {
+                       cont.typ = skip_tid(tore.typ);
+                       type_walk_s2s_2(cont, pre, post, env);
                        return;
                }
-               if (type_visited((ir_type *)tore)) return;
+               if (type_visited(tore.typ)) return;
                break;
        default:
                break;
        }
 
        /* iterate */
-       switch (get_kind(tore)) {
+       switch (get_kind(tore.typ)) {
        case k_type:
                {
-                       ir_type *tp = (ir_type *)tore;
+                       ir_type *tp = tore.typ;
                        mark_type_visited(tp);
                        switch (get_type_tpop_code(tp)) {
                        case tpo_class:
                                {
                                        n = get_class_n_supertypes(tp);
                                        for (i = 0; i < n; ++i) {
-                                               type_walk_s2s_2((type_or_ent *)get_class_supertype(tp, i), pre, post, env);
+                                               cont.typ = get_class_supertype(tp, i);
+                                               type_walk_s2s_2(cont, pre, post, env);
                                        }
                                        /* execute pre method */
                                        if (pre)
                                                pre(tore, env);
-                                       tp = skip_tid((ir_type*)tore);
+                                       tp = skip_tid(tp);
 
                                        n = get_class_n_subtypes(tp);
                                        for (i = 0; i < n; ++i) {
-                                               type_walk_s2s_2((type_or_ent *)get_class_subtype(tp, i), pre, post, env);
+                                               cont.typ = get_class_subtype(tp, i);
+                                               type_walk_s2s_2(cont, pre, post, env);
                                        }
 
                                        /* execute post method */
@@ -368,7 +393,7 @@ static void type_walk_s2s_2(type_or_ent *tore,
                        }
                } break; /* end case k_type */
        case k_entity:
-               /* dont care */
+               /* don't care */
                break;
        default:
                printf(" *** Faulty type or entity! \n");
@@ -381,47 +406,52 @@ void type_walk_super2sub(type_walk_func *pre,
                          type_walk_func *post,
                          void *env)
 {
-       int i, n_types = get_irp_n_types();
-       ir_type *tp;
+       type_or_ent cont;
+       int         i, n_types = get_irp_n_types();
 
        inc_master_type_visited();
-       type_walk_s2s_2((type_or_ent *)get_glob_type(), pre, post, env);
+       cont.typ = get_glob_type();
+       type_walk_s2s_2(cont, pre, post, env);
        for (i = 0; i < n_types; ++i) {
-               tp = get_irp_type(i);
-               type_walk_s2s_2((type_or_ent *)tp, pre, post, env);
+               cont.typ = get_irp_type(i);
+               type_walk_s2s_2(cont, pre, post, env);
        }
 }
 
 /*****************************************************************************/
 
 static void
-type_walk_super_2(type_or_ent *tore,
+type_walk_super_2(type_or_ent tore,
                   type_walk_func *pre,
                   type_walk_func *post,
                   void *env) {
-       int i, n;
+       type_or_ent cont;
+       int         i, n;
 
        /* marked? */
-       switch (get_kind(tore)) {
+       switch (get_kind(tore.ent)) {
        case k_entity:
-               if (entity_visited((ir_entity *)tore)) return;
+               if (entity_visited(tore.ent))
+                       return;
                break;
        case k_type:
-               if (type_id == get_type_tpop((ir_type*)tore)) {
-                       type_walk_super_2((type_or_ent *)skip_tid((ir_type *)tore), pre, post, env);
+               if (type_id == get_type_tpop(tore.typ)) {
+                       cont.typ = skip_tid(tore.typ);
+                       type_walk_super_2(cont, pre, post, env);
                        return;
                }
-               if (type_visited((ir_type *)tore)) return;
+               if (type_visited(tore.typ))
+                       return;
                break;
        default:
                break;
        }
 
        /* iterate */
-       switch (get_kind(tore)) {
+       switch (get_kind(tore.typ)) {
        case k_type:
                {
-                       ir_type *tp = (ir_type *)tore;
+                       ir_type *tp = tore.typ;
                        mark_type_visited(tp);
                        switch (get_type_tpop_code(tp)) {
                        case tpo_class:
@@ -429,12 +459,12 @@ type_walk_super_2(type_or_ent *tore,
                                        /* execute pre method */
                                        if (pre)
                                                pre(tore, env);
-                                       tp = skip_tid((ir_type*)tore);
+                                       tp = skip_tid(tp);
 
                                        n = get_class_n_supertypes(tp);
                                        for (i = 0; i < n; ++i) {
-                                               type_walk_super_2((type_or_ent *)get_class_supertype(tp, i), pre,
-                                                       post, env);
+                                               cont.typ = get_class_supertype(tp, i);
+                                               type_walk_super_2(cont, pre, post, env);
                                        }
 
                                        /* execute post method */
@@ -450,7 +480,7 @@ type_walk_super_2(type_or_ent *tore,
                        case tpo_pointer:
                        case tpo_primitive:
                        case tpo_id:
-                               /* dont care */
+                               /* don't care */
                                break;
                        default:
                                printf(" *** Faulty type! \n");
@@ -458,7 +488,7 @@ type_walk_super_2(type_or_ent *tore,
                        }
                } break; /* end case k_type */
        case k_entity:
-               /* dont care */
+               /* don't care */
                break;
        default:
                printf(" *** Faulty type or entity! \n");
@@ -470,14 +500,15 @@ type_walk_super_2(type_or_ent *tore,
 void type_walk_super(type_walk_func *pre,
                      type_walk_func *post,
                      void *env) {
-       int i, n_types = get_irp_n_types();
-       ir_type *tp;
+       int         i, n_types = get_irp_n_types();
+       type_or_ent cont;
 
        inc_master_type_visited();
-       type_walk_super_2((type_or_ent *)get_glob_type(), pre, post, env);
+       cont.typ = get_glob_type();
+       type_walk_super_2(cont, pre, post, env);
        for (i = 0; i < n_types; ++i) {
-               tp = get_irp_type(i);
-               type_walk_super_2((type_or_ent *)tp, pre, post, env);
+               cont.typ = get_irp_type(i);
+               type_walk_super_2(cont, pre, post, env);
        }
 }