Don't warn when alignment of global common data exceeds maximum alignment.
[official-gcc.git] / gcc / cfghooks.c
blob50b9b1776392d744aef0f14e2dda0cb17a73e0ea
1 /* Hooks for cfg representation specific functions.
2 Copyright (C) 2003-2021 Free Software Foundation, Inc.
3 Contributed by Sebastian Pop <s.pop@laposte.net>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "backend.h"
25 #include "rtl.h"
26 #include "cfghooks.h"
27 #include "timevar.h"
28 #include "pretty-print.h"
29 #include "diagnostic-core.h"
30 #include "dumpfile.h"
31 #include "cfganal.h"
32 #include "tree-ssa.h"
33 #include "cfgloop.h"
35 /* Disable warnings about missing quoting in GCC diagnostics. */
36 #if __GNUC__ >= 10
37 # pragma GCC diagnostic push
38 # pragma GCC diagnostic ignored "-Wformat-diag"
39 #endif
41 /* A pointer to one of the hooks containers. */
42 static struct cfg_hooks *cfg_hooks;
44 /* Initialization of functions specific to the rtl IR. */
45 void
46 rtl_register_cfg_hooks (void)
48 cfg_hooks = &rtl_cfg_hooks;
51 /* Initialization of functions specific to the rtl IR. */
52 void
53 cfg_layout_rtl_register_cfg_hooks (void)
55 cfg_hooks = &cfg_layout_rtl_cfg_hooks;
58 /* Initialization of functions specific to the tree IR. */
60 void
61 gimple_register_cfg_hooks (void)
63 cfg_hooks = &gimple_cfg_hooks;
66 struct cfg_hooks
67 get_cfg_hooks (void)
69 return *cfg_hooks;
72 void
73 set_cfg_hooks (struct cfg_hooks new_cfg_hooks)
75 *cfg_hooks = new_cfg_hooks;
78 /* Returns current ir type. */
80 enum ir_type
81 current_ir_type (void)
83 if (cfg_hooks == &gimple_cfg_hooks)
84 return IR_GIMPLE;
85 else if (cfg_hooks == &rtl_cfg_hooks)
86 return IR_RTL_CFGRTL;
87 else if (cfg_hooks == &cfg_layout_rtl_cfg_hooks)
88 return IR_RTL_CFGLAYOUT;
89 else
90 gcc_unreachable ();
93 /* Verify the CFG consistency.
95 Currently it does following: checks edge and basic block list correctness
96 and calls into IL dependent checking then. */
98 DEBUG_FUNCTION void
99 verify_flow_info (void)
101 size_t *edge_checksum;
102 int err = 0;
103 basic_block bb, last_bb_seen;
104 basic_block *last_visited;
106 timevar_push (TV_CFG_VERIFY);
107 last_visited = XCNEWVEC (basic_block, last_basic_block_for_fn (cfun));
108 edge_checksum = XCNEWVEC (size_t, last_basic_block_for_fn (cfun));
110 /* Check bb chain & numbers. */
111 last_bb_seen = ENTRY_BLOCK_PTR_FOR_FN (cfun);
112 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb, NULL, next_bb)
114 if (bb != EXIT_BLOCK_PTR_FOR_FN (cfun)
115 && bb != BASIC_BLOCK_FOR_FN (cfun, bb->index))
117 error ("bb %d on wrong place", bb->index);
118 err = 1;
121 if (bb->prev_bb != last_bb_seen)
123 error ("prev_bb of %d should be %d, not %d",
124 bb->index, last_bb_seen->index, bb->prev_bb->index);
125 err = 1;
128 last_bb_seen = bb;
131 /* Now check the basic blocks (boundaries etc.) */
132 FOR_EACH_BB_REVERSE_FN (bb, cfun)
134 int n_fallthru = 0;
135 edge e;
136 edge_iterator ei;
138 if (bb->loop_father != NULL && current_loops == NULL)
140 error ("verify_flow_info: Block %i has loop_father, but there are no loops",
141 bb->index);
142 err = 1;
144 if (bb->loop_father == NULL && current_loops != NULL)
146 error ("verify_flow_info: Block %i lacks loop_father", bb->index);
147 err = 1;
150 if (!bb->count.verify ())
152 error ("verify_flow_info: Wrong count of block %i", bb->index);
153 err = 1;
155 /* FIXME: Graphite and SLJL and target code still tends to produce
156 edges with no probability. */
157 if (profile_status_for_fn (cfun) >= PROFILE_GUESSED
158 && !bb->count.initialized_p () && !flag_graphite && 0)
160 error ("verify_flow_info: Missing count of block %i", bb->index);
161 err = 1;
164 FOR_EACH_EDGE (e, ei, bb->succs)
166 if (last_visited [e->dest->index] == bb)
168 error ("verify_flow_info: Duplicate edge %i->%i",
169 e->src->index, e->dest->index);
170 err = 1;
172 /* FIXME: Graphite and SLJL and target code still tends to produce
173 edges with no probability. */
174 if (profile_status_for_fn (cfun) >= PROFILE_GUESSED
175 && !e->probability.initialized_p () && !flag_graphite && 0)
177 error ("Uninitialized probability of edge %i->%i", e->src->index,
178 e->dest->index);
179 err = 1;
181 if (!e->probability.verify ())
183 error ("verify_flow_info: Wrong probability of edge %i->%i",
184 e->src->index, e->dest->index);
185 err = 1;
188 last_visited [e->dest->index] = bb;
190 if (e->flags & EDGE_FALLTHRU)
191 n_fallthru++;
193 if (e->src != bb)
195 error ("verify_flow_info: Basic block %d succ edge is corrupted",
196 bb->index);
197 fprintf (stderr, "Predecessor: ");
198 dump_edge_info (stderr, e, TDF_DETAILS, 0);
199 fprintf (stderr, "\nSuccessor: ");
200 dump_edge_info (stderr, e, TDF_DETAILS, 1);
201 fprintf (stderr, "\n");
202 err = 1;
205 edge_checksum[e->dest->index] += (size_t) e;
207 if (n_fallthru > 1)
209 error ("wrong amount of branch edges after unconditional jump %i", bb->index);
210 err = 1;
213 FOR_EACH_EDGE (e, ei, bb->preds)
215 if (e->dest != bb)
217 error ("basic block %d pred edge is corrupted", bb->index);
218 fputs ("Predecessor: ", stderr);
219 dump_edge_info (stderr, e, TDF_DETAILS, 0);
220 fputs ("\nSuccessor: ", stderr);
221 dump_edge_info (stderr, e, TDF_DETAILS, 1);
222 fputc ('\n', stderr);
223 err = 1;
226 if (ei.index != e->dest_idx)
228 error ("basic block %d pred edge is corrupted", bb->index);
229 error ("its dest_idx should be %d, not %d",
230 ei.index, e->dest_idx);
231 fputs ("Predecessor: ", stderr);
232 dump_edge_info (stderr, e, TDF_DETAILS, 0);
233 fputs ("\nSuccessor: ", stderr);
234 dump_edge_info (stderr, e, TDF_DETAILS, 1);
235 fputc ('\n', stderr);
236 err = 1;
239 edge_checksum[e->dest->index] -= (size_t) e;
243 /* Complete edge checksumming for ENTRY and EXIT. */
245 edge e;
246 edge_iterator ei;
248 FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs)
249 edge_checksum[e->dest->index] += (size_t) e;
251 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
252 edge_checksum[e->dest->index] -= (size_t) e;
255 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR_FOR_FN (cfun), NULL, next_bb)
256 if (edge_checksum[bb->index])
258 error ("basic block %i edge lists are corrupted", bb->index);
259 err = 1;
262 /* Clean up. */
263 free (last_visited);
264 free (edge_checksum);
266 if (cfg_hooks->verify_flow_info)
267 err |= cfg_hooks->verify_flow_info ();
268 if (err)
269 internal_error ("verify_flow_info failed");
270 timevar_pop (TV_CFG_VERIFY);
273 /* Print out one basic block BB to file OUTF. INDENT is printed at the
274 start of each new line. FLAGS are the TDF_* flags in dumpfile.h.
276 This function takes care of the purely graph related information.
277 The cfg hook for the active representation should dump
278 representation-specific information. */
280 void
281 dump_bb (FILE *outf, basic_block bb, int indent, dump_flags_t flags)
283 if (flags & TDF_BLOCKS)
284 dump_bb_info (outf, bb, indent, flags, true, false);
285 if (cfg_hooks->dump_bb)
286 cfg_hooks->dump_bb (outf, bb, indent, flags);
287 if (flags & TDF_BLOCKS)
288 dump_bb_info (outf, bb, indent, flags, false, true);
289 fputc ('\n', outf);
292 DEBUG_FUNCTION void
293 debug (basic_block_def &ref)
295 dump_bb (stderr, &ref, 0, TDF_NONE);
298 DEBUG_FUNCTION void
299 debug (basic_block_def *ptr)
301 if (ptr)
302 debug (*ptr);
303 else
304 fprintf (stderr, "<nil>\n");
307 static void
308 debug_slim (basic_block ptr)
310 fprintf (stderr, "<basic_block %p (%d)>", (void *) ptr, ptr->index);
313 DEFINE_DEBUG_VEC (basic_block_def *)
314 DEFINE_DEBUG_HASH_SET (basic_block_def *)
316 /* Dumps basic block BB to pretty-printer PP, for use as a label of
317 a DOT graph record-node. The implementation of this hook is
318 expected to write the label to the stream that is attached to PP.
319 Field separators between instructions are pipe characters printed
320 verbatim. Instructions should be written with some characters
321 escaped, using pp_write_text_as_dot_label_to_stream(). */
323 void
324 dump_bb_for_graph (pretty_printer *pp, basic_block bb)
326 if (!cfg_hooks->dump_bb_for_graph)
327 internal_error ("%s does not support dump_bb_for_graph",
328 cfg_hooks->name);
329 /* TODO: Add pretty printer for counter. */
330 if (bb->count.initialized_p ())
331 pp_printf (pp, "COUNT:" "%" PRId64, bb->count.to_gcov_type ());
332 pp_write_text_to_stream (pp);
333 if (!(dump_flags & TDF_SLIM))
334 cfg_hooks->dump_bb_for_graph (pp, bb);
337 /* Dump the complete CFG to FILE. FLAGS are the TDF_* flags in dumpfile.h. */
338 void
339 dump_flow_info (FILE *file, dump_flags_t flags)
341 basic_block bb;
343 fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks_for_fn (cfun),
344 n_edges_for_fn (cfun));
345 FOR_ALL_BB_FN (bb, cfun)
346 dump_bb (file, bb, 0, flags);
348 putc ('\n', file);
351 /* Like above, but dump to stderr. To be called from debuggers. */
352 void debug_flow_info (void);
353 DEBUG_FUNCTION void
354 debug_flow_info (void)
356 dump_flow_info (stderr, TDF_DETAILS);
359 /* Redirect edge E to the given basic block DEST and update underlying program
360 representation. Returns edge representing redirected branch (that may not
361 be equivalent to E in the case of duplicate edges being removed) or NULL
362 if edge is not easily redirectable for whatever reason. */
364 edge
365 redirect_edge_and_branch (edge e, basic_block dest)
367 edge ret;
369 if (!cfg_hooks->redirect_edge_and_branch)
370 internal_error ("%s does not support redirect_edge_and_branch",
371 cfg_hooks->name);
373 ret = cfg_hooks->redirect_edge_and_branch (e, dest);
375 /* If RET != E, then either the redirection failed, or the edge E
376 was removed since RET already lead to the same destination. */
377 if (current_loops != NULL && ret == e)
378 rescan_loop_exit (e, false, false);
380 return ret;
383 /* Returns true if it is possible to remove the edge E by redirecting it
384 to the destination of the other edge going from its source. */
386 bool
387 can_remove_branch_p (const_edge e)
389 if (!cfg_hooks->can_remove_branch_p)
390 internal_error ("%s does not support can_remove_branch_p",
391 cfg_hooks->name);
393 if (EDGE_COUNT (e->src->succs) != 2)
394 return false;
396 return cfg_hooks->can_remove_branch_p (e);
399 /* Removes E, by redirecting it to the destination of the other edge going
400 from its source. Can_remove_branch_p must be true for E, hence this
401 operation cannot fail. */
403 void
404 remove_branch (edge e)
406 edge other;
407 basic_block src = e->src;
408 int irr;
410 gcc_assert (EDGE_COUNT (e->src->succs) == 2);
412 other = EDGE_SUCC (src, EDGE_SUCC (src, 0) == e);
413 irr = other->flags & EDGE_IRREDUCIBLE_LOOP;
415 e = redirect_edge_and_branch (e, other->dest);
416 gcc_assert (e != NULL);
418 e->flags &= ~EDGE_IRREDUCIBLE_LOOP;
419 e->flags |= irr;
422 /* Removes edge E from cfg. Unlike remove_branch, it does not update IL. */
424 void
425 remove_edge (edge e)
427 if (current_loops != NULL)
429 rescan_loop_exit (e, false, true);
431 /* Removal of an edge inside an irreducible region or which leads
432 to an irreducible region can turn the region into a natural loop.
433 In that case, ask for the loop structure fixups.
435 FIXME: Note that LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS is not always
436 set, so always ask for fixups when removing an edge in that case. */
437 if (!loops_state_satisfies_p (LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
438 || (e->flags & EDGE_IRREDUCIBLE_LOOP)
439 || (e->dest->flags & BB_IRREDUCIBLE_LOOP))
440 loops_state_set (LOOPS_NEED_FIXUP);
443 /* This is probably not needed, but it doesn't hurt. */
444 /* FIXME: This should be called via a remove_edge hook. */
445 if (current_ir_type () == IR_GIMPLE)
446 redirect_edge_var_map_clear (e);
448 remove_edge_raw (e);
451 /* Like redirect_edge_succ but avoid possible duplicate edge. */
453 edge
454 redirect_edge_succ_nodup (edge e, basic_block new_succ)
456 edge s;
458 s = find_edge (e->src, new_succ);
459 if (s && s != e)
461 s->flags |= e->flags;
462 s->probability += e->probability;
463 /* FIXME: This should be called via a hook and only for IR_GIMPLE. */
464 redirect_edge_var_map_dup (s, e);
465 remove_edge (e);
466 e = s;
468 else
469 redirect_edge_succ (e, new_succ);
471 return e;
474 /* Redirect the edge E to basic block DEST even if it requires creating
475 of a new basic block; then it returns the newly created basic block.
476 Aborts when redirection is impossible. */
478 basic_block
479 redirect_edge_and_branch_force (edge e, basic_block dest)
481 basic_block ret, src = e->src;
483 if (!cfg_hooks->redirect_edge_and_branch_force)
484 internal_error ("%s does not support redirect_edge_and_branch_force",
485 cfg_hooks->name);
487 if (current_loops != NULL)
488 rescan_loop_exit (e, false, true);
490 ret = cfg_hooks->redirect_edge_and_branch_force (e, dest);
492 if (ret != NULL && dom_info_available_p (CDI_DOMINATORS))
493 set_immediate_dominator (CDI_DOMINATORS, ret, src);
495 if (current_loops != NULL)
497 if (ret != NULL)
499 class loop *loop
500 = find_common_loop (single_pred (ret)->loop_father,
501 single_succ (ret)->loop_father);
502 add_bb_to_loop (ret, loop);
504 else if (find_edge (src, dest) == e)
505 rescan_loop_exit (e, true, false);
508 return ret;
511 /* Splits basic block BB after the specified instruction I (but at least after
512 the labels). If I is NULL, splits just after labels. The newly created edge
513 is returned. The new basic block is created just after the old one. */
515 static edge
516 split_block_1 (basic_block bb, void *i)
518 basic_block new_bb;
519 edge res;
521 if (!cfg_hooks->split_block)
522 internal_error ("%s does not support split_block", cfg_hooks->name);
524 new_bb = cfg_hooks->split_block (bb, i);
525 if (!new_bb)
526 return NULL;
528 new_bb->count = bb->count;
529 new_bb->discriminator = bb->discriminator;
531 if (dom_info_available_p (CDI_DOMINATORS))
533 redirect_immediate_dominators (CDI_DOMINATORS, bb, new_bb);
534 set_immediate_dominator (CDI_DOMINATORS, new_bb, bb);
537 if (current_loops != NULL)
539 edge_iterator ei;
540 edge e;
541 add_bb_to_loop (new_bb, bb->loop_father);
542 /* Identify all loops bb may have been the latch of and adjust them. */
543 FOR_EACH_EDGE (e, ei, new_bb->succs)
544 if (e->dest->loop_father->latch == bb)
545 e->dest->loop_father->latch = new_bb;
548 res = make_single_succ_edge (bb, new_bb, EDGE_FALLTHRU);
550 if (bb->flags & BB_IRREDUCIBLE_LOOP)
552 new_bb->flags |= BB_IRREDUCIBLE_LOOP;
553 res->flags |= EDGE_IRREDUCIBLE_LOOP;
556 return res;
559 edge
560 split_block (basic_block bb, gimple *i)
562 return split_block_1 (bb, i);
565 edge
566 split_block (basic_block bb, rtx i)
568 return split_block_1 (bb, i);
571 /* Splits block BB just after labels. The newly created edge is returned. */
573 edge
574 split_block_after_labels (basic_block bb)
576 return split_block_1 (bb, NULL);
579 /* Moves block BB immediately after block AFTER. Returns false if the
580 movement was impossible. */
582 bool
583 move_block_after (basic_block bb, basic_block after)
585 bool ret;
587 if (!cfg_hooks->move_block_after)
588 internal_error ("%s does not support move_block_after", cfg_hooks->name);
590 ret = cfg_hooks->move_block_after (bb, after);
592 return ret;
595 /* Deletes the basic block BB. */
597 void
598 delete_basic_block (basic_block bb)
600 if (!cfg_hooks->delete_basic_block)
601 internal_error ("%s does not support delete_basic_block", cfg_hooks->name);
603 cfg_hooks->delete_basic_block (bb);
605 if (current_loops != NULL)
607 class loop *loop = bb->loop_father;
609 /* If we remove the header or the latch of a loop, mark the loop for
610 removal. */
611 if (loop->latch == bb
612 || loop->header == bb)
613 mark_loop_for_removal (loop);
615 remove_bb_from_loops (bb);
618 /* Remove the edges into and out of this block. Note that there may
619 indeed be edges in, if we are removing an unreachable loop. */
620 while (EDGE_COUNT (bb->preds) != 0)
621 remove_edge (EDGE_PRED (bb, 0));
622 while (EDGE_COUNT (bb->succs) != 0)
623 remove_edge (EDGE_SUCC (bb, 0));
625 if (dom_info_available_p (CDI_DOMINATORS))
626 delete_from_dominance_info (CDI_DOMINATORS, bb);
627 if (dom_info_available_p (CDI_POST_DOMINATORS))
628 delete_from_dominance_info (CDI_POST_DOMINATORS, bb);
630 /* Remove the basic block from the array. */
631 expunge_block (bb);
634 /* Splits edge E and returns the newly created basic block. */
636 basic_block
637 split_edge (edge e)
639 basic_block ret;
640 profile_count count = e->count ();
641 edge f;
642 bool irr = (e->flags & EDGE_IRREDUCIBLE_LOOP) != 0;
643 bool back = (e->flags & EDGE_DFS_BACK) != 0;
644 class loop *loop;
645 basic_block src = e->src, dest = e->dest;
647 if (!cfg_hooks->split_edge)
648 internal_error ("%s does not support split_edge", cfg_hooks->name);
650 if (current_loops != NULL)
651 rescan_loop_exit (e, false, true);
653 ret = cfg_hooks->split_edge (e);
654 ret->count = count;
655 single_succ_edge (ret)->probability = profile_probability::always ();
657 if (irr)
659 ret->flags |= BB_IRREDUCIBLE_LOOP;
660 single_pred_edge (ret)->flags |= EDGE_IRREDUCIBLE_LOOP;
661 single_succ_edge (ret)->flags |= EDGE_IRREDUCIBLE_LOOP;
663 if (back)
665 single_pred_edge (ret)->flags &= ~EDGE_DFS_BACK;
666 single_succ_edge (ret)->flags |= EDGE_DFS_BACK;
669 if (dom_info_available_p (CDI_DOMINATORS))
670 set_immediate_dominator (CDI_DOMINATORS, ret, single_pred (ret));
672 if (dom_info_state (CDI_DOMINATORS) >= DOM_NO_FAST_QUERY)
674 /* There are two cases:
676 If the immediate dominator of e->dest is not e->src, it
677 remains unchanged.
679 If immediate dominator of e->dest is e->src, it may become
680 ret, provided that all other predecessors of e->dest are
681 dominated by e->dest. */
683 if (get_immediate_dominator (CDI_DOMINATORS, single_succ (ret))
684 == single_pred (ret))
686 edge_iterator ei;
687 FOR_EACH_EDGE (f, ei, single_succ (ret)->preds)
689 if (f == single_succ_edge (ret))
690 continue;
692 if (!dominated_by_p (CDI_DOMINATORS, f->src,
693 single_succ (ret)))
694 break;
697 if (!f)
698 set_immediate_dominator (CDI_DOMINATORS, single_succ (ret), ret);
702 if (current_loops != NULL)
704 loop = find_common_loop (src->loop_father, dest->loop_father);
705 add_bb_to_loop (ret, loop);
707 /* If we split the latch edge of loop adjust the latch block. */
708 if (loop->latch == src
709 && loop->header == dest)
710 loop->latch = ret;
713 return ret;
716 /* Creates a new basic block just after the basic block AFTER.
717 HEAD and END are the first and the last statement belonging
718 to the block. If both are NULL, an empty block is created. */
720 static basic_block
721 create_basic_block_1 (void *head, void *end, basic_block after)
723 basic_block ret;
725 if (!cfg_hooks->create_basic_block)
726 internal_error ("%s does not support create_basic_block", cfg_hooks->name);
728 ret = cfg_hooks->create_basic_block (head, end, after);
730 if (dom_info_available_p (CDI_DOMINATORS))
731 add_to_dominance_info (CDI_DOMINATORS, ret);
732 if (dom_info_available_p (CDI_POST_DOMINATORS))
733 add_to_dominance_info (CDI_POST_DOMINATORS, ret);
735 return ret;
738 basic_block
739 create_basic_block (gimple_seq seq, basic_block after)
741 return create_basic_block_1 (seq, NULL, after);
744 basic_block
745 create_basic_block (rtx head, rtx end, basic_block after)
747 return create_basic_block_1 (head, end, after);
751 /* Creates an empty basic block just after basic block AFTER. */
753 basic_block
754 create_empty_bb (basic_block after)
756 return create_basic_block_1 (NULL, NULL, after);
759 /* Checks whether we may merge blocks BB1 and BB2. */
761 bool
762 can_merge_blocks_p (basic_block bb1, basic_block bb2)
764 bool ret;
766 if (!cfg_hooks->can_merge_blocks_p)
767 internal_error ("%s does not support can_merge_blocks_p", cfg_hooks->name);
769 ret = cfg_hooks->can_merge_blocks_p (bb1, bb2);
771 return ret;
774 void
775 predict_edge (edge e, enum br_predictor predictor, int probability)
777 if (!cfg_hooks->predict_edge)
778 internal_error ("%s does not support predict_edge", cfg_hooks->name);
780 cfg_hooks->predict_edge (e, predictor, probability);
783 bool
784 predicted_by_p (const_basic_block bb, enum br_predictor predictor)
786 if (!cfg_hooks->predict_edge)
787 internal_error ("%s does not support predicted_by_p", cfg_hooks->name);
789 return cfg_hooks->predicted_by_p (bb, predictor);
792 /* Merges basic block B into basic block A. */
794 void
795 merge_blocks (basic_block a, basic_block b)
797 edge e;
798 edge_iterator ei;
800 if (!cfg_hooks->merge_blocks)
801 internal_error ("%s does not support merge_blocks", cfg_hooks->name);
803 cfg_hooks->merge_blocks (a, b);
805 if (current_loops != NULL)
807 /* If the block we merge into is a loop header do nothing unless ... */
808 if (a->loop_father->header == a)
810 /* ... we merge two loop headers, in which case we kill
811 the inner loop. */
812 if (b->loop_father->header == b)
813 mark_loop_for_removal (b->loop_father);
815 /* If we merge a loop header into its predecessor, update the loop
816 structure. */
817 else if (b->loop_father->header == b)
819 remove_bb_from_loops (a);
820 add_bb_to_loop (a, b->loop_father);
821 a->loop_father->header = a;
823 /* If we merge a loop latch into its predecessor, update the loop
824 structure. */
825 if (b->loop_father->latch
826 && b->loop_father->latch == b)
827 b->loop_father->latch = a;
828 remove_bb_from_loops (b);
831 /* Normally there should only be one successor of A and that is B, but
832 partway though the merge of blocks for conditional_execution we'll
833 be merging a TEST block with THEN and ELSE successors. Free the
834 whole lot of them and hope the caller knows what they're doing. */
836 while (EDGE_COUNT (a->succs) != 0)
837 remove_edge (EDGE_SUCC (a, 0));
839 /* Adjust the edges out of B for the new owner. */
840 FOR_EACH_EDGE (e, ei, b->succs)
842 e->src = a;
843 if (current_loops != NULL)
845 /* If b was a latch, a now is. */
846 if (e->dest->loop_father->latch == b)
847 e->dest->loop_father->latch = a;
848 rescan_loop_exit (e, true, false);
851 a->succs = b->succs;
852 a->flags |= b->flags;
854 /* B hasn't quite yet ceased to exist. Attempt to prevent mishap. */
855 b->preds = b->succs = NULL;
857 if (dom_info_available_p (CDI_DOMINATORS))
858 redirect_immediate_dominators (CDI_DOMINATORS, b, a);
860 if (dom_info_available_p (CDI_DOMINATORS))
861 delete_from_dominance_info (CDI_DOMINATORS, b);
862 if (dom_info_available_p (CDI_POST_DOMINATORS))
863 delete_from_dominance_info (CDI_POST_DOMINATORS, b);
865 expunge_block (b);
868 /* Split BB into entry part and the rest (the rest is the newly created block).
869 Redirect those edges for that REDIRECT_EDGE_P returns true to the entry
870 part. Returns the edge connecting the entry part to the rest. */
872 edge
873 make_forwarder_block (basic_block bb, bool (*redirect_edge_p) (edge),
874 void (*new_bb_cbk) (basic_block))
876 edge e, fallthru;
877 edge_iterator ei;
878 basic_block dummy, jump;
879 class loop *loop, *ploop, *cloop;
881 if (!cfg_hooks->make_forwarder_block)
882 internal_error ("%s does not support make_forwarder_block",
883 cfg_hooks->name);
885 fallthru = split_block_after_labels (bb);
886 dummy = fallthru->src;
887 dummy->count = profile_count::zero ();
888 bb = fallthru->dest;
890 /* Redirect back edges we want to keep. */
891 for (ei = ei_start (dummy->preds); (e = ei_safe_edge (ei)); )
893 basic_block e_src;
895 if (redirect_edge_p (e))
897 dummy->count += e->count ();
898 ei_next (&ei);
899 continue;
902 e_src = e->src;
903 jump = redirect_edge_and_branch_force (e, bb);
904 if (jump != NULL)
906 /* If we redirected the loop latch edge, the JUMP block now acts like
907 the new latch of the loop. */
908 if (current_loops != NULL
909 && dummy->loop_father != NULL
910 && dummy->loop_father->header == dummy
911 && dummy->loop_father->latch == e_src)
912 dummy->loop_father->latch = jump;
914 if (new_bb_cbk != NULL)
915 new_bb_cbk (jump);
919 if (dom_info_available_p (CDI_DOMINATORS))
921 vec<basic_block> doms_to_fix;
922 doms_to_fix.create (2);
923 doms_to_fix.quick_push (dummy);
924 doms_to_fix.quick_push (bb);
925 iterate_fix_dominators (CDI_DOMINATORS, doms_to_fix, false);
926 doms_to_fix.release ();
929 if (current_loops != NULL)
931 /* If we do not split a loop header, then both blocks belong to the
932 same loop. In case we split loop header and do not redirect the
933 latch edge to DUMMY, then DUMMY belongs to the outer loop, and
934 BB becomes the new header. If latch is not recorded for the loop,
935 we leave this updating on the caller (this may only happen during
936 loop analysis). */
937 loop = dummy->loop_father;
938 if (loop->header == dummy
939 && loop->latch != NULL
940 && find_edge (loop->latch, dummy) == NULL)
942 remove_bb_from_loops (dummy);
943 loop->header = bb;
945 cloop = loop;
946 FOR_EACH_EDGE (e, ei, dummy->preds)
948 cloop = find_common_loop (cloop, e->src->loop_father);
950 add_bb_to_loop (dummy, cloop);
953 /* In case we split loop latch, update it. */
954 for (ploop = loop; ploop; ploop = loop_outer (ploop))
955 if (ploop->latch == dummy)
956 ploop->latch = bb;
959 cfg_hooks->make_forwarder_block (fallthru);
961 return fallthru;
964 /* Try to make the edge fallthru. */
966 void
967 tidy_fallthru_edge (edge e)
969 if (cfg_hooks->tidy_fallthru_edge)
970 cfg_hooks->tidy_fallthru_edge (e);
973 /* Fix up edges that now fall through, or rather should now fall through
974 but previously required a jump around now deleted blocks. Simplify
975 the search by only examining blocks numerically adjacent, since this
976 is how they were created.
978 ??? This routine is currently RTL specific. */
980 void
981 tidy_fallthru_edges (void)
983 basic_block b, c;
985 if (!cfg_hooks->tidy_fallthru_edge)
986 return;
988 if (ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
989 return;
991 FOR_BB_BETWEEN (b, ENTRY_BLOCK_PTR_FOR_FN (cfun)->next_bb,
992 EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb, next_bb)
994 edge s;
996 c = b->next_bb;
998 /* We care about simple conditional or unconditional jumps with
999 a single successor.
1001 If we had a conditional branch to the next instruction when
1002 CFG was built, then there will only be one out edge for the
1003 block which ended with the conditional branch (since we do
1004 not create duplicate edges).
1006 Furthermore, the edge will be marked as a fallthru because we
1007 merge the flags for the duplicate edges. So we do not want to
1008 check that the edge is not a FALLTHRU edge. */
1010 if (single_succ_p (b))
1012 s = single_succ_edge (b);
1013 if (! (s->flags & EDGE_COMPLEX)
1014 && s->dest == c
1015 && !(JUMP_P (BB_END (b)) && CROSSING_JUMP_P (BB_END (b))))
1016 tidy_fallthru_edge (s);
1021 /* Edge E is assumed to be fallthru edge. Emit needed jump instruction
1022 (and possibly create new basic block) to make edge non-fallthru.
1023 Return newly created BB or NULL if none. */
1025 basic_block
1026 force_nonfallthru (edge e)
1028 basic_block ret, src = e->src;
1030 if (!cfg_hooks->force_nonfallthru)
1031 internal_error ("%s does not support force_nonfallthru",
1032 cfg_hooks->name);
1034 ret = cfg_hooks->force_nonfallthru (e);
1035 if (ret != NULL)
1037 if (dom_info_available_p (CDI_DOMINATORS))
1038 set_immediate_dominator (CDI_DOMINATORS, ret, src);
1040 if (current_loops != NULL)
1042 basic_block pred = single_pred (ret);
1043 basic_block succ = single_succ (ret);
1044 class loop *loop
1045 = find_common_loop (pred->loop_father, succ->loop_father);
1046 rescan_loop_exit (e, false, true);
1047 add_bb_to_loop (ret, loop);
1049 /* If we split the latch edge of loop adjust the latch block. */
1050 if (loop->latch == pred
1051 && loop->header == succ)
1052 loop->latch = ret;
1056 return ret;
1059 /* Returns true if we can duplicate basic block BB. */
1061 bool
1062 can_duplicate_block_p (const_basic_block bb)
1064 if (!cfg_hooks->can_duplicate_block_p)
1065 internal_error ("%s does not support can_duplicate_block_p",
1066 cfg_hooks->name);
1068 if (bb == EXIT_BLOCK_PTR_FOR_FN (cfun) || bb == ENTRY_BLOCK_PTR_FOR_FN (cfun))
1069 return false;
1071 return cfg_hooks->can_duplicate_block_p (bb);
1074 /* Duplicates basic block BB and redirects edge E to it. Returns the
1075 new basic block. The new basic block is placed after the basic block
1076 AFTER. */
1078 basic_block
1079 duplicate_block (basic_block bb, edge e, basic_block after, copy_bb_data *id)
1081 edge s, n;
1082 basic_block new_bb;
1083 profile_count new_count = e ? e->count (): profile_count::uninitialized ();
1084 edge_iterator ei;
1086 if (!cfg_hooks->duplicate_block)
1087 internal_error ("%s does not support duplicate_block",
1088 cfg_hooks->name);
1090 if (bb->count < new_count)
1091 new_count = bb->count;
1093 gcc_checking_assert (can_duplicate_block_p (bb));
1095 new_bb = cfg_hooks->duplicate_block (bb, id);
1096 if (after)
1097 move_block_after (new_bb, after);
1099 new_bb->flags = (bb->flags & ~BB_DUPLICATED);
1100 FOR_EACH_EDGE (s, ei, bb->succs)
1102 /* Since we are creating edges from a new block to successors
1103 of another block (which therefore are known to be disjoint), there
1104 is no need to actually check for duplicated edges. */
1105 n = unchecked_make_edge (new_bb, s->dest, s->flags);
1106 n->probability = s->probability;
1107 n->aux = s->aux;
1110 if (e)
1112 new_bb->count = new_count;
1113 bb->count -= new_count;
1115 redirect_edge_and_branch_force (e, new_bb);
1117 else
1118 new_bb->count = bb->count;
1120 set_bb_original (new_bb, bb);
1121 set_bb_copy (bb, new_bb);
1123 /* Add the new block to the copy of the loop of BB, or directly to the loop
1124 of BB if the loop is not being copied. */
1125 if (current_loops != NULL)
1127 class loop *cloop = bb->loop_father;
1128 class loop *copy = get_loop_copy (cloop);
1129 /* If we copied the loop header block but not the loop
1130 we have created a loop with multiple entries. Ditch the loop,
1131 add the new block to the outer loop and arrange for a fixup. */
1132 if (!copy
1133 && cloop->header == bb)
1135 add_bb_to_loop (new_bb, loop_outer (cloop));
1136 mark_loop_for_removal (cloop);
1138 else
1140 add_bb_to_loop (new_bb, copy ? copy : cloop);
1141 /* If we copied the loop latch block but not the loop, adjust
1142 loop state. */
1143 if (!copy
1144 && cloop->latch == bb)
1146 cloop->latch = NULL;
1147 loops_state_set (LOOPS_MAY_HAVE_MULTIPLE_LATCHES);
1152 return new_bb;
1155 /* Return 1 if BB ends with a call, possibly followed by some
1156 instructions that must stay with the call, 0 otherwise. */
1158 bool
1159 block_ends_with_call_p (basic_block bb)
1161 if (!cfg_hooks->block_ends_with_call_p)
1162 internal_error ("%s does not support block_ends_with_call_p", cfg_hooks->name);
1164 return (cfg_hooks->block_ends_with_call_p) (bb);
1167 /* Return 1 if BB ends with a conditional branch, 0 otherwise. */
1169 bool
1170 block_ends_with_condjump_p (const_basic_block bb)
1172 if (!cfg_hooks->block_ends_with_condjump_p)
1173 internal_error ("%s does not support block_ends_with_condjump_p",
1174 cfg_hooks->name);
1176 return (cfg_hooks->block_ends_with_condjump_p) (bb);
1179 /* Add fake edges to the function exit for any non constant and non noreturn
1180 calls, volatile inline assembly in the bitmap of blocks specified by
1181 BLOCKS or to the whole CFG if BLOCKS is zero. Return the number of blocks
1182 that were split.
1184 The goal is to expose cases in which entering a basic block does not imply
1185 that all subsequent instructions must be executed. */
1188 flow_call_edges_add (sbitmap blocks)
1190 if (!cfg_hooks->flow_call_edges_add)
1191 internal_error ("%s does not support flow_call_edges_add",
1192 cfg_hooks->name);
1194 return (cfg_hooks->flow_call_edges_add) (blocks);
1197 /* This function is called immediately after edge E is added to the
1198 edge vector E->dest->preds. */
1200 void
1201 execute_on_growing_pred (edge e)
1203 if (! (e->dest->flags & BB_DUPLICATED)
1204 && cfg_hooks->execute_on_growing_pred)
1205 cfg_hooks->execute_on_growing_pred (e);
1208 /* This function is called immediately before edge E is removed from
1209 the edge vector E->dest->preds. */
1211 void
1212 execute_on_shrinking_pred (edge e)
1214 if (! (e->dest->flags & BB_DUPLICATED)
1215 && cfg_hooks->execute_on_shrinking_pred)
1216 cfg_hooks->execute_on_shrinking_pred (e);
1219 /* This is used inside loop versioning when we want to insert
1220 stmts/insns on the edges, which have a different behavior
1221 in tree's and in RTL, so we made a CFG hook. */
1222 void
1223 lv_flush_pending_stmts (edge e)
1225 if (cfg_hooks->flush_pending_stmts)
1226 cfg_hooks->flush_pending_stmts (e);
1229 /* Loop versioning uses the duplicate_loop_to_header_edge to create
1230 a new version of the loop basic-blocks, the parameters here are
1231 exactly the same as in duplicate_loop_to_header_edge or
1232 tree_duplicate_loop_to_header_edge; while in tree-ssa there is
1233 additional work to maintain ssa information that's why there is
1234 a need to call the tree_duplicate_loop_to_header_edge rather
1235 than duplicate_loop_to_header_edge when we are in tree mode. */
1236 bool
1237 cfg_hook_duplicate_loop_to_header_edge (class loop *loop, edge e,
1238 unsigned int ndupl,
1239 sbitmap wont_exit, edge orig,
1240 vec<edge> *to_remove,
1241 int flags)
1243 gcc_assert (cfg_hooks->cfg_hook_duplicate_loop_to_header_edge);
1244 return cfg_hooks->cfg_hook_duplicate_loop_to_header_edge (loop, e,
1245 ndupl, wont_exit,
1246 orig, to_remove,
1247 flags);
1250 /* Conditional jumps are represented differently in trees and RTL,
1251 this hook takes a basic block that is known to have a cond jump
1252 at its end and extracts the taken and not taken edges out of it
1253 and store it in E1 and E2 respectively. */
1254 void
1255 extract_cond_bb_edges (basic_block b, edge *e1, edge *e2)
1257 gcc_assert (cfg_hooks->extract_cond_bb_edges);
1258 cfg_hooks->extract_cond_bb_edges (b, e1, e2);
1261 /* Responsible for updating the ssa info (PHI nodes) on the
1262 new condition basic block that guards the versioned loop. */
1263 void
1264 lv_adjust_loop_header_phi (basic_block first, basic_block second,
1265 basic_block new_block, edge e)
1267 if (cfg_hooks->lv_adjust_loop_header_phi)
1268 cfg_hooks->lv_adjust_loop_header_phi (first, second, new_block, e);
1271 /* Conditions in trees and RTL are different so we need
1272 a different handling when we add the condition to the
1273 versioning code. */
1274 void
1275 lv_add_condition_to_bb (basic_block first, basic_block second,
1276 basic_block new_block, void *cond)
1278 gcc_assert (cfg_hooks->lv_add_condition_to_bb);
1279 cfg_hooks->lv_add_condition_to_bb (first, second, new_block, cond);
1282 /* Checks whether all N blocks in BBS array can be copied. */
1283 bool
1284 can_copy_bbs_p (basic_block *bbs, unsigned n)
1286 unsigned i;
1287 edge e;
1288 int ret = true;
1290 for (i = 0; i < n; i++)
1291 bbs[i]->flags |= BB_DUPLICATED;
1293 for (i = 0; i < n; i++)
1295 /* In case we should redirect abnormal edge during duplication, fail. */
1296 edge_iterator ei;
1297 FOR_EACH_EDGE (e, ei, bbs[i]->succs)
1298 if ((e->flags & EDGE_ABNORMAL)
1299 && (e->dest->flags & BB_DUPLICATED))
1301 ret = false;
1302 goto end;
1305 if (!can_duplicate_block_p (bbs[i]))
1307 ret = false;
1308 break;
1312 end:
1313 for (i = 0; i < n; i++)
1314 bbs[i]->flags &= ~BB_DUPLICATED;
1316 return ret;
1319 /* Duplicates N basic blocks stored in array BBS. Newly created basic blocks
1320 are placed into array NEW_BBS in the same order. Edges from basic blocks
1321 in BBS are also duplicated and copies of those that lead into BBS are
1322 redirected to appropriate newly created block. The function assigns bbs
1323 into loops (copy of basic block bb is assigned to bb->loop_father->copy
1324 loop, so this must be set up correctly in advance)
1326 If UPDATE_DOMINANCE is true then this function updates dominators locally
1327 (LOOPS structure that contains the information about dominators is passed
1328 to enable this), otherwise it does not update the dominator information
1329 and it assumed that the caller will do this, perhaps by destroying and
1330 recreating it instead of trying to do an incremental update like this
1331 function does when update_dominance is true.
1333 BASE is the superloop to that basic block belongs; if its header or latch
1334 is copied, we do not set the new blocks as header or latch.
1336 Created copies of N_EDGES edges in array EDGES are stored in array NEW_EDGES,
1337 also in the same order.
1339 Newly created basic blocks are put after the basic block AFTER in the
1340 instruction stream, and the order of the blocks in BBS array is preserved. */
1342 void
1343 copy_bbs (basic_block *bbs, unsigned n, basic_block *new_bbs,
1344 edge *edges, unsigned num_edges, edge *new_edges,
1345 class loop *base, basic_block after, bool update_dominance)
1347 unsigned i, j;
1348 basic_block bb, new_bb, dom_bb;
1349 edge e;
1350 copy_bb_data id;
1352 /* Mark the blocks to be copied. This is used by edge creation hooks
1353 to decide whether to reallocate PHI nodes capacity to avoid reallocating
1354 PHIs in the set of source BBs. */
1355 for (i = 0; i < n; i++)
1356 bbs[i]->flags |= BB_DUPLICATED;
1358 /* Duplicate bbs, update dominators, assign bbs to loops. */
1359 for (i = 0; i < n; i++)
1361 /* Duplicate. */
1362 bb = bbs[i];
1363 new_bb = new_bbs[i] = duplicate_block (bb, NULL, after, &id);
1364 after = new_bb;
1365 if (bb->loop_father)
1367 /* Possibly set loop header. */
1368 if (bb->loop_father->header == bb && bb->loop_father != base)
1369 new_bb->loop_father->header = new_bb;
1370 /* Or latch. */
1371 if (bb->loop_father->latch == bb && bb->loop_father != base)
1372 new_bb->loop_father->latch = new_bb;
1376 /* Set dominators. */
1377 if (update_dominance)
1379 for (i = 0; i < n; i++)
1381 bb = bbs[i];
1382 new_bb = new_bbs[i];
1384 dom_bb = get_immediate_dominator (CDI_DOMINATORS, bb);
1385 if (dom_bb->flags & BB_DUPLICATED)
1387 dom_bb = get_bb_copy (dom_bb);
1388 set_immediate_dominator (CDI_DOMINATORS, new_bb, dom_bb);
1393 /* Redirect edges. */
1394 for (i = 0; i < n; i++)
1396 edge_iterator ei;
1397 new_bb = new_bbs[i];
1398 bb = bbs[i];
1400 FOR_EACH_EDGE (e, ei, new_bb->succs)
1402 if (!(e->dest->flags & BB_DUPLICATED))
1403 continue;
1404 redirect_edge_and_branch_force (e, get_bb_copy (e->dest));
1407 for (j = 0; j < num_edges; j++)
1409 if (!edges[j])
1410 new_edges[j] = NULL;
1411 else
1413 basic_block src = edges[j]->src;
1414 basic_block dest = edges[j]->dest;
1415 if (src->flags & BB_DUPLICATED)
1416 src = get_bb_copy (src);
1417 if (dest->flags & BB_DUPLICATED)
1418 dest = get_bb_copy (dest);
1419 new_edges[j] = find_edge (src, dest);
1423 /* Clear information about duplicates. */
1424 for (i = 0; i < n; i++)
1425 bbs[i]->flags &= ~BB_DUPLICATED;
1428 /* Return true if BB contains only labels or non-executable
1429 instructions */
1430 bool
1431 empty_block_p (basic_block bb)
1433 gcc_assert (cfg_hooks->empty_block_p);
1434 return cfg_hooks->empty_block_p (bb);
1437 /* Split a basic block if it ends with a conditional branch and if
1438 the other part of the block is not empty. */
1439 basic_block
1440 split_block_before_cond_jump (basic_block bb)
1442 gcc_assert (cfg_hooks->split_block_before_cond_jump);
1443 return cfg_hooks->split_block_before_cond_jump (bb);
1446 /* Work-horse for passes.c:check_profile_consistency.
1447 Do book-keeping of the CFG for the profile consistency checker.
1448 Store the counting in RECORD. */
1450 void
1451 profile_record_check_consistency (profile_record *record)
1453 basic_block bb;
1454 edge_iterator ei;
1455 edge e;
1457 FOR_ALL_BB_FN (bb, cfun)
1459 if (bb != EXIT_BLOCK_PTR_FOR_FN (cfun)
1460 && profile_status_for_fn (cfun) != PROFILE_ABSENT)
1462 profile_probability sum = profile_probability::never ();
1463 FOR_EACH_EDGE (e, ei, bb->succs)
1464 sum += e->probability;
1465 if (EDGE_COUNT (bb->succs)
1466 && sum.differs_from_p (profile_probability::always ()))
1467 record->num_mismatched_freq_out++;
1468 profile_count lsum = profile_count::zero ();
1469 FOR_EACH_EDGE (e, ei, bb->succs)
1470 lsum += e->count ();
1471 if (EDGE_COUNT (bb->succs) && (lsum.differs_from_p (bb->count)))
1472 record->num_mismatched_count_out++;
1474 if (bb != ENTRY_BLOCK_PTR_FOR_FN (cfun)
1475 && profile_status_for_fn (cfun) != PROFILE_ABSENT)
1477 profile_probability sum = profile_probability::never ();
1478 profile_count lsum = profile_count::zero ();
1479 FOR_EACH_EDGE (e, ei, bb->preds)
1481 sum += e->probability;
1482 lsum += e->count ();
1484 if (EDGE_COUNT (bb->preds)
1485 && sum.differs_from_p (profile_probability::always ()))
1486 record->num_mismatched_freq_in++;
1487 if (lsum.differs_from_p (bb->count))
1488 record->num_mismatched_count_in++;
1490 if (bb == ENTRY_BLOCK_PTR_FOR_FN (cfun)
1491 || bb == EXIT_BLOCK_PTR_FOR_FN (cfun))
1492 continue;
1493 gcc_assert (cfg_hooks->account_profile_record);
1494 cfg_hooks->account_profile_record (bb, record);
1498 /* Work-horse for passes.c:acount_profile.
1499 Do book-keeping of the CFG for the profile accounting.
1500 Store the counting in RECORD. */
1502 void
1503 profile_record_account_profile (profile_record *record)
1505 basic_block bb;
1507 FOR_ALL_BB_FN (bb, cfun)
1509 gcc_assert (cfg_hooks->account_profile_record);
1510 cfg_hooks->account_profile_record (bb, record);
1514 #if __GNUC__ >= 10
1515 # pragma GCC diagnostic pop
1516 #endif