X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fir%2Firdump.c;h=7d1caaf7c5d5bc74a2c1cb9f583c5187df23dd19;hb=a1fc5d2a5ed66510bbb2199ea5ee75416755cf1c;hp=44a1e3809cc63b8238df82f72eaa76c54c2a61b9;hpb=01ddc5c06877693df7d5f286d43e433fedd87103;p=libfirm diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c index 44a1e3809..7d1caaf7c 100644 --- a/ir/ir/irdump.c +++ b/ir/ir/irdump.c @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2010 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2011 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -56,7 +56,7 @@ #include "irtools.h" #include "irprintf.h" -#include "irvrfy.h" +#include "irverify.h" #include "error.h" #include "array.h" @@ -203,7 +203,7 @@ static void custom_color(int num, const char *rgb_def) obstack_1grow(&color_obst, '\0'); color_rgb[num] = rgb_def; - color_names[num] = obstack_finish(&color_obst); + color_names[num] = (const char*)obstack_finish(&color_obst); } /** Define a named color. */ @@ -275,7 +275,7 @@ static void print_type_type_edge(FILE *F, const ir_type *S, const ir_type *T, co va_start(ap, fmt); fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(S); fprintf(F, " targetname: "); PRINT_TYPEID(T); - vfprintf(F, fmt, ap); + ir_vfprintf(F, fmt, ap); fprintf(F,"}\n"); va_end(ap); } @@ -291,7 +291,7 @@ static void print_type_ent_edge(FILE *F, const ir_type *tp, const ir_entity *ent va_start(ap, fmt); fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(tp); fprintf(F, " targetname: \""); PRINT_ENTID(ent); fprintf(F, "\""); - vfprintf(F, fmt, ap); + ir_vfprintf(F, fmt, ap); fprintf(F, "}\n"); va_end(ap); } @@ -311,9 +311,9 @@ static void print_ent_ent_edge(FILE *F, const ir_entity *ent1, const ir_entity * fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(ent1); fprintf(F, "\" targetname: \""); PRINT_ENTID(ent2); fprintf(F, "\""); - vfprintf(F, fmt, ap); + ir_vfprintf(F, fmt, ap); fprintf(F, " "); - if (color != (ird_color_t) -1) + if (color != ird_color_none) print_vcg_color(F, color); fprintf(F, "}\n"); va_end(ap); @@ -330,7 +330,7 @@ static void print_ent_type_edge(FILE *F, const ir_entity *ent, const ir_type *tp va_start(ap, fmt); fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(ent); fprintf(F, "\" targetname: "); PRINT_TYPEID(tp); - vfprintf(F, fmt, ap); + ir_vfprintf(F, fmt, ap); fprintf(F,"}\n"); va_end(ap); } @@ -346,7 +346,7 @@ static void print_node_type_edge(FILE *F, const ir_node *irn, ir_type *tp, const va_start(ap, fmt); fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(irn); fprintf(F, "\" targetname: "); PRINT_TYPEID(tp); - vfprintf(F, fmt, ap); + ir_vfprintf(F, fmt, ap); fprintf(F,"}\n"); va_end(ap); } @@ -363,7 +363,7 @@ static void print_node_ent_edge(FILE *F, const ir_node *irn, const ir_entity *en fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(irn); fprintf(F, "\" targetname: \""); PRINT_ENTID(ent); fprintf(F, "\""); - vfprintf(F, fmt, ap); + ir_vfprintf(F, fmt, ap); fprintf(F,"}\n"); va_end(ap); } @@ -379,7 +379,7 @@ static void print_ent_node_edge(FILE *F, const ir_entity *ent, const ir_node *ir va_start(ap, fmt); fprintf(F, "edge: { sourcename: \""); PRINT_ENTID(ent); fprintf(F, "\" targetname: \""); PRINT_NODEID(irn); fprintf(F, "\""); - vfprintf(F, fmt, ap); + ir_vfprintf(F, fmt, ap); fprintf(F,"}\n"); va_end(ap); } @@ -388,14 +388,14 @@ static void print_ent_node_edge(FILE *F, const ir_entity *ent, const ir_node *ir * Prints the edge from a type tp to an enumeration item item with additional info fmt, ... * to the file F. */ -static void print_enum_item_edge(FILE *F, const ir_type *tp, int item, const char *fmt, ...) +static void print_enum_item_edge(FILE *F, const ir_type *tp, size_t item, const char *fmt, ...) { va_list ap; va_start(ap, fmt); fprintf(F, "edge: { sourcename: "); PRINT_TYPEID(tp); fprintf(F, " targetname: \""); PRINT_ITEMID(tp, item); fprintf(F, "\" "); - vfprintf(F, fmt, ap); + ir_vfprintf(F, fmt, ap); fprintf(F,"}\n"); va_end(ap); } @@ -404,7 +404,6 @@ static void print_enum_item_edge(FILE *F, const ir_type *tp, int item, const cha /* global and ahead declarations */ /*-----------------------------------------------------------------*/ -static void dump_node_with_edges(ir_node *n, void *env); static void dump_loop_nodes_into_graph(FILE *F, ir_graph *irg); /*-----------------------------------------------------------------*/ @@ -540,7 +539,7 @@ static void ird_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *pos } /** - * Walker, allocates an array for all blocks and puts it's nodes non-floating + * Walker, allocates an array for all blocks and puts their non-floating * nodes into this array. */ static void collect_node(ir_node *node, void *env) @@ -579,7 +578,7 @@ static void collect_node(ir_node *node, void *env) */ static ir_node **construct_block_lists(ir_graph *irg) { - int i; + size_t i; int walk_flag = ir_resources_reserved(irg) & IR_RESOURCE_IRN_VISITED; ir_graph *rem = current_ir_graph; @@ -589,8 +588,8 @@ static ir_node **construct_block_lists(ir_graph *irg) ir_free_resources(irg, IR_RESOURCE_IRN_VISITED); } - for (i = get_irp_n_irgs() - 1; i >= 0; --i) - ird_set_irg_link(get_irp_irg(i), NULL); + for (i = get_irp_n_irgs(); i > 0;) + ird_set_irg_link(get_irp_irg(--i), NULL); ird_walk_graph(current_ir_graph, clear_link, collect_node, current_ir_graph); @@ -599,10 +598,10 @@ static ir_node **construct_block_lists(ir_graph *irg) } current_ir_graph = rem; - return ird_get_irg_link(irg); + return (ir_node**)ird_get_irg_link(irg); } -typedef struct _list_tuple { +typedef struct list_tuple { ir_node **blk_list; ir_extblk **extbb_list; } list_tuple; @@ -614,7 +613,7 @@ typedef struct _list_tuple { static list_tuple *construct_extblock_lists(ir_graph *irg) { ir_node **blk_list = construct_block_lists(irg); - int i; + size_t i, n; ir_graph *rem = current_ir_graph; list_tuple *lists = XMALLOC(list_tuple); @@ -624,7 +623,7 @@ static list_tuple *construct_extblock_lists(ir_graph *irg) lists->extbb_list = NEW_ARR_F(ir_extblk *, 0); inc_irg_block_visited(irg); - for (i = ARR_LEN(blk_list) - 1; i >= 0; --i) { + for (i = 0, n = ARR_LEN(blk_list); i < n; ++i) { ir_extblk *ext; if (is_Block(blk_list[i])) { @@ -691,18 +690,16 @@ void dump_node_opcode(FILE *F, ir_node *n) } break; case iro_Load: - if (get_Load_align(n) == align_non_aligned) + if (get_Load_unaligned(n) == align_non_aligned) fprintf(F, "ua"); fprintf(F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_Load_mode(n), NULL)); break; case iro_Store: - if (get_Store_align(n) == align_non_aligned) + if (get_Store_unaligned(n) == align_non_aligned) fprintf(F, "ua"); fprintf(F, "%s", get_irn_opname(n)); break; case iro_Block: - if (is_Block_dead(n)) - fputs("Dead ", F); if (n == get_irg_start_block(get_irn_irg(n))) fputs("Start ", F); if (n == get_irg_end_block(get_irn_irg(n))) @@ -724,9 +721,6 @@ void dump_node_opcode(FILE *F, ir_node *n) case iro_Mod: fprintf(F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_Mod_resmode(n), NULL)); break; - case iro_DivMod: - fprintf(F, "%s[%s]", get_irn_opname(n), get_mode_name_ex(get_DivMod_resmode(n), NULL)); - break; case iro_Builtin: fprintf(F, "%s[%s]", get_irn_opname(n), get_builtin_kind_name(get_Builtin_kind(n))); break; @@ -744,7 +738,7 @@ default_case: static void dump_node_mode(FILE *F, ir_node *n) { const ir_op_ops *ops = get_op_ops(get_irn_op(n)); - ir_opcode iro; + unsigned iro; ir_mode *mode; /* call the dump_node operation if available */ @@ -795,13 +789,13 @@ static int dump_node_typeinfo(FILE *F, ir_node *n) return bad; } -typedef struct _pns_lookup { +typedef struct pns_lookup { long nr; /**< the proj number */ const char *name; /**< the name of the Proj */ } pns_lookup_t; -typedef struct _proj_lookup { - ir_opcode code; /**< the opcode of the Proj predecessor */ +typedef struct proj_lookup { + unsigned code; /**< the opcode of the Proj predecessor */ unsigned num_data; /**< number of data entries */ const pns_lookup_t *data; /**< the data */ } proj_lookup_t; @@ -810,8 +804,8 @@ typedef struct _proj_lookup { static const pns_lookup_t start_lut[] = { #define X(a) { pn_Start_##a, #a } X(X_initial_exec), + X(M), X(P_frame_base), - X(P_tls), X(T_args), #undef X }; @@ -831,28 +825,6 @@ static const pns_lookup_t call_lut[] = { X(X_regular), X(X_except), X(T_result), - X(P_value_res_base) -#undef X -}; - -/** the lookup table for Proj(Quot) names */ -static const pns_lookup_t quot_lut[] = { -#define X(a) { pn_Quot_##a, #a } - X(M), - X(X_regular), - X(X_except), - X(res) -#undef X -}; - -/** the lookup table for Proj(DivMod) names */ -static const pns_lookup_t divmod_lut[] = { -#define X(a) { pn_DivMod_##a, #a } - X(M), - X(X_regular), - X(X_except), - X(res_div), - X(res_mod) #undef X }; @@ -948,8 +920,6 @@ static const proj_lookup_t proj_lut[] = { { iro_Start, E(start_lut) }, { iro_Cond, E(cond_lut) }, { iro_Call, E(call_lut) }, - { iro_Quot, E(quot_lut) }, - { iro_DivMod, E(divmod_lut) }, { iro_Div, E(div_lut) }, { iro_Mod, E(mod_lut) }, { iro_Load, E(load_lut) }, @@ -968,7 +938,7 @@ static const proj_lookup_t proj_lut[] = { static void dump_node_nodeattr(FILE *F, ir_node *n) { ir_node *pred; - ir_opcode code; + unsigned code; long proj_nr; const ir_op_ops *ops = get_op_ops(get_irn_op(n)); @@ -988,9 +958,7 @@ static void dump_node_nodeattr(FILE *F, ir_node *n) proj_nr = get_Proj_proj(n); code = get_irn_opcode(pred); - if (code == iro_Cmp) - fprintf(F, "%s ", get_pnc_string(get_Proj_proj(n))); - else if (code == iro_Proj && get_irn_opcode(get_Proj_pred(pred)) == iro_Start) + if (code == iro_Proj && get_irn_opcode(get_Proj_pred(pred)) == iro_Start) fprintf(F, "Arg %ld ", proj_nr); else if (code == iro_Cond && get_irn_mode(get_Cond_selector(pred)) != mode_b) fprintf(F, "%ld ", proj_nr); @@ -1025,21 +993,21 @@ static void dump_node_nodeattr(FILE *F, ir_node *n) case iro_Cast: ir_fprintf(F, "(%+F)", get_Cast_type(n)); break; + case iro_Cmp: + fprintf(F, "%s ", get_relation_string(get_Cmp_relation(n))); + break; case iro_Confirm: - fprintf(F, "%s ", get_pnc_string(get_Confirm_cmp(n))); + fprintf(F, "%s ", get_relation_string(get_Confirm_relation(n))); break; case iro_CopyB: ir_fprintf(F, "(%+F)", get_CopyB_type(n)); break; default: - ; - } /* end switch */ + break; + } } -#include -#include "execution_frequency.h" - static void dump_node_ana_vals(FILE *F, ir_node *n) { (void) F; @@ -1063,23 +1031,6 @@ void dump_node_label(FILE *F, ir_node *n) } } -void dump_vrp_info(FILE *F, ir_node *n) -{ - vrp_attr *vrp = vrp_get_info(n); - if (n == NULL) { - return; - } - - fprintf(F, "range_type: %d\n", (int) vrp->range_type); - if (vrp->range_type == VRP_RANGE || vrp->range_type == - VRP_ANTIRANGE) { - ir_fprintf(F, "range_bottom: %F\n",vrp->range_bottom); - ir_fprintf(F, "range_top: %F\n", vrp->range_top); - } - ir_fprintf(F, "bits_set: %T\n", vrp->bits_set); - ir_fprintf(F, "bits_not_set: %T\n", vrp->bits_not_set); -} - /** * Dumps the attributes of a node n into the file F. * Currently this is only the color of a node. @@ -1125,10 +1076,7 @@ static void dump_node_vcgattr(FILE *F, ir_node *node, ir_node *local, int bad) print_vcg_color(F, ird_color_error); break; case iro_Block: - if (is_Block_dead(n)) - print_vcg_color(F, ird_color_dead_block_background); - else - print_vcg_color(F, ird_color_block_background); + print_vcg_color(F, ird_color_block_background); break; case iro_Phi: print_vcg_color(F, ird_color_phi); @@ -1159,7 +1107,7 @@ static void dump_node_vcgattr(FILE *F, ir_node *node, ir_node *local, int bad) void *dump_add_node_info_callback(dump_node_info_cb_t *cb, void *data) { - hook_entry_t *info = XMALLOC(hook_entry_t); + hook_entry_t *info = XMALLOCZ(hook_entry_t); info->hook._hook_node_info = cb; info->context = data; @@ -1170,7 +1118,7 @@ void *dump_add_node_info_callback(dump_node_info_cb_t *cb, void *data) void dump_remove_node_info_callback(void *handle) { - hook_entry_t *info = handle; + hook_entry_t *info = (hook_entry_t*)handle; unregister_hook(hook_node_info, info); xfree(info); } @@ -1218,8 +1166,7 @@ static void dump_const_node_local(FILE *F, ir_node *n) for (i = 0; i < get_irn_arity(n); i++) { ir_node *con = get_irn_n(n, i); - if (is_constlike_node(con) && !irn_visited(con)) { - mark_irn_visited(con); + if (is_constlike_node(con) && !irn_visited_else_mark(con)) { /* Generate a new name for the node by appending the names of n and const. */ fprintf(F, "node: {title: "); PRINT_CONSTID(n, con); @@ -1319,7 +1266,7 @@ static void dump_node(FILE *F, ir_node *n) fputs("\"", F); fputs(" label: \"", F); - bad = ! irn_vrfy_irg_dump(n, current_ir_graph, &p); + bad = ! irn_verify_irg_dump(n, current_ir_graph, &p); dump_node_label(F, n); dump_node_ana_vals(F, n); //dump_node_ana_info(F, n); @@ -1395,7 +1342,7 @@ static void print_mem_edge_vcgattr(FILE *F, ir_node *from, int to) fprintf(F, INTER_MEM_EDGE_ATTR); } -/** Print the vcg attributes for the edge from node from to it's to's input */ +/** Print the vcg attributes for the edge from node "from" to its "to"th input */ static void print_edge_vcgattr(FILE *F, ir_node *from, int to) { assert(from); @@ -1492,16 +1439,6 @@ static void dump_ir_data_edges(FILE *F, ir_node *n) print_edge_vcgattr(F, n, i); fprintf(F, "}\n"); } - - if ((flags & ir_dump_flag_macroblock_edges) && is_Block(n)) { - ir_node *mb = get_Block_MacroBlock(n); - fprintf(F, "edge: {sourcename: \""); - PRINT_NODEID(n); - fprintf(F, "\" targetname: \""); - PRINT_NODEID(mb); - fprintf(F, "\" label: \"mb\" " MACROBLOCK_EDGE_ATTR); - fprintf(F, "}\n"); - } } /** @@ -1510,7 +1447,7 @@ static void dump_ir_data_edges(FILE *F, ir_node *n) static void dump_ir_edges(ir_node *node, void *env) { int i = 0; - FILE *F = env; + FILE *F = (FILE*)env; const ir_edge_t *edge; foreach_out_edge(node, edge) { @@ -1534,7 +1471,7 @@ static void dump_ir_edges(ir_node *node, void *env) /** Dumps a node and its edges but not the block edge */ static void dump_node_wo_blockedge(ir_node *n, void *env) { - FILE *F = env; + FILE *F = (FILE*)env; dump_node(F, n); dump_ir_data_edges(F, n); } @@ -1542,7 +1479,7 @@ static void dump_node_wo_blockedge(ir_node *n, void *env) /** Dumps a node and its edges. */ static void dump_node_with_edges(ir_node *n, void *env) { - FILE *F = env; + FILE *F = (FILE*)env; dump_node_wo_blockedge(n, env); if (!node_floats(n)) dump_ir_block_edge(F, n); @@ -1597,8 +1534,6 @@ static void dump_whole_block(FILE *F, ir_node *block) /* colorize blocks */ if (! get_Block_matured(block)) color = ird_color_block_background; - if (is_Block_dead(block)) - color = ird_color_dead_block_background; fprintf(F, "\" status:clustered "); print_vcg_color(F, color); @@ -1615,7 +1550,7 @@ static void dump_whole_block(FILE *F, ir_node *block) dump_block_edge_hook(F, block); /* dump the nodes that go into the block */ - for (node = ird_get_irn_link(block); node; node = ird_get_irn_link(node)) { + for (node = (ir_node*)ird_get_irn_link(block); node; node = (ir_node*)ird_get_irn_link(node)) { dump_node(F, node); dump_ir_data_edges(F, node); } @@ -1630,13 +1565,13 @@ static void dump_whole_block(FILE *F, ir_node *block) * The outermost nodes: blocks and nodes not op_pin_state_pinned, Bad, Unknown. */ static void dump_block_graph(FILE *F, ir_graph *irg) { - int i; + size_t i, n; ir_graph *rem = current_ir_graph; - ir_node **arr = ird_get_irg_link(irg); + ir_node **arr = (ir_node**)ird_get_irg_link(irg); current_ir_graph = irg; - for (i = ARR_LEN(arr) - 1; i >= 0; --i) { - ir_node * node = arr[i]; + for (i = 0, n = ARR_LEN(arr); i < n; ++i) { + ir_node *node = arr[i]; if (is_Block(node)) { /* Dumps the block and all the nodes in the block, which are to be found in Block->link. */ @@ -1653,7 +1588,8 @@ static void dump_block_graph(FILE *F, ir_graph *irg) dump_ir_edges(node, F); } - if ((flags & ir_dump_flag_loops) && (get_irg_loopinfo_state(irg) & loopinfo_valid)) + if ((flags & ir_dump_flag_loops) + && is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_LOOPINFO)) dump_loop_nodes_into_graph(F, irg); current_ir_graph = rem; @@ -1667,6 +1603,42 @@ static void dump_graph_info(FILE *F, ir_graph *irg) { fprintf(F, "info1: \""); dump_entity_to_file(F, get_irg_entity(irg)); + fprintf(F, "\n"); + + /* dump graph state */ + fprintf(F, "state:"); + if (is_irg_state(irg, IR_GRAPH_STATE_ARCH_DEP)) + fprintf(F, " arch_dep"); + if (is_irg_state(irg, IR_GRAPH_STATE_MODEB_LOWERED)) + fprintf(F, " modeb_lowered"); + if (is_irg_state(irg, IR_GRAPH_STATE_NORMALISATION2)) + fprintf(F, " normalisation2"); + if (is_irg_state(irg, IR_GRAPH_STATE_IMPLICIT_BITFIELD_MASKING)) + fprintf(F, " implicit_bitfield_masking"); + if (is_irg_state(irg, IR_GRAPH_STATE_OPTIMIZE_UNREACHABLE_CODE)) + fprintf(F, " optimize_unreachable_code"); + if (is_irg_state(irg, IR_GRAPH_STATE_NO_CRITICAL_EDGES)) + fprintf(F, " no_critical_edges"); + if (is_irg_state(irg, IR_GRAPH_STATE_NO_BADS)) + fprintf(F, " no_bads"); + if (is_irg_state(irg, IR_GRAPH_STATE_NO_UNREACHABLE_CODE)) + fprintf(F, " no_unreachable_code"); + if (is_irg_state(irg, IR_GRAPH_STATE_ONE_RETURN)) + fprintf(F, " one_return"); + if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_DOMINANCE)) + fprintf(F, " consistent_dominance"); + if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE)) + fprintf(F, " consistent_postdominance"); + if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_OUT_EDGES)) + fprintf(F, " consistent_out_edges"); + if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_OUTS)) + fprintf(F, " consistent_outs"); + if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_LOOPINFO)) + fprintf(F, " consistent_loopinfo"); + if (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_ENTITY_USAGE)) + fprintf(F, " consistent_entity_usage"); + if (is_irg_state(irg, IR_GRAPH_STATE_VALID_EXTENDED_BLOCKS)) + fprintf(F, " valid_exended_blocks"); fprintf(F, "\"\n"); } @@ -1698,7 +1670,7 @@ static void dump_graph_from_list(FILE *F, ir_graph *irg) /** dumps the edges between nodes and their type or entity attributes. */ static void dump_node2type_edges(ir_node *n, void *env) { - FILE *F = env; + FILE *F = (FILE*)env; assert(n); switch (get_irn_opcode(n)) { @@ -1771,7 +1743,7 @@ static void print_typespecific_info(FILE *F, ir_type *tp) break; default: break; - } /* switch type */ + } } #endif @@ -1798,18 +1770,18 @@ static void print_typespecific_vcgattr(FILE *F, ir_type *tp) break; default: break; - } /* switch type */ + } } void dump_type_node(FILE *F, ir_type *tp) { fprintf(F, "node: {title: "); PRINT_TYPEID(tp); - fprintf(F, " label: \"%s ", get_type_tpop_name(tp)); + fprintf(F, " label: \""); if (tp->dbi != NULL) { - char buf[256]; + char buf[1024]; ir_print_type(buf, sizeof(buf), tp); - fprintf(F, "'%s'", buf); + fprintf(F, "%s '%s'", get_type_tpop_name(tp), buf); } else { ir_fprintf(F, "%+F", tp); } @@ -1838,12 +1810,12 @@ static void dump_entity_node(FILE *F, ir_entity *ent) fprintf(F, "}\n"); } -static void dump_enum_item(FILE *F, ir_type *tp, int pos) +static void dump_enum_item(FILE *F, ir_type *tp, size_t pos) { char buf[1024]; ir_enum_const *ec = get_enumeration_const(tp, pos); ident *id = get_enumeration_const_nameid(ec); - tarval *tv = get_enumeration_value(ec); + ir_tarval *tv = get_enumeration_value(ec); if (tv) tarval_snprintf(buf, sizeof(buf), tv); @@ -1866,11 +1838,13 @@ static void dump_entity_initializer(FILE *F, const ir_entity *ent) (void) ent; } -/** Dumps a type or entity and it's edges. */ +/** + * type-walker: Dumps a type or entity and its edges. + */ static void dump_type_info(type_or_ent tore, void *env) { - FILE *F = env; - int i = 0; /* to shutup gcc */ + FILE *F = (FILE*)env; + size_t i = 0; /* to shutup gcc */ /* dump this type or entity */ @@ -1886,8 +1860,8 @@ static void dump_type_info(type_or_ent tore, void *env) ENT_OWN_EDGE_ATTR "}\n", ent, get_entity_owner(ent));*/ print_ent_type_edge(F,ent, get_entity_type(ent), ENT_TYPE_EDGE_ATTR); if (is_Class_type(get_entity_owner(ent))) { - for (i = get_entity_n_overwrites(ent) - 1; i >= 0; --i) - print_ent_ent_edge(F,ent, get_entity_overwrites(ent, i), 0, -1, ENT_OVERWRITES_EDGE_ATTR); + for (i = get_entity_n_overwrites(ent); i > 0;) + print_ent_ent_edge(F, ent, get_entity_overwrites(ent, --i), 0, ird_color_none, ENT_OVERWRITES_EDGE_ATTR); } /* attached subgraphs */ if (! (flags & ir_dump_flag_no_entity_values)) { @@ -1896,12 +1870,12 @@ static void dump_type_info(type_or_ent tore, void *env) dump_entity_initializer(F, ent); } else if (entity_has_compound_ent_values(ent)) { /* old style compound entity values */ - for (i = get_compound_ent_n_values(ent) - 1; i >= 0; --i) { - value = get_compound_ent_value(ent, i); + for (i = get_compound_ent_n_values(ent); i > 0;) { + value = get_compound_ent_value(ent, --i); if (value) { print_ent_node_edge(F, ent, value, ENT_VALUE_EDGE_ATTR, i); dump_const_expression(F, value); - print_ent_ent_edge(F, ent, get_compound_ent_value_member(ent, i), 0, -1, ENT_CORR_EDGE_ATTR, i); + print_ent_ent_edge(F, ent, get_compound_ent_value_member(ent, i), 0, ird_color_none, ENT_CORR_EDGE_ATTR, i); /* fprintf(F, "edge: { sourcename: \"%p\" targetname: \"%p\" " ENT_CORR_EDGE_ATTR "}\n", GET_ENTID(ent), @@ -1919,41 +1893,57 @@ static void dump_type_info(type_or_ent tore, void *env) /* and now the edges */ switch (get_type_tpop_code(tp)) { case tpo_class: - for (i = get_class_n_supertypes(tp) - 1; i >= 0; --i) + for (i = get_class_n_supertypes(tp); i > 0;) { + --i; print_type_type_edge(F, tp, get_class_supertype(tp, i), TYPE_SUPER_EDGE_ATTR); - for (i = get_class_n_members(tp) - 1; i >= 0; --i) + } + for (i = get_class_n_members(tp); i > 0;) { + --i; print_type_ent_edge(F, tp, get_class_member(tp, i), TYPE_MEMBER_EDGE_ATTR); + } break; case tpo_struct: - for (i = get_struct_n_members(tp) - 1; i >= 0; --i) + for (i = get_struct_n_members(tp); i > 0;) { + --i; print_type_ent_edge(F, tp, get_struct_member(tp, i), TYPE_MEMBER_EDGE_ATTR); + } break; case tpo_method: - for (i = get_method_n_params(tp) - 1; i >= 0; --i) + for (i = get_method_n_params(tp); i > 0;) { + --i; print_type_type_edge(F, tp, get_method_param_type(tp, i), METH_PAR_EDGE_ATTR,i); - for (i = get_method_n_ress(tp) - 1; i >= 0; --i) + } + for (i = get_method_n_ress(tp); i > 0;) { + --i; print_type_type_edge(F, tp, get_method_res_type(tp, i), METH_RES_EDGE_ATTR,i); + } break; case tpo_union: - for (i = get_union_n_members(tp) - 1; i >= 0; --i) + for (i = get_union_n_members(tp); i > 0;) { + --i; print_type_ent_edge(F, tp, get_union_member(tp, i), UNION_EDGE_ATTR); + } break; case tpo_array: print_type_type_edge(F, tp, get_array_element_type(tp), ARR_ELT_TYPE_EDGE_ATTR); print_type_ent_edge(F, tp, get_array_element_entity(tp), ARR_ENT_EDGE_ATTR); - for (i = get_array_n_dimensions(tp) - 1; i >= 0; --i) { - ir_node *upper = get_array_upper_bound(tp, i); - ir_node *lower = get_array_lower_bound(tp, i); - print_node_type_edge(F, upper, tp, "label: \"upper %d\"", get_array_order(tp, i)); - print_node_type_edge(F, lower, tp, "label: \"lower %d\"", get_array_order(tp, i)); + for (i = get_array_n_dimensions(tp); i > 0;) { + ir_node *upper, *lower; + + --i; + upper = get_array_upper_bound(tp, i); + lower = get_array_lower_bound(tp, i); + print_node_type_edge(F, upper, tp, "label: \"upper %zu\"", get_array_order(tp, i)); + print_node_type_edge(F, lower, tp, "label: \"lower %zu\"", get_array_order(tp, i)); dump_const_expression(F, upper); dump_const_expression(F, lower); } break; case tpo_enumeration: - for (i = get_enumeration_n_enums(tp) - 1; i >= 0; --i) { + for (i = get_enumeration_n_enums(tp); i > 0;) { + --i; dump_enum_item(F, tp, i); - print_enum_item_edge(F, tp, i, "label: \"item %d\"", i); + print_enum_item_edge(F, tp, i, "label: \"item %zu\"", i); } break; case tpo_pointer: @@ -1963,12 +1953,12 @@ static void dump_type_info(type_or_ent tore, void *env) break; default: break; - } /* switch type */ + } break; /* case k_type */ } default: printf(" *** irdump, dump_type_info(l.%i), faulty type.\n", __LINE__); - } /* switch kind_or_entity */ + } } /** For dumping class hierarchies. @@ -1976,8 +1966,8 @@ static void dump_type_info(type_or_ent tore, void *env) */ static void dump_class_hierarchy_node(type_or_ent tore, void *ctx) { - FILE *F = ctx; - int i = 0; /* to shutup gcc */ + FILE *F = (FILE*)ctx; + size_t i = 0; /* to shutup gcc */ /* dump this type or entity */ switch (get_kind(tore.ent)) { @@ -1992,8 +1982,10 @@ static void dump_class_hierarchy_node(type_or_ent tore, void *ctx) dump_entity_node(F, ent); /* The edges */ print_type_ent_edge(F, get_entity_owner(ent), ent, TYPE_MEMBER_EDGE_ATTR); - for (i = get_entity_n_overwrites(ent) - 1; i >= 0; --i) - print_ent_ent_edge(F, get_entity_overwrites(ent, i), ent, 0, -1, ENT_OVERWRITES_EDGE_ATTR); + for (i = get_entity_n_overwrites(ent); i > 0;) { + --i; + print_ent_ent_edge(F, get_entity_overwrites(ent, i), ent, 0, ird_color_none, ENT_OVERWRITES_EDGE_ATTR); + } } break; } @@ -2005,17 +1997,18 @@ static void dump_class_hierarchy_node(type_or_ent tore, void *ctx) case tpo_class: dump_type_node(F, tp); /* and now the edges */ - for (i = get_class_n_supertypes(tp) - 1; i >= 0; --i) { + for (i = get_class_n_supertypes(tp); i > 0;) { + --i; print_type_type_edge(F,tp,get_class_supertype(tp, i),TYPE_SUPER_EDGE_ATTR); } break; default: break; - } /* switch type */ + } break; /* case k_type */ } default: printf(" *** irdump, dump_class_hierarchy_node(l.%i), faulty type.\n", __LINE__); - } /* switch kind_or_entity */ + } } /*******************************************************************/ @@ -2025,7 +2018,7 @@ static void dump_class_hierarchy_node(type_or_ent tore, void *ctx) /* dump out edges */ static void dump_out_edge(ir_node *n, void *env) { - FILE *F = env; + FILE *F = (FILE*)env; int i; for (i = get_irn_n_outs(n) - 1; i >= 0; --i) { ir_node *succ = get_irn_out(n, i); @@ -2042,16 +2035,17 @@ static void dump_out_edge(ir_node *n, void *env) static void dump_loop_label(FILE *F, ir_loop *loop) { - fprintf(F, "loop %d, %d sons, %d nodes", - get_loop_depth(loop), get_loop_n_sons(loop), get_loop_n_nodes(loop)); + fprintf(F, "loop %u, %lu sons, %lu nodes", + get_loop_depth(loop), (unsigned long) get_loop_n_sons(loop), + (unsigned long) get_loop_n_nodes(loop)); } static void dump_loop_info(FILE *F, ir_loop *loop) { fprintf(F, " info1: \""); - fprintf(F, " loop nr: %d", get_loop_loop_nr(loop)); + fprintf(F, " loop nr: %ld", get_loop_loop_nr(loop)); #ifdef DEBUG_libfirm /* GL @@@ debug analyses */ - fprintf(F, "\n The loop was analyzed %d times.", PTR_TO_INT(get_loop_link(loop))); + fprintf(F, "\n The loop was analyzed %ld times.", (long int) PTR_TO_INT(get_loop_link(loop))); #endif fprintf(F, "\""); } @@ -2067,7 +2061,7 @@ static void dump_loop_node(FILE *F, ir_loop *loop) fprintf(F, "}\n"); } -static void dump_loop_node_edge(FILE *F, ir_loop *loop, int i) +static void dump_loop_node_edge(FILE *F, ir_loop *loop, size_t i) { assert(loop); fprintf(F, "edge: {sourcename: \""); @@ -2078,30 +2072,32 @@ static void dump_loop_node_edge(FILE *F, ir_loop *loop, int i) fprintf(F, "}\n"); } -static void dump_loop_son_edge(FILE *F, ir_loop *loop, int i) +static void dump_loop_son_edge(FILE *F, ir_loop *loop, size_t i) { assert(loop); fprintf(F, "edge: {sourcename: \""); PRINT_LOOPID(loop); fprintf(F, "\" targetname: \""); PRINT_LOOPID(get_loop_son(loop, i)); - fprintf(F, "\" color: darkgreen label: \"%d\"}\n", + ir_fprintf(F, "\" color: darkgreen label: \"%zu\"}\n", get_loop_element_pos(loop, get_loop_son(loop, i))); } static void dump_loops(FILE *F, ir_loop *loop) { - int i; + size_t i; /* dump this loop node */ dump_loop_node(F, loop); /* dump edges to nodes in loop -- only if it is a real loop */ if (get_loop_depth(loop) != 0) { - for (i = get_loop_n_nodes(loop) - 1; i >= 0; --i) { + for (i = get_loop_n_nodes(loop); i > 0;) { + --i; dump_loop_node_edge(F, loop, i); } } - for (i = get_loop_n_sons(loop) - 1; i >= 0; --i) { + for (i = get_loop_n_sons(loop); i > 0;) { + --i; dump_loops(F, get_loop_son(loop, i)); dump_loop_son_edge(F, loop, i); } @@ -2192,7 +2188,7 @@ void dump_vcg_footer(FILE *F) static void dump_blocks_as_subgraphs(FILE *out, ir_graph *irg) { - int i; + size_t i; construct_block_lists(irg); @@ -2201,13 +2197,13 @@ static void dump_blocks_as_subgraphs(FILE *out, ir_graph *irg) * only the requested irg but also all irgs that can be reached * from irg. */ - for (i = get_irp_n_irgs() - 1; i >= 0; --i) { - ir_graph *irg = get_irp_irg(i); - ir_node **arr = ird_get_irg_link(irg); + for (i = get_irp_n_irgs(); i > 0;) { + ir_graph *other_irg = get_irp_irg(--i); + ir_node **arr = (ir_node**)ird_get_irg_link(other_irg); if (arr == NULL) continue; - dump_graph_from_list(out, irg); + dump_graph_from_list(out, other_irg); DEL_ARR_F(arr); } } @@ -2216,23 +2212,23 @@ static void dump_blocks_as_subgraphs(FILE *out, ir_graph *irg) * The outermost nodes: blocks and nodes not op_pin_state_pinned, Bad, Unknown. */ static void dump_extblock_graph(FILE *F, ir_graph *irg) { - int i; + size_t i, arr_len; ir_graph *rem = current_ir_graph; - ir_extblk **arr = ird_get_irg_link(irg); + ir_extblk **arr = (ir_extblk**)ird_get_irg_link(irg); current_ir_graph = irg; - for (i = ARR_LEN(arr) - 1; i >= 0; --i) { + for (i = 0, arr_len = ARR_LEN(arr); i < arr_len; ++i) { ir_extblk *extbb = arr[i]; ir_node *leader = get_extbb_leader(extbb); - int j; + size_t j, n_blks; fprintf(F, "graph: { title: \""); PRINT_EXTBBID(leader); fprintf(F, "\" label: \"ExtBB %ld\" status:clustered color:lightgreen\n", get_irn_node_nr(leader)); - for (j = ARR_LEN(extbb->blks) - 1; j >= 0; --j) { - ir_node * node = extbb->blks[j]; + for (j = 0, n_blks = ARR_LEN(extbb->blks); j < n_blks; ++j) { + ir_node *node = extbb->blks[j]; if (is_Block(node)) { /* Dumps the block and all the nodes in the block, which are to be found in Block->link. */ @@ -2250,7 +2246,7 @@ static void dump_extblock_graph(FILE *F, ir_graph *irg) } if ((flags & ir_dump_flag_loops) - && (get_irg_loopinfo_state(irg) & loopinfo_valid)) + && (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_LOOPINFO))) dump_loop_nodes_into_graph(F, irg); current_ir_graph = rem; @@ -2259,10 +2255,10 @@ static void dump_extblock_graph(FILE *F, ir_graph *irg) static void dump_blocks_extbb_grouped(FILE *F, ir_graph *irg) { - int i; + size_t i; ir_entity *ent = get_irg_entity(irg); - if (get_irg_extblk_state(irg) != extblk_valid) + if (!is_irg_state(irg, IR_GRAPH_STATE_VALID_EXTENDED_BLOCKS)) compute_extbb(irg); construct_extblock_lists(irg); @@ -2275,21 +2271,21 @@ static void dump_blocks_extbb_grouped(FILE *F, ir_graph *irg) dump_graph_info(F, irg); print_dbg_info(F, get_entity_dbg_info(ent)); - for (i = get_irp_n_irgs() - 1; i >= 0; --i) { - ir_graph *irg = get_irp_irg(i); - list_tuple *lists = ird_get_irg_link(irg); + for (i = get_irp_n_irgs(); i > 0;) { + ir_graph *other_irg = get_irp_irg(--i); + list_tuple *lists = (list_tuple*)ird_get_irg_link(other_irg); if (lists) { /* dump the extended blocks first */ if (ARR_LEN(lists->extbb_list)) { - ird_set_irg_link(irg, lists->extbb_list); - dump_extblock_graph(F, irg); + ird_set_irg_link(other_irg, lists->extbb_list); + dump_extblock_graph(F, other_irg); } /* we may have blocks without extended blocks, bad for instance */ if (ARR_LEN(lists->blk_list)) { - ird_set_irg_link(irg, lists->blk_list); - dump_block_graph(F, irg); + ird_set_irg_link(other_irg, lists->blk_list); + dump_block_graph(F, other_irg); } DEL_ARR_F(lists->extbb_list); @@ -2340,7 +2336,7 @@ void dump_ir_graph_file(FILE *out, ir_graph *irg) /* dump the out edges in a separate walk */ if ((flags & ir_dump_flag_out_edges) - && (get_irg_outs_state(irg) != outs_none)) { + && (is_irg_state(irg, IR_GRAPH_STATE_CONSISTENT_OUTS))) { irg_out_walk(get_irg_start(irg), dump_out_edge, NULL, out); } @@ -2349,9 +2345,12 @@ void dump_ir_graph_file(FILE *out, ir_graph *irg) static void dump_block_to_cfg(ir_node *block, void *env) { - FILE *F = env; - int i, fl = 0; - ir_node *pred; + FILE *F = (FILE*)env; + int i; + + if (is_Bad(block) && get_irn_mode(block) == mode_X) { + dump_node(F, block); + } if (is_Block(block)) { /* This is a block. Dump a node for the block. */ @@ -2370,43 +2369,38 @@ static void dump_block_to_cfg(ir_node *block, void *env) /* the generic version. */ dump_irnode_to_file(F, block); - /* Check whether we have bad predecessors to color the block. */ - for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) - if ((fl = is_Bad(get_Block_cfgpred(block, i)))) - break; - fprintf(F, "\""); /* closing quote of info */ if ((block == get_irg_start_block(get_irn_irg(block))) || (block == get_irg_end_block(get_irn_irg(block))) ) fprintf(F, " color:blue "); - else if (fl) - fprintf(F, " color:yellow "); fprintf(F, "}\n"); + /* Dump the edges */ - for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) - if (!is_Bad(skip_Proj(get_Block_cfgpred(block, i)))) { - pred = get_nodes_block(skip_Proj(get_Block_cfgpred(block, i))); - fprintf(F, "edge: { sourcename: \""); - PRINT_NODEID(block); - fprintf(F, "\" targetname: \""); - PRINT_NODEID(pred); - fprintf(F, "\"}\n"); - } + for (i = get_Block_n_cfgpreds(block) - 1; i >= 0; --i) { + ir_node *pred = get_Block_cfgpred(block, i); + if (!is_Bad(pred)) + pred = get_nodes_block(pred); + fprintf(F, "edge: { sourcename: \""); + PRINT_NODEID(block); + fprintf(F, "\" targetname: \""); + PRINT_NODEID(pred); + fprintf(F, "\"}\n"); + } /* Dump dominator/postdominator edge */ if (ir_get_dump_flags() & ir_dump_flag_dominance) { - if (get_irg_dom_state(current_ir_graph) == dom_consistent && get_Block_idom(block)) { - pred = get_Block_idom(block); + if (is_irg_state(get_irn_irg(block), IR_GRAPH_STATE_CONSISTENT_DOMINANCE) && get_Block_idom(block)) { + ir_node *pred = get_Block_idom(block); fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(block); fprintf(F, "\" targetname: \""); PRINT_NODEID(pred); fprintf(F, "\" " DOMINATOR_EDGE_ATTR "}\n"); } - if (get_irg_postdom_state(current_ir_graph) == dom_consistent && get_Block_ipostdom(block)) { - pred = get_Block_ipostdom(block); + if (is_irg_state(get_irn_irg(block), IR_GRAPH_STATE_CONSISTENT_POSTDOMINANCE) && get_Block_ipostdom(block)) { + ir_node *pred = get_Block_ipostdom(block); fprintf(F, "edge: { sourcename: \""); PRINT_NODEID(block); fprintf(F, "\" targetname: \""); @@ -2422,33 +2416,31 @@ void dump_cfg(FILE *F, ir_graph *irg) dump_vcg_header(F, get_irg_dump_name(irg), NULL, NULL); /* walk over the blocks in the graph */ - irg_block_walk(get_irg_end(irg), dump_block_to_cfg, NULL, F); - dump_node(F, get_irg_bad(irg)); + irg_walk_graph(irg, dump_block_to_cfg, NULL, F); dump_vcg_footer(F); } void dump_callgraph(FILE *F) { - int i; + size_t i; ir_dump_flags_t old_flags = ir_get_dump_flags(); ir_remove_dump_flags(ir_dump_flag_disable_edge_labels); dump_vcg_header(F, "Callgraph", "Hierarchic", NULL); - for (i = get_irp_n_irgs() - 1; i >= 0; --i) { - ir_graph *irg = get_irp_irg(i); + for (i = get_irp_n_irgs(); i > 0;) { + ir_graph *irg = get_irp_irg(--i); ir_entity *ent = get_irg_entity(irg); - int j; - int n_callees = get_irg_n_callees(irg); + size_t j, n_callees = get_irg_n_callees(irg); dump_entity_node(F, ent); for (j = 0; j < n_callees; ++j) { ir_entity *c = get_irg_entity(get_irg_callee(irg, j)); int be = is_irg_callee_backedge(irg, j); const char *attr = be - ? "label:\"recursion %d\"" - : "label:\"calls %d\""; + ? "label:\"recursion %zu\"" + : "label:\"calls %zu\""; print_ent_ent_edge(F, ent, c, be, ird_color_entity, attr, get_irg_callee_loop_depth(irg, j)); } @@ -2474,7 +2466,10 @@ void dump_class_hierarchy(FILE *out) static void dump_loops_standalone(FILE *F, ir_loop *loop) { - int i = 0, loop_node_started = 0, son_number = 0, first = 0; + size_t i; + bool loop_node_started = false; + size_t first = 0; + size_t son_number = 0; loop_element le; ir_loop *son = NULL; @@ -2495,8 +2490,11 @@ static void dump_loops_standalone(FILE *F, ir_loop *loop) PRINT_LOOPID(loop); fprintf(F, "\" targetname: \""); PRINT_LOOPID(loop); - fprintf(F, "-%d-nodes\" label:\"%d...%d\"}\n", first, first, i-1); - loop_node_started = 0; + fprintf(F, "-%lu-nodes\" label:\"%lu...%lu\"}\n", + (unsigned long) first, + (unsigned long) first, + (unsigned long) i-1); + loop_node_started = false; } dump_loop_son_edge(F, loop, son_number++); dump_loops_standalone(F, son); @@ -2508,8 +2506,9 @@ static void dump_loops_standalone(FILE *F, ir_loop *loop) /* Start a new node which contains all firm nodes of the current loop */ fprintf(F, "node: { title: \""); PRINT_LOOPID(loop); - fprintf(F, "-%d-nodes\" color: lightyellow label: \"", i); - loop_node_started = 1; + fprintf(F, "-%lu-nodes\" color: lightyellow label: \"", + (unsigned long)i); + loop_node_started = true; first = i; } else fprintf(F, "\n"); @@ -2527,8 +2526,9 @@ static void dump_loops_standalone(FILE *F, ir_loop *loop) /* Start a new node which contains all firm nodes of the current loop */ fprintf(F, "node: { title: \""); PRINT_LOOPID(loop); - fprintf(F, "-%d-nodes\" color: lightyellow label: \"", i); - loop_node_started = 1; + fprintf(F, "-%lu-nodes\" color: lightyellow label: \"", + (unsigned long)i); + loop_node_started = true; first = i; } else fprintf(F, "\n"); @@ -2543,8 +2543,11 @@ static void dump_loops_standalone(FILE *F, ir_loop *loop) PRINT_LOOPID(loop); fprintf(F, "\" targetname: \""); PRINT_LOOPID(loop); - fprintf(F, "-%d-nodes\" label:\"%d...%d\"}\n", first, first, i-1); - loop_node_started = 0; + fprintf(F, "-%lu-nodes\" label:\"%lu...%lu\"}\n", + (unsigned long) first, + (unsigned long) first, + (unsigned long) i-1); + loop_node_started = false; } } @@ -2576,7 +2579,9 @@ void dump_callgraph_loop_tree(FILE *out) static void collect_nodeloop(FILE *F, ir_loop *loop, eset *loopnodes) { - int i, son_number = 0, node_number = 0; + size_t i; + int son_number = 0; + int node_number = 0; if (flags & ir_dump_flag_loops) dump_loop_node(F, loop); @@ -2599,7 +2604,8 @@ static void collect_nodeloop(FILE *F, ir_loop *loop, eset *loopnodes) static void collect_nodeloop_external_nodes(ir_loop *loop, eset *loopnodes, eset *extnodes) { - int i, j, start; + size_t i; + int j, start; for (i = 0; i < get_loop_n_elements(loop); i++) { loop_element le = get_loop_element(loop, i); @@ -2629,7 +2635,7 @@ void dump_loop(FILE *F, ir_loop *l) ir_node *n, *b; char name[50]; - snprintf(name, sizeof(name), "loop_%d", get_loop_loop_nr(l)); + snprintf(name, sizeof(name), "loop_%ld", get_loop_loop_nr(l)); dump_vcg_header(F, name, NULL, NULL); /* collect all nodes to dump */ @@ -2637,18 +2643,20 @@ void dump_loop(FILE *F, ir_loop *l) collect_nodeloop_external_nodes(l, loopnodes, extnodes); /* build block lists */ - for (n = eset_first(loopnodes); n != NULL; n = eset_next(loopnodes)) + eset_foreach(loopnodes, ir_node*, n) { set_irn_link(n, NULL); - for (n = eset_first(extnodes); n != NULL; n = eset_next(extnodes)) + } + eset_foreach(extnodes, ir_node*, n) { set_irn_link(n, NULL); - for (n = eset_first(loopnodes); n != NULL; n = eset_next(loopnodes)) { + } + eset_foreach(loopnodes, ir_node*, n) { if (!is_Block(n)) { b = get_nodes_block(n); set_irn_link(n, get_irn_link(b)); set_irn_link(b, n); } } - for (n = eset_first(extnodes); n != NULL; n = eset_next(extnodes)) { + eset_foreach(extnodes, ir_node*, n) { if (!is_Block(n)) { b = get_nodes_block(n); set_irn_link(n, get_irn_link(b)); @@ -2656,20 +2664,20 @@ void dump_loop(FILE *F, ir_loop *l) } } - for (b = eset_first(loopnodes); b != NULL; b = eset_next(loopnodes)) { + eset_foreach(loopnodes, ir_node*, b) { if (is_Block(b)) { fprintf(F, "graph: { title: \""); PRINT_NODEID(b); fprintf(F, "\" label: \""); dump_node_opcode(F, b); - fprintf(F, " %ld:%d", get_irn_node_nr(b), get_irn_idx(b)); + fprintf(F, " %ld:%u", get_irn_node_nr(b), get_irn_idx(b)); fprintf(F, "\" status:clustered color:yellow\n"); /* dump the blocks edges */ dump_ir_data_edges(F, b); /* dump the nodes that go into the block */ - for (n = get_irn_link(b); n; n = get_irn_link(n)) { + for (n = (ir_node*)get_irn_link(b); n; n = (ir_node*)get_irn_link(n)) { if (eset_contains(extnodes, n)) overrule_nodecolor = ird_color_block_inout; dump_node(F, n); @@ -2683,17 +2691,17 @@ void dump_loop(FILE *F, ir_loop *l) fprintf(F, "\n"); } } - for (b = eset_first(extnodes); b != NULL; b = eset_next(extnodes)) { + eset_foreach(extnodes, ir_node*, b) { if (is_Block(b)) { fprintf(F, "graph: { title: \""); PRINT_NODEID(b); fprintf(F, "\" label: \""); dump_node_opcode(F, b); - fprintf(F, " %ld:%d", get_irn_node_nr(b), get_irn_idx(b)); + fprintf(F, " %ld:%u", get_irn_node_nr(b), get_irn_idx(b)); fprintf(F, "\" status:clustered color:lightblue\n"); /* dump the nodes that go into the block */ - for (n = get_irn_link(b); n; n = get_irn_link(n)) { + for (n = (ir_node*)get_irn_link(b); n; n = (ir_node*)get_irn_link(n)) { if (!eset_contains(loopnodes, n)) overrule_nodecolor = ird_color_block_inout; dump_node(F, n); @@ -2777,7 +2785,7 @@ void dump_ir_graph_ext(ir_graph_dump_func func, ir_graph *graph, } obstack_1grow(&obst, '\0'); - file_name = obstack_finish(&obst); + file_name = (char*)obstack_finish(&obst); /* xvcg expects only so we need "b"inary mode (for win32) */ out = fopen(file_name, "wb"); obstack_free(&obst, file_name); @@ -2806,7 +2814,7 @@ void dump_ir_prog_ext(ir_prog_dump_func func, const char *suffix) } obstack_1grow(&obst, '\0'); - file_name = obstack_finish(&obst); + file_name = (char*)obstack_finish(&obst); out = fopen(file_name, "wb"); obstack_free(&obst, file_name); @@ -2828,8 +2836,7 @@ void dump_ir_graph(ir_graph *graph, const char *suffix) void dump_all_ir_graphs(const char *suffix) { - int n_irgs = get_irp_n_irgs(); - int i; + size_t i, n_irgs = get_irp_n_irgs(); for (i = 0; i < n_irgs; ++i) { ir_graph *irg = get_irp_irg(i); @@ -2837,17 +2844,17 @@ void dump_all_ir_graphs(const char *suffix) } } -struct pass_t { +typedef struct pass_t { ir_prog_pass_t pass; char suffix[1]; -}; +} pass_t; /** * Wrapper around dump_all_ir_graphs(). */ static int dump_all_ir_graphs_wrapper(ir_prog *irp, void *context) { - struct pass_t *pass = context; + pass_t *pass = (pass_t*)context; (void)irp; dump_all_ir_graphs(pass->suffix); @@ -2856,8 +2863,8 @@ static int dump_all_ir_graphs_wrapper(ir_prog *irp, void *context) ir_prog_pass_t *dump_all_ir_graph_pass(const char *name, const char *suffix) { - size_t len = strlen(suffix); - struct pass_t *pass = xmalloc(sizeof(*pass) + len); + size_t len = strlen(suffix) + 1; + pass_t *pass = XMALLOCF(pass_t, suffix, len); ir_prog_pass_t *res = def_prog_pass_constructor( &pass->pass, name ? name : "dump_all_graphs", dump_all_ir_graphs_wrapper); @@ -2865,7 +2872,7 @@ ir_prog_pass_t *dump_all_ir_graph_pass(const char *name, const char *suffix) res->dump_irprog = ir_prog_no_dump; res->verify_irprog = ir_prog_no_verify; - memcpy(pass->suffix, suffix, len+1); + memcpy(pass->suffix, suffix, len); return res; }