This is the mail archive of the
gcc-patches@gcc.gnu.org
mailing list for the GCC project.
Re: [ping] C++ fixes in the controll flow graph (cfg*)
Hello,
> > I have moved struct edge to graphds.h in a recent patch, so this part
> > needs to be slightly changed. I would recommend renaming struct edge to
> > something like struct graph_edge (instead of struct cfg_edge), since the
> > graphs represented using graphds.h do not necessarily have to be related
> > to cfg.
> Like this? Tested on x86_64.
yes (modulo the formating of the changelog entry).
Zdenek
> Thomas
>
> * cfg.c (init_flow): Use type safe memory macros.
> (alloc_block): Likewise.
> (unchecked_make_edge): Likewise:
> (dump_flow_info): Avoid using C++ keywords as variable names.
> (copy_original_table_clear): Cast according to the coding conventions.
> (copy_original_table_set): Likewise.
> * cfgexpand (label_rtx_for_bb): Likewise.
> (expand_gimüle_basic_block): Likewise.
> * cfghooks.c (dump_bb): Likewise.
> (lv_adjust_loop_header_phi): Avoid using C++ keywords as variable names.
> (lv_add_condition_to_bb): Likewise.
> * cfglayout (relink_block_chain): Cast according to the coding conventions.
> (fixup_reorder_chain): Likewise.
> (fixup_fallthru_exit_predecessor): Likewise.
> * cfgloop.c (glb_enum_p): Likewise.
> (get_exit_description): Likewise.
> (dump_recorded_exit): Likewise.
> * cfgloop.h (enum loop_estimation): Move out of struct scope...
> (struct loop): ... from here.
> * cfgloopmanip (rpe_enum_p): Cast according to the coding conventions.
> * cfgrtl.c (rtl_create_basic_block): Likewise.
> (rtl_split_block): Likewise.
> (rtl_dump_bb): Likewise.
> (cfg_layout_split_block): Likewise.
> (init_rtl_bb_info): Use typesafe memory macros.
>
> * graphds.h (struct graph_edge): Renamed edge to graph_edge.
> * graphds.h graphds.c cfgloopanal.c: Updated all usages of edge to
> graph_edge.
> Index: gcc/cfg.c
> ===================================================================
> --- gcc/cfg.c (Revision 125313)
> +++ gcc/cfg.c (Arbeitskopie)
> @@ -83,11 +83,11 @@ void
> init_flow (void)
> {
> if (!cfun->cfg)
> - cfun->cfg = ggc_alloc_cleared (sizeof (struct control_flow_graph));
> + cfun->cfg = GGC_CNEW (struct control_flow_graph);
> n_edges = 0;
> - ENTRY_BLOCK_PTR = ggc_alloc_cleared (sizeof (struct basic_block_def));
> + ENTRY_BLOCK_PTR = GGC_CNEW (struct basic_block_def);
> ENTRY_BLOCK_PTR->index = ENTRY_BLOCK;
> - EXIT_BLOCK_PTR = ggc_alloc_cleared (sizeof (struct basic_block_def));
> + EXIT_BLOCK_PTR = GGC_CNEW (struct basic_block_def);
> EXIT_BLOCK_PTR->index = EXIT_BLOCK;
> ENTRY_BLOCK_PTR->next_bb = EXIT_BLOCK_PTR;
> EXIT_BLOCK_PTR->prev_bb = ENTRY_BLOCK_PTR;
> @@ -134,7 +134,7 @@ basic_block
> alloc_block (void)
> {
> basic_block bb;
> - bb = ggc_alloc_cleared (sizeof (*bb));
> + bb = GGC_CNEW (struct basic_block_def);
> return bb;
> }
>
> @@ -264,7 +264,7 @@ edge
> unchecked_make_edge (basic_block src, basic_block dst, int flags)
> {
> edge e;
> - e = ggc_alloc_cleared (sizeof (*e));
> + e = GGC_CNEW (struct edge_def);
> n_edges++;
>
> e->src = src;
> @@ -542,7 +542,7 @@ dump_flow_info (FILE *file, int flags)
> for (i = FIRST_PSEUDO_REGISTER; i < max; i++)
> if (REG_N_REFS (i))
> {
> - enum reg_class class, altclass;
> + enum reg_class prefclass, altclass;
>
> fprintf (file, "\nRegister %d used %d times across %d insns",
> i, REG_N_REFS (i), REG_LIVE_LENGTH (i));
> @@ -563,17 +563,17 @@ dump_flow_info (FILE *file, int flags)
> && PSEUDO_REGNO_BYTES (i) != UNITS_PER_WORD)
> fprintf (file, "; %d bytes", PSEUDO_REGNO_BYTES (i));
>
> - class = reg_preferred_class (i);
> + prefclass = reg_preferred_class (i);
> altclass = reg_alternate_class (i);
> - if (class != GENERAL_REGS || altclass != ALL_REGS)
> + if (prefclass != GENERAL_REGS || altclass != ALL_REGS)
> {
> - if (altclass == ALL_REGS || class == ALL_REGS)
> - fprintf (file, "; pref %s", reg_class_names[(int) class]);
> + if (altclass == ALL_REGS || prefclass == ALL_REGS)
> + fprintf (file, "; pref %s", reg_class_names[(int) prefclass]);
> else if (altclass == NO_REGS)
> - fprintf (file, "; %s or none", reg_class_names[(int) class]);
> + fprintf (file, "; %s or none", reg_class_names[(int) prefclass]);
> else
> fprintf (file, "; pref %s, else %s",
> - reg_class_names[(int) class],
> + reg_class_names[(int) prefclass],
> reg_class_names[(int) altclass]);
> }
>
> @@ -1107,7 +1107,7 @@ copy_original_table_clear (htab_t tab, u
> if (!slot)
> return;
>
> - elt = *slot;
> + elt = (struct htab_bb_copy_original_entry *) *slot;
> htab_clear_slot (tab, slot);
> pool_free (original_copy_bb_pool, elt);
> }
> @@ -1129,7 +1129,8 @@ copy_original_table_set (htab_t tab, uns
> htab_find_slot (tab, &key, INSERT);
> if (!*slot)
> {
> - *slot = pool_alloc (original_copy_bb_pool);
> + *slot = (struct htab_bb_copy_original_entry *)
> + pool_alloc (original_copy_bb_pool);
> (*slot)->index1 = obj;
> }
> (*slot)->index2 = val;
> Index: gcc/cfgexpand.c
> ===================================================================
> --- gcc/cfgexpand.c (Revision 125313)
> +++ gcc/cfgexpand.c (Arbeitskopie)
> @@ -1262,7 +1262,7 @@ label_rtx_for_bb (basic_block bb)
>
> elt = pointer_map_contains (lab_rtx_for_bb, bb);
> if (elt)
> - return *elt;
> + return (rtx) *elt;
>
> /* Find the tree label if it is present. */
>
> @@ -1281,7 +1281,7 @@ label_rtx_for_bb (basic_block bb)
>
> elt = pointer_map_insert (lab_rtx_for_bb, bb);
> *elt = gen_label_rtx ();
> - return *elt;
> + return (rtx) *elt;
> }
>
> /* A subroutine of expand_gimple_basic_block. Expand one COND_EXPR.
> @@ -1538,7 +1538,7 @@ expand_gimple_basic_block (basic_block b
> }
>
> if (elt)
> - emit_label (*elt);
> + emit_label ((rtx) *elt);
>
> /* Java emits line number notes in the top of labels.
> ??? Make this go away once line number notes are obsoleted. */
> Index: gcc/cfghooks.c
> ===================================================================
> --- gcc/cfghooks.c (Revision 125313)
> +++ gcc/cfghooks.c (Arbeitskopie)
> @@ -259,7 +259,7 @@ dump_bb (basic_block bb, FILE *outf, int
> edge_iterator ei;
> char *s_indent;
>
> - s_indent = alloca ((size_t) indent + 1);
> + s_indent = (char *) alloca ((size_t) indent + 1);
> memset (s_indent, ' ', (size_t) indent);
> s_indent[indent] = '\0';
>
> @@ -1043,10 +1043,10 @@ extract_cond_bb_edges (basic_block b, ed
> new condition basic block that guards the versioned loop. */
> void
> lv_adjust_loop_header_phi (basic_block first, basic_block second,
> - basic_block new, edge e)
> + basic_block new_block, edge e)
> {
> if (cfg_hooks->lv_adjust_loop_header_phi)
> - cfg_hooks->lv_adjust_loop_header_phi (first, second, new, e);
> + cfg_hooks->lv_adjust_loop_header_phi (first, second, new_block, e);
> }
>
> /* Conditions in trees and RTL are different so we need
> @@ -1054,8 +1054,8 @@ lv_adjust_loop_header_phi (basic_block f
> versioning code. */
> void
> lv_add_condition_to_bb (basic_block first, basic_block second,
> - basic_block new, void *cond)
> + basic_block new_block, void *cond)
> {
> gcc_assert (cfg_hooks->lv_add_condition_to_bb);
> - cfg_hooks->lv_add_condition_to_bb (first, second, new, cond);
> + cfg_hooks->lv_add_condition_to_bb (first, second, new_block, cond);
> }
> Index: gcc/cfglayout.c
> ===================================================================
> --- gcc/cfglayout.c (Revision 125313)
> +++ gcc/cfglayout.c (Arbeitskopie)
> @@ -627,7 +627,7 @@ relink_block_chain (bool stay_in_cfglayo
> fprintf (dump_file, "Reordered sequence:\n");
> for (bb = ENTRY_BLOCK_PTR->next_bb, index = NUM_FIXED_BLOCKS;
> bb;
> - bb = bb->aux, index++)
> + bb = (basic_block) bb->aux, index++)
> {
> fprintf (dump_file, " %i ", index);
> if (get_bb_original (bb))
> @@ -645,7 +645,7 @@ relink_block_chain (bool stay_in_cfglayo
> /* Now reorder the blocks. */
> prev_bb = ENTRY_BLOCK_PTR;
> bb = ENTRY_BLOCK_PTR->next_bb;
> - for (; bb; prev_bb = bb, bb = bb->aux)
> + for (; bb; prev_bb = bb, bb = (basic_block) bb->aux)
> {
> bb->prev_bb = prev_bb;
> prev_bb->next_bb = bb;
> @@ -693,7 +693,7 @@ fixup_reorder_chain (void)
> /* First do the bulk reordering -- rechain the blocks without regard to
> the needed changes to jumps and labels. */
>
> - for (bb = ENTRY_BLOCK_PTR->next_bb; bb; bb = bb->aux)
> + for (bb = ENTRY_BLOCK_PTR->next_bb; bb; bb = (basic_block) bb->aux)
> {
> if (bb->il.rtl->header)
> {
> @@ -736,7 +736,7 @@ fixup_reorder_chain (void)
> /* Now add jumps and labels as needed to match the blocks new
> outgoing edges. */
>
> - for (bb = ENTRY_BLOCK_PTR->next_bb; bb ; bb = bb->aux)
> + for (bb = ENTRY_BLOCK_PTR->next_bb; bb ; bb = (basic_block) bb->aux)
> {
> edge e_fall, e_taken, e;
> rtx bb_end_insn;
> @@ -951,11 +951,11 @@ fixup_fallthru_exit_predecessor (void)
> }
>
> while (c->aux != bb)
> - c = c->aux;
> + c = (basic_block) c->aux;
>
> c->aux = bb->aux;
> while (c->aux)
> - c = c->aux;
> + c = (basic_block) c->aux;
>
> c->aux = bb;
> bb->aux = NULL;
> Index: gcc/cfgloopanal.c
> ===================================================================
> --- gcc/cfgloopanal.c (Revision 125313)
> +++ gcc/cfgloopanal.c (Arbeitskopie)
> @@ -55,9 +55,9 @@ just_once_each_iteration_p (const struct
> same scc. */
>
> static void
> -check_irred (struct graph *g, struct edge *e)
> +check_irred (struct graph *g, struct graph_edge *e)
> {
> - edge real = e->data;
> + edge real = (edge) e->data;
>
> /* All edges should lead from a component with higher number to the
> one with lower one. */
> Index: gcc/cfgloop.c
> ===================================================================
> --- gcc/cfgloop.c (Revision 125313)
> +++ gcc/cfgloop.c (Arbeitskopie)
> @@ -776,7 +776,7 @@ flow_bb_inside_loop_p (const struct loop
> static bool
> glb_enum_p (basic_block bb, void *glb_loop)
> {
> - struct loop *loop = glb_loop;
> + struct loop *loop = (struct loop *) glb_loop;
> return (bb != loop->header
> && dominated_by_p (CDI_DOMINATORS, bb, loop->header));
> }
> @@ -974,8 +974,8 @@ loop_exit_free (void *ex)
> static struct loop_exit *
> get_exit_descriptions (edge e)
> {
> - return htab_find_with_hash (current_loops->exits, e,
> - htab_hash_pointer (e));
> + return (struct loop_exit *) htab_find_with_hash (current_loops->exits, e,
> + htab_hash_pointer (e));
> }
>
> /* Updates the lists of loop exits in that E appears.
> @@ -1075,14 +1075,14 @@ record_loop_exits (void)
> static int
> dump_recorded_exit (void **slot, void *file)
> {
> - struct loop_exit *exit = *slot;
> + struct loop_exit *exit = (struct loop_exit *) *slot;
> unsigned n = 0;
> edge e = exit->e;
>
> for (; exit != NULL; exit = exit->next_e)
> n++;
>
> - fprintf (file, "Edge %d->%d exits %u loops\n",
> + fprintf ((FILE*) file, "Edge %d->%d exits %u loops\n",
> e->src->index, e->dest->index, n);
>
> return 1;
> Index: gcc/cfgloop.h
> ===================================================================
> --- gcc/cfgloop.h (Revision 125313)
> +++ gcc/cfgloop.h (Arbeitskopie)
> @@ -90,6 +90,16 @@ DEF_VEC_P (loop_p);
> DEF_VEC_ALLOC_P (loop_p, heap);
> DEF_VEC_ALLOC_P (loop_p, gc);
>
> +/* An integer estimation of the number of iterations. Estimate_state
> + describes what is the state of the estimation. */
> +enum loop_estimation
> +{
> + /* Estimate was not computed yet. */
> + EST_NOT_COMPUTED,
> + /* Estimate is ready. */
> + EST_AVAILABLE
> +};
> +
> /* Structure to hold information for each natural loop. */
> struct loop GTY ((chain_next ("%h.next")))
> {
> @@ -135,13 +145,7 @@ struct loop GTY ((chain_next ("%h.next")
>
> /* An integer estimation of the number of iterations. Estimate_state
> describes what is the state of the estimation. */
> - enum
> - {
> - /* Estimate was not computed yet. */
> - EST_NOT_COMPUTED,
> - /* Estimate is ready. */
> - EST_AVAILABLE
> - } estimate_state;
> + enum loop_estimation estimate_state;
>
> /* An integer guaranteed to bound the number of iterations of the loop
> from above. */
> Index: gcc/cfgloopmanip.c
> ===================================================================
> --- gcc/cfgloopmanip.c (Revision 125313)
> +++ gcc/cfgloopmanip.c (Arbeitskopie)
> @@ -49,7 +49,7 @@ static void unloop (struct loop *, bool
> static bool
> rpe_enum_p (basic_block bb, void *data)
> {
> - return dominated_by_p (CDI_DOMINATORS, bb, data);
> + return dominated_by_p (CDI_DOMINATORS, bb, (basic_block) data);
> }
>
> /* Remove basic blocks BBS. NBBS is the number of the basic blocks. */
> Index: gcc/cfgrtl.c
> ===================================================================
> --- gcc/cfgrtl.c (Revision 125313)
> +++ gcc/cfgrtl.c (Arbeitskopie)
> @@ -321,7 +321,7 @@ create_basic_block_structure (rtx head,
> static basic_block
> rtl_create_basic_block (void *headp, void *endp, basic_block after)
> {
> - rtx head = headp, end = endp;
> + rtx head = (rtx) headp, end = (rtx) endp;
> basic_block bb;
>
> /* Grow the basic block array if needed. */
> @@ -474,7 +474,7 @@ static basic_block
> rtl_split_block (basic_block bb, void *insnp)
> {
> basic_block new_bb;
> - rtx insn = insnp;
> + rtx insn = (rtx) insnp;
> edge e;
> edge_iterator ei;
>
> @@ -1519,7 +1519,7 @@ rtl_dump_bb (basic_block bb, FILE *outf,
> rtx last;
> char *s_indent;
>
> - s_indent = alloca ((size_t) indent + 1);
> + s_indent = (char *) alloca ((size_t) indent + 1);
> memset (s_indent, ' ', (size_t) indent);
> s_indent[indent] = '\0';
>
> @@ -2300,7 +2300,7 @@ purge_all_dead_edges (void)
> static basic_block
> cfg_layout_split_block (basic_block bb, void *insnp)
> {
> - rtx insn = insnp;
> + rtx insn = (rtx) insnp;
> basic_block new_bb = rtl_split_block (bb, insn);
>
> new_bb->il.rtl->footer = bb->il.rtl->footer;
> @@ -2879,7 +2879,7 @@ void
> init_rtl_bb_info (basic_block bb)
> {
> gcc_assert (!bb->il.rtl);
> - bb->il.rtl = ggc_alloc_cleared (sizeof (struct rtl_bb_info));
> + bb->il.rtl = GGC_CNEW (struct rtl_bb_info);
> }
>
>
> Index: gcc/graphds.c
> ===================================================================
> --- gcc/graphds.c (Revision 125313)
> +++ gcc/graphds.c (Arbeitskopie)
> @@ -34,7 +34,7 @@ void
> dump_graph (FILE *f, struct graph *g)
> {
> int i;
> - struct edge *e;
> + struct graph_edge *e;
>
> for (i = 0; i < g->n_vertices; i++)
> {
> @@ -69,10 +69,10 @@ new_graph (int n_vertices)
>
> /* Adds an edge from F to T to graph G. The new edge is returned. */
>
> -struct edge *
> +struct graph_edge *
> add_edge (struct graph *g, int f, int t)
> {
> - struct edge *e = XNEW (struct edge);
> + struct graph_edge *e = XNEW (struct graph_edge);
> struct vertex *vf = &g->vertices[f], *vt = &g->vertices[t];
>
>
> @@ -95,7 +95,7 @@ identify_vertices (struct graph *g, int
> {
> struct vertex *vv = &g->vertices[v];
> struct vertex *uu = &g->vertices[u];
> - struct edge *e, *next;
> + struct graph_edge *e, *next;
>
> for (e = uu->succ; e; e = next)
> {
> @@ -122,7 +122,7 @@ identify_vertices (struct graph *g, int
> direction given by FORWARD. */
>
> static inline int
> -dfs_edge_src (struct edge *e, bool forward)
> +dfs_edge_src (struct graph_edge *e, bool forward)
> {
> return forward ? e->src : e->dest;
> }
> @@ -131,7 +131,7 @@ dfs_edge_src (struct edge *e, bool forwa
> the direction given by FORWARD. */
>
> static inline int
> -dfs_edge_dest (struct edge *e, bool forward)
> +dfs_edge_dest (struct graph_edge *e, bool forward)
> {
> return forward ? e->dest : e->src;
> }
> @@ -139,8 +139,8 @@ dfs_edge_dest (struct edge *e, bool forw
> /* Helper function for graphds_dfs. Returns the first edge after E (including
> E), in the graph direction given by FORWARD, that belongs to SUBGRAPH. */
>
> -static inline struct edge *
> -foll_in_subgraph (struct edge *e, bool forward, bitmap subgraph)
> +static inline struct graph_edge *
> +foll_in_subgraph (struct graph_edge *e, bool forward, bitmap subgraph)
> {
> int d;
>
> @@ -162,10 +162,10 @@ foll_in_subgraph (struct edge *e, bool f
> /* Helper function for graphds_dfs. Select the first edge from V in G, in the
> direction given by FORWARD, that belongs to SUBGRAPH. */
>
> -static inline struct edge *
> +static inline struct graph_edge *
> dfs_fst_edge (struct graph *g, int v, bool forward, bitmap subgraph)
> {
> - struct edge *e;
> + struct graph_edge *e;
>
> e = (forward ? g->vertices[v].succ : g->vertices[v].pred);
> return foll_in_subgraph (e, forward, subgraph);
> @@ -174,8 +174,8 @@ dfs_fst_edge (struct graph *g, int v, bo
> /* Helper function for graphds_dfs. Returns the next edge after E, in the
> graph direction given by FORWARD, that belongs to SUBGRAPH. */
>
> -static inline struct edge *
> -dfs_next_edge (struct edge *e, bool forward, bitmap subgraph)
> +static inline struct graph_edge *
> +dfs_next_edge (struct graph_edge *e, bool forward, bitmap subgraph)
> {
> return foll_in_subgraph (forward ? e->succ_next : e->pred_next,
> forward, subgraph);
> @@ -192,8 +192,8 @@ graphds_dfs (struct graph *g, int *qs, i
> bool forward, bitmap subgraph)
> {
> int i, tick = 0, v, comp = 0, top;
> - struct edge *e;
> - struct edge **stack = XNEWVEC (struct edge *, g->n_vertices);
> + struct graph_edge *e;
> + struct graph_edge **stack = XNEWVEC (struct graph_edge *, g->n_vertices);
> bitmap_iterator bi;
> unsigned av;
>
> @@ -314,7 +314,7 @@ graphds_scc (struct graph *g, bitmap sub
> void
> for_each_edge (struct graph *g, graphds_edge_callback callback)
> {
> - struct edge *e;
> + struct graph_edge *e;
> int i;
>
> for (i = 0; i < g->n_vertices; i++)
> @@ -327,7 +327,7 @@ for_each_edge (struct graph *g, graphds_
> void
> free_graph (struct graph *g)
> {
> - struct edge *e, *n;
> + struct graph_edge *e, *n;
> struct vertex *v;
> int i;
>
> @@ -406,7 +406,7 @@ graphds_domtree (struct graph *g, int en
> int *marks = XCNEWVEC (int, g->n_vertices);
> int mark = 1, i, v, idom;
> bool changed = true;
> - struct edge *e;
> + struct graph_edge *e;
>
> /* We use a slight modification of the standard iterative algorithm, as
> described in
> Index: gcc/graphds.h
> ===================================================================
> --- gcc/graphds.h (Revision 125313)
> +++ gcc/graphds.h (Arbeitskopie)
> @@ -21,10 +21,10 @@ Software Foundation, 51 Franklin Street,
>
> /* Structure representing edge of a graph. */
>
> -struct edge
> +struct graph_edge
> {
> int src, dest; /* Source and destination. */
> - struct edge *pred_next, *succ_next;
> + struct graph_edge *pred_next, *succ_next;
> /* Next edge in predecessor and successor lists. */
> void *data; /* Data attached to the edge. */
> };
> @@ -33,7 +33,7 @@ struct edge
>
> struct vertex
> {
> - struct edge *pred, *succ;
> + struct graph_edge *pred, *succ;
> /* Lists of predecessors and successors. */
> int component; /* Number of dfs restarts before reaching the
> vertex. */
> @@ -52,12 +52,12 @@ struct graph
>
> struct graph *new_graph (int);
> void dump_graph (FILE *, struct graph *);
> -struct edge *add_edge (struct graph *, int, int);
> +struct graph_edge *add_edge (struct graph *, int, int);
> void identify_vertices (struct graph *, int, int);
> int graphds_dfs (struct graph *, int *, int,
> VEC (int, heap) **, bool, bitmap);
> int graphds_scc (struct graph *, bitmap);
> void graphds_domtree (struct graph *, int, int *, int *, int *);
> -typedef void (*graphds_edge_callback) (struct graph *, struct edge *);
> +typedef void (*graphds_edge_callback) (struct graph *, struct graph_edge *);
> void for_each_edge (struct graph *, graphds_edge_callback);
> void free_graph (struct graph *g);