Branch data Line data Source code
1 : : /* Define control flow data structures for the CFG.
2 : : Copyright (C) 1987-2025 Free Software Foundation, Inc.
3 : :
4 : : This file is part of GCC.
5 : :
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
9 : : version.
10 : :
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
14 : : for more details.
15 : :
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/>. */
19 : :
20 : : #ifndef GCC_BASIC_BLOCK_H
21 : : #define GCC_BASIC_BLOCK_H
22 : :
23 : : #include <profile-count.h>
24 : :
25 : : /* Control flow edge information. */
26 : : class GTY((user)) edge_def {
27 : : public:
28 : : /* The two blocks at the ends of the edge. */
29 : : basic_block src;
30 : : basic_block dest;
31 : :
32 : : /* Instructions queued on the edge. */
33 : : union edge_def_insns {
34 : : gimple_seq g;
35 : : rtx_insn *r;
36 : : } insns;
37 : :
38 : : /* Auxiliary info specific to a pass. */
39 : : void *aux;
40 : :
41 : : /* Location of any goto implicit in the edge. */
42 : : location_t goto_locus;
43 : :
44 : : /* The index number corresponding to this edge in the edge vector
45 : : dest->preds. */
46 : : unsigned int dest_idx;
47 : :
48 : : int flags; /* see cfg-flags.def */
49 : : profile_probability probability;
50 : :
51 : : /* Return count of edge E. */
52 : : inline profile_count count () const;
53 : : };
54 : :
55 : : /* Masks for edge.flags. */
56 : : #define DEF_EDGE_FLAG(NAME,IDX) EDGE_##NAME = 1 << IDX ,
57 : : enum cfg_edge_flags {
58 : : #include "cfg-flags.def"
59 : : LAST_CFG_EDGE_FLAG /* this is only used for EDGE_ALL_FLAGS */
60 : : };
61 : : #undef DEF_EDGE_FLAG
62 : :
63 : : /* Bit mask for all edge flags. */
64 : : #define EDGE_ALL_FLAGS ((LAST_CFG_EDGE_FLAG - 1) * 2 - 1)
65 : :
66 : : /* The following four flags all indicate something special about an edge.
67 : : Test the edge flags on EDGE_COMPLEX to detect all forms of "strange"
68 : : control flow transfers. */
69 : : #define EDGE_COMPLEX \
70 : : (EDGE_ABNORMAL | EDGE_ABNORMAL_CALL | EDGE_EH | EDGE_PRESERVE)
71 : :
72 : : struct GTY(()) rtl_bb_info {
73 : : /* The first insn of the block is embedded into bb->il.x. */
74 : : /* The last insn of the block. */
75 : : rtx_insn *end_;
76 : :
77 : : /* In CFGlayout mode points to insn notes/jumptables to be placed just before
78 : : and after the block. */
79 : : rtx_insn *header_;
80 : : rtx_insn *footer_;
81 : : };
82 : :
83 : : struct GTY(()) gimple_bb_info {
84 : : /* Sequence of statements in this block. */
85 : : gimple_seq seq;
86 : :
87 : : /* PHI nodes for this block. */
88 : : gimple_seq phi_nodes;
89 : : };
90 : :
91 : : /* A basic block is a sequence of instructions with only one entry and
92 : : only one exit. If any one of the instructions are executed, they
93 : : will all be executed, and in sequence from first to last.
94 : :
95 : : There may be COND_EXEC instructions in the basic block. The
96 : : COND_EXEC *instructions* will be executed -- but if the condition
97 : : is false the conditionally executed *expressions* will of course
98 : : not be executed. We don't consider the conditionally executed
99 : : expression (which might have side-effects) to be in a separate
100 : : basic block because the program counter will always be at the same
101 : : location after the COND_EXEC instruction, regardless of whether the
102 : : condition is true or not.
103 : :
104 : : Basic blocks need not start with a label nor end with a jump insn.
105 : : For example, a previous basic block may just "conditionally fall"
106 : : into the succeeding basic block, and the last basic block need not
107 : : end with a jump insn. Block 0 is a descendant of the entry block.
108 : :
109 : : A basic block beginning with two labels cannot have notes between
110 : : the labels.
111 : :
112 : : Data for jump tables are stored in jump_insns that occur in no
113 : : basic block even though these insns can follow or precede insns in
114 : : basic blocks. */
115 : :
116 : : /* Basic block information indexed by block number. */
117 : : struct GTY((chain_next ("%h.next_bb"), chain_prev ("%h.prev_bb"))) basic_block_def {
118 : : /* The edges into and out of the block. */
119 : : vec<edge, va_gc> *preds;
120 : : vec<edge, va_gc> *succs;
121 : :
122 : : /* Auxiliary info specific to a pass. */
123 : : void *GTY ((skip (""))) aux;
124 : :
125 : : /* Innermost loop containing the block. */
126 : : class loop *loop_father;
127 : :
128 : : /* The dominance and postdominance information node. */
129 : : struct et_node * GTY ((skip (""))) dom[2];
130 : :
131 : : /* Previous and next blocks in the chain. */
132 : : basic_block prev_bb;
133 : : basic_block next_bb;
134 : :
135 : : union basic_block_il_dependent {
136 : : struct gimple_bb_info GTY ((tag ("0"))) gimple;
137 : : struct {
138 : : rtx_insn *head_;
139 : : struct rtl_bb_info * rtl;
140 : : } GTY ((tag ("1"))) x;
141 : : } GTY ((desc ("((%1.flags & BB_RTL) != 0)"))) il;
142 : :
143 : : /* Various flags. See cfg-flags.def. */
144 : : int flags;
145 : :
146 : : /* The index of this block. */
147 : : int index;
148 : :
149 : : /* Expected number of executions: calculated in profile.cc. */
150 : : profile_count count;
151 : : };
152 : :
153 : : /* This ensures that struct gimple_bb_info is smaller than
154 : : struct rtl_bb_info, so that inlining the former into basic_block_def
155 : : is the better choice. */
156 : : STATIC_ASSERT (sizeof (rtl_bb_info) >= sizeof (gimple_bb_info));
157 : :
158 : : #define BB_FREQ_MAX 10000
159 : :
160 : : /* Masks for basic_block.flags. */
161 : : #define DEF_BASIC_BLOCK_FLAG(NAME,IDX) BB_##NAME = 1 << IDX ,
162 : : enum cfg_bb_flags
163 : : {
164 : : #include "cfg-flags.def"
165 : : LAST_CFG_BB_FLAG /* this is only used for BB_ALL_FLAGS */
166 : : };
167 : : #undef DEF_BASIC_BLOCK_FLAG
168 : :
169 : : /* Bit mask for all basic block flags. */
170 : : #define BB_ALL_FLAGS ((LAST_CFG_BB_FLAG - 1) * 2 - 1)
171 : :
172 : : /* Bit mask for all basic block flags that must be preserved. These are
173 : : the bit masks that are *not* cleared by clear_bb_flags. */
174 : : #define BB_FLAGS_TO_PRESERVE \
175 : : (BB_DISABLE_SCHEDULE | BB_RTL | BB_NON_LOCAL_GOTO_TARGET \
176 : : | BB_HOT_PARTITION | BB_COLD_PARTITION)
177 : :
178 : : /* Dummy bitmask for convenience in the hot/cold partitioning code. */
179 : : #define BB_UNPARTITIONED 0
180 : :
181 : : /* Partitions, to be used when partitioning hot and cold basic blocks into
182 : : separate sections. */
183 : : #define BB_PARTITION(bb) ((bb)->flags & (BB_HOT_PARTITION|BB_COLD_PARTITION))
184 : : #define BB_SET_PARTITION(bb, part) do { \
185 : : basic_block bb_ = (bb); \
186 : : bb_->flags = ((bb_->flags & ~(BB_HOT_PARTITION|BB_COLD_PARTITION)) \
187 : : | (part)); \
188 : : } while (0)
189 : :
190 : : #define BB_COPY_PARTITION(dstbb, srcbb) \
191 : : BB_SET_PARTITION (dstbb, BB_PARTITION (srcbb))
192 : :
193 : : /* Defines for accessing the fields of the CFG structure for function FN. */
194 : : #define ENTRY_BLOCK_PTR_FOR_FN(FN) ((FN)->cfg->x_entry_block_ptr)
195 : : #define EXIT_BLOCK_PTR_FOR_FN(FN) ((FN)->cfg->x_exit_block_ptr)
196 : : #define basic_block_info_for_fn(FN) ((FN)->cfg->x_basic_block_info)
197 : : #define n_basic_blocks_for_fn(FN) ((FN)->cfg->x_n_basic_blocks)
198 : : #define n_edges_for_fn(FN) ((FN)->cfg->x_n_edges)
199 : : #define last_basic_block_for_fn(FN) ((FN)->cfg->x_last_basic_block)
200 : : #define label_to_block_map_for_fn(FN) ((FN)->cfg->x_label_to_block_map)
201 : : #define profile_status_for_fn(FN) ((FN)->cfg->x_profile_status)
202 : :
203 : : #define BASIC_BLOCK_FOR_FN(FN,N) \
204 : : ((*basic_block_info_for_fn (FN))[(N)])
205 : : #define SET_BASIC_BLOCK_FOR_FN(FN,N,BB) \
206 : : ((*basic_block_info_for_fn (FN))[(N)] = (BB))
207 : :
208 : : /* For iterating over basic blocks. */
209 : : #define FOR_BB_BETWEEN(BB, FROM, TO, DIR) \
210 : : for (BB = FROM; BB != TO; BB = BB->DIR)
211 : :
212 : : #define FOR_EACH_BB_FN(BB, FN) \
213 : : FOR_BB_BETWEEN (BB, (FN)->cfg->x_entry_block_ptr->next_bb, (FN)->cfg->x_exit_block_ptr, next_bb)
214 : :
215 : : #define FOR_EACH_BB_REVERSE_FN(BB, FN) \
216 : : FOR_BB_BETWEEN (BB, (FN)->cfg->x_exit_block_ptr->prev_bb, (FN)->cfg->x_entry_block_ptr, prev_bb)
217 : :
218 : : /* For iterating over insns in basic block. */
219 : : #define FOR_BB_INSNS(BB, INSN) \
220 : : for ((INSN) = BB_HEAD (BB); \
221 : : (INSN) && (INSN) != NEXT_INSN (BB_END (BB)); \
222 : : (INSN) = NEXT_INSN (INSN))
223 : :
224 : : /* For iterating over insns in basic block when we might remove the
225 : : current insn. */
226 : : #define FOR_BB_INSNS_SAFE(BB, INSN, CURR) \
227 : : for ((INSN) = BB_HEAD (BB), (CURR) = (INSN) ? NEXT_INSN ((INSN)) : NULL; \
228 : : (INSN) && (INSN) != NEXT_INSN (BB_END (BB)); \
229 : : (INSN) = (CURR), (CURR) = (INSN) ? NEXT_INSN ((INSN)) : NULL)
230 : :
231 : : #define FOR_BB_INSNS_REVERSE(BB, INSN) \
232 : : for ((INSN) = BB_END (BB); \
233 : : (INSN) && (INSN) != PREV_INSN (BB_HEAD (BB)); \
234 : : (INSN) = PREV_INSN (INSN))
235 : :
236 : : #define FOR_BB_INSNS_REVERSE_SAFE(BB, INSN, CURR) \
237 : : for ((INSN) = BB_END (BB),(CURR) = (INSN) ? PREV_INSN ((INSN)) : NULL; \
238 : : (INSN) && (INSN) != PREV_INSN (BB_HEAD (BB)); \
239 : : (INSN) = (CURR), (CURR) = (INSN) ? PREV_INSN ((INSN)) : NULL)
240 : :
241 : : /* Cycles through _all_ basic blocks, even the fake ones (entry and
242 : : exit block). */
243 : :
244 : : #define FOR_ALL_BB_FN(BB, FN) \
245 : : for (BB = ENTRY_BLOCK_PTR_FOR_FN (FN); BB; BB = BB->next_bb)
246 : :
247 : :
248 : : /* Stuff for recording basic block info. */
249 : :
250 : : /* For now, these will be functions (so that they can include checked casts
251 : : to rtx_insn. Once the underlying fields are converted from rtx
252 : : to rtx_insn, these can be converted back to macros. */
253 : :
254 : : #define BB_HEAD(B) (B)->il.x.head_
255 : : #define BB_END(B) (B)->il.x.rtl->end_
256 : : #define BB_HEADER(B) (B)->il.x.rtl->header_
257 : : #define BB_FOOTER(B) (B)->il.x.rtl->footer_
258 : :
259 : : /* Special block numbers [markers] for entry and exit.
260 : : Neither of them is supposed to hold actual statements. */
261 : : #define ENTRY_BLOCK (0)
262 : : #define EXIT_BLOCK (1)
263 : :
264 : : /* The two blocks that are always in the cfg. */
265 : : #define NUM_FIXED_BLOCKS (2)
266 : :
267 : : /* This is the value which indicates no edge is present. */
268 : : #define EDGE_INDEX_NO_EDGE -1
269 : :
270 : : /* EDGE_INDEX returns an integer index for an edge, or EDGE_INDEX_NO_EDGE
271 : : if there is no edge between the 2 basic blocks. */
272 : : #define EDGE_INDEX(el, pred, succ) (find_edge_index ((el), (pred), (succ)))
273 : :
274 : : /* INDEX_EDGE_PRED_BB and INDEX_EDGE_SUCC_BB return a pointer to the basic
275 : : block which is either the pred or succ end of the indexed edge. */
276 : : #define INDEX_EDGE_PRED_BB(el, index) ((el)->index_to_edge[(index)]->src)
277 : : #define INDEX_EDGE_SUCC_BB(el, index) ((el)->index_to_edge[(index)]->dest)
278 : :
279 : : /* INDEX_EDGE returns a pointer to the edge. */
280 : : #define INDEX_EDGE(el, index) ((el)->index_to_edge[(index)])
281 : :
282 : : /* Number of edges in the compressed edge list. */
283 : : #define NUM_EDGES(el) ((el)->num_edges)
284 : :
285 : : /* BB is assumed to contain conditional jump. Return the fallthru edge. */
286 : : #define FALLTHRU_EDGE(bb) (EDGE_SUCC ((bb), 0)->flags & EDGE_FALLTHRU \
287 : : ? EDGE_SUCC ((bb), 0) : EDGE_SUCC ((bb), 1))
288 : :
289 : : /* BB is assumed to contain conditional jump. Return the branch edge. */
290 : : #define BRANCH_EDGE(bb) (EDGE_SUCC ((bb), 0)->flags & EDGE_FALLTHRU \
291 : : ? EDGE_SUCC ((bb), 1) : EDGE_SUCC ((bb), 0))
292 : :
293 : : /* Return expected execution frequency of the edge E. */
294 : : #define EDGE_FREQUENCY(e) e->count ().to_frequency (cfun)
295 : :
296 : : /* Return nonzero if edge is critical. */
297 : : #define EDGE_CRITICAL_P(e) (EDGE_COUNT ((e)->src->succs) >= 2 \
298 : : && EDGE_COUNT ((e)->dest->preds) >= 2)
299 : :
300 : : #define EDGE_COUNT(ev) vec_safe_length (ev)
301 : : #define EDGE_I(ev,i) (*ev)[(i)]
302 : : #define EDGE_PRED(bb,i) (*(bb)->preds)[(i)]
303 : : #define EDGE_SUCC(bb,i) (*(bb)->succs)[(i)]
304 : :
305 : : /* Returns true if BB has precisely one successor. */
306 : :
307 : : inline bool
308 : 4910591166 : single_succ_p (const_basic_block bb)
309 : : {
310 : 19108240125 : return EDGE_COUNT (bb->succs) == 1;
311 : : }
312 : :
313 : : /* Returns true if BB has precisely one predecessor. */
314 : :
315 : : inline bool
316 : 1445575739 : single_pred_p (const_basic_block bb)
317 : : {
318 : 4178130224 : return EDGE_COUNT (bb->preds) == 1;
319 : : }
320 : :
321 : : /* Returns the single successor edge of basic block BB. Aborts if
322 : : BB does not have exactly one successor. */
323 : :
324 : : inline edge
325 : 2167921008 : single_succ_edge (const_basic_block bb)
326 : : {
327 : 2167921008 : gcc_checking_assert (single_succ_p (bb));
328 : 2167921008 : return EDGE_SUCC (bb, 0);
329 : : }
330 : :
331 : : /* Returns the single predecessor edge of basic block BB. Aborts
332 : : if BB does not have exactly one predecessor. */
333 : :
334 : : inline edge
335 : 1043939467 : single_pred_edge (const_basic_block bb)
336 : : {
337 : 1043939467 : gcc_checking_assert (single_pred_p (bb));
338 : 1043939467 : return EDGE_PRED (bb, 0);
339 : : }
340 : :
341 : : /* Returns the single successor block of basic block BB. Aborts
342 : : if BB does not have exactly one successor. */
343 : :
344 : : inline basic_block
345 : 1189901254 : single_succ (const_basic_block bb)
346 : : {
347 : 1193304003 : return single_succ_edge (bb)->dest;
348 : : }
349 : :
350 : : /* Returns the single predecessor block of basic block BB. Aborts
351 : : if BB does not have exactly one predecessor.*/
352 : :
353 : : inline basic_block
354 : 564358433 : single_pred (const_basic_block bb)
355 : : {
356 : 564132052 : return single_pred_edge (bb)->src;
357 : : }
358 : :
359 : : /* Iterator object for edges. */
360 : :
361 : : struct edge_iterator {
362 : : unsigned index;
363 : : vec<edge, va_gc> **container;
364 : : };
365 : :
366 : : inline vec<edge, va_gc> *
367 : >34944*10^7 : ei_container (edge_iterator i)
368 : : {
369 : >34944*10^7 : gcc_checking_assert (i.container);
370 : >34944*10^7 : return *i.container;
371 : : }
372 : :
373 : : #define ei_start(iter) ei_start_1 (&(iter))
374 : : #define ei_last(iter) ei_last_1 (&(iter))
375 : :
376 : : /* Return an iterator pointing to the start of an edge vector. */
377 : : inline edge_iterator
378 : 19432922049 : ei_start_1 (vec<edge, va_gc> **ev)
379 : : {
380 : 19432922049 : edge_iterator i;
381 : :
382 : 19432922049 : i.index = 0;
383 : 19432922049 : i.container = ev;
384 : :
385 : 19432922049 : return i;
386 : : }
387 : :
388 : : /* Return an iterator pointing to the last element of an edge
389 : : vector. */
390 : : inline edge_iterator
391 : : ei_last_1 (vec<edge, va_gc> **ev)
392 : : {
393 : : edge_iterator i;
394 : :
395 : : i.index = EDGE_COUNT (*ev) - 1;
396 : : i.container = ev;
397 : :
398 : : return i;
399 : : }
400 : :
401 : : /* Is the iterator `i' at the end of the sequence? */
402 : : inline bool
403 : >15236*10^7 : ei_end_p (edge_iterator i)
404 : : {
405 : >15236*10^7 : return (i.index == EDGE_COUNT (ei_container (i)));
406 : : }
407 : :
408 : : /* Is the iterator `i' at one position before the end of the
409 : : sequence? */
410 : : inline bool
411 : 8599022605 : ei_one_before_end_p (edge_iterator i)
412 : : {
413 : 8599022605 : return (i.index + 1 == EDGE_COUNT (ei_container (i)));
414 : : }
415 : :
416 : : /* Advance the iterator to the next element. */
417 : : inline void
418 : 88920412605 : ei_next (edge_iterator *i)
419 : : {
420 : 88920412605 : gcc_checking_assert (i->index < EDGE_COUNT (ei_container (*i)));
421 : 88920412605 : i->index++;
422 : 88920412605 : }
423 : :
424 : : /* Move the iterator to the previous element. */
425 : : inline void
426 : : ei_prev (edge_iterator *i)
427 : : {
428 : : gcc_checking_assert (i->index > 0);
429 : : i->index--;
430 : : }
431 : :
432 : : /* Return the edge pointed to by the iterator `i'. */
433 : : inline edge
434 : 98847516957 : ei_edge (edge_iterator i)
435 : : {
436 : 98847516957 : return EDGE_I (ei_container (i), i.index);
437 : : }
438 : :
439 : : /* Return an edge pointed to by the iterator. Do it safely so that
440 : : NULL is returned when the iterator is pointing at the end of the
441 : : sequence. */
442 : : inline edge
443 : 2656137173 : ei_safe_edge (edge_iterator i)
444 : : {
445 : 2656137173 : return !ei_end_p (i) ? ei_edge (i) : NULL;
446 : : }
447 : :
448 : : /* Return 1 if we should continue to iterate. Return 0 otherwise.
449 : : *Edge P is set to the next edge if we are to continue to iterate
450 : : and NULL otherwise. */
451 : :
452 : : inline bool
453 : >10143*10^7 : ei_cond (edge_iterator ei, edge *p)
454 : : {
455 : >10143*10^7 : if (!ei_end_p (ei))
456 : : {
457 : 60254467864 : *p = ei_edge (ei);
458 : 60254467864 : return 1;
459 : : }
460 : : else
461 : : {
462 : 41176743561 : *p = NULL;
463 : 41176743561 : return 0;
464 : : }
465 : : }
466 : :
467 : : /* This macro serves as a convenient way to iterate each edge in a
468 : : vector of predecessor or successor edges. It must not be used when
469 : : an element might be removed during the traversal, otherwise
470 : : elements will be missed. Instead, use a for-loop like that shown
471 : : in the following pseudo-code:
472 : :
473 : : FOR (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
474 : : {
475 : : IF (e != taken_edge)
476 : : remove_edge (e);
477 : : ELSE
478 : : ei_next (&ei);
479 : : }
480 : : */
481 : :
482 : : #define FOR_EACH_EDGE(EDGE,ITER,EDGE_VEC) \
483 : : for ((ITER) = ei_start ((EDGE_VEC)); \
484 : : ei_cond ((ITER), &(EDGE)); \
485 : : ei_next (&(ITER)))
486 : :
487 : : #define CLEANUP_EXPENSIVE 1 /* Do relatively expensive optimizations
488 : : except for edge forwarding */
489 : : #define CLEANUP_CROSSJUMP 2 /* Do crossjumping. */
490 : : #define CLEANUP_POST_REGSTACK 4 /* We run after reg-stack and need
491 : : to care REG_DEAD notes. */
492 : : #define CLEANUP_THREADING 8 /* Do jump threading. */
493 : : #define CLEANUP_NO_INSN_DEL 16 /* Do not try to delete trivially dead
494 : : insns. */
495 : : #define CLEANUP_CFGLAYOUT 32 /* Do cleanup in cfglayout mode. */
496 : : #define CLEANUP_CFG_CHANGED 64 /* The caller changed the CFG. */
497 : : #define CLEANUP_NO_PARTITIONING 128 /* Do not try to fix partitions. */
498 : : #define CLEANUP_FORCE_FAST_DCE 0x100 /* Force run_fast_dce to be called
499 : : at least once. */
500 : :
501 : : /* Return true if BB is in a transaction. */
502 : :
503 : : inline bool
504 : 12278 : bb_in_transaction (basic_block bb)
505 : : {
506 : 12278 : return bb->flags & BB_IN_TRANSACTION;
507 : : }
508 : :
509 : : /* Return true when one of the predecessor edges of BB is marked with EDGE_EH. */
510 : : inline bool
511 : 897228666 : bb_has_eh_pred (basic_block bb)
512 : : {
513 : 897228666 : edge e;
514 : 897228666 : edge_iterator ei;
515 : :
516 : 2158015886 : FOR_EACH_EDGE (e, ei, bb->preds)
517 : : {
518 : 1271454603 : if (e->flags & EDGE_EH)
519 : : return true;
520 : : }
521 : : return false;
522 : : }
523 : :
524 : : /* Return true when one of the predecessor edges of BB is marked with EDGE_ABNORMAL. */
525 : : inline bool
526 : 4217912268 : bb_has_abnormal_pred (basic_block bb)
527 : : {
528 : 4217912268 : edge e;
529 : 4217912268 : edge_iterator ei;
530 : :
531 : 10237631782 : FOR_EACH_EDGE (e, ei, bb->preds)
532 : : {
533 : 6031567968 : if (e->flags & EDGE_ABNORMAL)
534 : : return true;
535 : : }
536 : : return false;
537 : : }
538 : :
539 : : /* Return the fallthru edge in EDGES if it exists, NULL otherwise. */
540 : : inline edge
541 : 725496867 : find_fallthru_edge (vec<edge, va_gc> *edges)
542 : : {
543 : 725496867 : edge e;
544 : 725496867 : edge_iterator ei;
545 : :
546 : 1159982731 : FOR_EACH_EDGE (e, ei, edges)
547 : 947896643 : if (e->flags & EDGE_FALLTHRU)
548 : : break;
549 : :
550 : 725496867 : return e;
551 : : }
552 : :
553 : : /* Check tha probability is sane. */
554 : :
555 : : inline void
556 : 1741144 : check_probability (int prob)
557 : : {
558 : 1741144 : gcc_checking_assert (prob >= 0 && prob <= REG_BR_PROB_BASE);
559 : 1741144 : }
560 : :
561 : : /* Given PROB1 and PROB2, return PROB1*PROB2/REG_BR_PROB_BASE.
562 : : Used to combine BB probabilities. */
563 : :
564 : : inline int
565 : 870572 : combine_probabilities (int prob1, int prob2)
566 : : {
567 : 870572 : check_probability (prob1);
568 : 870572 : check_probability (prob2);
569 : 870572 : return RDIV (prob1 * prob2, REG_BR_PROB_BASE);
570 : : }
571 : :
572 : : /* Apply scale factor SCALE on frequency or count FREQ. Use this
573 : : interface when potentially scaling up, so that SCALE is not
574 : : constrained to be < REG_BR_PROB_BASE. */
575 : :
576 : : inline gcov_type
577 : : apply_scale (gcov_type freq, gcov_type scale)
578 : : {
579 : : return RDIV (freq * scale, REG_BR_PROB_BASE);
580 : : }
581 : :
582 : : /* Apply probability PROB on frequency or count FREQ. */
583 : :
584 : : inline gcov_type
585 : : apply_probability (gcov_type freq, int prob)
586 : : {
587 : : check_probability (prob);
588 : : return apply_scale (freq, prob);
589 : : }
590 : :
591 : : /* Return inverse probability for PROB. */
592 : :
593 : : inline int
594 : : inverse_probability (int prob1)
595 : : {
596 : : check_probability (prob1);
597 : : return REG_BR_PROB_BASE - prob1;
598 : : }
599 : :
600 : : /* Return true if BB has at least one abnormal outgoing edge. */
601 : :
602 : : inline bool
603 : 20234801 : has_abnormal_or_eh_outgoing_edge_p (basic_block bb)
604 : : {
605 : 20234801 : edge e;
606 : 20234801 : edge_iterator ei;
607 : :
608 : 66284318 : FOR_EACH_EDGE (e, ei, bb->succs)
609 : 47683472 : if (e->flags & (EDGE_ABNORMAL | EDGE_EH))
610 : : return true;
611 : :
612 : : return false;
613 : : }
614 : :
615 : : /* Return true when one of the predecessor edges of BB is marked with
616 : : EDGE_ABNORMAL_CALL or EDGE_EH. */
617 : :
618 : : inline bool
619 : 130120464 : has_abnormal_call_or_eh_pred_edge_p (basic_block bb)
620 : : {
621 : 130120464 : edge e;
622 : 130120464 : edge_iterator ei;
623 : :
624 : 301265694 : FOR_EACH_EDGE (e, ei, bb->preds)
625 : 173223841 : if (e->flags & (EDGE_ABNORMAL_CALL | EDGE_EH))
626 : : return true;
627 : :
628 : : return false;
629 : : }
630 : :
631 : : /* Return count of edge E. */
632 : 389134870 : inline profile_count edge_def::count () const
633 : : {
634 : 364288521 : return src->count.apply_probability (probability);
635 : : }
636 : :
637 : : #endif /* GCC_BASIC_BLOCK_H */
|
