1 /* Control flow graph manipulation code for GNU compiler.
2 Copyright (C) 1987-2020 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* This file contains low level functions to manipulate the CFG and
21 analyze it. All other modules should not transform the data structure
22 directly and use abstraction instead. The file is supposed to be
23 ordered bottom-up and should not contain any code dependent on a
24 particular intermediate language (RTL or trees).
26 Available functionality:
27 - Initialization/deallocation
29 - Low level basic block manipulation
30 alloc_block, expunge_block
32 make_edge, make_single_succ_edge, cached_make_edge, remove_edge
33 - Low level edge redirection (without updating instruction chain)
34 redirect_edge_succ, redirect_edge_succ_nodup, redirect_edge_pred
35 - Dumping and debugging
36 dump_flow_info, debug_flow_info, dump_edge_info
37 - Allocation of AUX fields for basic blocks
38 alloc_aux_for_blocks, free_aux_for_blocks, alloc_aux_for_block
40 - Consistency checking
42 - Dumping and debugging
43 print_rtl_with_bb, dump_bb, debug_bb, debug_bb_n
45 TODO: Document these "Available functionality" functions in the files
51 #include "coretypes.h"
53 #include "hard-reg-set.h"
58 #include "cfgloop.h" /* FIXME: For struct loop. */
63 /* Called once at initialization time. */
66 init_flow (struct function
*the_fun
)
69 the_fun
->cfg
= ggc_cleared_alloc
<control_flow_graph
> ();
70 n_edges_for_fn (the_fun
) = 0;
71 the_fun
->cfg
->count_max
= profile_count::uninitialized ();
72 ENTRY_BLOCK_PTR_FOR_FN (the_fun
)
74 ENTRY_BLOCK_PTR_FOR_FN (the_fun
)->index
= ENTRY_BLOCK
;
75 EXIT_BLOCK_PTR_FOR_FN (the_fun
)
77 EXIT_BLOCK_PTR_FOR_FN (the_fun
)->index
= EXIT_BLOCK
;
78 ENTRY_BLOCK_PTR_FOR_FN (the_fun
)->next_bb
79 = EXIT_BLOCK_PTR_FOR_FN (the_fun
);
80 EXIT_BLOCK_PTR_FOR_FN (the_fun
)->prev_bb
81 = ENTRY_BLOCK_PTR_FOR_FN (the_fun
);
82 the_fun
->cfg
->edge_flags_allocated
= EDGE_ALL_FLAGS
;
83 the_fun
->cfg
->bb_flags_allocated
= BB_ALL_FLAGS
;
86 /* Helper function for remove_edge and free_cffg. Frees edge structure
87 without actually removing it from the pred/succ arrays. */
90 free_edge (function
*fn
, edge e
)
92 n_edges_for_fn (fn
)--;
96 /* Free basic block BB. */
99 free_block (basic_block bb
)
101 vec_free (bb
->succs
);
103 vec_free (bb
->preds
);
105 /* Do not free BB itself yet since we leak pointers to dead statements
106 that points to dead basic blocks. */
109 /* Free the memory associated with the CFG in FN. */
112 free_cfg (struct function
*fn
)
118 for (basic_block bb
= ENTRY_BLOCK_PTR_FOR_FN (fn
); bb
; bb
= next
)
121 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
126 gcc_assert (!n_edges_for_fn (fn
));
127 /* Sanity check that dominance tree is freed. */
128 gcc_assert (!fn
->cfg
->x_dom_computed
[0] && !fn
->cfg
->x_dom_computed
[1]);
130 vec_free (fn
->cfg
->x_label_to_block_map
);
131 vec_free (basic_block_info_for_fn (fn
));
136 /* Allocate memory for basic_block. */
142 bb
= ggc_cleared_alloc
<basic_block_def
> ();
143 bb
->count
= profile_count::uninitialized ();
147 /* Link block B to chain after AFTER. */
149 link_block (basic_block b
, basic_block after
)
151 b
->next_bb
= after
->next_bb
;
154 b
->next_bb
->prev_bb
= b
;
157 /* Unlink block B from chain. */
159 unlink_block (basic_block b
)
161 b
->next_bb
->prev_bb
= b
->prev_bb
;
162 b
->prev_bb
->next_bb
= b
->next_bb
;
167 /* Sequentially order blocks and compact the arrays. */
169 compact_blocks (void)
173 SET_BASIC_BLOCK_FOR_FN (cfun
, ENTRY_BLOCK
, ENTRY_BLOCK_PTR_FOR_FN (cfun
));
174 SET_BASIC_BLOCK_FOR_FN (cfun
, EXIT_BLOCK
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
177 df_compact_blocks ();
182 i
= NUM_FIXED_BLOCKS
;
183 FOR_EACH_BB_FN (bb
, cfun
)
185 SET_BASIC_BLOCK_FOR_FN (cfun
, i
, bb
);
189 gcc_assert (i
== n_basic_blocks_for_fn (cfun
));
191 for (; i
< last_basic_block_for_fn (cfun
); i
++)
192 SET_BASIC_BLOCK_FOR_FN (cfun
, i
, NULL
);
194 last_basic_block_for_fn (cfun
) = n_basic_blocks_for_fn (cfun
);
197 /* Remove block B from the basic block array. */
200 expunge_block (basic_block b
)
203 SET_BASIC_BLOCK_FOR_FN (cfun
, b
->index
, NULL
);
204 n_basic_blocks_for_fn (cfun
)--;
205 /* We should be able to ggc_free here, but we are not.
206 The dead SSA_NAMES are left pointing to dead statements that are pointing
207 to dead basic blocks making garbage collector to die.
208 We should be able to release all dead SSA_NAMES and at the same time we
209 should clear out BB pointer of dead statements consistently. */
212 /* Connect E to E->src. */
217 vec_safe_push (e
->src
->succs
, e
);
218 df_mark_solutions_dirty ();
221 /* Connect E to E->dest. */
224 connect_dest (edge e
)
226 basic_block dest
= e
->dest
;
227 vec_safe_push (dest
->preds
, e
);
228 e
->dest_idx
= EDGE_COUNT (dest
->preds
) - 1;
229 df_mark_solutions_dirty ();
232 /* Disconnect edge E from E->src. */
235 disconnect_src (edge e
)
237 basic_block src
= e
->src
;
241 for (ei
= ei_start (src
->succs
); (tmp
= ei_safe_edge (ei
)); )
245 src
->succs
->unordered_remove (ei
.index
);
246 df_mark_solutions_dirty ();
256 /* Disconnect edge E from E->dest. */
259 disconnect_dest (edge e
)
261 basic_block dest
= e
->dest
;
262 unsigned int dest_idx
= e
->dest_idx
;
264 dest
->preds
->unordered_remove (dest_idx
);
266 /* If we removed an edge in the middle of the edge vector, we need
267 to update dest_idx of the edge that moved into the "hole". */
268 if (dest_idx
< EDGE_COUNT (dest
->preds
))
269 EDGE_PRED (dest
, dest_idx
)->dest_idx
= dest_idx
;
270 df_mark_solutions_dirty ();
273 /* Create an edge connecting SRC and DEST with flags FLAGS. Return newly
274 created edge. Use this only if you are sure that this edge can't
275 possibly already exist. */
278 unchecked_make_edge (basic_block src
, basic_block dst
, int flags
)
281 e
= ggc_cleared_alloc
<edge_def
> ();
282 n_edges_for_fn (cfun
)++;
284 e
->probability
= profile_probability::uninitialized ();
292 execute_on_growing_pred (e
);
296 /* Create an edge connecting SRC and DST with FLAGS optionally using
297 edge cache CACHE. Return the new edge, NULL if already exist. */
300 cached_make_edge (sbitmap edge_cache
, basic_block src
, basic_block dst
, int flags
)
302 if (edge_cache
== NULL
303 || src
== ENTRY_BLOCK_PTR_FOR_FN (cfun
)
304 || dst
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
305 return make_edge (src
, dst
, flags
);
307 /* Does the requested edge already exist? */
308 if (! bitmap_bit_p (edge_cache
, dst
->index
))
310 /* The edge does not exist. Create one and update the
312 bitmap_set_bit (edge_cache
, dst
->index
);
313 return unchecked_make_edge (src
, dst
, flags
);
316 /* At this point, we know that the requested edge exists. Adjust
317 flags if necessary. */
320 edge e
= find_edge (src
, dst
);
327 /* Create an edge connecting SRC and DEST with flags FLAGS. Return newly
328 created edge or NULL if already exist. */
331 make_edge (basic_block src
, basic_block dest
, int flags
)
333 edge e
= find_edge (src
, dest
);
335 /* Make sure we don't add duplicate edges. */
342 return unchecked_make_edge (src
, dest
, flags
);
345 /* Create an edge connecting SRC to DEST and set probability by knowing
346 that it is the single edge leaving SRC. */
349 make_single_succ_edge (basic_block src
, basic_block dest
, int flags
)
351 edge e
= make_edge (src
, dest
, flags
);
353 e
->probability
= profile_probability::always ();
357 /* This function will remove an edge from the flow graph. */
360 remove_edge_raw (edge e
)
362 remove_predictions_associated_with_edge (e
);
363 execute_on_shrinking_pred (e
);
371 /* Redirect an edge's successor from one block to another. */
374 redirect_edge_succ (edge e
, basic_block new_succ
)
376 execute_on_shrinking_pred (e
);
382 /* Reconnect the edge to the new successor block. */
385 execute_on_growing_pred (e
);
388 /* Redirect an edge's predecessor from one block to another. */
391 redirect_edge_pred (edge e
, basic_block new_pred
)
397 /* Reconnect the edge to the new predecessor block. */
401 /* Clear all basic block flags that do not have to be preserved. */
403 clear_bb_flags (void)
406 int flags_to_preserve
= BB_FLAGS_TO_PRESERVE
;
408 && loops_state_satisfies_p (cfun
, LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS
))
409 flags_to_preserve
|= BB_IRREDUCIBLE_LOOP
;
411 FOR_ALL_BB_FN (bb
, cfun
)
412 bb
->flags
&= flags_to_preserve
;
415 /* Check the consistency of profile information. We can't do that
416 in verify_flow_info, as the counts may get invalid for incompletely
417 solved graphs, later eliminating of conditionals or roundoff errors.
418 It is still practical to have them reported for debugging of simple
421 check_bb_profile (basic_block bb
, FILE * file
, int indent
)
425 struct function
*fun
= DECL_STRUCT_FUNCTION (current_function_decl
);
426 char *s_indent
= (char *) alloca ((size_t) indent
+ 1);
427 memset ((void *) s_indent
, ' ', (size_t) indent
);
428 s_indent
[indent
] = '\0';
430 if (profile_status_for_fn (fun
) == PROFILE_ABSENT
)
433 if (bb
!= EXIT_BLOCK_PTR_FOR_FN (fun
))
436 profile_probability sum
= profile_probability::never ();
439 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
441 if (!(e
->flags
& (EDGE_EH
| EDGE_FAKE
)))
443 sum
+= e
->probability
;
444 if (e
->probability
.initialized_p ())
445 isum
+= e
->probability
.to_reg_br_prob_base ();
447 /* Only report mismatches for non-EH control flow. If there are only EH
448 edges it means that the BB ends by noreturn call. Here the control
449 flow may just terminate. */
452 if (sum
.differs_from_p (profile_probability::always ()))
455 ";; %sInvalid sum of outgoing probabilities ",
458 fprintf (file
, "\n");
460 /* Probabilities caps to 100% and thus the previous test will never
461 fire if the sum of probabilities is too large. */
462 else if (isum
> REG_BR_PROB_BASE
+ 100)
465 ";; %sInvalid sum of outgoing probabilities %.1f%%\n",
466 s_indent
, isum
* 100.0 / REG_BR_PROB_BASE
);
470 if (bb
!= ENTRY_BLOCK_PTR_FOR_FN (fun
))
472 profile_count sum
= profile_count::zero ();
473 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
475 if (sum
.differs_from_p (bb
->count
))
477 fprintf (file
, ";; %sInvalid sum of incoming counts ",
480 fprintf (file
, ", should be ");
481 bb
->count
.dump (file
);
482 fprintf (file
, "\n");
485 if (BB_PARTITION (bb
) == BB_COLD_PARTITION
)
487 /* Warn about inconsistencies in the partitioning that are
488 currently caused by profile insanities created via optimization. */
489 if (!probably_never_executed_bb_p (fun
, bb
))
490 fprintf (file
, ";; %sBlock in cold partition with hot count\n",
492 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
494 if (!probably_never_executed_edge_p (fun
, e
))
496 ";; %sBlock in cold partition with incoming hot edge\n",
503 dump_edge_info (FILE *file
, edge e
, dump_flags_t flags
, int do_succ
)
505 basic_block side
= (do_succ
? e
->dest
: e
->src
);
506 bool do_details
= false;
508 if ((flags
& TDF_DETAILS
) != 0
509 && (flags
& TDF_SLIM
) == 0)
512 if (side
->index
== ENTRY_BLOCK
)
513 fputs (" ENTRY", file
);
514 else if (side
->index
== EXIT_BLOCK
)
515 fputs (" EXIT", file
);
517 fprintf (file
, " %d", side
->index
);
519 if (e
->probability
.initialized_p () && do_details
)
521 fprintf (file
, " [");
522 e
->probability
.dump (file
);
523 fprintf (file
, "] ");
526 if (e
->count ().initialized_p () && do_details
)
528 fputs (" count:", file
);
529 e
->count ().dump (file
);
532 if (e
->flags
&& do_details
)
534 static const char * const bitnames
[] =
536 #define DEF_EDGE_FLAG(NAME,IDX) #NAME ,
537 #include "cfg-flags.def"
542 int i
, flags
= e
->flags
;
544 gcc_assert (e
->flags
<= EDGE_ALL_FLAGS
);
546 for (i
= 0; flags
; i
++)
547 if (flags
& (1 << i
))
553 fputs (bitnames
[i
], file
);
562 debug (edge_def
&ref
)
564 fprintf (stderr
, "<edge (%d -> %d)>\n",
565 ref
.src
->index
, ref
.dest
->index
);
566 dump_edge_info (stderr
, &ref
, TDF_DETAILS
, false);
567 fprintf (stderr
, "\n");
571 debug (edge_def
*ptr
)
576 fprintf (stderr
, "<nil>\n");
582 fprintf (stderr
, "<edge 0x%p (%d -> %d)>", (void *) e
,
583 e
->src
->index
, e
->dest
->index
);
586 DEFINE_DEBUG_VEC (edge
)
587 DEFINE_DEBUG_HASH_SET (edge
)
589 /* Simple routines to easily allocate AUX fields of basic blocks. */
591 static struct obstack block_aux_obstack
;
592 static void *first_block_aux_obj
= 0;
593 static struct obstack edge_aux_obstack
;
594 static void *first_edge_aux_obj
= 0;
596 /* Allocate a memory block of SIZE as BB->aux. The obstack must
597 be first initialized by alloc_aux_for_blocks. */
600 alloc_aux_for_block (basic_block bb
, int size
)
602 /* Verify that aux field is clear. */
603 gcc_assert (!bb
->aux
&& first_block_aux_obj
);
604 bb
->aux
= obstack_alloc (&block_aux_obstack
, size
);
605 memset (bb
->aux
, 0, size
);
608 /* Initialize the block_aux_obstack and if SIZE is nonzero, call
609 alloc_aux_for_block for each basic block. */
612 alloc_aux_for_blocks (int size
)
614 static int initialized
;
618 gcc_obstack_init (&block_aux_obstack
);
622 /* Check whether AUX data are still allocated. */
623 gcc_assert (!first_block_aux_obj
);
625 first_block_aux_obj
= obstack_alloc (&block_aux_obstack
, 0);
630 FOR_ALL_BB_FN (bb
, cfun
)
631 alloc_aux_for_block (bb
, size
);
635 /* Clear AUX pointers of all blocks. */
638 clear_aux_for_blocks (void)
642 FOR_ALL_BB_FN (bb
, cfun
)
646 /* Free data allocated in block_aux_obstack and clear AUX pointers
650 free_aux_for_blocks (void)
652 gcc_assert (first_block_aux_obj
);
653 obstack_free (&block_aux_obstack
, first_block_aux_obj
);
654 first_block_aux_obj
= NULL
;
656 clear_aux_for_blocks ();
659 /* Allocate a memory edge of SIZE as E->aux. The obstack must
660 be first initialized by alloc_aux_for_edges. */
663 alloc_aux_for_edge (edge e
, int size
)
665 /* Verify that aux field is clear. */
666 gcc_assert (!e
->aux
&& first_edge_aux_obj
);
667 e
->aux
= obstack_alloc (&edge_aux_obstack
, size
);
668 memset (e
->aux
, 0, size
);
671 /* Initialize the edge_aux_obstack and if SIZE is nonzero, call
672 alloc_aux_for_edge for each basic edge. */
675 alloc_aux_for_edges (int size
)
677 static int initialized
;
681 gcc_obstack_init (&edge_aux_obstack
);
685 /* Check whether AUX data are still allocated. */
686 gcc_assert (!first_edge_aux_obj
);
688 first_edge_aux_obj
= obstack_alloc (&edge_aux_obstack
, 0);
693 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (cfun
),
694 EXIT_BLOCK_PTR_FOR_FN (cfun
), next_bb
)
699 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
700 alloc_aux_for_edge (e
, size
);
705 /* Clear AUX pointers of all edges. */
708 clear_aux_for_edges (void)
713 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR_FOR_FN (cfun
),
714 EXIT_BLOCK_PTR_FOR_FN (cfun
), next_bb
)
717 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
722 /* Free data allocated in edge_aux_obstack and clear AUX pointers
726 free_aux_for_edges (void)
728 gcc_assert (first_edge_aux_obj
);
729 obstack_free (&edge_aux_obstack
, first_edge_aux_obj
);
730 first_edge_aux_obj
= NULL
;
732 clear_aux_for_edges ();
736 debug_bb (basic_block bb
)
738 debug_bb (bb
, dump_flags
);
741 DEBUG_FUNCTION basic_block
744 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, n
);
749 /* Print BB with specified FLAGS. */
752 debug_bb (basic_block bb
, dump_flags_t flags
)
754 dump_bb (stderr
, bb
, 0, flags
);
757 /* Print basic block numbered N with specified FLAGS. */
759 DEBUG_FUNCTION basic_block
760 debug_bb_n (int n
, dump_flags_t flags
)
762 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, n
);
763 debug_bb (bb
, flags
);
767 /* Dumps cfg related information about basic block BB to OUTF.
768 If HEADER is true, dump things that appear before the instructions
769 contained in BB. If FOOTER is true, dump things that appear after.
770 Flags are the TDF_* masks as documented in dumpfile.h.
771 NB: With TDF_DETAILS, it is assumed that cfun is available, so
772 that maybe_hot_bb_p and probably_never_executed_bb_p don't ICE. */
775 dump_bb_info (FILE *outf
, basic_block bb
, int indent
, dump_flags_t flags
,
776 bool do_header
, bool do_footer
)
780 static const char * const bb_bitnames
[] =
782 #define DEF_BASIC_BLOCK_FLAG(NAME,IDX) #NAME ,
783 #include "cfg-flags.def"
785 #undef DEF_BASIC_BLOCK_FLAG
787 const unsigned n_bitnames
= sizeof (bb_bitnames
) / sizeof (char *);
789 char *s_indent
= (char *) alloca ((size_t) indent
+ 1);
790 memset ((void *) s_indent
, ' ', (size_t) indent
);
791 s_indent
[indent
] = '\0';
793 gcc_assert (bb
->flags
<= BB_ALL_FLAGS
);
800 fprintf (outf
, "%sbasic block %d, loop depth %d",
801 s_indent
, bb
->index
, bb_loop_depth (bb
));
802 if (flags
& TDF_DETAILS
)
804 struct function
*fun
= DECL_STRUCT_FUNCTION (current_function_decl
);
805 if (bb
->count
.initialized_p ())
807 fputs (", count ", outf
);
808 bb
->count
.dump (outf
);
810 if (maybe_hot_bb_p (fun
, bb
))
811 fputs (", maybe hot", outf
);
812 if (probably_never_executed_bb_p (fun
, bb
))
813 fputs (", probably never executed", outf
);
817 if (flags
& TDF_DETAILS
)
819 check_bb_profile (bb
, outf
, indent
);
821 fprintf (outf
, "%s prev block ", s_indent
);
823 fprintf (outf
, "%d", bb
->prev_bb
->index
);
825 fprintf (outf
, "(nil)");
826 fprintf (outf
, ", next block ");
828 fprintf (outf
, "%d", bb
->next_bb
->index
);
830 fprintf (outf
, "(nil)");
832 fputs (", flags:", outf
);
834 for (i
= 0; i
< n_bitnames
; i
++)
835 if (bb
->flags
& (1 << i
))
842 fputs (bb_bitnames
[i
], outf
);
850 fprintf (outf
, "%s pred: ", s_indent
);
852 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
857 fprintf (outf
, "%s ", s_indent
);
860 dump_edge_info (outf
, e
, flags
, 0);
870 fprintf (outf
, "%s succ: ", s_indent
);
872 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
877 fprintf (outf
, "%s ", s_indent
);
880 dump_edge_info (outf
, e
, flags
, 1);
888 /* Dumps a brief description of cfg to FILE. */
891 brief_dump_cfg (FILE *file
, dump_flags_t flags
)
895 FOR_EACH_BB_FN (bb
, cfun
)
897 dump_bb_info (file
, bb
, 0, flags
& TDF_DETAILS
, true, true);
901 /* An edge originally destinating BB of COUNT has been proved to
902 leave the block by TAKEN_EDGE. Update profile of BB such that edge E can be
903 redirected to destination of TAKEN_EDGE.
905 This function may leave the profile inconsistent in the case TAKEN_EDGE
906 frequency or count is believed to be lower than COUNT
909 update_bb_profile_for_threading (basic_block bb
,
910 profile_count count
, edge taken_edge
)
913 profile_probability prob
;
916 if (bb
->count
< count
)
919 fprintf (dump_file
, "bb %i count became negative after threading",
924 /* Compute the probability of TAKEN_EDGE being reached via threaded edge.
925 Watch for overflows. */
926 if (bb
->count
.nonzero_p ())
927 prob
= count
.probability_in (bb
->count
);
929 prob
= profile_probability::never ();
930 if (prob
> taken_edge
->probability
)
934 fprintf (dump_file
, "Jump threading proved probability of edge "
935 "%i->%i too small (it is ",
936 taken_edge
->src
->index
, taken_edge
->dest
->index
);
937 taken_edge
->probability
.dump (dump_file
);
938 fprintf (dump_file
, " should be ");
939 prob
.dump (dump_file
);
940 fprintf (dump_file
, ")\n");
942 prob
= taken_edge
->probability
.apply_scale (6, 8);
945 /* Now rescale the probabilities. */
946 taken_edge
->probability
-= prob
;
947 prob
= prob
.invert ();
948 if (prob
== profile_probability::never ())
951 fprintf (dump_file
, "Edge probabilities of bb %i has been reset, "
952 "count of block should end up being 0, it is non-zero\n",
954 EDGE_SUCC (bb
, 0)->probability
= profile_probability::guessed_always ();
955 ei
= ei_start (bb
->succs
);
957 for (; (c
= ei_safe_edge (ei
)); ei_next (&ei
))
958 c
->probability
= profile_probability::guessed_never ();
960 else if (!(prob
== profile_probability::always ()))
962 FOR_EACH_EDGE (c
, ei
, bb
->succs
)
963 c
->probability
/= prob
;
966 gcc_assert (bb
== taken_edge
->src
);
969 /* Multiply all frequencies of basic blocks in array BBS of length NBBS
970 by NUM/DEN, in profile_count arithmetic. More accurate than previous
971 function but considerably slower. */
973 scale_bbs_frequencies_profile_count (basic_block
*bbs
, int nbbs
,
974 profile_count num
, profile_count den
)
977 if (num
== profile_count::zero () || den
.nonzero_p ())
978 for (i
= 0; i
< nbbs
; i
++)
979 bbs
[i
]->count
= bbs
[i
]->count
.apply_scale (num
, den
);
982 /* Multiply all frequencies of basic blocks in array BBS of length NBBS
983 by NUM/DEN, in profile_count arithmetic. More accurate than previous
984 function but considerably slower. */
986 scale_bbs_frequencies (basic_block
*bbs
, int nbbs
,
987 profile_probability p
)
991 for (i
= 0; i
< nbbs
; i
++)
992 bbs
[i
]->count
= bbs
[i
]->count
.apply_probability (p
);
995 /* Data structures used to maintain mapping between basic blocks and
997 typedef hash_map
<int_hash
<int, -1, -2>, int> copy_map_t
;
998 static copy_map_t
*bb_original
;
999 static copy_map_t
*bb_copy
;
1001 /* And between loops and copies. */
1002 static copy_map_t
*loop_copy
;
1004 /* Initialize the data structures to maintain mapping between blocks
1007 initialize_original_copy_tables (void)
1009 bb_original
= new copy_map_t (10);
1010 bb_copy
= new copy_map_t (10);
1011 loop_copy
= new copy_map_t (10);
1014 /* Reset the data structures to maintain mapping between blocks and
1018 reset_original_copy_tables (void)
1020 bb_original
->empty ();
1022 loop_copy
->empty ();
1025 /* Free the data structures to maintain mapping between blocks and
1028 free_original_copy_tables (void)
1038 /* Return true iff we have had a call to initialize_original_copy_tables
1039 without a corresponding call to free_original_copy_tables. */
1042 original_copy_tables_initialized_p (void)
1044 return bb_copy
!= NULL
;
1047 /* Removes the value associated with OBJ from table TAB. */
1050 copy_original_table_clear (copy_map_t
*tab
, unsigned obj
)
1052 if (!original_copy_tables_initialized_p ())
1058 /* Sets the value associated with OBJ in table TAB to VAL.
1059 Do nothing when data structures are not initialized. */
1062 copy_original_table_set (copy_map_t
*tab
,
1063 unsigned obj
, unsigned val
)
1065 if (!original_copy_tables_initialized_p ())
1068 tab
->put (obj
, val
);
1071 /* Set original for basic block. Do nothing when data structures are not
1072 initialized so passes not needing this don't need to care. */
1074 set_bb_original (basic_block bb
, basic_block original
)
1076 copy_original_table_set (bb_original
, bb
->index
, original
->index
);
1079 /* Get the original basic block. */
1081 get_bb_original (basic_block bb
)
1083 gcc_assert (original_copy_tables_initialized_p ());
1085 int *entry
= bb_original
->get (bb
->index
);
1087 return BASIC_BLOCK_FOR_FN (cfun
, *entry
);
1092 /* Set copy for basic block. Do nothing when data structures are not
1093 initialized so passes not needing this don't need to care. */
1095 set_bb_copy (basic_block bb
, basic_block copy
)
1097 copy_original_table_set (bb_copy
, bb
->index
, copy
->index
);
1100 /* Get the copy of basic block. */
1102 get_bb_copy (basic_block bb
)
1104 gcc_assert (original_copy_tables_initialized_p ());
1106 int *entry
= bb_copy
->get (bb
->index
);
1108 return BASIC_BLOCK_FOR_FN (cfun
, *entry
);
1113 /* Set copy for LOOP to COPY. Do nothing when data structures are not
1114 initialized so passes not needing this don't need to care. */
1117 set_loop_copy (class loop
*loop
, class loop
*copy
)
1120 copy_original_table_clear (loop_copy
, loop
->num
);
1122 copy_original_table_set (loop_copy
, loop
->num
, copy
->num
);
1125 /* Get the copy of LOOP. */
1128 get_loop_copy (class loop
*loop
)
1130 gcc_assert (original_copy_tables_initialized_p ());
1132 int *entry
= loop_copy
->get (loop
->num
);
1134 return get_loop (cfun
, *entry
);