X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;ds=sidebyside;f=ir%2Ftr%2Ftypewalk.c;h=c510a4e0fbb5d6d23c3b01144de3686169d8155c;hb=226c238839ce84c2c310c8e7522838160c6f71af;hp=99bcdd466d100e2a57293677ac2c6e2c88e09ff3;hpb=6c1a97fd2c011beb75d9ae7f0746dd6bd22ce064;p=libfirm diff --git a/ir/tr/typewalk.c b/ir/tr/typewalk.c index 99bcdd466..c510a4e0f 100644 --- a/ir/tr/typewalk.c +++ b/ir/tr/typewalk.c @@ -1,190 +1,206 @@ /* - * Project: libFIRM - * File name: ir/tr/typewalk.c - * Purpose: Traverse the type information. - * Author: Goetz Lindenmaier - * Modified by: - * Created: - * CVS-ID: $Id$ - * Copyright: (c) 1999-2003 Universität Karlsruhe - * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + * This file is part of libFirm. + * Copyright (C) 2012 University of Karlsruhe. */ /** - * @file typewalk.c + * @file + * @brief Functionality to modify the type graph. + * @author Goetz Lindenmaier + * @brief * * Traverse the type information. The walker walks the whole ir graph * to find the distinct type trees in the type graph forest. * - execute the pre function before recursion * - execute the post function after recursion */ +#include "config.h" -#ifdef HAVE_CONFIG_H -# include "config.h" -#endif - -#ifdef HAVE_STDLIB_H -# include -#endif - +#include #include -#include "typewalk.h" #include "entity_t.h" #include "type_t.h" -#include "type_or_entity.h" -#include "typegmod.h" #include "irprog_t.h" #include "irgraph_t.h" #include "irnode_t.h" #include "irgwalk.h" +#include "error.h" +#include "ircons.h" /** * The walker environment */ typedef struct type_walk_env { - type_walk_func *pre; /**< Pre-walker function */ - type_walk_func *post; /**< Post-walker function */ - void *env; /**< environment for walker functions */ + type_walk_func *pre; /**< Pre-walker function */ + type_walk_func *post; /**< Post-walker function */ + void *env; /**< environment for walker functions */ } type_walk_env; /* a walker for irn's */ static void irn_type_walker( - ir_node *node, type_walk_func *pre, type_walk_func *post, void *env); + ir_node *node, type_walk_func *pre, type_walk_func *post, void *env); + +static void walk_initializer(ir_initializer_t *initializer, + type_walk_func *pre, type_walk_func *post, + void *env) +{ + switch (initializer->kind) { + case IR_INITIALIZER_CONST: + irn_type_walker(initializer->consti.value, pre, post, env); + return; + case IR_INITIALIZER_TARVAL: + case IR_INITIALIZER_NULL: + return; + + case IR_INITIALIZER_COMPOUND: { + size_t i; + for (i = 0; i < initializer->compound.n_initializers; ++i) { + ir_initializer_t *subinitializer + = initializer->compound.initializers[i]; + walk_initializer(subinitializer, pre, post, env); + } + return; + } + } + panic("invalid initializer found"); +} /** * Main walker: walks over all used types/entities of a * type entity. */ -static void do_type_walk(type_or_ent *tore, - type_walk_func *pre, - type_walk_func *post, - void *env) +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; - entity *ent = NULL; - ir_type *tp = NULL; - ir_node *n; - - /* marked? */ - switch (get_kind(tore)) { - case k_entity: - ent = (entity *)tore; - if (entity_visited(ent)) return; - break; - case k_type: - tp = skip_tid((ir_type *)tore); - if (type_visited(tp)) return; - break; - default: - break; - } - - /* execute pre method */ - if (pre) - pre(tore, env); - - /* iterate */ - switch (get_kind(tore)) { - 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); - - if (get_entity_variability(ent) != variability_uninitialized) { - /* walk over the value types */ - if (is_atomic_entity(ent)) { - n = get_atomic_ent_value(ent); - irn_type_walker(n, pre, post, env); - } - else { - n_mem = get_compound_ent_n_values(ent); - for (i = 0; i < n_mem; ++i) { - n = get_compound_ent_value(ent, i); - irn_type_walker(n, pre, post, env); - } - } - } - break; - case k_type: - mark_type_visited(tp); - switch (get_type_tpop_code(tp)) { - - 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); - - 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); - - 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); - 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); - 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); - - 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); - 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); - 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); - break; - - case tpo_enumeration: - /* a leave */ - break; - - case tpo_pointer: - do_type_walk((type_or_ent *)get_pointer_points_to_type(tp), - pre, post, env); - break; - - case tpo_primitive: - case tpo_id: - case tpo_none: - case tpo_unknown: - /* a leave. */ - break; - default: - assert(0 && "Faulty type"); - break; - } - break; /* end case k_type */ - - default: - printf(" *** Faulty type or entity! \n"); - break; - } - - /* execute post method */ - if (post) - post(tore, env); - - return; + size_t i, n_types, n_mem; + ir_entity *ent = NULL; + ir_type *tp = NULL; + type_or_ent cont; + + /* marked? */ + switch (get_kind(tore.ent)) { + case k_entity: + ent = tore.ent; + if (entity_visited(ent)) + return; + mark_entity_visited(ent); + break; + case k_type: + tp = tore.typ; + if (type_visited(tp)) + return; + mark_type_visited(tp); + break; + default: + break; + } + + /* execute pre method */ + if (pre) + pre(tore, env); + + /* iterate */ + switch (get_kind(tore.ent)) { + case k_entity: + 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); + + /* walk over the value types */ + if (ent->initializer != NULL) { + walk_initializer(ent->initializer, pre, post, env); + } + break; + case k_type: + switch (get_type_tpop_code(tp)) { + case tpo_class: + n_types = get_class_n_supertypes(tp); + 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) { + 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) { + 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) { + 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) { + 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) { + 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) { + cont.ent = get_union_member(tp, i); + do_type_walk(cont, pre, post, env); + } + break; + + case tpo_array: + 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: + /* a leave */ + break; + + case tpo_pointer: + cont.typ = get_pointer_points_to_type(tp); + do_type_walk(cont, pre, post, env); + break; + + case tpo_code: + case tpo_primitive: + case tpo_none: + case tpo_unknown: + /* a leave. */ + break; + case tpo_uninitialized: + assert(0 && "Faulty type"); + break; + } + break; /* end case k_type */ + + default: + printf(" *** Faulty type or entity! \n"); + break; + } + + /* execute post method */ + if (post) + post(tore, env); } /** Check whether node contains types or entities as an attribute. @@ -192,361 +208,353 @@ 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) { - entity *ent; - ir_type *tp; + type_or_ent cont; - assert(node); + 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. If so start a walk over that information. */ -static void start_type_walk(ir_node *node, void *ctx) { - type_walk_env *env = ctx; - type_walk_func *pre; - type_walk_func *post; - void *envi; +static void start_type_walk(ir_node *node, void *ctx) +{ + type_walk_env *env = (type_walk_env*)ctx; + type_walk_func *pre; + type_walk_func *post; + void *envi; - pre = env->pre; - post = env->post; - envi = env->env; + pre = env->pre; + post = env->post; + envi = env->env; - irn_type_walker(node, pre, post, envi); + irn_type_walker(node, pre, post, envi); } -/* 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(); - - inc_master_type_visited(); - for (i = 0; i < n_types; ++i) { - do_type_walk((type_or_ent *)get_irp_type(i), pre, post, env); - } - do_type_walk((type_or_ent *)get_glob_type(), pre, post, env); +void type_walk(type_walk_func *pre, type_walk_func *post, void *env) +{ + size_t i, n_types = get_irp_n_types(); + type_or_ent cont; + + irp_reserve_resources(irp, IRP_RESOURCE_TYPE_VISITED); + inc_master_type_visited(); + for (i = 0; i < n_types; ++i) { + cont.typ = get_irp_type(i); + do_type_walk(cont, pre, post, env); + } + cont.typ = get_glob_type(); + do_type_walk(cont, pre, post, env); + irp_free_resources(irp, IRP_RESOURCE_TYPE_VISITED); } -void type_walk_irg (ir_graph *irg, - void (*pre)(type_or_ent*, void*), - void (*post)(type_or_ent*, void*), - void *env) +void type_walk_irg(ir_graph *irg, + type_walk_func *pre, + type_walk_func *post, + void *env) { - ir_graph *rem = current_ir_graph; - /* this is needed to pass the parameters to the walker that actually - walks the type information */ - type_walk_env type_env; - - type_env.pre = pre; - type_env.post = post; - type_env.env = env; - - current_ir_graph = irg; - - /* We walk over the irg to find all irnodes 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 - 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 - not increase the flag. - */ - 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); - - do_type_walk((type_or_ent *)get_irg_frame_type(irg), pre, post, env); - - current_ir_graph = rem; - return; + ir_graph *rem = current_ir_graph; + /* 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; + type_env.env = env; + + current_ir_graph = irg; + + /* 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 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 + not increase the flag. + */ + irp_reserve_resources(irp, IRP_RESOURCE_TYPE_VISITED); + inc_master_type_visited(); + irg_walk(get_irg_end(irg), start_type_walk, NULL, &type_env); + + cont.ent = get_irg_entity(irg); + do_type_walk(cont, pre, post, env); + + cont.typ = get_irg_frame_type(irg); + do_type_walk(cont, pre, post, env); + + current_ir_graph = rem; + irp_free_resources(irp, IRP_RESOURCE_TYPE_VISITED); } -static void type_walk_s2s_2(type_or_ent *tore, - void (*pre)(type_or_ent*, void*), - void (*post)(type_or_ent*, void*), - void *env) +static void type_walk_s2s_2(type_or_ent tore, + type_walk_func *pre, + type_walk_func *post, + void *env) { - int i, n; - - /* marked? */ - switch (get_kind(tore)) { - case k_entity: - if (entity_visited((entity *)tore)) 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); - return; - } - if (type_visited((ir_type *)tore)) return; - break; - default: - break; - } - - /* iterate */ - switch (get_kind(tore)) { - case k_type: - { - ir_type *tp = (ir_type *)tore; - 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); - } - /* execute pre method */ - if (pre) - pre(tore, env); - tp = skip_tid((ir_type*)tore); - - 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); - } - - /* execute post method */ - if (post) - post(tore, env); - } - break; - case tpo_struct: - case tpo_method: - case tpo_union: - case tpo_array: - case tpo_enumeration: - case tpo_pointer: - case tpo_primitive: - case tpo_id: - /* dont care */ - break; - default: - printf(" *** Faulty type! \n"); - break; - } - } break; /* end case k_type */ - case k_entity: - /* dont care */ - break; - default: - printf(" *** Faulty type or entity! \n"); - break; - } - return; + type_or_ent cont; + + /* marked? */ + switch (get_kind(tore.ent)) { + case k_entity: + if (entity_visited(tore.ent)) return; + break; + case k_type: + if (type_visited(tore.typ)) return; + break; + default: + break; + } + + /* iterate */ + switch (get_kind(tore.typ)) { + case k_type: + { + ir_type *tp = tore.typ; + mark_type_visited(tp); + switch (get_type_tpop_code(tp)) { + case tpo_class: + { + size_t i, n; + + n = get_class_n_supertypes(tp); + for (i = 0; i < n; ++i) { + cont.typ = get_class_supertype(tp, i); + type_walk_s2s_2(cont, pre, post, env); + } + /* execute pre method */ + if (pre) + pre(tore, env); + + n = get_class_n_subtypes(tp); + for (i = 0; i < n; ++i) { + cont.typ = get_class_subtype(tp, i); + type_walk_s2s_2(cont, pre, post, env); + } + + /* execute post method */ + if (post) + post(tore, env); + } + break; + case tpo_struct: + case tpo_method: + case tpo_union: + case tpo_array: + case tpo_enumeration: + case tpo_pointer: + case tpo_primitive: + /* dont care */ + break; + default: + printf(" *** Faulty type! \n"); + break; + } + } break; /* end case k_type */ + case k_entity: + /* don't care */ + break; + default: + printf(" *** Faulty type or entity! \n"); + break; + } } -void type_walk_super2sub( - void (*pre)(type_or_ent*, void*), - void (*post)(type_or_ent*, void*), - void *env) +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; - - inc_master_type_visited(); - type_walk_s2s_2((type_or_ent *)get_glob_type(), 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); - } + type_or_ent cont; + size_t i, n_types = get_irp_n_types(); + + irp_reserve_resources(irp, IRP_RESOURCE_TYPE_VISITED); + inc_master_type_visited(); + cont.typ = get_glob_type(); + type_walk_s2s_2(cont, pre, post, env); + for (i = 0; i < n_types; ++i) { + cont.typ = get_irp_type(i); + type_walk_s2s_2(cont, pre, post, env); + } + irp_free_resources(irp, IRP_RESOURCE_TYPE_VISITED); } /*****************************************************************************/ -static void -type_walk_super_2(type_or_ent *tore, - void (*pre)(type_or_ent*, void*), - void (*post)(type_or_ent*, void*), - void *env) +static void type_walk_super_2(type_or_ent tore, type_walk_func *pre, + type_walk_func *post, void *env) { - int i, n; - - /* marked? */ - switch (get_kind(tore)) { - case k_entity: - if (entity_visited((entity *)tore)) 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); - return; - } - if (type_visited((ir_type *)tore)) return; - break; - default: - break; - } - - /* iterate */ - switch (get_kind(tore)) { - case k_type: - { - ir_type *tp = (ir_type *)tore; - mark_type_visited(tp); - switch (get_type_tpop_code(tp)) { - case tpo_class: - { - /* execute pre method */ - if (pre) - pre(tore, env); - tp = skip_tid((ir_type*)tore); - - 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); - } - - /* execute post method */ - if (post) - post(tore, env); - } - break; - case tpo_struct: - case tpo_method: - case tpo_union: - case tpo_array: - case tpo_enumeration: - case tpo_pointer: - case tpo_primitive: - case tpo_id: - /* dont care */ - break; - default: - printf(" *** Faulty type! \n"); - break; - } - } break; /* end case k_type */ - case k_entity: - /* dont care */ - break; - default: - printf(" *** Faulty type or entity! \n"); - break; - } - return; + type_or_ent cont; + + /* marked? */ + switch (get_kind(tore.ent)) { + case k_entity: + if (entity_visited(tore.ent)) + return; + break; + case k_type: + if (type_visited(tore.typ)) + return; + break; + default: + break; + } + + /* iterate */ + switch (get_kind(tore.typ)) { + case k_type: + { + ir_type *tp = tore.typ; + mark_type_visited(tp); + switch (get_type_tpop_code(tp)) { + case tpo_class: + { + size_t i, n; + + /* execute pre method */ + if (pre) + pre(tore, env); + + n = get_class_n_supertypes(tp); + for (i = 0; i < n; ++i) { + cont.typ = get_class_supertype(tp, i); + type_walk_super_2(cont, pre, post, env); + } + + /* execute post method */ + if (post) + post(tore, env); + } + break; + case tpo_struct: + case tpo_method: + case tpo_union: + case tpo_array: + case tpo_enumeration: + case tpo_pointer: + case tpo_primitive: + /* don't care */ + break; + default: + printf(" *** Faulty type! \n"); + break; + } + } break; /* end case k_type */ + case k_entity: + /* don't care */ + break; + default: + printf(" *** Faulty type or entity! \n"); + break; + } } -void type_walk_super( - void (*pre)(type_or_ent*, void*), - void (*post)(type_or_ent*, void*), - void *env) { - int i, n_types = get_irp_n_types(); - ir_type *tp; - - inc_master_type_visited(); - type_walk_super_2((type_or_ent *)get_glob_type(), 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); - } +void type_walk_super(type_walk_func *pre, type_walk_func *post, void *env) +{ + size_t i, n_types = get_irp_n_types(); + type_or_ent cont; + + irp_reserve_resources(irp, IRP_RESOURCE_TYPE_VISITED); + inc_master_type_visited(); + cont.typ = get_glob_type(); + type_walk_super_2(cont, pre, post, env); + for (i = 0; i < n_types; ++i) { + cont.typ = get_irp_type(i); + type_walk_super_2(cont, pre, post, env); + } + irp_free_resources(irp, IRP_RESOURCE_TYPE_VISITED); } /*****************************************************************************/ -static void -class_walk_s2s_2(ir_type *tp, - void (*pre)(ir_type*, void*), - void (*post)(ir_type*, void*), - void *env) +static void class_walk_s2s_2(ir_type *tp, class_walk_func *pre, + class_walk_func *post, void *env) { - int i, n; - - /* marked? */ - if (type_visited(tp)) return; - - assert(is_Class_type(tp)); - /* Assure all supertypes are visited before */ - n = get_class_n_supertypes(tp); - for (i = 0; i < n; ++i) { - if (type_not_visited(get_class_supertype(tp, i))) - return; - } - - mark_type_visited(tp); - - /* execute pre method */ - if (pre) - pre(tp, env); - - tp = skip_tid(tp); - n = get_class_n_subtypes(tp); - for (i = 0; i < n; ++i) { - class_walk_s2s_2(get_class_subtype(tp, i), pre, post, env); - } - /* execute post method */ - if (post) - post(tp, env); - - return; + size_t i, n; + + /* marked? */ + if (type_visited(tp)) return; + + /* Assure all supertypes are visited before */ + n = get_class_n_supertypes(tp); + for (i = 0; i < n; ++i) { + if (type_not_visited(get_class_supertype(tp, i))) + return; + } + + mark_type_visited(tp); + + /* execute pre method */ + if (pre) + pre(tp, env); + + n = get_class_n_subtypes(tp); + for (i = 0; i < n; ++i) { + class_walk_s2s_2(get_class_subtype(tp, i), pre, post, env); + } + /* execute post method */ + if (post) + post(tp, env); } -void class_walk_super2sub( - void (*pre)(ir_type*, void*), - void (*post)(ir_type*, void*), - void *env) +void class_walk_super2sub(class_walk_func *pre, + class_walk_func *post, + void *env) { - int i, n_types = get_irp_n_types(); - ir_type *tp; - - inc_master_type_visited(); - for (i = 0; i < n_types; i++) { - tp = get_irp_type(i); - if (is_Class_type(tp) && - (get_class_n_supertypes(tp) == 0) && - type_not_visited(tp)) { - assert(! is_frame_type(tp)); - assert(tp != get_glob_type()); - class_walk_s2s_2(tp, pre, post, env); - } - } + size_t i, n_types = get_irp_n_types(); + ir_type *tp; + + irp_reserve_resources(irp, IRP_RESOURCE_TYPE_VISITED); + inc_master_type_visited(); + for (i = 0; i < n_types; i++) { + tp = get_irp_type(i); + if (is_Class_type(tp) && + (get_class_n_supertypes(tp) == 0) && + type_not_visited(tp) && + (! is_frame_type(tp)) && + (tp != get_glob_type())) { + class_walk_s2s_2(tp, pre, post, env); + } + } + irp_free_resources(irp, IRP_RESOURCE_TYPE_VISITED); } -/* Walks over all entities in the type */ -void walk_types_entities( - ir_type *tp, - void (*doit)(entity*, void*), - void *env) +void walk_types_entities(ir_type *tp, + entity_walk_func *doit, + void *env) { - int i, n; - - switch (get_type_tpop_code(tp)) { - case tpo_class: - n = get_class_n_members(tp); - for (i = 0; i < n; ++i) - doit(get_class_member(tp, i), env); - break; - case tpo_struct: - n = get_struct_n_members(tp); - for (i = 0; i < n; ++i) - doit(get_struct_member(tp, i), env); - break; - case tpo_union: - n = get_union_n_members(tp); - for (i = 0; i < n; ++i) - doit(get_union_member(tp, i), env); - break; - case tpo_array: - doit(get_array_element_entity(tp), env); - break; - case tpo_method: - case tpo_enumeration: - case tpo_pointer: - case tpo_primitive: - case tpo_id: - default: - break; - } + size_t i, n; + + switch (get_type_tpop_code(tp)) { + case tpo_class: + n = get_class_n_members(tp); + for (i = 0; i < n; ++i) + doit(get_class_member(tp, i), env); + break; + case tpo_struct: + n = get_struct_n_members(tp); + for (i = 0; i < n; ++i) + doit(get_struct_member(tp, i), env); + break; + case tpo_union: + n = get_union_n_members(tp); + for (i = 0; i < n; ++i) + doit(get_union_member(tp, i), env); + break; + case tpo_array: + doit(get_array_element_entity(tp), env); + break; + case tpo_method: + case tpo_enumeration: + case tpo_pointer: + case tpo_primitive: + default: + break; + } }