/*
- * 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.
*
#include "irtools.h"
#include "irprintf.h"
-#include "irvrfy.h"
+#include "irverify.h"
#include "error.h"
#include "array.h"
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. */
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);
}
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);
}
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);
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);
}
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);
}
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);
}
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);
}
* 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);
}
/* 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);
/*-----------------------------------------------------------------*/
}
/**
- * 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)
*/
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;
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);
}
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;
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);
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])) {
} 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)))
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;
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 */
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;
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
};
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
};
{ 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) },
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));
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);
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 <math.h>
-#include "execution_frequency.h"
-
static void dump_node_ana_vals(FILE *F, ir_node *n)
{
(void) F;
}
}
-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.
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);
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;
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);
}
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);
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);
static void dump_ir_block_edge(FILE *F, ir_node *n)
{
if (get_opt_dump_const_local() && is_constlike_node(n)) return;
- if (is_no_Block(n)) {
+ if (!is_Block(n)) {
ir_node *block = get_nodes_block(n);
if (get_opt_dump_const_local() && is_constlike_node(block)) {
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);
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");
- }
}
/**
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) {
/** 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);
}
/** 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);
/* 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);
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);
}
* 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. */
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;
{
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");
}
/** 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)) {
break;
default:
break;
- } /* switch type */
+ }
}
#endif
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);
}
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);
(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 */
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)) {
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),
/* 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:
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.
*/
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)) {
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;
}
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 */
+ }
}
/*******************************************************************/
/* 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);
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, "\"");
}
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: \"");
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);
}
static void dump_blocks_as_subgraphs(FILE *out, ir_graph *irg)
{
- int i;
+ size_t i;
construct_block_lists(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);
}
}
* 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. */
}
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;
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);
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);
/* 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);
}
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. */
/* 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: \"");
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));
}
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;
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);
/* 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");
/* 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");
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;
}
}
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);
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);
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 */
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));
}
}
- 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);
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);
}
obstack_1grow(&obst, '\0');
- file_name = obstack_finish(&obst);
+ file_name = (char*)obstack_finish(&obst);
/* xvcg expects only <CR> so we need "b"inary mode (for win32) */
out = fopen(file_name, "wb");
obstack_free(&obst, file_name);
}
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);
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);
}
}
-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);
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);
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;
}
projects / libfirm / blobdiff