1 /* Control flow graph manipulation code for GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
22 /* This file contains low level functions to manipulate the CFG and
23 analyze it. All other modules should not transform the data structure
24 directly and use abstraction instead. The file is supposed to be
25 ordered bottom-up and should not contain any code dependent on a
26 particular intermediate language (RTL or trees).
28 Available functionality:
29 - Initialization/deallocation
30 init_flow, clear_edges
31 - Low level basic block manipulation
32 alloc_block, expunge_block
34 make_edge, make_single_succ_edge, cached_make_edge, remove_edge
35 - Low level edge redirection (without updating instruction chain)
36 redirect_edge_succ, redirect_edge_succ_nodup, redirect_edge_pred
37 - Dumping and debugging
38 dump_flow_info, debug_flow_info, dump_edge_info
39 - Allocation of AUX fields for basic blocks
40 alloc_aux_for_blocks, free_aux_for_blocks, alloc_aux_for_block
42 - Consistency checking
44 - Dumping and debugging
45 print_rtl_with_bb, dump_bb, debug_bb, debug_bb_n
50 #include "coretypes.h"
54 #include "hard-reg-set.h"
55 #include "basic-block.h"
64 #include "alloc-pool.h"
68 /* The obstack on which the flow graph components are allocated. */
70 struct obstack flow_obstack;
71 static char *flow_firstobj;
73 /* Number of basic blocks in the current function. */
77 /* First free basic block number. */
81 /* Number of edges in the current function. */
85 /* The basic block array. */
87 varray_type basic_block_info;
89 /* The special entry and exit blocks. */
90 basic_block ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR;
92 /* Memory alloc pool for bb member rbi. */
95 void debug_flow_info (void);
96 static void free_edge (edge);
98 /* Indicate the presence of the profile. */
99 enum profile_status profile_status;
101 /* Called once at initialization time. */
106 static int initialized;
112 gcc_obstack_init (&flow_obstack);
113 flow_firstobj = obstack_alloc (&flow_obstack, 0);
118 obstack_free (&flow_obstack, flow_firstobj);
119 flow_firstobj = obstack_alloc (&flow_obstack, 0);
122 ENTRY_BLOCK_PTR = ggc_alloc_cleared (sizeof (*ENTRY_BLOCK_PTR));
123 ENTRY_BLOCK_PTR->index = ENTRY_BLOCK;
124 EXIT_BLOCK_PTR = ggc_alloc_cleared (sizeof (*EXIT_BLOCK_PTR));
125 EXIT_BLOCK_PTR->index = EXIT_BLOCK;
126 ENTRY_BLOCK_PTR->next_bb = EXIT_BLOCK_PTR;
127 EXIT_BLOCK_PTR->prev_bb = ENTRY_BLOCK_PTR;
130 /* Helper function for remove_edge and clear_edges. Frees edge structure
131 without actually unlinking it from the pred/succ lists. */
134 free_edge (edge e ATTRIBUTE_UNUSED)
140 /* Free the memory associated with the edge structures. */
154 edge next = e->succ_next;
164 e = ENTRY_BLOCK_PTR->succ;
167 edge next = e->succ_next;
173 EXIT_BLOCK_PTR->pred = NULL;
174 ENTRY_BLOCK_PTR->succ = NULL;
176 gcc_assert (!n_edges);
179 /* Allocate memory for basic_block. */
185 bb = ggc_alloc_cleared (sizeof (*bb));
189 /* Create memory pool for rbi_pool. */
192 alloc_rbi_pool (void)
194 rbi_pool = create_alloc_pool ("rbi pool",
195 sizeof (struct reorder_block_def),
204 free_alloc_pool (rbi_pool);
207 /* Initialize rbi (the structure containing data used by basic block
208 duplication and reordering) for the given basic block. */
211 initialize_bb_rbi (basic_block bb)
213 gcc_assert (!bb->rbi);
214 bb->rbi = pool_alloc (rbi_pool);
215 memset (bb->rbi, 0, sizeof (struct reorder_block_def));
218 /* Link block B to chain after AFTER. */
220 link_block (basic_block b, basic_block after)
222 b->next_bb = after->next_bb;
225 b->next_bb->prev_bb = b;
228 /* Unlink block B from chain. */
230 unlink_block (basic_block b)
232 b->next_bb->prev_bb = b->prev_bb;
233 b->prev_bb->next_bb = b->next_bb;
238 /* Sequentially order blocks and compact the arrays. */
240 compact_blocks (void)
248 BASIC_BLOCK (i) = bb;
253 gcc_assert (i == n_basic_blocks);
255 for (; i < last_basic_block; i++)
256 BASIC_BLOCK (i) = NULL;
258 last_basic_block = n_basic_blocks;
261 /* Remove block B from the basic block array. */
264 expunge_block (basic_block b)
267 BASIC_BLOCK (b->index) = NULL;
272 /* Create an edge connecting SRC and DEST with flags FLAGS. Return newly
273 created edge. Use this only if you are sure that this edge can't
274 possibly already exist. */
277 unchecked_make_edge (basic_block src, basic_block dst, int flags)
280 e = ggc_alloc_cleared (sizeof (*e));
283 e->succ_next = src->succ;
284 e->pred_next = dst->pred;
295 /* Create an edge connecting SRC and DST with FLAGS optionally using
296 edge cache CACHE. Return the new edge, NULL if already exist. */
299 cached_make_edge (sbitmap *edge_cache, basic_block src, basic_block dst, int flags)
304 /* Don't bother with edge cache for ENTRY or EXIT, if there aren't that
305 many edges to them, or we didn't allocate memory for it. */
306 use_edge_cache = (edge_cache
307 && src != ENTRY_BLOCK_PTR && dst != EXIT_BLOCK_PTR);
309 /* Make sure we don't add duplicate edges. */
310 switch (use_edge_cache)
313 /* Quick test for non-existence of the edge. */
314 if (! TEST_BIT (edge_cache[src->index], dst->index))
317 /* The edge exists; early exit if no work to do. */
323 for (e = src->succ; e; e = e->succ_next)
332 e = unchecked_make_edge (src, dst, flags);
335 SET_BIT (edge_cache[src->index], dst->index);
340 /* Create an edge connecting SRC and DEST with flags FLAGS. Return newly
341 created edge or NULL if already exist. */
344 make_edge (basic_block src, basic_block dest, int flags)
346 return cached_make_edge (NULL, src, dest, flags);
349 /* Create an edge connecting SRC to DEST and set probability by knowing
350 that it is the single edge leaving SRC. */
353 make_single_succ_edge (basic_block src, basic_block dest, int flags)
355 edge e = make_edge (src, dest, flags);
357 e->probability = REG_BR_PROB_BASE;
358 e->count = src->count;
362 /* This function will remove an edge from the flow graph. */
367 edge last_pred = NULL;
368 edge last_succ = NULL;
370 basic_block src, dest;
374 for (tmp = src->succ; tmp && tmp != e; tmp = tmp->succ_next)
379 last_succ->succ_next = e->succ_next;
381 src->succ = e->succ_next;
383 for (tmp = dest->pred; tmp && tmp != e; tmp = tmp->pred_next)
388 last_pred->pred_next = e->pred_next;
390 dest->pred = e->pred_next;
395 /* Redirect an edge's successor from one block to another. */
398 redirect_edge_succ (edge e, basic_block new_succ)
402 /* Disconnect the edge from the old successor block. */
403 for (pe = &e->dest->pred; *pe != e; pe = &(*pe)->pred_next)
405 *pe = (*pe)->pred_next;
407 /* Reconnect the edge to the new successor block. */
408 e->pred_next = new_succ->pred;
413 /* Like previous but avoid possible duplicate edge. */
416 redirect_edge_succ_nodup (edge e, basic_block new_succ)
420 /* Check whether the edge is already present. */
421 for (s = e->src->succ; s; s = s->succ_next)
422 if (s->dest == new_succ && s != e)
427 s->flags |= e->flags;
428 s->probability += e->probability;
429 if (s->probability > REG_BR_PROB_BASE)
430 s->probability = REG_BR_PROB_BASE;
431 s->count += e->count;
436 redirect_edge_succ (e, new_succ);
441 /* Redirect an edge's predecessor from one block to another. */
444 redirect_edge_pred (edge e, basic_block new_pred)
448 /* Disconnect the edge from the old predecessor block. */
449 for (pe = &e->src->succ; *pe != e; pe = &(*pe)->succ_next)
452 *pe = (*pe)->succ_next;
454 /* Reconnect the edge to the new predecessor block. */
455 e->succ_next = new_pred->succ;
460 /* Clear all basic block flags, with the exception of partitioning. */
462 clear_bb_flags (void)
466 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
467 bb->flags = BB_PARTITION (bb);
470 /* Check the consistency of profile information. We can't do that
471 in verify_flow_info, as the counts may get invalid for incompletely
472 solved graphs, later eliminating of conditionals or roundoff errors.
473 It is still practical to have them reported for debugging of simple
476 check_bb_profile (basic_block bb, FILE * file)
482 if (profile_status == PROFILE_ABSENT)
485 if (bb != EXIT_BLOCK_PTR)
487 for (e = bb->succ; e; e = e->succ_next)
488 sum += e->probability;
489 if (bb->succ && abs (sum - REG_BR_PROB_BASE) > 100)
490 fprintf (file, "Invalid sum of outgoing probabilities %.1f%%\n",
491 sum * 100.0 / REG_BR_PROB_BASE);
493 for (e = bb->succ; e; e = e->succ_next)
495 if (bb->succ && (lsum - bb->count > 100 || lsum - bb->count < -100))
496 fprintf (file, "Invalid sum of outgoing counts %i, should be %i\n",
497 (int) lsum, (int) bb->count);
499 if (bb != ENTRY_BLOCK_PTR)
502 for (e = bb->pred; e; e = e->pred_next)
503 sum += EDGE_FREQUENCY (e);
504 if (abs (sum - bb->frequency) > 100)
506 "Invalid sum of incoming frequencies %i, should be %i\n",
509 for (e = bb->pred; e; e = e->pred_next)
511 if (lsum - bb->count > 100 || lsum - bb->count < -100)
512 fprintf (file, "Invalid sum of incoming counts %i, should be %i\n",
513 (int) lsum, (int) bb->count);
518 dump_flow_info (FILE *file)
522 static const char * const reg_class_names[] = REG_CLASS_NAMES;
526 int max_regno = max_reg_num ();
527 fprintf (file, "%d registers.\n", max_regno);
528 for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
531 enum reg_class class, altclass;
533 fprintf (file, "\nRegister %d used %d times across %d insns",
534 i, REG_N_REFS (i), REG_LIVE_LENGTH (i));
535 if (REG_BASIC_BLOCK (i) >= 0)
536 fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
538 fprintf (file, "; set %d time%s", REG_N_SETS (i),
539 (REG_N_SETS (i) == 1) ? "" : "s");
540 if (regno_reg_rtx[i] != NULL && REG_USERVAR_P (regno_reg_rtx[i]))
541 fprintf (file, "; user var");
542 if (REG_N_DEATHS (i) != 1)
543 fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
544 if (REG_N_CALLS_CROSSED (i) == 1)
545 fprintf (file, "; crosses 1 call");
546 else if (REG_N_CALLS_CROSSED (i))
547 fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
548 if (regno_reg_rtx[i] != NULL
549 && PSEUDO_REGNO_BYTES (i) != UNITS_PER_WORD)
550 fprintf (file, "; %d bytes", PSEUDO_REGNO_BYTES (i));
552 class = reg_preferred_class (i);
553 altclass = reg_alternate_class (i);
554 if (class != GENERAL_REGS || altclass != ALL_REGS)
556 if (altclass == ALL_REGS || class == ALL_REGS)
557 fprintf (file, "; pref %s", reg_class_names[(int) class]);
558 else if (altclass == NO_REGS)
559 fprintf (file, "; %s or none", reg_class_names[(int) class]);
561 fprintf (file, "; pref %s, else %s",
562 reg_class_names[(int) class],
563 reg_class_names[(int) altclass]);
566 if (regno_reg_rtx[i] != NULL && REG_POINTER (regno_reg_rtx[i]))
567 fprintf (file, "; pointer");
568 fprintf (file, ".\n");
572 fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks, n_edges);
577 fprintf (file, "\nBasic block %d ", bb->index);
578 fprintf (file, "prev %d, next %d, ",
579 bb->prev_bb->index, bb->next_bb->index);
580 fprintf (file, "loop_depth %d, count ", bb->loop_depth);
581 fprintf (file, HOST_WIDEST_INT_PRINT_DEC, bb->count);
582 fprintf (file, ", freq %i", bb->frequency);
583 if (maybe_hot_bb_p (bb))
584 fprintf (file, ", maybe hot");
585 if (probably_never_executed_bb_p (bb))
586 fprintf (file, ", probably never executed");
587 fprintf (file, ".\n");
589 fprintf (file, "Predecessors: ");
590 for (e = bb->pred; e; e = e->pred_next)
591 dump_edge_info (file, e, 0);
593 fprintf (file, "\nSuccessors: ");
594 for (e = bb->succ; e; e = e->succ_next)
595 dump_edge_info (file, e, 1);
597 fprintf (file, "\nRegisters live at start:");
598 dump_regset (bb->global_live_at_start, file);
600 fprintf (file, "\nRegisters live at end:");
601 dump_regset (bb->global_live_at_end, file);
605 if (bb->global_live_at_start)
607 fprintf (file, "\nRegisters live at start:");
608 dump_regset (bb->global_live_at_start, file);
611 if (bb->global_live_at_end)
613 fprintf (file, "\nRegisters live at end:");
614 dump_regset (bb->global_live_at_end, file);
618 check_bb_profile (bb, file);
625 debug_flow_info (void)
627 dump_flow_info (stderr);
631 dump_edge_info (FILE *file, edge e, int do_succ)
633 basic_block side = (do_succ ? e->dest : e->src);
635 if (side == ENTRY_BLOCK_PTR)
636 fputs (" ENTRY", file);
637 else if (side == EXIT_BLOCK_PTR)
638 fputs (" EXIT", file);
640 fprintf (file, " %d", side->index);
643 fprintf (file, " [%.1f%%] ", e->probability * 100.0 / REG_BR_PROB_BASE);
647 fprintf (file, " count:");
648 fprintf (file, HOST_WIDEST_INT_PRINT_DEC, e->count);
653 static const char * const bitnames[] = {
654 "fallthru", "ab", "abcall", "eh", "fake", "dfs_back",
655 "can_fallthru", "irreducible", "sibcall", "loop_exit",
656 "true", "false", "exec"
659 int i, flags = e->flags;
662 for (i = 0; flags; i++)
663 if (flags & (1 << i))
669 if (i < (int) ARRAY_SIZE (bitnames))
670 fputs (bitnames[i], file);
672 fprintf (file, "%d", i);
680 /* Simple routines to easily allocate AUX fields of basic blocks. */
682 static struct obstack block_aux_obstack;
683 static void *first_block_aux_obj = 0;
684 static struct obstack edge_aux_obstack;
685 static void *first_edge_aux_obj = 0;
687 /* Allocate a memory block of SIZE as BB->aux. The obstack must
688 be first initialized by alloc_aux_for_blocks. */
691 alloc_aux_for_block (basic_block bb, int size)
693 /* Verify that aux field is clear. */
694 gcc_assert (!bb->aux && first_block_aux_obj);
695 bb->aux = obstack_alloc (&block_aux_obstack, size);
696 memset (bb->aux, 0, size);
699 /* Initialize the block_aux_obstack and if SIZE is nonzero, call
700 alloc_aux_for_block for each basic block. */
703 alloc_aux_for_blocks (int size)
705 static int initialized;
709 gcc_obstack_init (&block_aux_obstack);
713 /* Check whether AUX data are still allocated. */
714 gcc_assert (!first_block_aux_obj);
716 first_block_aux_obj = obstack_alloc (&block_aux_obstack, 0);
721 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
722 alloc_aux_for_block (bb, size);
726 /* Clear AUX pointers of all blocks. */
729 clear_aux_for_blocks (void)
733 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
737 /* Free data allocated in block_aux_obstack and clear AUX pointers
741 free_aux_for_blocks (void)
743 gcc_assert (first_block_aux_obj);
744 obstack_free (&block_aux_obstack, first_block_aux_obj);
745 first_block_aux_obj = NULL;
747 clear_aux_for_blocks ();
750 /* Allocate a memory edge of SIZE as BB->aux. The obstack must
751 be first initialized by alloc_aux_for_edges. */
754 alloc_aux_for_edge (edge e, int size)
756 /* Verify that aux field is clear. */
757 gcc_assert (!e->aux && first_edge_aux_obj);
758 e->aux = obstack_alloc (&edge_aux_obstack, size);
759 memset (e->aux, 0, size);
762 /* Initialize the edge_aux_obstack and if SIZE is nonzero, call
763 alloc_aux_for_edge for each basic edge. */
766 alloc_aux_for_edges (int size)
768 static int initialized;
772 gcc_obstack_init (&edge_aux_obstack);
776 /* Check whether AUX data are still allocated. */
777 gcc_assert (!first_edge_aux_obj);
779 first_edge_aux_obj = obstack_alloc (&edge_aux_obstack, 0);
784 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
788 for (e = bb->succ; e; e = e->succ_next)
789 alloc_aux_for_edge (e, size);
794 /* Clear AUX pointers of all edges. */
797 clear_aux_for_edges (void)
802 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
804 for (e = bb->succ; e; e = e->succ_next)
809 /* Free data allocated in edge_aux_obstack and clear AUX pointers
813 free_aux_for_edges (void)
815 gcc_assert (first_edge_aux_obj);
816 obstack_free (&edge_aux_obstack, first_edge_aux_obj);
817 first_edge_aux_obj = NULL;
819 clear_aux_for_edges ();
823 debug_bb (basic_block bb)
825 dump_bb (bb, stderr, 0);
831 basic_block bb = BASIC_BLOCK (n);
832 dump_bb (bb, stderr, 0);
836 /* Dumps cfg related information about basic block BB to FILE. */
839 dump_cfg_bb_info (FILE *file, basic_block bb)
843 static const char * const bb_bitnames[] =
845 "dirty", "new", "reachable", "visited", "irreducible_loop", "superblock"
847 const unsigned n_bitnames = sizeof (bb_bitnames) / sizeof (char *);
850 fprintf (file, "Basic block %d", bb->index);
851 for (i = 0; i < n_bitnames; i++)
852 if (bb->flags & (1 << i))
855 fprintf (file, " (");
857 fprintf (file, ", ");
859 fprintf (file, bb_bitnames[i]);
863 fprintf (file, "\n");
865 fprintf (file, "Predecessors: ");
866 for (e = bb->pred; e; e = e->pred_next)
867 dump_edge_info (file, e, 0);
869 fprintf (file, "\nSuccessors: ");
870 for (e = bb->succ; e; e = e->succ_next)
871 dump_edge_info (file, e, 1);
872 fprintf (file, "\n\n");
875 /* Dumps a brief description of cfg to FILE. */
878 brief_dump_cfg (FILE *file)
884 dump_cfg_bb_info (file, bb);