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, 2005
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 /* This file contains low level functions to manipulate the CFG and
24 analyze it. All other modules should not transform the data structure
25 directly and use abstraction instead. The file is supposed to be
26 ordered bottom-up and should not contain any code dependent on a
27 particular intermediate language (RTL or trees).
29 Available functionality:
30 - Initialization/deallocation
31 init_flow, clear_edges
32 - Low level basic block manipulation
33 alloc_block, expunge_block
35 make_edge, make_single_succ_edge, cached_make_edge, remove_edge
36 - Low level edge redirection (without updating instruction chain)
37 redirect_edge_succ, redirect_edge_succ_nodup, redirect_edge_pred
38 - Dumping and debugging
39 dump_flow_info, debug_flow_info, dump_edge_info
40 - Allocation of AUX fields for basic blocks
41 alloc_aux_for_blocks, free_aux_for_blocks, alloc_aux_for_block
43 - Consistency checking
45 - Dumping and debugging
46 print_rtl_with_bb, dump_bb, debug_bb, debug_bb_n
51 #include "coretypes.h"
55 #include "hard-reg-set.h"
63 #include "alloc-pool.h"
67 /* The obstack on which the flow graph components are allocated. */
69 struct bitmap_obstack reg_obstack
;
71 /* Number of basic blocks in the current function. */
75 /* First free basic block number. */
79 /* Number of edges in the current function. */
83 /* The basic block array. */
85 varray_type basic_block_info
;
87 /* The special entry and exit blocks. */
88 basic_block ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
;
90 /* Memory alloc pool for bb member rbi. */
91 static alloc_pool rbi_pool
;
93 void debug_flow_info (void);
94 static void free_edge (edge
);
96 /* Indicate the presence of the profile. */
97 enum profile_status profile_status
;
99 #define RDIV(X,Y) (((X) + (Y) / 2) / (Y))
101 /* Called once at initialization time. */
108 ENTRY_BLOCK_PTR
= ggc_alloc_cleared (sizeof (*ENTRY_BLOCK_PTR
));
109 ENTRY_BLOCK_PTR
->index
= ENTRY_BLOCK
;
110 EXIT_BLOCK_PTR
= ggc_alloc_cleared (sizeof (*EXIT_BLOCK_PTR
));
111 EXIT_BLOCK_PTR
->index
= EXIT_BLOCK
;
112 ENTRY_BLOCK_PTR
->next_bb
= EXIT_BLOCK_PTR
;
113 EXIT_BLOCK_PTR
->prev_bb
= ENTRY_BLOCK_PTR
;
116 /* Helper function for remove_edge and clear_edges. Frees edge structure
117 without actually unlinking it from the pred/succ lists. */
120 free_edge (edge e ATTRIBUTE_UNUSED
)
126 /* Free the memory associated with the edge structures. */
137 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
139 VEC_truncate (edge
, bb
->succs
, 0);
140 VEC_truncate (edge
, bb
->preds
, 0);
143 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR
->succs
)
145 VEC_truncate (edge
, EXIT_BLOCK_PTR
->preds
, 0);
146 VEC_truncate (edge
, ENTRY_BLOCK_PTR
->succs
, 0);
148 gcc_assert (!n_edges
);
151 /* Allocate memory for basic_block. */
157 bb
= ggc_alloc_cleared (sizeof (*bb
));
161 /* Create memory pool for rbi_pool. */
164 alloc_rbi_pool (void)
166 rbi_pool
= create_alloc_pool ("rbi pool",
167 sizeof (struct reorder_block_def
),
176 free_alloc_pool (rbi_pool
);
179 /* Initialize rbi (the structure containing data used by basic block
180 duplication and reordering) for the given basic block. */
183 initialize_bb_rbi (basic_block bb
)
185 gcc_assert (!bb
->rbi
);
186 bb
->rbi
= pool_alloc (rbi_pool
);
187 memset (bb
->rbi
, 0, sizeof (struct reorder_block_def
));
190 /* Link block B to chain after AFTER. */
192 link_block (basic_block b
, basic_block after
)
194 b
->next_bb
= after
->next_bb
;
197 b
->next_bb
->prev_bb
= b
;
200 /* Unlink block B from chain. */
202 unlink_block (basic_block b
)
204 b
->next_bb
->prev_bb
= b
->prev_bb
;
205 b
->prev_bb
->next_bb
= b
->next_bb
;
210 /* Sequentially order blocks and compact the arrays. */
212 compact_blocks (void)
220 BASIC_BLOCK (i
) = bb
;
225 gcc_assert (i
== n_basic_blocks
);
227 for (; i
< last_basic_block
; i
++)
228 BASIC_BLOCK (i
) = NULL
;
230 last_basic_block
= n_basic_blocks
;
233 /* Remove block B from the basic block array. */
236 expunge_block (basic_block b
)
239 BASIC_BLOCK (b
->index
) = NULL
;
241 /* We should be able to ggc_free here, but we are not.
242 The dead SSA_NAMES are left pointing to dead statements that are pointing
243 to dead basic blocks making garbage collector to die.
244 We should be able to release all dead SSA_NAMES and at the same time we should
245 clear out BB pointer of dead statements consistently. */
248 /* Connect E to E->src. */
253 VEC_safe_push (edge
, e
->src
->succs
, e
);
256 /* Connect E to E->dest. */
259 connect_dest (edge e
)
261 basic_block dest
= e
->dest
;
262 VEC_safe_push (edge
, dest
->preds
, e
);
263 e
->dest_idx
= EDGE_COUNT (dest
->preds
) - 1;
266 /* Disconnect edge E from E->src. */
269 disconnect_src (edge e
)
271 basic_block src
= e
->src
;
275 for (ei
= ei_start (src
->succs
); (tmp
= ei_safe_edge (ei
)); )
279 VEC_unordered_remove (edge
, src
->succs
, ei
.index
);
289 /* Disconnect edge E from E->dest. */
292 disconnect_dest (edge e
)
294 basic_block dest
= e
->dest
;
295 unsigned int dest_idx
= e
->dest_idx
;
297 VEC_unordered_remove (edge
, dest
->preds
, dest_idx
);
299 /* If we removed an edge in the middle of the edge vector, we need
300 to update dest_idx of the edge that moved into the "hole". */
301 if (dest_idx
< EDGE_COUNT (dest
->preds
))
302 EDGE_PRED (dest
, dest_idx
)->dest_idx
= dest_idx
;
305 /* Create an edge connecting SRC and DEST with flags FLAGS. Return newly
306 created edge. Use this only if you are sure that this edge can't
307 possibly already exist. */
310 unchecked_make_edge (basic_block src
, basic_block dst
, int flags
)
313 e
= ggc_alloc_cleared (sizeof (*e
));
323 execute_on_growing_pred (e
);
328 /* Create an edge connecting SRC and DST with FLAGS optionally using
329 edge cache CACHE. Return the new edge, NULL if already exist. */
332 cached_make_edge (sbitmap edge_cache
, basic_block src
, basic_block dst
, int flags
)
334 if (edge_cache
== NULL
335 || src
== ENTRY_BLOCK_PTR
336 || dst
== EXIT_BLOCK_PTR
)
337 return make_edge (src
, dst
, flags
);
339 /* Does the requested edge already exist? */
340 if (! TEST_BIT (edge_cache
, dst
->index
))
342 /* The edge does not exist. Create one and update the
344 SET_BIT (edge_cache
, dst
->index
);
345 return unchecked_make_edge (src
, dst
, flags
);
348 /* At this point, we know that the requested edge exists. Adjust
349 flags if necessary. */
352 edge e
= find_edge (src
, dst
);
359 /* Create an edge connecting SRC and DEST with flags FLAGS. Return newly
360 created edge or NULL if already exist. */
363 make_edge (basic_block src
, basic_block dest
, int flags
)
365 edge e
= find_edge (src
, dest
);
367 /* Make sure we don't add duplicate edges. */
374 return unchecked_make_edge (src
, dest
, flags
);
377 /* Create an edge connecting SRC to DEST and set probability by knowing
378 that it is the single edge leaving SRC. */
381 make_single_succ_edge (basic_block src
, basic_block dest
, int flags
)
383 edge e
= make_edge (src
, dest
, flags
);
385 e
->probability
= REG_BR_PROB_BASE
;
386 e
->count
= src
->count
;
390 /* This function will remove an edge from the flow graph. */
395 execute_on_shrinking_pred (e
);
403 /* Redirect an edge's successor from one block to another. */
406 redirect_edge_succ (edge e
, basic_block new_succ
)
408 execute_on_shrinking_pred (e
);
414 /* Reconnect the edge to the new successor block. */
417 execute_on_growing_pred (e
);
420 /* Like previous but avoid possible duplicate edge. */
423 redirect_edge_succ_nodup (edge e
, basic_block new_succ
)
427 s
= find_edge (e
->src
, new_succ
);
430 s
->flags
|= e
->flags
;
431 s
->probability
+= e
->probability
;
432 if (s
->probability
> REG_BR_PROB_BASE
)
433 s
->probability
= REG_BR_PROB_BASE
;
434 s
->count
+= e
->count
;
439 redirect_edge_succ (e
, new_succ
);
444 /* Redirect an edge's predecessor from one block to another. */
447 redirect_edge_pred (edge e
, basic_block new_pred
)
453 /* Reconnect the edge to the new predecessor block. */
457 /* Clear all basic block flags, with the exception of partitioning. */
459 clear_bb_flags (void)
463 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
, NULL
, next_bb
)
464 bb
->flags
= BB_PARTITION (bb
) | (bb
->flags
& BB_DISABLE_SCHEDULE
);
467 /* Check the consistency of profile information. We can't do that
468 in verify_flow_info, as the counts may get invalid for incompletely
469 solved graphs, later eliminating of conditionals or roundoff errors.
470 It is still practical to have them reported for debugging of simple
473 check_bb_profile (basic_block bb
, FILE * file
)
480 if (profile_status
== PROFILE_ABSENT
)
483 if (bb
!= EXIT_BLOCK_PTR
)
485 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
486 sum
+= e
->probability
;
487 if (EDGE_COUNT (bb
->succs
) && abs (sum
- REG_BR_PROB_BASE
) > 100)
488 fprintf (file
, "Invalid sum of outgoing probabilities %.1f%%\n",
489 sum
* 100.0 / REG_BR_PROB_BASE
);
491 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
493 if (EDGE_COUNT (bb
->succs
)
494 && (lsum
- bb
->count
> 100 || lsum
- bb
->count
< -100))
495 fprintf (file
, "Invalid sum of outgoing counts %i, should be %i\n",
496 (int) lsum
, (int) bb
->count
);
498 if (bb
!= ENTRY_BLOCK_PTR
)
501 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
502 sum
+= EDGE_FREQUENCY (e
);
503 if (abs (sum
- bb
->frequency
) > 100)
505 "Invalid sum of incoming frequencies %i, should be %i\n",
508 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
510 if (lsum
- bb
->count
> 100 || lsum
- bb
->count
< -100)
511 fprintf (file
, "Invalid sum of incoming counts %i, should be %i\n",
512 (int) lsum
, (int) bb
->count
);
517 dump_flow_info (FILE *file
)
522 /* There are no pseudo registers after reload. Don't dump them. */
523 if (reg_n_info
&& !reload_completed
)
525 int max_regno
= max_reg_num ();
526 fprintf (file
, "%d registers.\n", max_regno
);
527 for (i
= FIRST_PSEUDO_REGISTER
; i
< max_regno
; i
++)
530 enum reg_class
class, altclass
;
532 fprintf (file
, "\nRegister %d used %d times across %d insns",
533 i
, REG_N_REFS (i
), REG_LIVE_LENGTH (i
));
534 if (REG_BASIC_BLOCK (i
) >= 0)
535 fprintf (file
, " in block %d", REG_BASIC_BLOCK (i
));
537 fprintf (file
, "; set %d time%s", REG_N_SETS (i
),
538 (REG_N_SETS (i
) == 1) ? "" : "s");
539 if (regno_reg_rtx
[i
] != NULL
&& REG_USERVAR_P (regno_reg_rtx
[i
]))
540 fprintf (file
, "; user var");
541 if (REG_N_DEATHS (i
) != 1)
542 fprintf (file
, "; dies in %d places", REG_N_DEATHS (i
));
543 if (REG_N_CALLS_CROSSED (i
) == 1)
544 fprintf (file
, "; crosses 1 call");
545 else if (REG_N_CALLS_CROSSED (i
))
546 fprintf (file
, "; crosses %d calls", REG_N_CALLS_CROSSED (i
));
547 if (regno_reg_rtx
[i
] != NULL
548 && PSEUDO_REGNO_BYTES (i
) != UNITS_PER_WORD
)
549 fprintf (file
, "; %d bytes", PSEUDO_REGNO_BYTES (i
));
551 class = reg_preferred_class (i
);
552 altclass
= reg_alternate_class (i
);
553 if (class != GENERAL_REGS
|| altclass
!= ALL_REGS
)
555 if (altclass
== ALL_REGS
|| class == ALL_REGS
)
556 fprintf (file
, "; pref %s", reg_class_names
[(int) class]);
557 else if (altclass
== NO_REGS
)
558 fprintf (file
, "; %s or none", reg_class_names
[(int) class]);
560 fprintf (file
, "; pref %s, else %s",
561 reg_class_names
[(int) class],
562 reg_class_names
[(int) altclass
]);
565 if (regno_reg_rtx
[i
] != NULL
&& REG_POINTER (regno_reg_rtx
[i
]))
566 fprintf (file
, "; pointer");
567 fprintf (file
, ".\n");
571 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_EACH_EDGE (e
, ei
, bb
->preds
)
591 dump_edge_info (file
, e
, 0);
593 fprintf (file
, "\nSuccessors: ");
594 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
595 dump_edge_info (file
, e
, 1);
597 if (bb
->global_live_at_start
)
599 fprintf (file
, "\nRegisters live at start:");
600 dump_regset (bb
->global_live_at_start
, file
);
603 if (bb
->global_live_at_end
)
605 fprintf (file
, "\nRegisters live at end:");
606 dump_regset (bb
->global_live_at_end
, file
);
610 check_bb_profile (bb
, file
);
617 debug_flow_info (void)
619 dump_flow_info (stderr
);
623 dump_edge_info (FILE *file
, edge e
, int do_succ
)
625 basic_block side
= (do_succ
? e
->dest
: e
->src
);
627 if (side
== ENTRY_BLOCK_PTR
)
628 fputs (" ENTRY", file
);
629 else if (side
== EXIT_BLOCK_PTR
)
630 fputs (" EXIT", file
);
632 fprintf (file
, " %d", side
->index
);
635 fprintf (file
, " [%.1f%%] ", e
->probability
* 100.0 / REG_BR_PROB_BASE
);
639 fprintf (file
, " count:");
640 fprintf (file
, HOST_WIDEST_INT_PRINT_DEC
, e
->count
);
645 static const char * const bitnames
[] = {
646 "fallthru", "ab", "abcall", "eh", "fake", "dfs_back",
647 "can_fallthru", "irreducible", "sibcall", "loop_exit",
648 "true", "false", "exec"
651 int i
, flags
= e
->flags
;
654 for (i
= 0; flags
; i
++)
655 if (flags
& (1 << i
))
661 if (i
< (int) ARRAY_SIZE (bitnames
))
662 fputs (bitnames
[i
], file
);
664 fprintf (file
, "%d", i
);
672 /* Simple routines to easily allocate AUX fields of basic blocks. */
674 static struct obstack block_aux_obstack
;
675 static void *first_block_aux_obj
= 0;
676 static struct obstack edge_aux_obstack
;
677 static void *first_edge_aux_obj
= 0;
679 /* Allocate a memory block of SIZE as BB->aux. The obstack must
680 be first initialized by alloc_aux_for_blocks. */
683 alloc_aux_for_block (basic_block bb
, int size
)
685 /* Verify that aux field is clear. */
686 gcc_assert (!bb
->aux
&& first_block_aux_obj
);
687 bb
->aux
= obstack_alloc (&block_aux_obstack
, size
);
688 memset (bb
->aux
, 0, size
);
691 /* Initialize the block_aux_obstack and if SIZE is nonzero, call
692 alloc_aux_for_block for each basic block. */
695 alloc_aux_for_blocks (int size
)
697 static int initialized
;
701 gcc_obstack_init (&block_aux_obstack
);
705 /* Check whether AUX data are still allocated. */
706 gcc_assert (!first_block_aux_obj
);
708 first_block_aux_obj
= obstack_alloc (&block_aux_obstack
, 0);
713 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
, NULL
, next_bb
)
714 alloc_aux_for_block (bb
, size
);
718 /* Clear AUX pointers of all blocks. */
721 clear_aux_for_blocks (void)
725 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
, NULL
, next_bb
)
729 /* Free data allocated in block_aux_obstack and clear AUX pointers
733 free_aux_for_blocks (void)
735 gcc_assert (first_block_aux_obj
);
736 obstack_free (&block_aux_obstack
, first_block_aux_obj
);
737 first_block_aux_obj
= NULL
;
739 clear_aux_for_blocks ();
742 /* Allocate a memory edge of SIZE as BB->aux. The obstack must
743 be first initialized by alloc_aux_for_edges. */
746 alloc_aux_for_edge (edge e
, int size
)
748 /* Verify that aux field is clear. */
749 gcc_assert (!e
->aux
&& first_edge_aux_obj
);
750 e
->aux
= obstack_alloc (&edge_aux_obstack
, size
);
751 memset (e
->aux
, 0, size
);
754 /* Initialize the edge_aux_obstack and if SIZE is nonzero, call
755 alloc_aux_for_edge for each basic edge. */
758 alloc_aux_for_edges (int size
)
760 static int initialized
;
764 gcc_obstack_init (&edge_aux_obstack
);
768 /* Check whether AUX data are still allocated. */
769 gcc_assert (!first_edge_aux_obj
);
771 first_edge_aux_obj
= obstack_alloc (&edge_aux_obstack
, 0);
776 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, next_bb
)
781 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
782 alloc_aux_for_edge (e
, size
);
787 /* Clear AUX pointers of all edges. */
790 clear_aux_for_edges (void)
795 FOR_BB_BETWEEN (bb
, ENTRY_BLOCK_PTR
, EXIT_BLOCK_PTR
, next_bb
)
798 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
803 /* Free data allocated in edge_aux_obstack and clear AUX pointers
807 free_aux_for_edges (void)
809 gcc_assert (first_edge_aux_obj
);
810 obstack_free (&edge_aux_obstack
, first_edge_aux_obj
);
811 first_edge_aux_obj
= NULL
;
813 clear_aux_for_edges ();
817 debug_bb (basic_block bb
)
819 dump_bb (bb
, stderr
, 0);
825 basic_block bb
= BASIC_BLOCK (n
);
826 dump_bb (bb
, stderr
, 0);
830 /* Dumps cfg related information about basic block BB to FILE. */
833 dump_cfg_bb_info (FILE *file
, basic_block bb
)
838 static const char * const bb_bitnames
[] =
840 "dirty", "new", "reachable", "visited", "irreducible_loop", "superblock"
842 const unsigned n_bitnames
= sizeof (bb_bitnames
) / sizeof (char *);
845 fprintf (file
, "Basic block %d", bb
->index
);
846 for (i
= 0; i
< n_bitnames
; i
++)
847 if (bb
->flags
& (1 << i
))
850 fprintf (file
, " (");
852 fprintf (file
, ", ");
854 fprintf (file
, bb_bitnames
[i
]);
858 fprintf (file
, "\n");
860 fprintf (file
, "Predecessors: ");
861 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
862 dump_edge_info (file
, e
, 0);
864 fprintf (file
, "\nSuccessors: ");
865 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
866 dump_edge_info (file
, e
, 1);
867 fprintf (file
, "\n\n");
870 /* Dumps a brief description of cfg to FILE. */
873 brief_dump_cfg (FILE *file
)
879 dump_cfg_bb_info (file
, bb
);
883 /* An edge originally destinating BB of FREQUENCY and COUNT has been proved to
884 leave the block by TAKEN_EDGE. Update profile of BB such that edge E can be
885 redirected to destination of TAKEN_EDGE.
887 This function may leave the profile inconsistent in the case TAKEN_EDGE
888 frequency or count is believed to be lower than FREQUENCY or COUNT
891 update_bb_profile_for_threading (basic_block bb
, int edge_frequency
,
892 gcov_type count
, edge taken_edge
)
902 /* Compute the probability of TAKEN_EDGE being reached via threaded edge.
903 Watch for overflows. */
905 prob
= edge_frequency
* REG_BR_PROB_BASE
/ bb
->frequency
;
908 if (prob
> taken_edge
->probability
)
911 fprintf (dump_file
, "Jump threading proved probability of edge "
912 "%i->%i too small (it is %i, should be %i).\n",
913 taken_edge
->src
->index
, taken_edge
->dest
->index
,
914 taken_edge
->probability
, prob
);
915 prob
= taken_edge
->probability
;
918 /* Now rescale the probabilities. */
919 taken_edge
->probability
-= prob
;
920 prob
= REG_BR_PROB_BASE
- prob
;
921 bb
->frequency
-= edge_frequency
;
922 if (bb
->frequency
< 0)
927 fprintf (dump_file
, "Edge frequencies of bb %i has been reset, "
928 "frequency of block should end up being 0, it is %i\n",
929 bb
->index
, bb
->frequency
);
930 EDGE_SUCC (bb
, 0)->probability
= REG_BR_PROB_BASE
;
931 ei
= ei_start (bb
->succs
);
933 for (; (c
= ei_safe_edge (ei
)); ei_next (&ei
))
936 else if (prob
!= REG_BR_PROB_BASE
)
938 int scale
= 65536 * REG_BR_PROB_BASE
/ prob
;
940 FOR_EACH_EDGE (c
, ei
, bb
->succs
)
941 c
->probability
*= scale
/ 65536;
944 if (bb
!= taken_edge
->src
)
946 taken_edge
->count
-= count
;
947 if (taken_edge
->count
< 0)
948 taken_edge
->count
= 0;
951 /* Multiply all frequencies of basic blocks in array BBS of length NBBS
952 by NUM/DEN, in int arithmetic. May lose some accuracy. */
954 scale_bbs_frequencies_int (basic_block
*bbs
, int nbbs
, int num
, int den
)
958 for (i
= 0; i
< nbbs
; i
++)
961 bbs
[i
]->frequency
= (bbs
[i
]->frequency
* num
) / den
;
962 bbs
[i
]->count
= RDIV (bbs
[i
]->count
* num
, den
);
963 FOR_EACH_EDGE (e
, ei
, bbs
[i
]->succs
)
964 e
->count
= (e
->count
* num
) /den
;
968 /* Multiply all frequencies of basic blocks in array BBS of length NBBS
969 by NUM/DEN, in gcov_type arithmetic. More accurate than previous
970 function but considerably slower. */
972 scale_bbs_frequencies_gcov_type (basic_block
*bbs
, int nbbs
, gcov_type num
,
978 for (i
= 0; i
< nbbs
; i
++)
981 bbs
[i
]->frequency
= (bbs
[i
]->frequency
* num
) / den
;
982 bbs
[i
]->count
= RDIV (bbs
[i
]->count
* num
, den
);
983 FOR_EACH_EDGE (e
, ei
, bbs
[i
]->succs
)
984 e
->count
= (e
->count
* num
) /den
;