Daily bump.
[official-gcc.git] / gcc / tree-cfg.c
blobb3a27bcd17ce437835b635cc58e329338a6c5354
1 /* Control flow functions for trees.
2 Copyright (C) 2001-2021 Free Software Foundation, Inc.
3 Contributed by Diego Novillo <dnovillo@redhat.com>
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 "target.h"
26 #include "rtl.h"
27 #include "tree.h"
28 #include "gimple.h"
29 #include "cfghooks.h"
30 #include "tree-pass.h"
31 #include "ssa.h"
32 #include "cgraph.h"
33 #include "gimple-pretty-print.h"
34 #include "diagnostic-core.h"
35 #include "fold-const.h"
36 #include "trans-mem.h"
37 #include "stor-layout.h"
38 #include "print-tree.h"
39 #include "cfganal.h"
40 #include "gimple-fold.h"
41 #include "tree-eh.h"
42 #include "gimple-iterator.h"
43 #include "gimplify-me.h"
44 #include "gimple-walk.h"
45 #include "tree-cfg.h"
46 #include "tree-ssa-loop-manip.h"
47 #include "tree-ssa-loop-niter.h"
48 #include "tree-into-ssa.h"
49 #include "tree-dfa.h"
50 #include "tree-ssa.h"
51 #include "except.h"
52 #include "cfgloop.h"
53 #include "tree-ssa-propagate.h"
54 #include "value-prof.h"
55 #include "tree-inline.h"
56 #include "tree-ssa-live.h"
57 #include "tree-ssa-dce.h"
58 #include "omp-general.h"
59 #include "omp-expand.h"
60 #include "tree-cfgcleanup.h"
61 #include "gimplify.h"
62 #include "attribs.h"
63 #include "selftest.h"
64 #include "opts.h"
65 #include "asan.h"
66 #include "profile.h"
68 /* This file contains functions for building the Control Flow Graph (CFG)
69 for a function tree. */
71 /* Local declarations. */
73 /* Initial capacity for the basic block array. */
74 static const int initial_cfg_capacity = 20;
76 /* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
77 which use a particular edge. The CASE_LABEL_EXPRs are chained together
78 via their CASE_CHAIN field, which we clear after we're done with the
79 hash table to prevent problems with duplication of GIMPLE_SWITCHes.
81 Access to this list of CASE_LABEL_EXPRs allows us to efficiently
82 update the case vector in response to edge redirections.
84 Right now this table is set up and torn down at key points in the
85 compilation process. It would be nice if we could make the table
86 more persistent. The key is getting notification of changes to
87 the CFG (particularly edge removal, creation and redirection). */
89 static hash_map<edge, tree> *edge_to_cases;
91 /* If we record edge_to_cases, this bitmap will hold indexes
92 of basic blocks that end in a GIMPLE_SWITCH which we touched
93 due to edge manipulations. */
95 static bitmap touched_switch_bbs;
97 /* OpenMP region idxs for blocks during cfg pass. */
98 static vec<int> bb_to_omp_idx;
100 /* CFG statistics. */
101 struct cfg_stats_d
103 long num_merged_labels;
106 static struct cfg_stats_d cfg_stats;
108 /* Data to pass to replace_block_vars_by_duplicates_1. */
109 struct replace_decls_d
111 hash_map<tree, tree> *vars_map;
112 tree to_context;
115 /* Hash table to store last discriminator assigned for each locus. */
116 struct locus_discrim_map
118 int location_line;
119 int discriminator;
122 /* Hashtable helpers. */
124 struct locus_discrim_hasher : free_ptr_hash <locus_discrim_map>
126 static inline hashval_t hash (const locus_discrim_map *);
127 static inline bool equal (const locus_discrim_map *,
128 const locus_discrim_map *);
131 /* Trivial hash function for a location_t. ITEM is a pointer to
132 a hash table entry that maps a location_t to a discriminator. */
134 inline hashval_t
135 locus_discrim_hasher::hash (const locus_discrim_map *item)
137 return item->location_line;
140 /* Equality function for the locus-to-discriminator map. A and B
141 point to the two hash table entries to compare. */
143 inline bool
144 locus_discrim_hasher::equal (const locus_discrim_map *a,
145 const locus_discrim_map *b)
147 return a->location_line == b->location_line;
150 static hash_table<locus_discrim_hasher> *discriminator_per_locus;
152 /* Basic blocks and flowgraphs. */
153 static void make_blocks (gimple_seq);
155 /* Edges. */
156 static void make_edges (void);
157 static void assign_discriminators (void);
158 static void make_cond_expr_edges (basic_block);
159 static void make_gimple_switch_edges (gswitch *, basic_block);
160 static bool make_goto_expr_edges (basic_block);
161 static void make_gimple_asm_edges (basic_block);
162 static edge gimple_redirect_edge_and_branch (edge, basic_block);
163 static edge gimple_try_redirect_by_replacing_jump (edge, basic_block);
165 /* Various helpers. */
166 static inline bool stmt_starts_bb_p (gimple *, gimple *);
167 static int gimple_verify_flow_info (void);
168 static void gimple_make_forwarder_block (edge);
169 static gimple *first_non_label_stmt (basic_block);
170 static bool verify_gimple_transaction (gtransaction *);
171 static bool call_can_make_abnormal_goto (gimple *);
173 /* Flowgraph optimization and cleanup. */
174 static void gimple_merge_blocks (basic_block, basic_block);
175 static bool gimple_can_merge_blocks_p (basic_block, basic_block);
176 static void remove_bb (basic_block);
177 static edge find_taken_edge_computed_goto (basic_block, tree);
178 static edge find_taken_edge_cond_expr (const gcond *, tree);
180 void
181 init_empty_tree_cfg_for_function (struct function *fn)
183 /* Initialize the basic block array. */
184 init_flow (fn);
185 profile_status_for_fn (fn) = PROFILE_ABSENT;
186 n_basic_blocks_for_fn (fn) = NUM_FIXED_BLOCKS;
187 last_basic_block_for_fn (fn) = NUM_FIXED_BLOCKS;
188 vec_safe_grow_cleared (basic_block_info_for_fn (fn),
189 initial_cfg_capacity, true);
191 /* Build a mapping of labels to their associated blocks. */
192 vec_safe_grow_cleared (label_to_block_map_for_fn (fn),
193 initial_cfg_capacity, true);
195 SET_BASIC_BLOCK_FOR_FN (fn, ENTRY_BLOCK, ENTRY_BLOCK_PTR_FOR_FN (fn));
196 SET_BASIC_BLOCK_FOR_FN (fn, EXIT_BLOCK, EXIT_BLOCK_PTR_FOR_FN (fn));
198 ENTRY_BLOCK_PTR_FOR_FN (fn)->next_bb
199 = EXIT_BLOCK_PTR_FOR_FN (fn);
200 EXIT_BLOCK_PTR_FOR_FN (fn)->prev_bb
201 = ENTRY_BLOCK_PTR_FOR_FN (fn);
204 void
205 init_empty_tree_cfg (void)
207 init_empty_tree_cfg_for_function (cfun);
210 /*---------------------------------------------------------------------------
211 Create basic blocks
212 ---------------------------------------------------------------------------*/
214 /* Entry point to the CFG builder for trees. SEQ is the sequence of
215 statements to be added to the flowgraph. */
217 static void
218 build_gimple_cfg (gimple_seq seq)
220 /* Register specific gimple functions. */
221 gimple_register_cfg_hooks ();
223 memset ((void *) &cfg_stats, 0, sizeof (cfg_stats));
225 init_empty_tree_cfg ();
227 make_blocks (seq);
229 /* Make sure there is always at least one block, even if it's empty. */
230 if (n_basic_blocks_for_fn (cfun) == NUM_FIXED_BLOCKS)
231 create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun));
233 /* Adjust the size of the array. */
234 if (basic_block_info_for_fn (cfun)->length ()
235 < (size_t) n_basic_blocks_for_fn (cfun))
236 vec_safe_grow_cleared (basic_block_info_for_fn (cfun),
237 n_basic_blocks_for_fn (cfun));
239 /* To speed up statement iterator walks, we first purge dead labels. */
240 cleanup_dead_labels ();
242 /* Group case nodes to reduce the number of edges.
243 We do this after cleaning up dead labels because otherwise we miss
244 a lot of obvious case merging opportunities. */
245 group_case_labels ();
247 /* Create the edges of the flowgraph. */
248 discriminator_per_locus = new hash_table<locus_discrim_hasher> (13);
249 make_edges ();
250 assign_discriminators ();
251 cleanup_dead_labels ();
252 delete discriminator_per_locus;
253 discriminator_per_locus = NULL;
256 /* Look for ANNOTATE calls with loop annotation kind in BB; if found, remove
257 them and propagate the information to LOOP. We assume that the annotations
258 come immediately before the condition in BB, if any. */
260 static void
261 replace_loop_annotate_in_block (basic_block bb, class loop *loop)
263 gimple_stmt_iterator gsi = gsi_last_bb (bb);
264 gimple *stmt = gsi_stmt (gsi);
266 if (!(stmt && gimple_code (stmt) == GIMPLE_COND))
267 return;
269 for (gsi_prev_nondebug (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
271 stmt = gsi_stmt (gsi);
272 if (gimple_code (stmt) != GIMPLE_CALL)
273 break;
274 if (!gimple_call_internal_p (stmt)
275 || gimple_call_internal_fn (stmt) != IFN_ANNOTATE)
276 break;
278 switch ((annot_expr_kind) tree_to_shwi (gimple_call_arg (stmt, 1)))
280 case annot_expr_ivdep_kind:
281 loop->safelen = INT_MAX;
282 break;
283 case annot_expr_unroll_kind:
284 loop->unroll
285 = (unsigned short) tree_to_shwi (gimple_call_arg (stmt, 2));
286 cfun->has_unroll = true;
287 break;
288 case annot_expr_no_vector_kind:
289 loop->dont_vectorize = true;
290 break;
291 case annot_expr_vector_kind:
292 loop->force_vectorize = true;
293 cfun->has_force_vectorize_loops = true;
294 break;
295 case annot_expr_parallel_kind:
296 loop->can_be_parallel = true;
297 loop->safelen = INT_MAX;
298 break;
299 default:
300 gcc_unreachable ();
303 stmt = gimple_build_assign (gimple_call_lhs (stmt),
304 gimple_call_arg (stmt, 0));
305 gsi_replace (&gsi, stmt, true);
309 /* Look for ANNOTATE calls with loop annotation kind; if found, remove
310 them and propagate the information to the loop. We assume that the
311 annotations come immediately before the condition of the loop. */
313 static void
314 replace_loop_annotate (void)
316 basic_block bb;
317 gimple_stmt_iterator gsi;
318 gimple *stmt;
320 for (auto loop : loops_list (cfun, 0))
322 /* First look into the header. */
323 replace_loop_annotate_in_block (loop->header, loop);
325 /* Then look into the latch, if any. */
326 if (loop->latch)
327 replace_loop_annotate_in_block (loop->latch, loop);
329 /* Push the global flag_finite_loops state down to individual loops. */
330 loop->finite_p = flag_finite_loops;
333 /* Remove IFN_ANNOTATE. Safeguard for the case loop->latch == NULL. */
334 FOR_EACH_BB_FN (bb, cfun)
336 for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
338 stmt = gsi_stmt (gsi);
339 if (gimple_code (stmt) != GIMPLE_CALL)
340 continue;
341 if (!gimple_call_internal_p (stmt)
342 || gimple_call_internal_fn (stmt) != IFN_ANNOTATE)
343 continue;
345 switch ((annot_expr_kind) tree_to_shwi (gimple_call_arg (stmt, 1)))
347 case annot_expr_ivdep_kind:
348 case annot_expr_unroll_kind:
349 case annot_expr_no_vector_kind:
350 case annot_expr_vector_kind:
351 case annot_expr_parallel_kind:
352 break;
353 default:
354 gcc_unreachable ();
357 warning_at (gimple_location (stmt), 0, "ignoring loop annotation");
358 stmt = gimple_build_assign (gimple_call_lhs (stmt),
359 gimple_call_arg (stmt, 0));
360 gsi_replace (&gsi, stmt, true);
365 static unsigned int
366 execute_build_cfg (void)
368 gimple_seq body = gimple_body (current_function_decl);
370 build_gimple_cfg (body);
371 gimple_set_body (current_function_decl, NULL);
372 if (dump_file && (dump_flags & TDF_DETAILS))
374 fprintf (dump_file, "Scope blocks:\n");
375 dump_scope_blocks (dump_file, dump_flags);
377 cleanup_tree_cfg ();
379 bb_to_omp_idx.release ();
381 loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
382 replace_loop_annotate ();
383 return 0;
386 namespace {
388 const pass_data pass_data_build_cfg =
390 GIMPLE_PASS, /* type */
391 "cfg", /* name */
392 OPTGROUP_NONE, /* optinfo_flags */
393 TV_TREE_CFG, /* tv_id */
394 PROP_gimple_leh, /* properties_required */
395 ( PROP_cfg | PROP_loops ), /* properties_provided */
396 0, /* properties_destroyed */
397 0, /* todo_flags_start */
398 0, /* todo_flags_finish */
401 class pass_build_cfg : public gimple_opt_pass
403 public:
404 pass_build_cfg (gcc::context *ctxt)
405 : gimple_opt_pass (pass_data_build_cfg, ctxt)
408 /* opt_pass methods: */
409 virtual unsigned int execute (function *) { return execute_build_cfg (); }
411 }; // class pass_build_cfg
413 } // anon namespace
415 gimple_opt_pass *
416 make_pass_build_cfg (gcc::context *ctxt)
418 return new pass_build_cfg (ctxt);
422 /* Return true if T is a computed goto. */
424 bool
425 computed_goto_p (gimple *t)
427 return (gimple_code (t) == GIMPLE_GOTO
428 && TREE_CODE (gimple_goto_dest (t)) != LABEL_DECL);
431 /* Returns true if the sequence of statements STMTS only contains
432 a call to __builtin_unreachable (). */
434 bool
435 gimple_seq_unreachable_p (gimple_seq stmts)
437 if (stmts == NULL
438 /* Return false if -fsanitize=unreachable, we don't want to
439 optimize away those calls, but rather turn them into
440 __ubsan_handle_builtin_unreachable () or __builtin_trap ()
441 later. */
442 || sanitize_flags_p (SANITIZE_UNREACHABLE))
443 return false;
445 gimple_stmt_iterator gsi = gsi_last (stmts);
447 if (!gimple_call_builtin_p (gsi_stmt (gsi), BUILT_IN_UNREACHABLE))
448 return false;
450 for (gsi_prev (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
452 gimple *stmt = gsi_stmt (gsi);
453 if (gimple_code (stmt) != GIMPLE_LABEL
454 && !is_gimple_debug (stmt)
455 && !gimple_clobber_p (stmt))
456 return false;
458 return true;
461 /* Returns true for edge E where e->src ends with a GIMPLE_COND and
462 the other edge points to a bb with just __builtin_unreachable ().
463 I.e. return true for C->M edge in:
464 <bb C>:
466 if (something)
467 goto <bb N>;
468 else
469 goto <bb M>;
470 <bb N>:
471 __builtin_unreachable ();
472 <bb M>: */
474 bool
475 assert_unreachable_fallthru_edge_p (edge e)
477 basic_block pred_bb = e->src;
478 gimple *last = last_stmt (pred_bb);
479 if (last && gimple_code (last) == GIMPLE_COND)
481 basic_block other_bb = EDGE_SUCC (pred_bb, 0)->dest;
482 if (other_bb == e->dest)
483 other_bb = EDGE_SUCC (pred_bb, 1)->dest;
484 if (EDGE_COUNT (other_bb->succs) == 0)
485 return gimple_seq_unreachable_p (bb_seq (other_bb));
487 return false;
491 /* Initialize GF_CALL_CTRL_ALTERING flag, which indicates the call
492 could alter control flow except via eh. We initialize the flag at
493 CFG build time and only ever clear it later. */
495 static void
496 gimple_call_initialize_ctrl_altering (gimple *stmt)
498 int flags = gimple_call_flags (stmt);
500 /* A call alters control flow if it can make an abnormal goto. */
501 if (call_can_make_abnormal_goto (stmt)
502 /* A call also alters control flow if it does not return. */
503 || flags & ECF_NORETURN
504 /* TM ending statements have backedges out of the transaction.
505 Return true so we split the basic block containing them.
506 Note that the TM_BUILTIN test is merely an optimization. */
507 || ((flags & ECF_TM_BUILTIN)
508 && is_tm_ending_fndecl (gimple_call_fndecl (stmt)))
509 /* BUILT_IN_RETURN call is same as return statement. */
510 || gimple_call_builtin_p (stmt, BUILT_IN_RETURN)
511 /* IFN_UNIQUE should be the last insn, to make checking for it
512 as cheap as possible. */
513 || (gimple_call_internal_p (stmt)
514 && gimple_call_internal_unique_p (stmt)))
515 gimple_call_set_ctrl_altering (stmt, true);
516 else
517 gimple_call_set_ctrl_altering (stmt, false);
521 /* Insert SEQ after BB and build a flowgraph. */
523 static basic_block
524 make_blocks_1 (gimple_seq seq, basic_block bb)
526 gimple_stmt_iterator i = gsi_start (seq);
527 gimple *stmt = NULL;
528 gimple *prev_stmt = NULL;
529 bool start_new_block = true;
530 bool first_stmt_of_seq = true;
532 while (!gsi_end_p (i))
534 /* PREV_STMT should only be set to a debug stmt if the debug
535 stmt is before nondebug stmts. Once stmt reaches a nondebug
536 nonlabel, prev_stmt will be set to it, so that
537 stmt_starts_bb_p will know to start a new block if a label is
538 found. However, if stmt was a label after debug stmts only,
539 keep the label in prev_stmt even if we find further debug
540 stmts, for there may be other labels after them, and they
541 should land in the same block. */
542 if (!prev_stmt || !stmt || !is_gimple_debug (stmt))
543 prev_stmt = stmt;
544 stmt = gsi_stmt (i);
546 if (stmt && is_gimple_call (stmt))
547 gimple_call_initialize_ctrl_altering (stmt);
549 /* If the statement starts a new basic block or if we have determined
550 in a previous pass that we need to create a new block for STMT, do
551 so now. */
552 if (start_new_block || stmt_starts_bb_p (stmt, prev_stmt))
554 if (!first_stmt_of_seq)
555 gsi_split_seq_before (&i, &seq);
556 bb = create_basic_block (seq, bb);
557 start_new_block = false;
558 prev_stmt = NULL;
561 /* Now add STMT to BB and create the subgraphs for special statement
562 codes. */
563 gimple_set_bb (stmt, bb);
565 /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
566 next iteration. */
567 if (stmt_ends_bb_p (stmt))
569 /* If the stmt can make abnormal goto use a new temporary
570 for the assignment to the LHS. This makes sure the old value
571 of the LHS is available on the abnormal edge. Otherwise
572 we will end up with overlapping life-ranges for abnormal
573 SSA names. */
574 if (gimple_has_lhs (stmt)
575 && stmt_can_make_abnormal_goto (stmt)
576 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt))))
578 tree lhs = gimple_get_lhs (stmt);
579 tree tmp = create_tmp_var (TREE_TYPE (lhs));
580 gimple *s = gimple_build_assign (lhs, tmp);
581 gimple_set_location (s, gimple_location (stmt));
582 gimple_set_block (s, gimple_block (stmt));
583 gimple_set_lhs (stmt, tmp);
584 gsi_insert_after (&i, s, GSI_SAME_STMT);
586 start_new_block = true;
589 gsi_next (&i);
590 first_stmt_of_seq = false;
592 return bb;
595 /* Build a flowgraph for the sequence of stmts SEQ. */
597 static void
598 make_blocks (gimple_seq seq)
600 /* Look for debug markers right before labels, and move the debug
601 stmts after the labels. Accepting labels among debug markers
602 adds no value, just complexity; if we wanted to annotate labels
603 with view numbers (so sequencing among markers would matter) or
604 somesuch, we're probably better off still moving the labels, but
605 adding other debug annotations in their original positions or
606 emitting nonbind or bind markers associated with the labels in
607 the original position of the labels.
609 Moving labels would probably be simpler, but we can't do that:
610 moving labels assigns label ids to them, and doing so because of
611 debug markers makes for -fcompare-debug and possibly even codegen
612 differences. So, we have to move the debug stmts instead. To
613 that end, we scan SEQ backwards, marking the position of the
614 latest (earliest we find) label, and moving debug stmts that are
615 not separated from it by nondebug nonlabel stmts after the
616 label. */
617 if (MAY_HAVE_DEBUG_MARKER_STMTS)
619 gimple_stmt_iterator label = gsi_none ();
621 for (gimple_stmt_iterator i = gsi_last (seq); !gsi_end_p (i); gsi_prev (&i))
623 gimple *stmt = gsi_stmt (i);
625 /* If this is the first label we encounter (latest in SEQ)
626 before nondebug stmts, record its position. */
627 if (is_a <glabel *> (stmt))
629 if (gsi_end_p (label))
630 label = i;
631 continue;
634 /* Without a recorded label position to move debug stmts to,
635 there's nothing to do. */
636 if (gsi_end_p (label))
637 continue;
639 /* Move the debug stmt at I after LABEL. */
640 if (is_gimple_debug (stmt))
642 gcc_assert (gimple_debug_nonbind_marker_p (stmt));
643 /* As STMT is removed, I advances to the stmt after
644 STMT, so the gsi_prev in the for "increment"
645 expression gets us to the stmt we're to visit after
646 STMT. LABEL, however, would advance to the moved
647 stmt if we passed it to gsi_move_after, so pass it a
648 copy instead, so as to keep LABEL pointing to the
649 LABEL. */
650 gimple_stmt_iterator copy = label;
651 gsi_move_after (&i, &copy);
652 continue;
655 /* There aren't any (more?) debug stmts before label, so
656 there isn't anything else to move after it. */
657 label = gsi_none ();
661 make_blocks_1 (seq, ENTRY_BLOCK_PTR_FOR_FN (cfun));
664 /* Create and return a new empty basic block after bb AFTER. */
666 static basic_block
667 create_bb (void *h, void *e, basic_block after)
669 basic_block bb;
671 gcc_assert (!e);
673 /* Create and initialize a new basic block. Since alloc_block uses
674 GC allocation that clears memory to allocate a basic block, we do
675 not have to clear the newly allocated basic block here. */
676 bb = alloc_block ();
678 bb->index = last_basic_block_for_fn (cfun);
679 bb->flags = BB_NEW;
680 set_bb_seq (bb, h ? (gimple_seq) h : NULL);
682 /* Add the new block to the linked list of blocks. */
683 link_block (bb, after);
685 /* Grow the basic block array if needed. */
686 if ((size_t) last_basic_block_for_fn (cfun)
687 == basic_block_info_for_fn (cfun)->length ())
688 vec_safe_grow_cleared (basic_block_info_for_fn (cfun),
689 last_basic_block_for_fn (cfun) + 1);
691 /* Add the newly created block to the array. */
692 SET_BASIC_BLOCK_FOR_FN (cfun, last_basic_block_for_fn (cfun), bb);
694 n_basic_blocks_for_fn (cfun)++;
695 last_basic_block_for_fn (cfun)++;
697 return bb;
701 /*---------------------------------------------------------------------------
702 Edge creation
703 ---------------------------------------------------------------------------*/
705 /* If basic block BB has an abnormal edge to a basic block
706 containing IFN_ABNORMAL_DISPATCHER internal call, return
707 that the dispatcher's basic block, otherwise return NULL. */
709 basic_block
710 get_abnormal_succ_dispatcher (basic_block bb)
712 edge e;
713 edge_iterator ei;
715 FOR_EACH_EDGE (e, ei, bb->succs)
716 if ((e->flags & (EDGE_ABNORMAL | EDGE_EH)) == EDGE_ABNORMAL)
718 gimple_stmt_iterator gsi
719 = gsi_start_nondebug_after_labels_bb (e->dest);
720 gimple *g = gsi_stmt (gsi);
721 if (g && gimple_call_internal_p (g, IFN_ABNORMAL_DISPATCHER))
722 return e->dest;
724 return NULL;
727 /* Helper function for make_edges. Create a basic block with
728 with ABNORMAL_DISPATCHER internal call in it if needed, and
729 create abnormal edges from BBS to it and from it to FOR_BB
730 if COMPUTED_GOTO is false, otherwise factor the computed gotos. */
732 static void
733 handle_abnormal_edges (basic_block *dispatcher_bbs, basic_block for_bb,
734 auto_vec<basic_block> *bbs, bool computed_goto)
736 basic_block *dispatcher = dispatcher_bbs + (computed_goto ? 1 : 0);
737 unsigned int idx = 0;
738 basic_block bb;
739 bool inner = false;
741 if (!bb_to_omp_idx.is_empty ())
743 dispatcher = dispatcher_bbs + 2 * bb_to_omp_idx[for_bb->index];
744 if (bb_to_omp_idx[for_bb->index] != 0)
745 inner = true;
748 /* If the dispatcher has been created already, then there are basic
749 blocks with abnormal edges to it, so just make a new edge to
750 for_bb. */
751 if (*dispatcher == NULL)
753 /* Check if there are any basic blocks that need to have
754 abnormal edges to this dispatcher. If there are none, return
755 early. */
756 if (bb_to_omp_idx.is_empty ())
758 if (bbs->is_empty ())
759 return;
761 else
763 FOR_EACH_VEC_ELT (*bbs, idx, bb)
764 if (bb_to_omp_idx[bb->index] == bb_to_omp_idx[for_bb->index])
765 break;
766 if (bb == NULL)
767 return;
770 /* Create the dispatcher bb. */
771 *dispatcher = create_basic_block (NULL, for_bb);
772 if (computed_goto)
774 /* Factor computed gotos into a common computed goto site. Also
775 record the location of that site so that we can un-factor the
776 gotos after we have converted back to normal form. */
777 gimple_stmt_iterator gsi = gsi_start_bb (*dispatcher);
779 /* Create the destination of the factored goto. Each original
780 computed goto will put its desired destination into this
781 variable and jump to the label we create immediately below. */
782 tree var = create_tmp_var (ptr_type_node, "gotovar");
784 /* Build a label for the new block which will contain the
785 factored computed goto. */
786 tree factored_label_decl
787 = create_artificial_label (UNKNOWN_LOCATION);
788 gimple *factored_computed_goto_label
789 = gimple_build_label (factored_label_decl);
790 gsi_insert_after (&gsi, factored_computed_goto_label, GSI_NEW_STMT);
792 /* Build our new computed goto. */
793 gimple *factored_computed_goto = gimple_build_goto (var);
794 gsi_insert_after (&gsi, factored_computed_goto, GSI_NEW_STMT);
796 FOR_EACH_VEC_ELT (*bbs, idx, bb)
798 if (!bb_to_omp_idx.is_empty ()
799 && bb_to_omp_idx[bb->index] != bb_to_omp_idx[for_bb->index])
800 continue;
802 gsi = gsi_last_bb (bb);
803 gimple *last = gsi_stmt (gsi);
805 gcc_assert (computed_goto_p (last));
807 /* Copy the original computed goto's destination into VAR. */
808 gimple *assignment
809 = gimple_build_assign (var, gimple_goto_dest (last));
810 gsi_insert_before (&gsi, assignment, GSI_SAME_STMT);
812 edge e = make_edge (bb, *dispatcher, EDGE_FALLTHRU);
813 e->goto_locus = gimple_location (last);
814 gsi_remove (&gsi, true);
817 else
819 tree arg = inner ? boolean_true_node : boolean_false_node;
820 gimple *g = gimple_build_call_internal (IFN_ABNORMAL_DISPATCHER,
821 1, arg);
822 gimple_stmt_iterator gsi = gsi_after_labels (*dispatcher);
823 gsi_insert_after (&gsi, g, GSI_NEW_STMT);
825 /* Create predecessor edges of the dispatcher. */
826 FOR_EACH_VEC_ELT (*bbs, idx, bb)
828 if (!bb_to_omp_idx.is_empty ()
829 && bb_to_omp_idx[bb->index] != bb_to_omp_idx[for_bb->index])
830 continue;
831 make_edge (bb, *dispatcher, EDGE_ABNORMAL);
836 make_edge (*dispatcher, for_bb, EDGE_ABNORMAL);
839 /* Creates outgoing edges for BB. Returns 1 when it ends with an
840 computed goto, returns 2 when it ends with a statement that
841 might return to this function via an nonlocal goto, otherwise
842 return 0. Updates *PCUR_REGION with the OMP region this BB is in. */
844 static int
845 make_edges_bb (basic_block bb, struct omp_region **pcur_region, int *pomp_index)
847 gimple *last = last_stmt (bb);
848 bool fallthru = false;
849 int ret = 0;
851 if (!last)
852 return ret;
854 switch (gimple_code (last))
856 case GIMPLE_GOTO:
857 if (make_goto_expr_edges (bb))
858 ret = 1;
859 fallthru = false;
860 break;
861 case GIMPLE_RETURN:
863 edge e = make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
864 e->goto_locus = gimple_location (last);
865 fallthru = false;
867 break;
868 case GIMPLE_COND:
869 make_cond_expr_edges (bb);
870 fallthru = false;
871 break;
872 case GIMPLE_SWITCH:
873 make_gimple_switch_edges (as_a <gswitch *> (last), bb);
874 fallthru = false;
875 break;
876 case GIMPLE_RESX:
877 make_eh_edges (last);
878 fallthru = false;
879 break;
880 case GIMPLE_EH_DISPATCH:
881 fallthru = make_eh_dispatch_edges (as_a <geh_dispatch *> (last));
882 break;
884 case GIMPLE_CALL:
885 /* If this function receives a nonlocal goto, then we need to
886 make edges from this call site to all the nonlocal goto
887 handlers. */
888 if (stmt_can_make_abnormal_goto (last))
889 ret = 2;
891 /* If this statement has reachable exception handlers, then
892 create abnormal edges to them. */
893 make_eh_edges (last);
895 /* BUILTIN_RETURN is really a return statement. */
896 if (gimple_call_builtin_p (last, BUILT_IN_RETURN))
898 make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
899 fallthru = false;
901 /* Some calls are known not to return. */
902 else
903 fallthru = !gimple_call_noreturn_p (last);
904 break;
906 case GIMPLE_ASSIGN:
907 /* A GIMPLE_ASSIGN may throw internally and thus be considered
908 control-altering. */
909 if (is_ctrl_altering_stmt (last))
910 make_eh_edges (last);
911 fallthru = true;
912 break;
914 case GIMPLE_ASM:
915 make_gimple_asm_edges (bb);
916 fallthru = true;
917 break;
919 CASE_GIMPLE_OMP:
920 fallthru = omp_make_gimple_edges (bb, pcur_region, pomp_index);
921 break;
923 case GIMPLE_TRANSACTION:
925 gtransaction *txn = as_a <gtransaction *> (last);
926 tree label1 = gimple_transaction_label_norm (txn);
927 tree label2 = gimple_transaction_label_uninst (txn);
929 if (label1)
930 make_edge (bb, label_to_block (cfun, label1), EDGE_FALLTHRU);
931 if (label2)
932 make_edge (bb, label_to_block (cfun, label2),
933 EDGE_TM_UNINSTRUMENTED | (label1 ? 0 : EDGE_FALLTHRU));
935 tree label3 = gimple_transaction_label_over (txn);
936 if (gimple_transaction_subcode (txn)
937 & (GTMA_HAVE_ABORT | GTMA_IS_OUTER))
938 make_edge (bb, label_to_block (cfun, label3), EDGE_TM_ABORT);
940 fallthru = false;
942 break;
944 default:
945 gcc_assert (!stmt_ends_bb_p (last));
946 fallthru = true;
947 break;
950 if (fallthru)
951 make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
953 return ret;
956 /* Join all the blocks in the flowgraph. */
958 static void
959 make_edges (void)
961 basic_block bb;
962 struct omp_region *cur_region = NULL;
963 auto_vec<basic_block> ab_edge_goto;
964 auto_vec<basic_block> ab_edge_call;
965 int cur_omp_region_idx = 0;
967 /* Create an edge from entry to the first block with executable
968 statements in it. */
969 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun),
970 BASIC_BLOCK_FOR_FN (cfun, NUM_FIXED_BLOCKS),
971 EDGE_FALLTHRU);
973 /* Traverse the basic block array placing edges. */
974 FOR_EACH_BB_FN (bb, cfun)
976 int mer;
978 if (!bb_to_omp_idx.is_empty ())
979 bb_to_omp_idx[bb->index] = cur_omp_region_idx;
981 mer = make_edges_bb (bb, &cur_region, &cur_omp_region_idx);
982 if (mer == 1)
983 ab_edge_goto.safe_push (bb);
984 else if (mer == 2)
985 ab_edge_call.safe_push (bb);
987 if (cur_region && bb_to_omp_idx.is_empty ())
988 bb_to_omp_idx.safe_grow_cleared (n_basic_blocks_for_fn (cfun), true);
991 /* Computed gotos are hell to deal with, especially if there are
992 lots of them with a large number of destinations. So we factor
993 them to a common computed goto location before we build the
994 edge list. After we convert back to normal form, we will un-factor
995 the computed gotos since factoring introduces an unwanted jump.
996 For non-local gotos and abnormal edges from calls to calls that return
997 twice or forced labels, factor the abnormal edges too, by having all
998 abnormal edges from the calls go to a common artificial basic block
999 with ABNORMAL_DISPATCHER internal call and abnormal edges from that
1000 basic block to all forced labels and calls returning twice.
1001 We do this per-OpenMP structured block, because those regions
1002 are guaranteed to be single entry single exit by the standard,
1003 so it is not allowed to enter or exit such regions abnormally this way,
1004 thus all computed gotos, non-local gotos and setjmp/longjmp calls
1005 must not transfer control across SESE region boundaries. */
1006 if (!ab_edge_goto.is_empty () || !ab_edge_call.is_empty ())
1008 gimple_stmt_iterator gsi;
1009 basic_block dispatcher_bb_array[2] = { NULL, NULL };
1010 basic_block *dispatcher_bbs = dispatcher_bb_array;
1011 int count = n_basic_blocks_for_fn (cfun);
1013 if (!bb_to_omp_idx.is_empty ())
1014 dispatcher_bbs = XCNEWVEC (basic_block, 2 * count);
1016 FOR_EACH_BB_FN (bb, cfun)
1018 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
1020 glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
1021 tree target;
1023 if (!label_stmt)
1024 break;
1026 target = gimple_label_label (label_stmt);
1028 /* Make an edge to every label block that has been marked as a
1029 potential target for a computed goto or a non-local goto. */
1030 if (FORCED_LABEL (target))
1031 handle_abnormal_edges (dispatcher_bbs, bb, &ab_edge_goto,
1032 true);
1033 if (DECL_NONLOCAL (target))
1035 handle_abnormal_edges (dispatcher_bbs, bb, &ab_edge_call,
1036 false);
1037 break;
1041 if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
1042 gsi_next_nondebug (&gsi);
1043 if (!gsi_end_p (gsi))
1045 /* Make an edge to every setjmp-like call. */
1046 gimple *call_stmt = gsi_stmt (gsi);
1047 if (is_gimple_call (call_stmt)
1048 && ((gimple_call_flags (call_stmt) & ECF_RETURNS_TWICE)
1049 || gimple_call_builtin_p (call_stmt,
1050 BUILT_IN_SETJMP_RECEIVER)))
1051 handle_abnormal_edges (dispatcher_bbs, bb, &ab_edge_call,
1052 false);
1056 if (!bb_to_omp_idx.is_empty ())
1057 XDELETE (dispatcher_bbs);
1060 omp_free_regions ();
1063 /* Add SEQ after GSI. Start new bb after GSI, and created further bbs as
1064 needed. Returns true if new bbs were created.
1065 Note: This is transitional code, and should not be used for new code. We
1066 should be able to get rid of this by rewriting all target va-arg
1067 gimplification hooks to use an interface gimple_build_cond_value as described
1068 in https://gcc.gnu.org/ml/gcc-patches/2015-02/msg01194.html. */
1070 bool
1071 gimple_find_sub_bbs (gimple_seq seq, gimple_stmt_iterator *gsi)
1073 gimple *stmt = gsi_stmt (*gsi);
1074 basic_block bb = gimple_bb (stmt);
1075 basic_block lastbb, afterbb;
1076 int old_num_bbs = n_basic_blocks_for_fn (cfun);
1077 edge e;
1078 lastbb = make_blocks_1 (seq, bb);
1079 if (old_num_bbs == n_basic_blocks_for_fn (cfun))
1080 return false;
1081 e = split_block (bb, stmt);
1082 /* Move e->dest to come after the new basic blocks. */
1083 afterbb = e->dest;
1084 unlink_block (afterbb);
1085 link_block (afterbb, lastbb);
1086 redirect_edge_succ (e, bb->next_bb);
1087 bb = bb->next_bb;
1088 while (bb != afterbb)
1090 struct omp_region *cur_region = NULL;
1091 profile_count cnt = profile_count::zero ();
1092 bool all = true;
1094 int cur_omp_region_idx = 0;
1095 int mer = make_edges_bb (bb, &cur_region, &cur_omp_region_idx);
1096 gcc_assert (!mer && !cur_region);
1097 add_bb_to_loop (bb, afterbb->loop_father);
1099 edge e;
1100 edge_iterator ei;
1101 FOR_EACH_EDGE (e, ei, bb->preds)
1103 if (e->count ().initialized_p ())
1104 cnt += e->count ();
1105 else
1106 all = false;
1108 tree_guess_outgoing_edge_probabilities (bb);
1109 if (all || profile_status_for_fn (cfun) == PROFILE_READ)
1110 bb->count = cnt;
1112 bb = bb->next_bb;
1114 return true;
1117 /* Find the next available discriminator value for LOCUS. The
1118 discriminator distinguishes among several basic blocks that
1119 share a common locus, allowing for more accurate sample-based
1120 profiling. */
1122 static int
1123 next_discriminator_for_locus (int line)
1125 struct locus_discrim_map item;
1126 struct locus_discrim_map **slot;
1128 item.location_line = line;
1129 item.discriminator = 0;
1130 slot = discriminator_per_locus->find_slot_with_hash (&item, line, INSERT);
1131 gcc_assert (slot);
1132 if (*slot == HTAB_EMPTY_ENTRY)
1134 *slot = XNEW (struct locus_discrim_map);
1135 gcc_assert (*slot);
1136 (*slot)->location_line = line;
1137 (*slot)->discriminator = 0;
1139 (*slot)->discriminator++;
1140 return (*slot)->discriminator;
1143 /* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line. */
1145 static bool
1146 same_line_p (location_t locus1, expanded_location *from, location_t locus2)
1148 expanded_location to;
1150 if (locus1 == locus2)
1151 return true;
1153 to = expand_location (locus2);
1155 if (from->line != to.line)
1156 return false;
1157 if (from->file == to.file)
1158 return true;
1159 return (from->file != NULL
1160 && to.file != NULL
1161 && filename_cmp (from->file, to.file) == 0);
1164 /* Assign discriminators to each basic block. */
1166 static void
1167 assign_discriminators (void)
1169 basic_block bb;
1171 FOR_EACH_BB_FN (bb, cfun)
1173 edge e;
1174 edge_iterator ei;
1175 gimple *last = last_stmt (bb);
1176 location_t locus = last ? gimple_location (last) : UNKNOWN_LOCATION;
1178 if (locus == UNKNOWN_LOCATION)
1179 continue;
1181 expanded_location locus_e = expand_location (locus);
1183 FOR_EACH_EDGE (e, ei, bb->succs)
1185 gimple *first = first_non_label_stmt (e->dest);
1186 gimple *last = last_stmt (e->dest);
1187 if ((first && same_line_p (locus, &locus_e,
1188 gimple_location (first)))
1189 || (last && same_line_p (locus, &locus_e,
1190 gimple_location (last))))
1192 if (e->dest->discriminator != 0 && bb->discriminator == 0)
1193 bb->discriminator
1194 = next_discriminator_for_locus (locus_e.line);
1195 else
1196 e->dest->discriminator
1197 = next_discriminator_for_locus (locus_e.line);
1203 /* Create the edges for a GIMPLE_COND starting at block BB. */
1205 static void
1206 make_cond_expr_edges (basic_block bb)
1208 gcond *entry = as_a <gcond *> (last_stmt (bb));
1209 gimple *then_stmt, *else_stmt;
1210 basic_block then_bb, else_bb;
1211 tree then_label, else_label;
1212 edge e;
1214 gcc_assert (entry);
1215 gcc_assert (gimple_code (entry) == GIMPLE_COND);
1217 /* Entry basic blocks for each component. */
1218 then_label = gimple_cond_true_label (entry);
1219 else_label = gimple_cond_false_label (entry);
1220 then_bb = label_to_block (cfun, then_label);
1221 else_bb = label_to_block (cfun, else_label);
1222 then_stmt = first_stmt (then_bb);
1223 else_stmt = first_stmt (else_bb);
1225 e = make_edge (bb, then_bb, EDGE_TRUE_VALUE);
1226 e->goto_locus = gimple_location (then_stmt);
1227 e = make_edge (bb, else_bb, EDGE_FALSE_VALUE);
1228 if (e)
1229 e->goto_locus = gimple_location (else_stmt);
1231 /* We do not need the labels anymore. */
1232 gimple_cond_set_true_label (entry, NULL_TREE);
1233 gimple_cond_set_false_label (entry, NULL_TREE);
1237 /* Called for each element in the hash table (P) as we delete the
1238 edge to cases hash table.
1240 Clear all the CASE_CHAINs to prevent problems with copying of
1241 SWITCH_EXPRs and structure sharing rules, then free the hash table
1242 element. */
1244 bool
1245 edge_to_cases_cleanup (edge const &, tree const &value, void *)
1247 tree t, next;
1249 for (t = value; t; t = next)
1251 next = CASE_CHAIN (t);
1252 CASE_CHAIN (t) = NULL;
1255 return true;
1258 /* Start recording information mapping edges to case labels. */
1260 void
1261 start_recording_case_labels (void)
1263 gcc_assert (edge_to_cases == NULL);
1264 edge_to_cases = new hash_map<edge, tree>;
1265 touched_switch_bbs = BITMAP_ALLOC (NULL);
1268 /* Return nonzero if we are recording information for case labels. */
1270 static bool
1271 recording_case_labels_p (void)
1273 return (edge_to_cases != NULL);
1276 /* Stop recording information mapping edges to case labels and
1277 remove any information we have recorded. */
1278 void
1279 end_recording_case_labels (void)
1281 bitmap_iterator bi;
1282 unsigned i;
1283 edge_to_cases->traverse<void *, edge_to_cases_cleanup> (NULL);
1284 delete edge_to_cases;
1285 edge_to_cases = NULL;
1286 EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs, 0, i, bi)
1288 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
1289 if (bb)
1291 gimple *stmt = last_stmt (bb);
1292 if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
1293 group_case_labels_stmt (as_a <gswitch *> (stmt));
1296 BITMAP_FREE (touched_switch_bbs);
1299 /* If we are inside a {start,end}_recording_cases block, then return
1300 a chain of CASE_LABEL_EXPRs from T which reference E.
1302 Otherwise return NULL. */
1304 static tree
1305 get_cases_for_edge (edge e, gswitch *t)
1307 tree *slot;
1308 size_t i, n;
1310 /* If we are not recording cases, then we do not have CASE_LABEL_EXPR
1311 chains available. Return NULL so the caller can detect this case. */
1312 if (!recording_case_labels_p ())
1313 return NULL;
1315 slot = edge_to_cases->get (e);
1316 if (slot)
1317 return *slot;
1319 /* If we did not find E in the hash table, then this must be the first
1320 time we have been queried for information about E & T. Add all the
1321 elements from T to the hash table then perform the query again. */
1323 n = gimple_switch_num_labels (t);
1324 for (i = 0; i < n; i++)
1326 tree elt = gimple_switch_label (t, i);
1327 tree lab = CASE_LABEL (elt);
1328 basic_block label_bb = label_to_block (cfun, lab);
1329 edge this_edge = find_edge (e->src, label_bb);
1331 /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
1332 a new chain. */
1333 tree &s = edge_to_cases->get_or_insert (this_edge);
1334 CASE_CHAIN (elt) = s;
1335 s = elt;
1338 return *edge_to_cases->get (e);
1341 /* Create the edges for a GIMPLE_SWITCH starting at block BB. */
1343 static void
1344 make_gimple_switch_edges (gswitch *entry, basic_block bb)
1346 size_t i, n;
1348 n = gimple_switch_num_labels (entry);
1350 for (i = 0; i < n; ++i)
1352 basic_block label_bb = gimple_switch_label_bb (cfun, entry, i);
1353 make_edge (bb, label_bb, 0);
1358 /* Return the basic block holding label DEST. */
1360 basic_block
1361 label_to_block (struct function *ifun, tree dest)
1363 int uid = LABEL_DECL_UID (dest);
1365 /* We would die hard when faced by an undefined label. Emit a label to
1366 the very first basic block. This will hopefully make even the dataflow
1367 and undefined variable warnings quite right. */
1368 if (seen_error () && uid < 0)
1370 gimple_stmt_iterator gsi =
1371 gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun, NUM_FIXED_BLOCKS));
1372 gimple *stmt;
1374 stmt = gimple_build_label (dest);
1375 gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
1376 uid = LABEL_DECL_UID (dest);
1378 if (vec_safe_length (ifun->cfg->x_label_to_block_map) <= (unsigned int) uid)
1379 return NULL;
1380 return (*ifun->cfg->x_label_to_block_map)[uid];
1383 /* Create edges for a goto statement at block BB. Returns true
1384 if abnormal edges should be created. */
1386 static bool
1387 make_goto_expr_edges (basic_block bb)
1389 gimple_stmt_iterator last = gsi_last_bb (bb);
1390 gimple *goto_t = gsi_stmt (last);
1392 /* A simple GOTO creates normal edges. */
1393 if (simple_goto_p (goto_t))
1395 tree dest = gimple_goto_dest (goto_t);
1396 basic_block label_bb = label_to_block (cfun, dest);
1397 edge e = make_edge (bb, label_bb, EDGE_FALLTHRU);
1398 e->goto_locus = gimple_location (goto_t);
1399 gsi_remove (&last, true);
1400 return false;
1403 /* A computed GOTO creates abnormal edges. */
1404 return true;
1407 /* Create edges for an asm statement with labels at block BB. */
1409 static void
1410 make_gimple_asm_edges (basic_block bb)
1412 gasm *stmt = as_a <gasm *> (last_stmt (bb));
1413 int i, n = gimple_asm_nlabels (stmt);
1415 for (i = 0; i < n; ++i)
1417 tree label = TREE_VALUE (gimple_asm_label_op (stmt, i));
1418 basic_block label_bb = label_to_block (cfun, label);
1419 make_edge (bb, label_bb, 0);
1423 /*---------------------------------------------------------------------------
1424 Flowgraph analysis
1425 ---------------------------------------------------------------------------*/
1427 /* Cleanup useless labels in basic blocks. This is something we wish
1428 to do early because it allows us to group case labels before creating
1429 the edges for the CFG, and it speeds up block statement iterators in
1430 all passes later on.
1431 We rerun this pass after CFG is created, to get rid of the labels that
1432 are no longer referenced. After then we do not run it any more, since
1433 (almost) no new labels should be created. */
1435 /* A map from basic block index to the leading label of that block. */
1436 struct label_record
1438 /* The label. */
1439 tree label;
1441 /* True if the label is referenced from somewhere. */
1442 bool used;
1445 /* Given LABEL return the first label in the same basic block. */
1447 static tree
1448 main_block_label (tree label, label_record *label_for_bb)
1450 basic_block bb = label_to_block (cfun, label);
1451 tree main_label = label_for_bb[bb->index].label;
1453 /* label_to_block possibly inserted undefined label into the chain. */
1454 if (!main_label)
1456 label_for_bb[bb->index].label = label;
1457 main_label = label;
1460 label_for_bb[bb->index].used = true;
1461 return main_label;
1464 /* Clean up redundant labels within the exception tree. */
1466 static void
1467 cleanup_dead_labels_eh (label_record *label_for_bb)
1469 eh_landing_pad lp;
1470 eh_region r;
1471 tree lab;
1472 int i;
1474 if (cfun->eh == NULL)
1475 return;
1477 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
1478 if (lp && lp->post_landing_pad)
1480 lab = main_block_label (lp->post_landing_pad, label_for_bb);
1481 if (lab != lp->post_landing_pad)
1483 EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
1484 lp->post_landing_pad = lab;
1485 EH_LANDING_PAD_NR (lab) = lp->index;
1489 FOR_ALL_EH_REGION (r)
1490 switch (r->type)
1492 case ERT_CLEANUP:
1493 case ERT_MUST_NOT_THROW:
1494 break;
1496 case ERT_TRY:
1498 eh_catch c;
1499 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
1501 lab = c->label;
1502 if (lab)
1503 c->label = main_block_label (lab, label_for_bb);
1506 break;
1508 case ERT_ALLOWED_EXCEPTIONS:
1509 lab = r->u.allowed.label;
1510 if (lab)
1511 r->u.allowed.label = main_block_label (lab, label_for_bb);
1512 break;
1517 /* Cleanup redundant labels. This is a three-step process:
1518 1) Find the leading label for each block.
1519 2) Redirect all references to labels to the leading labels.
1520 3) Cleanup all useless labels. */
1522 void
1523 cleanup_dead_labels (void)
1525 basic_block bb;
1526 label_record *label_for_bb = XCNEWVEC (struct label_record,
1527 last_basic_block_for_fn (cfun));
1529 /* Find a suitable label for each block. We use the first user-defined
1530 label if there is one, or otherwise just the first label we see. */
1531 FOR_EACH_BB_FN (bb, cfun)
1533 gimple_stmt_iterator i;
1535 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
1537 tree label;
1538 glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (i));
1540 if (!label_stmt)
1541 break;
1543 label = gimple_label_label (label_stmt);
1545 /* If we have not yet seen a label for the current block,
1546 remember this one and see if there are more labels. */
1547 if (!label_for_bb[bb->index].label)
1549 label_for_bb[bb->index].label = label;
1550 continue;
1553 /* If we did see a label for the current block already, but it
1554 is an artificially created label, replace it if the current
1555 label is a user defined label. */
1556 if (!DECL_ARTIFICIAL (label)
1557 && DECL_ARTIFICIAL (label_for_bb[bb->index].label))
1559 label_for_bb[bb->index].label = label;
1560 break;
1565 /* Now redirect all jumps/branches to the selected label.
1566 First do so for each block ending in a control statement. */
1567 FOR_EACH_BB_FN (bb, cfun)
1569 gimple *stmt = last_stmt (bb);
1570 tree label, new_label;
1572 if (!stmt)
1573 continue;
1575 switch (gimple_code (stmt))
1577 case GIMPLE_COND:
1579 gcond *cond_stmt = as_a <gcond *> (stmt);
1580 label = gimple_cond_true_label (cond_stmt);
1581 if (label)
1583 new_label = main_block_label (label, label_for_bb);
1584 if (new_label != label)
1585 gimple_cond_set_true_label (cond_stmt, new_label);
1588 label = gimple_cond_false_label (cond_stmt);
1589 if (label)
1591 new_label = main_block_label (label, label_for_bb);
1592 if (new_label != label)
1593 gimple_cond_set_false_label (cond_stmt, new_label);
1596 break;
1598 case GIMPLE_SWITCH:
1600 gswitch *switch_stmt = as_a <gswitch *> (stmt);
1601 size_t i, n = gimple_switch_num_labels (switch_stmt);
1603 /* Replace all destination labels. */
1604 for (i = 0; i < n; ++i)
1606 tree case_label = gimple_switch_label (switch_stmt, i);
1607 label = CASE_LABEL (case_label);
1608 new_label = main_block_label (label, label_for_bb);
1609 if (new_label != label)
1610 CASE_LABEL (case_label) = new_label;
1612 break;
1615 case GIMPLE_ASM:
1617 gasm *asm_stmt = as_a <gasm *> (stmt);
1618 int i, n = gimple_asm_nlabels (asm_stmt);
1620 for (i = 0; i < n; ++i)
1622 tree cons = gimple_asm_label_op (asm_stmt, i);
1623 tree label = main_block_label (TREE_VALUE (cons), label_for_bb);
1624 TREE_VALUE (cons) = label;
1626 break;
1629 /* We have to handle gotos until they're removed, and we don't
1630 remove them until after we've created the CFG edges. */
1631 case GIMPLE_GOTO:
1632 if (!computed_goto_p (stmt))
1634 ggoto *goto_stmt = as_a <ggoto *> (stmt);
1635 label = gimple_goto_dest (goto_stmt);
1636 new_label = main_block_label (label, label_for_bb);
1637 if (new_label != label)
1638 gimple_goto_set_dest (goto_stmt, new_label);
1640 break;
1642 case GIMPLE_TRANSACTION:
1644 gtransaction *txn = as_a <gtransaction *> (stmt);
1646 label = gimple_transaction_label_norm (txn);
1647 if (label)
1649 new_label = main_block_label (label, label_for_bb);
1650 if (new_label != label)
1651 gimple_transaction_set_label_norm (txn, new_label);
1654 label = gimple_transaction_label_uninst (txn);
1655 if (label)
1657 new_label = main_block_label (label, label_for_bb);
1658 if (new_label != label)
1659 gimple_transaction_set_label_uninst (txn, new_label);
1662 label = gimple_transaction_label_over (txn);
1663 if (label)
1665 new_label = main_block_label (label, label_for_bb);
1666 if (new_label != label)
1667 gimple_transaction_set_label_over (txn, new_label);
1670 break;
1672 default:
1673 break;
1677 /* Do the same for the exception region tree labels. */
1678 cleanup_dead_labels_eh (label_for_bb);
1680 /* Finally, purge dead labels. All user-defined labels and labels that
1681 can be the target of non-local gotos and labels which have their
1682 address taken are preserved. */
1683 FOR_EACH_BB_FN (bb, cfun)
1685 gimple_stmt_iterator i;
1686 tree label_for_this_bb = label_for_bb[bb->index].label;
1688 if (!label_for_this_bb)
1689 continue;
1691 /* If the main label of the block is unused, we may still remove it. */
1692 if (!label_for_bb[bb->index].used)
1693 label_for_this_bb = NULL;
1695 for (i = gsi_start_bb (bb); !gsi_end_p (i); )
1697 tree label;
1698 glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (i));
1700 if (!label_stmt)
1701 break;
1703 label = gimple_label_label (label_stmt);
1705 if (label == label_for_this_bb
1706 || !DECL_ARTIFICIAL (label)
1707 || DECL_NONLOCAL (label)
1708 || FORCED_LABEL (label))
1709 gsi_next (&i);
1710 else
1712 gcc_checking_assert (EH_LANDING_PAD_NR (label) == 0);
1713 gsi_remove (&i, true);
1718 free (label_for_bb);
1721 /* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
1722 the ones jumping to the same label.
1723 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
1725 bool
1726 group_case_labels_stmt (gswitch *stmt)
1728 int old_size = gimple_switch_num_labels (stmt);
1729 int i, next_index, new_size;
1730 basic_block default_bb = NULL;
1731 hash_set<tree> *removed_labels = NULL;
1733 default_bb = gimple_switch_default_bb (cfun, stmt);
1735 /* Look for possible opportunities to merge cases. */
1736 new_size = i = 1;
1737 while (i < old_size)
1739 tree base_case, base_high;
1740 basic_block base_bb;
1742 base_case = gimple_switch_label (stmt, i);
1744 gcc_assert (base_case);
1745 base_bb = label_to_block (cfun, CASE_LABEL (base_case));
1747 /* Discard cases that have the same destination as the default case or
1748 whose destination blocks have already been removed as unreachable. */
1749 if (base_bb == NULL
1750 || base_bb == default_bb
1751 || (removed_labels
1752 && removed_labels->contains (CASE_LABEL (base_case))))
1754 i++;
1755 continue;
1758 base_high = CASE_HIGH (base_case)
1759 ? CASE_HIGH (base_case)
1760 : CASE_LOW (base_case);
1761 next_index = i + 1;
1763 /* Try to merge case labels. Break out when we reach the end
1764 of the label vector or when we cannot merge the next case
1765 label with the current one. */
1766 while (next_index < old_size)
1768 tree merge_case = gimple_switch_label (stmt, next_index);
1769 basic_block merge_bb = label_to_block (cfun, CASE_LABEL (merge_case));
1770 wide_int bhp1 = wi::to_wide (base_high) + 1;
1772 /* Merge the cases if they jump to the same place,
1773 and their ranges are consecutive. */
1774 if (merge_bb == base_bb
1775 && (removed_labels == NULL
1776 || !removed_labels->contains (CASE_LABEL (merge_case)))
1777 && wi::to_wide (CASE_LOW (merge_case)) == bhp1)
1779 base_high
1780 = (CASE_HIGH (merge_case)
1781 ? CASE_HIGH (merge_case) : CASE_LOW (merge_case));
1782 CASE_HIGH (base_case) = base_high;
1783 next_index++;
1785 else
1786 break;
1789 /* Discard cases that have an unreachable destination block. */
1790 if (EDGE_COUNT (base_bb->succs) == 0
1791 && gimple_seq_unreachable_p (bb_seq (base_bb))
1792 /* Don't optimize this if __builtin_unreachable () is the
1793 implicitly added one by the C++ FE too early, before
1794 -Wreturn-type can be diagnosed. We'll optimize it later
1795 during switchconv pass or any other cfg cleanup. */
1796 && (gimple_in_ssa_p (cfun)
1797 || (LOCATION_LOCUS (gimple_location (last_stmt (base_bb)))
1798 != BUILTINS_LOCATION)))
1800 edge base_edge = find_edge (gimple_bb (stmt), base_bb);
1801 if (base_edge != NULL)
1803 for (gimple_stmt_iterator gsi = gsi_start_bb (base_bb);
1804 !gsi_end_p (gsi); gsi_next (&gsi))
1805 if (glabel *stmt = dyn_cast <glabel *> (gsi_stmt (gsi)))
1807 if (FORCED_LABEL (gimple_label_label (stmt))
1808 || DECL_NONLOCAL (gimple_label_label (stmt)))
1810 /* Forced/non-local labels aren't going to be removed,
1811 but they will be moved to some neighbouring basic
1812 block. If some later case label refers to one of
1813 those labels, we should throw that case away rather
1814 than keeping it around and refering to some random
1815 other basic block without an edge to it. */
1816 if (removed_labels == NULL)
1817 removed_labels = new hash_set<tree>;
1818 removed_labels->add (gimple_label_label (stmt));
1821 else
1822 break;
1823 remove_edge_and_dominated_blocks (base_edge);
1825 i = next_index;
1826 continue;
1829 if (new_size < i)
1830 gimple_switch_set_label (stmt, new_size,
1831 gimple_switch_label (stmt, i));
1832 i = next_index;
1833 new_size++;
1836 gcc_assert (new_size <= old_size);
1838 if (new_size < old_size)
1839 gimple_switch_set_num_labels (stmt, new_size);
1841 delete removed_labels;
1842 return new_size < old_size;
1845 /* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
1846 and scan the sorted vector of cases. Combine the ones jumping to the
1847 same label. */
1849 bool
1850 group_case_labels (void)
1852 basic_block bb;
1853 bool changed = false;
1855 FOR_EACH_BB_FN (bb, cfun)
1857 gimple *stmt = last_stmt (bb);
1858 if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
1859 changed |= group_case_labels_stmt (as_a <gswitch *> (stmt));
1862 return changed;
1865 /* Checks whether we can merge block B into block A. */
1867 static bool
1868 gimple_can_merge_blocks_p (basic_block a, basic_block b)
1870 gimple *stmt;
1872 if (!single_succ_p (a))
1873 return false;
1875 if (single_succ_edge (a)->flags & EDGE_COMPLEX)
1876 return false;
1878 if (single_succ (a) != b)
1879 return false;
1881 if (!single_pred_p (b))
1882 return false;
1884 if (a == ENTRY_BLOCK_PTR_FOR_FN (cfun)
1885 || b == EXIT_BLOCK_PTR_FOR_FN (cfun))
1886 return false;
1888 /* If A ends by a statement causing exceptions or something similar, we
1889 cannot merge the blocks. */
1890 stmt = last_stmt (a);
1891 if (stmt && stmt_ends_bb_p (stmt))
1892 return false;
1894 /* Do not allow a block with only a non-local label to be merged. */
1895 if (stmt)
1896 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
1897 if (DECL_NONLOCAL (gimple_label_label (label_stmt)))
1898 return false;
1900 /* Examine the labels at the beginning of B. */
1901 for (gimple_stmt_iterator gsi = gsi_start_bb (b); !gsi_end_p (gsi);
1902 gsi_next (&gsi))
1904 tree lab;
1905 glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
1906 if (!label_stmt)
1907 break;
1908 lab = gimple_label_label (label_stmt);
1910 /* Do not remove user forced labels or for -O0 any user labels. */
1911 if (!DECL_ARTIFICIAL (lab) && (!optimize || FORCED_LABEL (lab)))
1912 return false;
1915 /* Protect simple loop latches. We only want to avoid merging
1916 the latch with the loop header or with a block in another
1917 loop in this case. */
1918 if (current_loops
1919 && b->loop_father->latch == b
1920 && loops_state_satisfies_p (LOOPS_HAVE_SIMPLE_LATCHES)
1921 && (b->loop_father->header == a
1922 || b->loop_father != a->loop_father))
1923 return false;
1925 /* It must be possible to eliminate all phi nodes in B. If ssa form
1926 is not up-to-date and a name-mapping is registered, we cannot eliminate
1927 any phis. Symbols marked for renaming are never a problem though. */
1928 for (gphi_iterator gsi = gsi_start_phis (b); !gsi_end_p (gsi);
1929 gsi_next (&gsi))
1931 gphi *phi = gsi.phi ();
1932 /* Technically only new names matter. */
1933 if (name_registered_for_update_p (PHI_RESULT (phi)))
1934 return false;
1937 /* When not optimizing, don't merge if we'd lose goto_locus. */
1938 if (!optimize
1939 && single_succ_edge (a)->goto_locus != UNKNOWN_LOCATION)
1941 location_t goto_locus = single_succ_edge (a)->goto_locus;
1942 gimple_stmt_iterator prev, next;
1943 prev = gsi_last_nondebug_bb (a);
1944 next = gsi_after_labels (b);
1945 if (!gsi_end_p (next) && is_gimple_debug (gsi_stmt (next)))
1946 gsi_next_nondebug (&next);
1947 if ((gsi_end_p (prev)
1948 || gimple_location (gsi_stmt (prev)) != goto_locus)
1949 && (gsi_end_p (next)
1950 || gimple_location (gsi_stmt (next)) != goto_locus))
1951 return false;
1954 return true;
1957 /* Replaces all uses of NAME by VAL. */
1959 void
1960 replace_uses_by (tree name, tree val)
1962 imm_use_iterator imm_iter;
1963 use_operand_p use;
1964 gimple *stmt;
1965 edge e;
1967 FOR_EACH_IMM_USE_STMT (stmt, imm_iter, name)
1969 /* Mark the block if we change the last stmt in it. */
1970 if (cfgcleanup_altered_bbs
1971 && stmt_ends_bb_p (stmt))
1972 bitmap_set_bit (cfgcleanup_altered_bbs, gimple_bb (stmt)->index);
1974 FOR_EACH_IMM_USE_ON_STMT (use, imm_iter)
1976 replace_exp (use, val);
1978 if (gimple_code (stmt) == GIMPLE_PHI)
1980 e = gimple_phi_arg_edge (as_a <gphi *> (stmt),
1981 PHI_ARG_INDEX_FROM_USE (use));
1982 if (e->flags & EDGE_ABNORMAL
1983 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val))
1985 /* This can only occur for virtual operands, since
1986 for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
1987 would prevent replacement. */
1988 gcc_checking_assert (virtual_operand_p (name));
1989 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val) = 1;
1994 if (gimple_code (stmt) != GIMPLE_PHI)
1996 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
1997 gimple *orig_stmt = stmt;
1998 size_t i;
2000 /* FIXME. It shouldn't be required to keep TREE_CONSTANT
2001 on ADDR_EXPRs up-to-date on GIMPLE. Propagation will
2002 only change sth from non-invariant to invariant, and only
2003 when propagating constants. */
2004 if (is_gimple_min_invariant (val))
2005 for (i = 0; i < gimple_num_ops (stmt); i++)
2007 tree op = gimple_op (stmt, i);
2008 /* Operands may be empty here. For example, the labels
2009 of a GIMPLE_COND are nulled out following the creation
2010 of the corresponding CFG edges. */
2011 if (op && TREE_CODE (op) == ADDR_EXPR)
2012 recompute_tree_invariant_for_addr_expr (op);
2015 if (fold_stmt (&gsi))
2016 stmt = gsi_stmt (gsi);
2018 if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt))
2019 gimple_purge_dead_eh_edges (gimple_bb (stmt));
2021 update_stmt (stmt);
2025 gcc_checking_assert (has_zero_uses (name));
2027 /* Also update the trees stored in loop structures. */
2028 if (current_loops)
2030 for (auto loop : loops_list (cfun, 0))
2031 substitute_in_loop_info (loop, name, val);
2035 /* Merge block B into block A. */
2037 static void
2038 gimple_merge_blocks (basic_block a, basic_block b)
2040 gimple_stmt_iterator last, gsi;
2041 gphi_iterator psi;
2043 if (dump_file)
2044 fprintf (dump_file, "Merging blocks %d and %d\n", a->index, b->index);
2046 /* Remove all single-valued PHI nodes from block B of the form
2047 V_i = PHI <V_j> by propagating V_j to all the uses of V_i. */
2048 gsi = gsi_last_bb (a);
2049 for (psi = gsi_start_phis (b); !gsi_end_p (psi); )
2051 gimple *phi = gsi_stmt (psi);
2052 tree def = gimple_phi_result (phi), use = gimple_phi_arg_def (phi, 0);
2053 gimple *copy;
2054 bool may_replace_uses = (virtual_operand_p (def)
2055 || may_propagate_copy (def, use));
2057 /* In case we maintain loop closed ssa form, do not propagate arguments
2058 of loop exit phi nodes. */
2059 if (current_loops
2060 && loops_state_satisfies_p (LOOP_CLOSED_SSA)
2061 && !virtual_operand_p (def)
2062 && TREE_CODE (use) == SSA_NAME
2063 && a->loop_father != b->loop_father)
2064 may_replace_uses = false;
2066 if (!may_replace_uses)
2068 gcc_assert (!virtual_operand_p (def));
2070 /* Note that just emitting the copies is fine -- there is no problem
2071 with ordering of phi nodes. This is because A is the single
2072 predecessor of B, therefore results of the phi nodes cannot
2073 appear as arguments of the phi nodes. */
2074 copy = gimple_build_assign (def, use);
2075 gsi_insert_after (&gsi, copy, GSI_NEW_STMT);
2076 remove_phi_node (&psi, false);
2078 else
2080 /* If we deal with a PHI for virtual operands, we can simply
2081 propagate these without fussing with folding or updating
2082 the stmt. */
2083 if (virtual_operand_p (def))
2085 imm_use_iterator iter;
2086 use_operand_p use_p;
2087 gimple *stmt;
2089 FOR_EACH_IMM_USE_STMT (stmt, iter, def)
2090 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
2091 SET_USE (use_p, use);
2093 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
2094 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use) = 1;
2096 else
2097 replace_uses_by (def, use);
2099 remove_phi_node (&psi, true);
2103 /* Ensure that B follows A. */
2104 move_block_after (b, a);
2106 gcc_assert (single_succ_edge (a)->flags & EDGE_FALLTHRU);
2107 gcc_assert (!last_stmt (a) || !stmt_ends_bb_p (last_stmt (a)));
2109 /* Remove labels from B and set gimple_bb to A for other statements. */
2110 for (gsi = gsi_start_bb (b); !gsi_end_p (gsi);)
2112 gimple *stmt = gsi_stmt (gsi);
2113 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
2115 tree label = gimple_label_label (label_stmt);
2116 int lp_nr;
2118 gsi_remove (&gsi, false);
2120 /* Now that we can thread computed gotos, we might have
2121 a situation where we have a forced label in block B
2122 However, the label at the start of block B might still be
2123 used in other ways (think about the runtime checking for
2124 Fortran assigned gotos). So we cannot just delete the
2125 label. Instead we move the label to the start of block A. */
2126 if (FORCED_LABEL (label))
2128 gimple_stmt_iterator dest_gsi = gsi_start_bb (a);
2129 tree first_label = NULL_TREE;
2130 if (!gsi_end_p (dest_gsi))
2131 if (glabel *first_label_stmt
2132 = dyn_cast <glabel *> (gsi_stmt (dest_gsi)))
2133 first_label = gimple_label_label (first_label_stmt);
2134 if (first_label
2135 && (DECL_NONLOCAL (first_label)
2136 || EH_LANDING_PAD_NR (first_label) != 0))
2137 gsi_insert_after (&dest_gsi, stmt, GSI_NEW_STMT);
2138 else
2139 gsi_insert_before (&dest_gsi, stmt, GSI_NEW_STMT);
2141 /* Other user labels keep around in a form of a debug stmt. */
2142 else if (!DECL_ARTIFICIAL (label) && MAY_HAVE_DEBUG_BIND_STMTS)
2144 gimple *dbg = gimple_build_debug_bind (label,
2145 integer_zero_node,
2146 stmt);
2147 gimple_debug_bind_reset_value (dbg);
2148 gsi_insert_before (&gsi, dbg, GSI_SAME_STMT);
2151 lp_nr = EH_LANDING_PAD_NR (label);
2152 if (lp_nr)
2154 eh_landing_pad lp = get_eh_landing_pad_from_number (lp_nr);
2155 lp->post_landing_pad = NULL;
2158 else
2160 gimple_set_bb (stmt, a);
2161 gsi_next (&gsi);
2165 /* When merging two BBs, if their counts are different, the larger count
2166 is selected as the new bb count. This is to handle inconsistent
2167 profiles. */
2168 if (a->loop_father == b->loop_father)
2170 a->count = a->count.merge (b->count);
2173 /* Merge the sequences. */
2174 last = gsi_last_bb (a);
2175 gsi_insert_seq_after (&last, bb_seq (b), GSI_NEW_STMT);
2176 set_bb_seq (b, NULL);
2178 if (cfgcleanup_altered_bbs)
2179 bitmap_set_bit (cfgcleanup_altered_bbs, a->index);
2183 /* Return the one of two successors of BB that is not reachable by a
2184 complex edge, if there is one. Else, return BB. We use
2185 this in optimizations that use post-dominators for their heuristics,
2186 to catch the cases in C++ where function calls are involved. */
2188 basic_block
2189 single_noncomplex_succ (basic_block bb)
2191 edge e0, e1;
2192 if (EDGE_COUNT (bb->succs) != 2)
2193 return bb;
2195 e0 = EDGE_SUCC (bb, 0);
2196 e1 = EDGE_SUCC (bb, 1);
2197 if (e0->flags & EDGE_COMPLEX)
2198 return e1->dest;
2199 if (e1->flags & EDGE_COMPLEX)
2200 return e0->dest;
2202 return bb;
2205 /* T is CALL_EXPR. Set current_function_calls_* flags. */
2207 void
2208 notice_special_calls (gcall *call)
2210 int flags = gimple_call_flags (call);
2212 if (flags & ECF_MAY_BE_ALLOCA)
2213 cfun->calls_alloca = true;
2214 if (flags & ECF_RETURNS_TWICE)
2215 cfun->calls_setjmp = true;
2219 /* Clear flags set by notice_special_calls. Used by dead code removal
2220 to update the flags. */
2222 void
2223 clear_special_calls (void)
2225 cfun->calls_alloca = false;
2226 cfun->calls_setjmp = false;
2229 /* Remove PHI nodes associated with basic block BB and all edges out of BB. */
2231 static void
2232 remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb)
2234 /* Since this block is no longer reachable, we can just delete all
2235 of its PHI nodes. */
2236 remove_phi_nodes (bb);
2238 /* Remove edges to BB's successors. */
2239 while (EDGE_COUNT (bb->succs) > 0)
2240 remove_edge (EDGE_SUCC (bb, 0));
2244 /* Remove statements of basic block BB. */
2246 static void
2247 remove_bb (basic_block bb)
2249 gimple_stmt_iterator i;
2251 if (dump_file)
2253 fprintf (dump_file, "Removing basic block %d\n", bb->index);
2254 if (dump_flags & TDF_DETAILS)
2256 dump_bb (dump_file, bb, 0, TDF_BLOCKS);
2257 fprintf (dump_file, "\n");
2261 if (current_loops)
2263 class loop *loop = bb->loop_father;
2265 /* If a loop gets removed, clean up the information associated
2266 with it. */
2267 if (loop->latch == bb
2268 || loop->header == bb)
2269 free_numbers_of_iterations_estimates (loop);
2272 /* Remove all the instructions in the block. */
2273 if (bb_seq (bb) != NULL)
2275 /* Walk backwards so as to get a chance to substitute all
2276 released DEFs into debug stmts. See
2277 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
2278 details. */
2279 for (i = gsi_last_bb (bb); !gsi_end_p (i);)
2281 gimple *stmt = gsi_stmt (i);
2282 glabel *label_stmt = dyn_cast <glabel *> (stmt);
2283 if (label_stmt
2284 && (FORCED_LABEL (gimple_label_label (label_stmt))
2285 || DECL_NONLOCAL (gimple_label_label (label_stmt))))
2287 basic_block new_bb;
2288 gimple_stmt_iterator new_gsi;
2290 /* A non-reachable non-local label may still be referenced.
2291 But it no longer needs to carry the extra semantics of
2292 non-locality. */
2293 if (DECL_NONLOCAL (gimple_label_label (label_stmt)))
2295 DECL_NONLOCAL (gimple_label_label (label_stmt)) = 0;
2296 FORCED_LABEL (gimple_label_label (label_stmt)) = 1;
2299 new_bb = bb->prev_bb;
2300 /* Don't move any labels into ENTRY block. */
2301 if (new_bb == ENTRY_BLOCK_PTR_FOR_FN (cfun))
2303 new_bb = single_succ (new_bb);
2304 gcc_assert (new_bb != bb);
2306 if ((unsigned) bb->index < bb_to_omp_idx.length ()
2307 && ((unsigned) new_bb->index >= bb_to_omp_idx.length ()
2308 || (bb_to_omp_idx[bb->index]
2309 != bb_to_omp_idx[new_bb->index])))
2311 /* During cfg pass make sure to put orphaned labels
2312 into the right OMP region. */
2313 unsigned int i;
2314 int idx;
2315 new_bb = NULL;
2316 FOR_EACH_VEC_ELT (bb_to_omp_idx, i, idx)
2317 if (i >= NUM_FIXED_BLOCKS
2318 && idx == bb_to_omp_idx[bb->index]
2319 && i != (unsigned) bb->index)
2321 new_bb = BASIC_BLOCK_FOR_FN (cfun, i);
2322 break;
2324 if (new_bb == NULL)
2326 new_bb = single_succ (ENTRY_BLOCK_PTR_FOR_FN (cfun));
2327 gcc_assert (new_bb != bb);
2330 new_gsi = gsi_after_labels (new_bb);
2331 gsi_remove (&i, false);
2332 gsi_insert_before (&new_gsi, stmt, GSI_NEW_STMT);
2334 else
2336 /* Release SSA definitions. */
2337 release_defs (stmt);
2338 gsi_remove (&i, true);
2341 if (gsi_end_p (i))
2342 i = gsi_last_bb (bb);
2343 else
2344 gsi_prev (&i);
2348 if ((unsigned) bb->index < bb_to_omp_idx.length ())
2349 bb_to_omp_idx[bb->index] = -1;
2350 remove_phi_nodes_and_edges_for_unreachable_block (bb);
2351 bb->il.gimple.seq = NULL;
2352 bb->il.gimple.phi_nodes = NULL;
2356 /* Given a basic block BB and a value VAL for use in the final statement
2357 of the block (if a GIMPLE_COND, GIMPLE_SWITCH, or computed goto), return
2358 the edge that will be taken out of the block.
2359 If VAL is NULL_TREE, then the current value of the final statement's
2360 predicate or index is used.
2361 If the value does not match a unique edge, NULL is returned. */
2363 edge
2364 find_taken_edge (basic_block bb, tree val)
2366 gimple *stmt;
2368 stmt = last_stmt (bb);
2370 /* Handle ENTRY and EXIT. */
2371 if (!stmt)
2372 return NULL;
2374 if (gimple_code (stmt) == GIMPLE_COND)
2375 return find_taken_edge_cond_expr (as_a <gcond *> (stmt), val);
2377 if (gimple_code (stmt) == GIMPLE_SWITCH)
2378 return find_taken_edge_switch_expr (as_a <gswitch *> (stmt), val);
2380 if (computed_goto_p (stmt))
2382 /* Only optimize if the argument is a label, if the argument is
2383 not a label then we cannot construct a proper CFG.
2385 It may be the case that we only need to allow the LABEL_REF to
2386 appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
2387 appear inside a LABEL_EXPR just to be safe. */
2388 if (val
2389 && (TREE_CODE (val) == ADDR_EXPR || TREE_CODE (val) == LABEL_EXPR)
2390 && TREE_CODE (TREE_OPERAND (val, 0)) == LABEL_DECL)
2391 return find_taken_edge_computed_goto (bb, TREE_OPERAND (val, 0));
2394 /* Otherwise we only know the taken successor edge if it's unique. */
2395 return single_succ_p (bb) ? single_succ_edge (bb) : NULL;
2398 /* Given a constant value VAL and the entry block BB to a GOTO_EXPR
2399 statement, determine which of the outgoing edges will be taken out of the
2400 block. Return NULL if either edge may be taken. */
2402 static edge
2403 find_taken_edge_computed_goto (basic_block bb, tree val)
2405 basic_block dest;
2406 edge e = NULL;
2408 dest = label_to_block (cfun, val);
2409 if (dest)
2410 e = find_edge (bb, dest);
2412 /* It's possible for find_edge to return NULL here on invalid code
2413 that abuses the labels-as-values extension (e.g. code that attempts to
2414 jump *between* functions via stored labels-as-values; PR 84136).
2415 If so, then we simply return that NULL for the edge.
2416 We don't currently have a way of detecting such invalid code, so we
2417 can't assert that it was the case when a NULL edge occurs here. */
2419 return e;
2422 /* Given COND_STMT and a constant value VAL for use as the predicate,
2423 determine which of the two edges will be taken out of
2424 the statement's block. Return NULL if either edge may be taken.
2425 If VAL is NULL_TREE, then the current value of COND_STMT's predicate
2426 is used. */
2428 static edge
2429 find_taken_edge_cond_expr (const gcond *cond_stmt, tree val)
2431 edge true_edge, false_edge;
2433 if (val == NULL_TREE)
2435 /* Use the current value of the predicate. */
2436 if (gimple_cond_true_p (cond_stmt))
2437 val = integer_one_node;
2438 else if (gimple_cond_false_p (cond_stmt))
2439 val = integer_zero_node;
2440 else
2441 return NULL;
2443 else if (TREE_CODE (val) != INTEGER_CST)
2444 return NULL;
2446 extract_true_false_edges_from_block (gimple_bb (cond_stmt),
2447 &true_edge, &false_edge);
2449 return (integer_zerop (val) ? false_edge : true_edge);
2452 /* Given SWITCH_STMT and an INTEGER_CST VAL for use as the index, determine
2453 which edge will be taken out of the statement's block. Return NULL if any
2454 edge may be taken.
2455 If VAL is NULL_TREE, then the current value of SWITCH_STMT's index
2456 is used. */
2458 edge
2459 find_taken_edge_switch_expr (const gswitch *switch_stmt, tree val)
2461 basic_block dest_bb;
2462 edge e;
2463 tree taken_case;
2465 if (gimple_switch_num_labels (switch_stmt) == 1)
2466 taken_case = gimple_switch_default_label (switch_stmt);
2467 else
2469 if (val == NULL_TREE)
2470 val = gimple_switch_index (switch_stmt);
2471 if (TREE_CODE (val) != INTEGER_CST)
2472 return NULL;
2473 else
2474 taken_case = find_case_label_for_value (switch_stmt, val);
2476 dest_bb = label_to_block (cfun, CASE_LABEL (taken_case));
2478 e = find_edge (gimple_bb (switch_stmt), dest_bb);
2479 gcc_assert (e);
2480 return e;
2484 /* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
2485 We can make optimal use here of the fact that the case labels are
2486 sorted: We can do a binary search for a case matching VAL. */
2488 tree
2489 find_case_label_for_value (const gswitch *switch_stmt, tree val)
2491 size_t low, high, n = gimple_switch_num_labels (switch_stmt);
2492 tree default_case = gimple_switch_default_label (switch_stmt);
2494 for (low = 0, high = n; high - low > 1; )
2496 size_t i = (high + low) / 2;
2497 tree t = gimple_switch_label (switch_stmt, i);
2498 int cmp;
2500 /* Cache the result of comparing CASE_LOW and val. */
2501 cmp = tree_int_cst_compare (CASE_LOW (t), val);
2503 if (cmp > 0)
2504 high = i;
2505 else
2506 low = i;
2508 if (CASE_HIGH (t) == NULL)
2510 /* A singe-valued case label. */
2511 if (cmp == 0)
2512 return t;
2514 else
2516 /* A case range. We can only handle integer ranges. */
2517 if (cmp <= 0 && tree_int_cst_compare (CASE_HIGH (t), val) >= 0)
2518 return t;
2522 return default_case;
2526 /* Dump a basic block on stderr. */
2528 void
2529 gimple_debug_bb (basic_block bb)
2531 dump_bb (stderr, bb, 0, TDF_VOPS|TDF_MEMSYMS|TDF_BLOCKS);
2535 /* Dump basic block with index N on stderr. */
2537 basic_block
2538 gimple_debug_bb_n (int n)
2540 gimple_debug_bb (BASIC_BLOCK_FOR_FN (cfun, n));
2541 return BASIC_BLOCK_FOR_FN (cfun, n);
2545 /* Dump the CFG on stderr.
2547 FLAGS are the same used by the tree dumping functions
2548 (see TDF_* in dumpfile.h). */
2550 void
2551 gimple_debug_cfg (dump_flags_t flags)
2553 gimple_dump_cfg (stderr, flags);
2557 /* Dump the program showing basic block boundaries on the given FILE.
2559 FLAGS are the same used by the tree dumping functions (see TDF_* in
2560 tree.h). */
2562 void
2563 gimple_dump_cfg (FILE *file, dump_flags_t flags)
2565 if (flags & TDF_DETAILS)
2567 dump_function_header (file, current_function_decl, flags);
2568 fprintf (file, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
2569 n_basic_blocks_for_fn (cfun), n_edges_for_fn (cfun),
2570 last_basic_block_for_fn (cfun));
2572 brief_dump_cfg (file, flags);
2573 fprintf (file, "\n");
2576 if (flags & TDF_STATS)
2577 dump_cfg_stats (file);
2579 dump_function_to_file (current_function_decl, file, flags | TDF_BLOCKS);
2583 /* Dump CFG statistics on FILE. */
2585 void
2586 dump_cfg_stats (FILE *file)
2588 static long max_num_merged_labels = 0;
2589 unsigned long size, total = 0;
2590 long num_edges;
2591 basic_block bb;
2592 const char * const fmt_str = "%-30s%-13s%12s\n";
2593 const char * const fmt_str_1 = "%-30s%13d" PRsa (11) "\n";
2594 const char * const fmt_str_2 = "%-30s%13ld" PRsa (11) "\n";
2595 const char * const fmt_str_3 = "%-43s" PRsa (11) "\n";
2596 const char *funcname = current_function_name ();
2598 fprintf (file, "\nCFG Statistics for %s\n\n", funcname);
2600 fprintf (file, "---------------------------------------------------------\n");
2601 fprintf (file, fmt_str, "", " Number of ", "Memory");
2602 fprintf (file, fmt_str, "", " instances ", "used ");
2603 fprintf (file, "---------------------------------------------------------\n");
2605 size = n_basic_blocks_for_fn (cfun) * sizeof (struct basic_block_def);
2606 total += size;
2607 fprintf (file, fmt_str_1, "Basic blocks", n_basic_blocks_for_fn (cfun),
2608 SIZE_AMOUNT (size));
2610 num_edges = 0;
2611 FOR_EACH_BB_FN (bb, cfun)
2612 num_edges += EDGE_COUNT (bb->succs);
2613 size = num_edges * sizeof (class edge_def);
2614 total += size;
2615 fprintf (file, fmt_str_2, "Edges", num_edges, SIZE_AMOUNT (size));
2617 fprintf (file, "---------------------------------------------------------\n");
2618 fprintf (file, fmt_str_3, "Total memory used by CFG data",
2619 SIZE_AMOUNT (total));
2620 fprintf (file, "---------------------------------------------------------\n");
2621 fprintf (file, "\n");
2623 if (cfg_stats.num_merged_labels > max_num_merged_labels)
2624 max_num_merged_labels = cfg_stats.num_merged_labels;
2626 fprintf (file, "Coalesced label blocks: %ld (Max so far: %ld)\n",
2627 cfg_stats.num_merged_labels, max_num_merged_labels);
2629 fprintf (file, "\n");
2633 /* Dump CFG statistics on stderr. Keep extern so that it's always
2634 linked in the final executable. */
2636 DEBUG_FUNCTION void
2637 debug_cfg_stats (void)
2639 dump_cfg_stats (stderr);
2642 /*---------------------------------------------------------------------------
2643 Miscellaneous helpers
2644 ---------------------------------------------------------------------------*/
2646 /* Return true if T, a GIMPLE_CALL, can make an abnormal transfer of control
2647 flow. Transfers of control flow associated with EH are excluded. */
2649 static bool
2650 call_can_make_abnormal_goto (gimple *t)
2652 /* If the function has no non-local labels, then a call cannot make an
2653 abnormal transfer of control. */
2654 if (!cfun->has_nonlocal_label
2655 && !cfun->calls_setjmp)
2656 return false;
2658 /* Likewise if the call has no side effects. */
2659 if (!gimple_has_side_effects (t))
2660 return false;
2662 /* Likewise if the called function is leaf. */
2663 if (gimple_call_flags (t) & ECF_LEAF)
2664 return false;
2666 return true;
2670 /* Return true if T can make an abnormal transfer of control flow.
2671 Transfers of control flow associated with EH are excluded. */
2673 bool
2674 stmt_can_make_abnormal_goto (gimple *t)
2676 if (computed_goto_p (t))
2677 return true;
2678 if (is_gimple_call (t))
2679 return call_can_make_abnormal_goto (t);
2680 return false;
2684 /* Return true if T represents a stmt that always transfers control. */
2686 bool
2687 is_ctrl_stmt (gimple *t)
2689 switch (gimple_code (t))
2691 case GIMPLE_COND:
2692 case GIMPLE_SWITCH:
2693 case GIMPLE_GOTO:
2694 case GIMPLE_RETURN:
2695 case GIMPLE_RESX:
2696 return true;
2697 default:
2698 return false;
2703 /* Return true if T is a statement that may alter the flow of control
2704 (e.g., a call to a non-returning function). */
2706 bool
2707 is_ctrl_altering_stmt (gimple *t)
2709 gcc_assert (t);
2711 switch (gimple_code (t))
2713 case GIMPLE_CALL:
2714 /* Per stmt call flag indicates whether the call could alter
2715 controlflow. */
2716 if (gimple_call_ctrl_altering_p (t))
2717 return true;
2718 break;
2720 case GIMPLE_EH_DISPATCH:
2721 /* EH_DISPATCH branches to the individual catch handlers at
2722 this level of a try or allowed-exceptions region. It can
2723 fallthru to the next statement as well. */
2724 return true;
2726 case GIMPLE_ASM:
2727 if (gimple_asm_nlabels (as_a <gasm *> (t)) > 0)
2728 return true;
2729 break;
2731 CASE_GIMPLE_OMP:
2732 /* OpenMP directives alter control flow. */
2733 return true;
2735 case GIMPLE_TRANSACTION:
2736 /* A transaction start alters control flow. */
2737 return true;
2739 default:
2740 break;
2743 /* If a statement can throw, it alters control flow. */
2744 return stmt_can_throw_internal (cfun, t);
2748 /* Return true if T is a simple local goto. */
2750 bool
2751 simple_goto_p (gimple *t)
2753 return (gimple_code (t) == GIMPLE_GOTO
2754 && TREE_CODE (gimple_goto_dest (t)) == LABEL_DECL);
2758 /* Return true if STMT should start a new basic block. PREV_STMT is
2759 the statement preceding STMT. It is used when STMT is a label or a
2760 case label. Labels should only start a new basic block if their
2761 previous statement wasn't a label. Otherwise, sequence of labels
2762 would generate unnecessary basic blocks that only contain a single
2763 label. */
2765 static inline bool
2766 stmt_starts_bb_p (gimple *stmt, gimple *prev_stmt)
2768 if (stmt == NULL)
2769 return false;
2771 /* PREV_STMT is only set to a debug stmt if the debug stmt is before
2772 any nondebug stmts in the block. We don't want to start another
2773 block in this case: the debug stmt will already have started the
2774 one STMT would start if we weren't outputting debug stmts. */
2775 if (prev_stmt && is_gimple_debug (prev_stmt))
2776 return false;
2778 /* Labels start a new basic block only if the preceding statement
2779 wasn't a label of the same type. This prevents the creation of
2780 consecutive blocks that have nothing but a single label. */
2781 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
2783 /* Nonlocal and computed GOTO targets always start a new block. */
2784 if (DECL_NONLOCAL (gimple_label_label (label_stmt))
2785 || FORCED_LABEL (gimple_label_label (label_stmt)))
2786 return true;
2788 if (glabel *plabel = safe_dyn_cast <glabel *> (prev_stmt))
2790 if (DECL_NONLOCAL (gimple_label_label (plabel))
2791 || !DECL_ARTIFICIAL (gimple_label_label (plabel)))
2792 return true;
2794 cfg_stats.num_merged_labels++;
2795 return false;
2797 else
2798 return true;
2800 else if (gimple_code (stmt) == GIMPLE_CALL)
2802 if (gimple_call_flags (stmt) & ECF_RETURNS_TWICE)
2803 /* setjmp acts similar to a nonlocal GOTO target and thus should
2804 start a new block. */
2805 return true;
2806 if (gimple_call_internal_p (stmt, IFN_PHI)
2807 && prev_stmt
2808 && gimple_code (prev_stmt) != GIMPLE_LABEL
2809 && (gimple_code (prev_stmt) != GIMPLE_CALL
2810 || ! gimple_call_internal_p (prev_stmt, IFN_PHI)))
2811 /* PHI nodes start a new block unless preceeded by a label
2812 or another PHI. */
2813 return true;
2816 return false;
2820 /* Return true if T should end a basic block. */
2822 bool
2823 stmt_ends_bb_p (gimple *t)
2825 return is_ctrl_stmt (t) || is_ctrl_altering_stmt (t);
2828 /* Remove block annotations and other data structures. */
2830 void
2831 delete_tree_cfg_annotations (struct function *fn)
2833 vec_free (label_to_block_map_for_fn (fn));
2836 /* Return the virtual phi in BB. */
2838 gphi *
2839 get_virtual_phi (basic_block bb)
2841 for (gphi_iterator gsi = gsi_start_phis (bb);
2842 !gsi_end_p (gsi);
2843 gsi_next (&gsi))
2845 gphi *phi = gsi.phi ();
2847 if (virtual_operand_p (PHI_RESULT (phi)))
2848 return phi;
2851 return NULL;
2854 /* Return the first statement in basic block BB. */
2856 gimple *
2857 first_stmt (basic_block bb)
2859 gimple_stmt_iterator i = gsi_start_bb (bb);
2860 gimple *stmt = NULL;
2862 while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
2864 gsi_next (&i);
2865 stmt = NULL;
2867 return stmt;
2870 /* Return the first non-label statement in basic block BB. */
2872 static gimple *
2873 first_non_label_stmt (basic_block bb)
2875 gimple_stmt_iterator i = gsi_start_bb (bb);
2876 while (!gsi_end_p (i) && gimple_code (gsi_stmt (i)) == GIMPLE_LABEL)
2877 gsi_next (&i);
2878 return !gsi_end_p (i) ? gsi_stmt (i) : NULL;
2881 /* Return the last statement in basic block BB. */
2883 gimple *
2884 last_stmt (basic_block bb)
2886 gimple_stmt_iterator i = gsi_last_bb (bb);
2887 gimple *stmt = NULL;
2889 while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
2891 gsi_prev (&i);
2892 stmt = NULL;
2894 return stmt;
2897 /* Return the last statement of an otherwise empty block. Return NULL
2898 if the block is totally empty, or if it contains more than one
2899 statement. */
2901 gimple *
2902 last_and_only_stmt (basic_block bb)
2904 gimple_stmt_iterator i = gsi_last_nondebug_bb (bb);
2905 gimple *last, *prev;
2907 if (gsi_end_p (i))
2908 return NULL;
2910 last = gsi_stmt (i);
2911 gsi_prev_nondebug (&i);
2912 if (gsi_end_p (i))
2913 return last;
2915 /* Empty statements should no longer appear in the instruction stream.
2916 Everything that might have appeared before should be deleted by
2917 remove_useless_stmts, and the optimizers should just gsi_remove
2918 instead of smashing with build_empty_stmt.
2920 Thus the only thing that should appear here in a block containing
2921 one executable statement is a label. */
2922 prev = gsi_stmt (i);
2923 if (gimple_code (prev) == GIMPLE_LABEL)
2924 return last;
2925 else
2926 return NULL;
2929 /* Returns the basic block after which the new basic block created
2930 by splitting edge EDGE_IN should be placed. Tries to keep the new block
2931 near its "logical" location. This is of most help to humans looking
2932 at debugging dumps. */
2934 basic_block
2935 split_edge_bb_loc (edge edge_in)
2937 basic_block dest = edge_in->dest;
2938 basic_block dest_prev = dest->prev_bb;
2940 if (dest_prev)
2942 edge e = find_edge (dest_prev, dest);
2943 if (e && !(e->flags & EDGE_COMPLEX))
2944 return edge_in->src;
2946 return dest_prev;
2949 /* Split a (typically critical) edge EDGE_IN. Return the new block.
2950 Abort on abnormal edges. */
2952 static basic_block
2953 gimple_split_edge (edge edge_in)
2955 basic_block new_bb, after_bb, dest;
2956 edge new_edge, e;
2958 /* Abnormal edges cannot be split. */
2959 gcc_assert (!(edge_in->flags & EDGE_ABNORMAL));
2961 dest = edge_in->dest;
2963 after_bb = split_edge_bb_loc (edge_in);
2965 new_bb = create_empty_bb (after_bb);
2966 new_bb->count = edge_in->count ();
2968 /* We want to avoid re-allocating PHIs when we first
2969 add the fallthru edge from new_bb to dest but we also
2970 want to avoid changing PHI argument order when
2971 first redirecting edge_in away from dest. The former
2972 avoids changing PHI argument order by adding them
2973 last and then the redirection swapping it back into
2974 place by means of unordered remove.
2975 So hack around things by temporarily removing all PHIs
2976 from the destination during the edge redirection and then
2977 making sure the edges stay in order. */
2978 gimple_seq saved_phis = phi_nodes (dest);
2979 unsigned old_dest_idx = edge_in->dest_idx;
2980 set_phi_nodes (dest, NULL);
2981 new_edge = make_single_succ_edge (new_bb, dest, EDGE_FALLTHRU);
2982 e = redirect_edge_and_branch (edge_in, new_bb);
2983 gcc_assert (e == edge_in && new_edge->dest_idx == old_dest_idx);
2984 /* set_phi_nodes sets the BB of the PHI nodes, so do it manually here. */
2985 dest->il.gimple.phi_nodes = saved_phis;
2987 return new_bb;
2991 /* Verify properties of the address expression T whose base should be
2992 TREE_ADDRESSABLE if VERIFY_ADDRESSABLE is true. */
2994 static bool
2995 verify_address (tree t, bool verify_addressable)
2997 bool old_constant;
2998 bool old_side_effects;
2999 bool new_constant;
3000 bool new_side_effects;
3002 old_constant = TREE_CONSTANT (t);
3003 old_side_effects = TREE_SIDE_EFFECTS (t);
3005 recompute_tree_invariant_for_addr_expr (t);
3006 new_side_effects = TREE_SIDE_EFFECTS (t);
3007 new_constant = TREE_CONSTANT (t);
3009 if (old_constant != new_constant)
3011 error ("constant not recomputed when %<ADDR_EXPR%> changed");
3012 return true;
3014 if (old_side_effects != new_side_effects)
3016 error ("side effects not recomputed when %<ADDR_EXPR%> changed");
3017 return true;
3020 tree base = TREE_OPERAND (t, 0);
3021 while (handled_component_p (base))
3022 base = TREE_OPERAND (base, 0);
3024 if (!(VAR_P (base)
3025 || TREE_CODE (base) == PARM_DECL
3026 || TREE_CODE (base) == RESULT_DECL))
3027 return false;
3029 if (verify_addressable && !TREE_ADDRESSABLE (base))
3031 error ("address taken but %<TREE_ADDRESSABLE%> bit not set");
3032 return true;
3035 return false;
3039 /* Verify if EXPR is a valid GIMPLE reference expression. If
3040 REQUIRE_LVALUE is true verifies it is an lvalue. Returns true
3041 if there is an error, otherwise false. */
3043 static bool
3044 verify_types_in_gimple_reference (tree expr, bool require_lvalue)
3046 const char *code_name = get_tree_code_name (TREE_CODE (expr));
3048 if (TREE_CODE (expr) == REALPART_EXPR
3049 || TREE_CODE (expr) == IMAGPART_EXPR
3050 || TREE_CODE (expr) == BIT_FIELD_REF)
3052 tree op = TREE_OPERAND (expr, 0);
3053 if (!is_gimple_reg_type (TREE_TYPE (expr)))
3055 error ("non-scalar %qs", code_name);
3056 return true;
3059 if (TREE_CODE (expr) == BIT_FIELD_REF)
3061 tree t1 = TREE_OPERAND (expr, 1);
3062 tree t2 = TREE_OPERAND (expr, 2);
3063 poly_uint64 size, bitpos;
3064 if (!poly_int_tree_p (t1, &size)
3065 || !poly_int_tree_p (t2, &bitpos)
3066 || !types_compatible_p (bitsizetype, TREE_TYPE (t1))
3067 || !types_compatible_p (bitsizetype, TREE_TYPE (t2)))
3069 error ("invalid position or size operand to %qs", code_name);
3070 return true;
3072 if (INTEGRAL_TYPE_P (TREE_TYPE (expr))
3073 && maybe_ne (TYPE_PRECISION (TREE_TYPE (expr)), size))
3075 error ("integral result type precision does not match "
3076 "field size of %qs", code_name);
3077 return true;
3079 else if (!INTEGRAL_TYPE_P (TREE_TYPE (expr))
3080 && TYPE_MODE (TREE_TYPE (expr)) != BLKmode
3081 && maybe_ne (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr))),
3082 size))
3084 error ("mode size of non-integral result does not "
3085 "match field size of %qs",
3086 code_name);
3087 return true;
3089 if (INTEGRAL_TYPE_P (TREE_TYPE (op))
3090 && !type_has_mode_precision_p (TREE_TYPE (op)))
3092 error ("%qs of non-mode-precision operand", code_name);
3093 return true;
3095 if (!AGGREGATE_TYPE_P (TREE_TYPE (op))
3096 && maybe_gt (size + bitpos,
3097 tree_to_poly_uint64 (TYPE_SIZE (TREE_TYPE (op)))))
3099 error ("position plus size exceeds size of referenced object in "
3100 "%qs", code_name);
3101 return true;
3105 if ((TREE_CODE (expr) == REALPART_EXPR
3106 || TREE_CODE (expr) == IMAGPART_EXPR)
3107 && !useless_type_conversion_p (TREE_TYPE (expr),
3108 TREE_TYPE (TREE_TYPE (op))))
3110 error ("type mismatch in %qs reference", code_name);
3111 debug_generic_stmt (TREE_TYPE (expr));
3112 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
3113 return true;
3115 expr = op;
3118 while (handled_component_p (expr))
3120 code_name = get_tree_code_name (TREE_CODE (expr));
3122 if (TREE_CODE (expr) == REALPART_EXPR
3123 || TREE_CODE (expr) == IMAGPART_EXPR
3124 || TREE_CODE (expr) == BIT_FIELD_REF)
3126 error ("non-top-level %qs", code_name);
3127 return true;
3130 tree op = TREE_OPERAND (expr, 0);
3132 if (TREE_CODE (expr) == ARRAY_REF
3133 || TREE_CODE (expr) == ARRAY_RANGE_REF)
3135 if (!is_gimple_val (TREE_OPERAND (expr, 1))
3136 || (TREE_OPERAND (expr, 2)
3137 && !is_gimple_val (TREE_OPERAND (expr, 2)))
3138 || (TREE_OPERAND (expr, 3)
3139 && !is_gimple_val (TREE_OPERAND (expr, 3))))
3141 error ("invalid operands to %qs", code_name);
3142 debug_generic_stmt (expr);
3143 return true;
3147 /* Verify if the reference array element types are compatible. */
3148 if (TREE_CODE (expr) == ARRAY_REF
3149 && !useless_type_conversion_p (TREE_TYPE (expr),
3150 TREE_TYPE (TREE_TYPE (op))))
3152 error ("type mismatch in %qs", code_name);
3153 debug_generic_stmt (TREE_TYPE (expr));
3154 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
3155 return true;
3157 if (TREE_CODE (expr) == ARRAY_RANGE_REF
3158 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr)),
3159 TREE_TYPE (TREE_TYPE (op))))
3161 error ("type mismatch in %qs", code_name);
3162 debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr)));
3163 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
3164 return true;
3167 if (TREE_CODE (expr) == COMPONENT_REF)
3169 if (TREE_OPERAND (expr, 2)
3170 && !is_gimple_val (TREE_OPERAND (expr, 2)))
3172 error ("invalid %qs offset operator", code_name);
3173 return true;
3175 if (!useless_type_conversion_p (TREE_TYPE (expr),
3176 TREE_TYPE (TREE_OPERAND (expr, 1))))
3178 error ("type mismatch in %qs", code_name);
3179 debug_generic_stmt (TREE_TYPE (expr));
3180 debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr, 1)));
3181 return true;
3185 if (TREE_CODE (expr) == VIEW_CONVERT_EXPR)
3187 /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
3188 that their operand is not an SSA name or an invariant when
3189 requiring an lvalue (this usually means there is a SRA or IPA-SRA
3190 bug). Otherwise there is nothing to verify, gross mismatches at
3191 most invoke undefined behavior. */
3192 if (require_lvalue
3193 && (TREE_CODE (op) == SSA_NAME
3194 || is_gimple_min_invariant (op)))
3196 error ("conversion of %qs on the left hand side of %qs",
3197 get_tree_code_name (TREE_CODE (op)), code_name);
3198 debug_generic_stmt (expr);
3199 return true;
3201 else if (TREE_CODE (op) == SSA_NAME
3202 && TYPE_SIZE (TREE_TYPE (expr)) != TYPE_SIZE (TREE_TYPE (op)))
3204 error ("conversion of register to a different size in %qs",
3205 code_name);
3206 debug_generic_stmt (expr);
3207 return true;
3209 else if (!handled_component_p (op))
3210 return false;
3213 expr = op;
3216 code_name = get_tree_code_name (TREE_CODE (expr));
3218 if (TREE_CODE (expr) == MEM_REF)
3220 if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr, 0))
3221 || (TREE_CODE (TREE_OPERAND (expr, 0)) == ADDR_EXPR
3222 && verify_address (TREE_OPERAND (expr, 0), false)))
3224 error ("invalid address operand in %qs", code_name);
3225 debug_generic_stmt (expr);
3226 return true;
3228 if (!poly_int_tree_p (TREE_OPERAND (expr, 1))
3229 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 1))))
3231 error ("invalid offset operand in %qs", code_name);
3232 debug_generic_stmt (expr);
3233 return true;
3235 if (MR_DEPENDENCE_CLIQUE (expr) != 0
3236 && MR_DEPENDENCE_CLIQUE (expr) > cfun->last_clique)
3238 error ("invalid clique in %qs", code_name);
3239 debug_generic_stmt (expr);
3240 return true;
3243 else if (TREE_CODE (expr) == TARGET_MEM_REF)
3245 if (!TMR_BASE (expr)
3246 || !is_gimple_mem_ref_addr (TMR_BASE (expr))
3247 || (TREE_CODE (TMR_BASE (expr)) == ADDR_EXPR
3248 && verify_address (TMR_BASE (expr), false)))
3250 error ("invalid address operand in %qs", code_name);
3251 return true;
3253 if (!TMR_OFFSET (expr)
3254 || !poly_int_tree_p (TMR_OFFSET (expr))
3255 || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr))))
3257 error ("invalid offset operand in %qs", code_name);
3258 debug_generic_stmt (expr);
3259 return true;
3261 if (MR_DEPENDENCE_CLIQUE (expr) != 0
3262 && MR_DEPENDENCE_CLIQUE (expr) > cfun->last_clique)
3264 error ("invalid clique in %qs", code_name);
3265 debug_generic_stmt (expr);
3266 return true;
3269 else if (TREE_CODE (expr) == INDIRECT_REF)
3271 error ("%qs in gimple IL", code_name);
3272 debug_generic_stmt (expr);
3273 return true;
3276 if (!require_lvalue
3277 && (TREE_CODE (expr) == SSA_NAME || is_gimple_min_invariant (expr)))
3278 return false;
3280 if (TREE_CODE (expr) != SSA_NAME && is_gimple_id (expr))
3281 return false;
3283 if (TREE_CODE (expr) != TARGET_MEM_REF
3284 && TREE_CODE (expr) != MEM_REF)
3286 error ("invalid expression for min lvalue");
3287 return true;
3290 return false;
3293 /* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
3294 list of pointer-to types that is trivially convertible to DEST. */
3296 static bool
3297 one_pointer_to_useless_type_conversion_p (tree dest, tree src_obj)
3299 tree src;
3301 if (!TYPE_POINTER_TO (src_obj))
3302 return true;
3304 for (src = TYPE_POINTER_TO (src_obj); src; src = TYPE_NEXT_PTR_TO (src))
3305 if (useless_type_conversion_p (dest, src))
3306 return true;
3308 return false;
3311 /* Return true if TYPE1 is a fixed-point type and if conversions to and
3312 from TYPE2 can be handled by FIXED_CONVERT_EXPR. */
3314 static bool
3315 valid_fixed_convert_types_p (tree type1, tree type2)
3317 return (FIXED_POINT_TYPE_P (type1)
3318 && (INTEGRAL_TYPE_P (type2)
3319 || SCALAR_FLOAT_TYPE_P (type2)
3320 || FIXED_POINT_TYPE_P (type2)));
3323 /* Verify the contents of a GIMPLE_CALL STMT. Returns true when there
3324 is a problem, otherwise false. */
3326 static bool
3327 verify_gimple_call (gcall *stmt)
3329 tree fn = gimple_call_fn (stmt);
3330 tree fntype, fndecl;
3331 unsigned i;
3333 if (gimple_call_internal_p (stmt))
3335 if (fn)
3337 error ("gimple call has two targets");
3338 debug_generic_stmt (fn);
3339 return true;
3342 else
3344 if (!fn)
3346 error ("gimple call has no target");
3347 return true;
3351 if (fn && !is_gimple_call_addr (fn))
3353 error ("invalid function in gimple call");
3354 debug_generic_stmt (fn);
3355 return true;
3358 if (fn
3359 && (!POINTER_TYPE_P (TREE_TYPE (fn))
3360 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn))) != FUNCTION_TYPE
3361 && TREE_CODE (TREE_TYPE (TREE_TYPE (fn))) != METHOD_TYPE)))
3363 error ("non-function in gimple call");
3364 return true;
3367 fndecl = gimple_call_fndecl (stmt);
3368 if (fndecl
3369 && TREE_CODE (fndecl) == FUNCTION_DECL
3370 && DECL_LOOPING_CONST_OR_PURE_P (fndecl)
3371 && !DECL_PURE_P (fndecl)
3372 && !TREE_READONLY (fndecl))
3374 error ("invalid pure const state for function");
3375 return true;
3378 tree lhs = gimple_call_lhs (stmt);
3379 if (lhs
3380 && (!is_gimple_reg (lhs)
3381 && (!is_gimple_lvalue (lhs)
3382 || verify_types_in_gimple_reference
3383 (TREE_CODE (lhs) == WITH_SIZE_EXPR
3384 ? TREE_OPERAND (lhs, 0) : lhs, true))))
3386 error ("invalid LHS in gimple call");
3387 return true;
3390 if (gimple_call_ctrl_altering_p (stmt)
3391 && gimple_call_noreturn_p (stmt)
3392 && should_remove_lhs_p (lhs))
3394 error ("LHS in %<noreturn%> call");
3395 return true;
3398 fntype = gimple_call_fntype (stmt);
3399 if (fntype
3400 && lhs
3401 && !useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (fntype))
3402 /* ??? At least C++ misses conversions at assignments from
3403 void * call results.
3404 For now simply allow arbitrary pointer type conversions. */
3405 && !(POINTER_TYPE_P (TREE_TYPE (lhs))
3406 && POINTER_TYPE_P (TREE_TYPE (fntype))))
3408 error ("invalid conversion in gimple call");
3409 debug_generic_stmt (TREE_TYPE (lhs));
3410 debug_generic_stmt (TREE_TYPE (fntype));
3411 return true;
3414 if (gimple_call_chain (stmt)
3415 && !is_gimple_val (gimple_call_chain (stmt)))
3417 error ("invalid static chain in gimple call");
3418 debug_generic_stmt (gimple_call_chain (stmt));
3419 return true;
3422 /* If there is a static chain argument, the call should either be
3423 indirect, or the decl should have DECL_STATIC_CHAIN set. */
3424 if (gimple_call_chain (stmt)
3425 && fndecl
3426 && !DECL_STATIC_CHAIN (fndecl))
3428 error ("static chain with function that doesn%'t use one");
3429 return true;
3432 if (fndecl && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL))
3434 switch (DECL_FUNCTION_CODE (fndecl))
3436 case BUILT_IN_UNREACHABLE:
3437 case BUILT_IN_TRAP:
3438 if (gimple_call_num_args (stmt) > 0)
3440 /* Built-in unreachable with parameters might not be caught by
3441 undefined behavior sanitizer. Front-ends do check users do not
3442 call them that way but we also produce calls to
3443 __builtin_unreachable internally, for example when IPA figures
3444 out a call cannot happen in a legal program. In such cases,
3445 we must make sure arguments are stripped off. */
3446 error ("%<__builtin_unreachable%> or %<__builtin_trap%> call "
3447 "with arguments");
3448 return true;
3450 break;
3451 default:
3452 break;
3456 /* For a call to .DEFERRED_INIT,
3457 LHS = DEFERRED_INIT (SIZE of the DECL, INIT_TYPE, IS_VLA)
3458 we should guarantee that the 1st and the 3rd arguments are consistent:
3459 1st argument: SIZE of the DECL;
3460 3rd argument: IS_VLA, 0 NO, 1 YES;
3462 if IS_VLA is false, the 1st argument should be a constant and the same as
3463 the size of the LHS. */
3464 if (gimple_call_internal_p (stmt, IFN_DEFERRED_INIT))
3466 tree size_of_arg0 = gimple_call_arg (stmt, 0);
3467 tree size_of_lhs = TYPE_SIZE_UNIT (TREE_TYPE (lhs));
3468 tree is_vla_node = gimple_call_arg (stmt, 2);
3469 bool is_vla = (bool) TREE_INT_CST_LOW (is_vla_node);
3471 if (TREE_CODE (lhs) == SSA_NAME)
3472 lhs = SSA_NAME_VAR (lhs);
3474 poly_uint64 size_from_arg0, size_from_lhs;
3475 bool is_constant_size_arg0 = poly_int_tree_p (size_of_arg0,
3476 &size_from_arg0);
3477 bool is_constant_size_lhs = poly_int_tree_p (size_of_lhs,
3478 &size_from_lhs);
3479 if (!is_vla)
3481 if (!is_constant_size_arg0)
3483 error ("%<DEFFERED_INIT%> calls for non-VLA should have "
3484 "constant size for the first argument");
3485 return true;
3487 else if (!is_constant_size_lhs)
3489 error ("%<DEFFERED_INIT%> calls for non-VLA should have "
3490 "constant size for the LHS");
3491 return true;
3493 else if (maybe_ne (size_from_arg0, size_from_lhs))
3495 error ("%<DEFFERED_INIT%> calls for non-VLA should have same "
3496 "constant size for the first argument and LHS");
3497 return true;
3502 /* ??? The C frontend passes unpromoted arguments in case it
3503 didn't see a function declaration before the call. So for now
3504 leave the call arguments mostly unverified. Once we gimplify
3505 unit-at-a-time we have a chance to fix this. */
3506 for (i = 0; i < gimple_call_num_args (stmt); ++i)
3508 tree arg = gimple_call_arg (stmt, i);
3509 if ((is_gimple_reg_type (TREE_TYPE (arg))
3510 && !is_gimple_val (arg))
3511 || (!is_gimple_reg_type (TREE_TYPE (arg))
3512 && !is_gimple_lvalue (arg)))
3514 error ("invalid argument to gimple call");
3515 debug_generic_expr (arg);
3516 return true;
3518 if (!is_gimple_reg (arg))
3520 if (TREE_CODE (arg) == WITH_SIZE_EXPR)
3521 arg = TREE_OPERAND (arg, 0);
3522 if (verify_types_in_gimple_reference (arg, false))
3523 return true;
3527 return false;
3530 /* Verifies the gimple comparison with the result type TYPE and
3531 the operands OP0 and OP1, comparison code is CODE. */
3533 static bool
3534 verify_gimple_comparison (tree type, tree op0, tree op1, enum tree_code code)
3536 tree op0_type = TREE_TYPE (op0);
3537 tree op1_type = TREE_TYPE (op1);
3539 if (!is_gimple_val (op0) || !is_gimple_val (op1))
3541 error ("invalid operands in gimple comparison");
3542 return true;
3545 /* For comparisons we do not have the operations type as the
3546 effective type the comparison is carried out in. Instead
3547 we require that either the first operand is trivially
3548 convertible into the second, or the other way around. */
3549 if (!useless_type_conversion_p (op0_type, op1_type)
3550 && !useless_type_conversion_p (op1_type, op0_type))
3552 error ("mismatching comparison operand types");
3553 debug_generic_expr (op0_type);
3554 debug_generic_expr (op1_type);
3555 return true;
3558 /* The resulting type of a comparison may be an effective boolean type. */
3559 if (INTEGRAL_TYPE_P (type)
3560 && (TREE_CODE (type) == BOOLEAN_TYPE
3561 || TYPE_PRECISION (type) == 1))
3563 if ((TREE_CODE (op0_type) == VECTOR_TYPE
3564 || TREE_CODE (op1_type) == VECTOR_TYPE)
3565 && code != EQ_EXPR && code != NE_EXPR
3566 && !VECTOR_BOOLEAN_TYPE_P (op0_type)
3567 && !VECTOR_INTEGER_TYPE_P (op0_type))
3569 error ("unsupported operation or type for vector comparison"
3570 " returning a boolean");
3571 debug_generic_expr (op0_type);
3572 debug_generic_expr (op1_type);
3573 return true;
3576 /* Or a boolean vector type with the same element count
3577 as the comparison operand types. */
3578 else if (TREE_CODE (type) == VECTOR_TYPE
3579 && TREE_CODE (TREE_TYPE (type)) == BOOLEAN_TYPE)
3581 if (TREE_CODE (op0_type) != VECTOR_TYPE
3582 || TREE_CODE (op1_type) != VECTOR_TYPE)
3584 error ("non-vector operands in vector comparison");
3585 debug_generic_expr (op0_type);
3586 debug_generic_expr (op1_type);
3587 return true;
3590 if (maybe_ne (TYPE_VECTOR_SUBPARTS (type),
3591 TYPE_VECTOR_SUBPARTS (op0_type)))
3593 error ("invalid vector comparison resulting type");
3594 debug_generic_expr (type);
3595 return true;
3598 else
3600 error ("bogus comparison result type");
3601 debug_generic_expr (type);
3602 return true;
3605 return false;
3608 /* Verify a gimple assignment statement STMT with an unary rhs.
3609 Returns true if anything is wrong. */
3611 static bool
3612 verify_gimple_assign_unary (gassign *stmt)
3614 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
3615 tree lhs = gimple_assign_lhs (stmt);
3616 tree lhs_type = TREE_TYPE (lhs);
3617 tree rhs1 = gimple_assign_rhs1 (stmt);
3618 tree rhs1_type = TREE_TYPE (rhs1);
3620 if (!is_gimple_reg (lhs))
3622 error ("non-register as LHS of unary operation");
3623 return true;
3626 if (!is_gimple_val (rhs1))
3628 error ("invalid operand in unary operation");
3629 return true;
3632 const char* const code_name = get_tree_code_name (rhs_code);
3634 /* First handle conversions. */
3635 switch (rhs_code)
3637 CASE_CONVERT:
3639 /* Allow conversions between vectors with the same number of elements,
3640 provided that the conversion is OK for the element types too. */
3641 if (VECTOR_TYPE_P (lhs_type)
3642 && VECTOR_TYPE_P (rhs1_type)
3643 && known_eq (TYPE_VECTOR_SUBPARTS (lhs_type),
3644 TYPE_VECTOR_SUBPARTS (rhs1_type)))
3646 lhs_type = TREE_TYPE (lhs_type);
3647 rhs1_type = TREE_TYPE (rhs1_type);
3649 else if (VECTOR_TYPE_P (lhs_type) || VECTOR_TYPE_P (rhs1_type))
3651 error ("invalid vector types in nop conversion");
3652 debug_generic_expr (lhs_type);
3653 debug_generic_expr (rhs1_type);
3654 return true;
3657 /* Allow conversions from pointer type to integral type only if
3658 there is no sign or zero extension involved.
3659 For targets were the precision of ptrofftype doesn't match that
3660 of pointers we allow conversions to types where
3661 POINTERS_EXTEND_UNSIGNED specifies how that works. */
3662 if ((POINTER_TYPE_P (lhs_type)
3663 && INTEGRAL_TYPE_P (rhs1_type))
3664 || (POINTER_TYPE_P (rhs1_type)
3665 && INTEGRAL_TYPE_P (lhs_type)
3666 && (TYPE_PRECISION (rhs1_type) >= TYPE_PRECISION (lhs_type)
3667 #if defined(POINTERS_EXTEND_UNSIGNED)
3668 || (TYPE_MODE (rhs1_type) == ptr_mode
3669 && (TYPE_PRECISION (lhs_type)
3670 == BITS_PER_WORD /* word_mode */
3671 || (TYPE_PRECISION (lhs_type)
3672 == GET_MODE_PRECISION (Pmode))))
3673 #endif
3675 return false;
3677 /* Allow conversion from integral to offset type and vice versa. */
3678 if ((TREE_CODE (lhs_type) == OFFSET_TYPE
3679 && INTEGRAL_TYPE_P (rhs1_type))
3680 || (INTEGRAL_TYPE_P (lhs_type)
3681 && TREE_CODE (rhs1_type) == OFFSET_TYPE))
3682 return false;
3684 /* Otherwise assert we are converting between types of the
3685 same kind. */
3686 if (INTEGRAL_TYPE_P (lhs_type) != INTEGRAL_TYPE_P (rhs1_type))
3688 error ("invalid types in nop conversion");
3689 debug_generic_expr (lhs_type);
3690 debug_generic_expr (rhs1_type);
3691 return true;
3694 return false;
3697 case ADDR_SPACE_CONVERT_EXPR:
3699 if (!POINTER_TYPE_P (rhs1_type) || !POINTER_TYPE_P (lhs_type)
3700 || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type))
3701 == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type))))
3703 error ("invalid types in address space conversion");
3704 debug_generic_expr (lhs_type);
3705 debug_generic_expr (rhs1_type);
3706 return true;
3709 return false;
3712 case FIXED_CONVERT_EXPR:
3714 if (!valid_fixed_convert_types_p (lhs_type, rhs1_type)
3715 && !valid_fixed_convert_types_p (rhs1_type, lhs_type))
3717 error ("invalid types in fixed-point conversion");
3718 debug_generic_expr (lhs_type);
3719 debug_generic_expr (rhs1_type);
3720 return true;
3723 return false;
3726 case FLOAT_EXPR:
3728 if ((!INTEGRAL_TYPE_P (rhs1_type) || !SCALAR_FLOAT_TYPE_P (lhs_type))
3729 && (!VECTOR_INTEGER_TYPE_P (rhs1_type)
3730 || !VECTOR_FLOAT_TYPE_P (lhs_type)))
3732 error ("invalid types in conversion to floating-point");
3733 debug_generic_expr (lhs_type);
3734 debug_generic_expr (rhs1_type);
3735 return true;
3738 return false;
3741 case FIX_TRUNC_EXPR:
3743 if ((!INTEGRAL_TYPE_P (lhs_type) || !SCALAR_FLOAT_TYPE_P (rhs1_type))
3744 && (!VECTOR_INTEGER_TYPE_P (lhs_type)
3745 || !VECTOR_FLOAT_TYPE_P (rhs1_type)))
3747 error ("invalid types in conversion to integer");
3748 debug_generic_expr (lhs_type);
3749 debug_generic_expr (rhs1_type);
3750 return true;
3753 return false;
3756 case VEC_UNPACK_HI_EXPR:
3757 case VEC_UNPACK_LO_EXPR:
3758 case VEC_UNPACK_FLOAT_HI_EXPR:
3759 case VEC_UNPACK_FLOAT_LO_EXPR:
3760 case VEC_UNPACK_FIX_TRUNC_HI_EXPR:
3761 case VEC_UNPACK_FIX_TRUNC_LO_EXPR:
3762 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
3763 || TREE_CODE (lhs_type) != VECTOR_TYPE
3764 || (!INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))
3765 && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type)))
3766 || (!INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
3767 && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type)))
3768 || ((rhs_code == VEC_UNPACK_HI_EXPR
3769 || rhs_code == VEC_UNPACK_LO_EXPR)
3770 && (INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))
3771 != INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))))
3772 || ((rhs_code == VEC_UNPACK_FLOAT_HI_EXPR
3773 || rhs_code == VEC_UNPACK_FLOAT_LO_EXPR)
3774 && (INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))
3775 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type))))
3776 || ((rhs_code == VEC_UNPACK_FIX_TRUNC_HI_EXPR
3777 || rhs_code == VEC_UNPACK_FIX_TRUNC_LO_EXPR)
3778 && (INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
3779 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type))))
3780 || (maybe_ne (GET_MODE_SIZE (element_mode (lhs_type)),
3781 2 * GET_MODE_SIZE (element_mode (rhs1_type)))
3782 && (!VECTOR_BOOLEAN_TYPE_P (lhs_type)
3783 || !VECTOR_BOOLEAN_TYPE_P (rhs1_type)))
3784 || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (lhs_type),
3785 TYPE_VECTOR_SUBPARTS (rhs1_type)))
3787 error ("type mismatch in %qs expression", code_name);
3788 debug_generic_expr (lhs_type);
3789 debug_generic_expr (rhs1_type);
3790 return true;
3793 return false;
3795 case NEGATE_EXPR:
3796 case ABS_EXPR:
3797 case BIT_NOT_EXPR:
3798 case PAREN_EXPR:
3799 case CONJ_EXPR:
3800 /* Disallow pointer and offset types for many of the unary gimple. */
3801 if (POINTER_TYPE_P (lhs_type)
3802 || TREE_CODE (lhs_type) == OFFSET_TYPE)
3804 error ("invalid types for %qs", code_name);
3805 debug_generic_expr (lhs_type);
3806 debug_generic_expr (rhs1_type);
3807 return true;
3809 break;
3811 case ABSU_EXPR:
3812 if (!ANY_INTEGRAL_TYPE_P (lhs_type)
3813 || !TYPE_UNSIGNED (lhs_type)
3814 || !ANY_INTEGRAL_TYPE_P (rhs1_type)
3815 || TYPE_UNSIGNED (rhs1_type)
3816 || element_precision (lhs_type) != element_precision (rhs1_type))
3818 error ("invalid types for %qs", code_name);
3819 debug_generic_expr (lhs_type);
3820 debug_generic_expr (rhs1_type);
3821 return true;
3823 return false;
3825 case VEC_DUPLICATE_EXPR:
3826 if (TREE_CODE (lhs_type) != VECTOR_TYPE
3827 || !useless_type_conversion_p (TREE_TYPE (lhs_type), rhs1_type))
3829 error ("%qs should be from a scalar to a like vector", code_name);
3830 debug_generic_expr (lhs_type);
3831 debug_generic_expr (rhs1_type);
3832 return true;
3834 return false;
3836 default:
3837 gcc_unreachable ();
3840 /* For the remaining codes assert there is no conversion involved. */
3841 if (!useless_type_conversion_p (lhs_type, rhs1_type))
3843 error ("non-trivial conversion in unary operation");
3844 debug_generic_expr (lhs_type);
3845 debug_generic_expr (rhs1_type);
3846 return true;
3849 return false;
3852 /* Verify a gimple assignment statement STMT with a binary rhs.
3853 Returns true if anything is wrong. */
3855 static bool
3856 verify_gimple_assign_binary (gassign *stmt)
3858 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
3859 tree lhs = gimple_assign_lhs (stmt);
3860 tree lhs_type = TREE_TYPE (lhs);
3861 tree rhs1 = gimple_assign_rhs1 (stmt);
3862 tree rhs1_type = TREE_TYPE (rhs1);
3863 tree rhs2 = gimple_assign_rhs2 (stmt);
3864 tree rhs2_type = TREE_TYPE (rhs2);
3866 if (!is_gimple_reg (lhs))
3868 error ("non-register as LHS of binary operation");
3869 return true;
3872 if (!is_gimple_val (rhs1)
3873 || !is_gimple_val (rhs2))
3875 error ("invalid operands in binary operation");
3876 return true;
3879 const char* const code_name = get_tree_code_name (rhs_code);
3881 /* First handle operations that involve different types. */
3882 switch (rhs_code)
3884 case COMPLEX_EXPR:
3886 if (TREE_CODE (lhs_type) != COMPLEX_TYPE
3887 || !(INTEGRAL_TYPE_P (rhs1_type)
3888 || SCALAR_FLOAT_TYPE_P (rhs1_type))
3889 || !(INTEGRAL_TYPE_P (rhs2_type)
3890 || SCALAR_FLOAT_TYPE_P (rhs2_type)))
3892 error ("type mismatch in %qs", code_name);
3893 debug_generic_expr (lhs_type);
3894 debug_generic_expr (rhs1_type);
3895 debug_generic_expr (rhs2_type);
3896 return true;
3899 return false;
3902 case LSHIFT_EXPR:
3903 case RSHIFT_EXPR:
3904 case LROTATE_EXPR:
3905 case RROTATE_EXPR:
3907 /* Shifts and rotates are ok on integral types, fixed point
3908 types and integer vector types. */
3909 if ((!INTEGRAL_TYPE_P (rhs1_type)
3910 && !FIXED_POINT_TYPE_P (rhs1_type)
3911 && !(TREE_CODE (rhs1_type) == VECTOR_TYPE
3912 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))))
3913 || (!INTEGRAL_TYPE_P (rhs2_type)
3914 /* Vector shifts of vectors are also ok. */
3915 && !(TREE_CODE (rhs1_type) == VECTOR_TYPE
3916 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
3917 && TREE_CODE (rhs2_type) == VECTOR_TYPE
3918 && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type))))
3919 || !useless_type_conversion_p (lhs_type, rhs1_type))
3921 error ("type mismatch in %qs", code_name);
3922 debug_generic_expr (lhs_type);
3923 debug_generic_expr (rhs1_type);
3924 debug_generic_expr (rhs2_type);
3925 return true;
3928 return false;
3931 case WIDEN_LSHIFT_EXPR:
3933 if (!INTEGRAL_TYPE_P (lhs_type)
3934 || !INTEGRAL_TYPE_P (rhs1_type)
3935 || TREE_CODE (rhs2) != INTEGER_CST
3936 || (2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type)))
3938 error ("type mismatch in %qs", code_name);
3939 debug_generic_expr (lhs_type);
3940 debug_generic_expr (rhs1_type);
3941 debug_generic_expr (rhs2_type);
3942 return true;
3945 return false;
3948 case VEC_WIDEN_LSHIFT_HI_EXPR:
3949 case VEC_WIDEN_LSHIFT_LO_EXPR:
3951 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
3952 || TREE_CODE (lhs_type) != VECTOR_TYPE
3953 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
3954 || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))
3955 || TREE_CODE (rhs2) != INTEGER_CST
3956 || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type))
3957 > TYPE_PRECISION (TREE_TYPE (lhs_type))))
3959 error ("type mismatch in %qs", code_name);
3960 debug_generic_expr (lhs_type);
3961 debug_generic_expr (rhs1_type);
3962 debug_generic_expr (rhs2_type);
3963 return true;
3966 return false;
3969 case WIDEN_PLUS_EXPR:
3970 case WIDEN_MINUS_EXPR:
3971 case PLUS_EXPR:
3972 case MINUS_EXPR:
3974 tree lhs_etype = lhs_type;
3975 tree rhs1_etype = rhs1_type;
3976 tree rhs2_etype = rhs2_type;
3977 if (TREE_CODE (lhs_type) == VECTOR_TYPE)
3979 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
3980 || TREE_CODE (rhs2_type) != VECTOR_TYPE)
3982 error ("invalid non-vector operands to %qs", code_name);
3983 return true;
3985 lhs_etype = TREE_TYPE (lhs_type);
3986 rhs1_etype = TREE_TYPE (rhs1_type);
3987 rhs2_etype = TREE_TYPE (rhs2_type);
3989 if (POINTER_TYPE_P (lhs_etype)
3990 || POINTER_TYPE_P (rhs1_etype)
3991 || POINTER_TYPE_P (rhs2_etype))
3993 error ("invalid (pointer) operands %qs", code_name);
3994 return true;
3997 /* Continue with generic binary expression handling. */
3998 break;
4001 case POINTER_PLUS_EXPR:
4003 if (!POINTER_TYPE_P (rhs1_type)
4004 || !useless_type_conversion_p (lhs_type, rhs1_type)
4005 || !ptrofftype_p (rhs2_type))
4007 error ("type mismatch in %qs", code_name);
4008 debug_generic_stmt (lhs_type);
4009 debug_generic_stmt (rhs1_type);
4010 debug_generic_stmt (rhs2_type);
4011 return true;
4014 return false;
4017 case POINTER_DIFF_EXPR:
4019 if (!POINTER_TYPE_P (rhs1_type)
4020 || !POINTER_TYPE_P (rhs2_type)
4021 /* Because we special-case pointers to void we allow difference
4022 of arbitrary pointers with the same mode. */
4023 || TYPE_MODE (rhs1_type) != TYPE_MODE (rhs2_type)
4024 || !INTEGRAL_TYPE_P (lhs_type)
4025 || TYPE_UNSIGNED (lhs_type)
4026 || TYPE_PRECISION (lhs_type) != TYPE_PRECISION (rhs1_type))
4028 error ("type mismatch in %qs", code_name);
4029 debug_generic_stmt (lhs_type);
4030 debug_generic_stmt (rhs1_type);
4031 debug_generic_stmt (rhs2_type);
4032 return true;
4035 return false;
4038 case TRUTH_ANDIF_EXPR:
4039 case TRUTH_ORIF_EXPR:
4040 case TRUTH_AND_EXPR:
4041 case TRUTH_OR_EXPR:
4042 case TRUTH_XOR_EXPR:
4044 gcc_unreachable ();
4046 case LT_EXPR:
4047 case LE_EXPR:
4048 case GT_EXPR:
4049 case GE_EXPR:
4050 case EQ_EXPR:
4051 case NE_EXPR:
4052 case UNORDERED_EXPR:
4053 case ORDERED_EXPR:
4054 case UNLT_EXPR:
4055 case UNLE_EXPR:
4056 case UNGT_EXPR:
4057 case UNGE_EXPR:
4058 case UNEQ_EXPR:
4059 case LTGT_EXPR:
4060 /* Comparisons are also binary, but the result type is not
4061 connected to the operand types. */
4062 return verify_gimple_comparison (lhs_type, rhs1, rhs2, rhs_code);
4064 case WIDEN_MULT_EXPR:
4065 if (TREE_CODE (lhs_type) != INTEGER_TYPE)
4066 return true;
4067 return ((2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type))
4068 || (TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (rhs2_type)));
4070 case WIDEN_SUM_EXPR:
4072 if (((TREE_CODE (rhs1_type) != VECTOR_TYPE
4073 || TREE_CODE (lhs_type) != VECTOR_TYPE)
4074 && ((!INTEGRAL_TYPE_P (rhs1_type)
4075 && !SCALAR_FLOAT_TYPE_P (rhs1_type))
4076 || (!INTEGRAL_TYPE_P (lhs_type)
4077 && !SCALAR_FLOAT_TYPE_P (lhs_type))))
4078 || !useless_type_conversion_p (lhs_type, rhs2_type)
4079 || maybe_lt (GET_MODE_SIZE (element_mode (rhs2_type)),
4080 2 * GET_MODE_SIZE (element_mode (rhs1_type))))
4082 error ("type mismatch in %qs", code_name);
4083 debug_generic_expr (lhs_type);
4084 debug_generic_expr (rhs1_type);
4085 debug_generic_expr (rhs2_type);
4086 return true;
4088 return false;
4091 case VEC_WIDEN_MINUS_HI_EXPR:
4092 case VEC_WIDEN_MINUS_LO_EXPR:
4093 case VEC_WIDEN_PLUS_HI_EXPR:
4094 case VEC_WIDEN_PLUS_LO_EXPR:
4095 case VEC_WIDEN_MULT_HI_EXPR:
4096 case VEC_WIDEN_MULT_LO_EXPR:
4097 case VEC_WIDEN_MULT_EVEN_EXPR:
4098 case VEC_WIDEN_MULT_ODD_EXPR:
4100 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
4101 || TREE_CODE (lhs_type) != VECTOR_TYPE
4102 || !types_compatible_p (rhs1_type, rhs2_type)
4103 || maybe_ne (GET_MODE_SIZE (element_mode (lhs_type)),
4104 2 * GET_MODE_SIZE (element_mode (rhs1_type))))
4106 error ("type mismatch in %qs", code_name);
4107 debug_generic_expr (lhs_type);
4108 debug_generic_expr (rhs1_type);
4109 debug_generic_expr (rhs2_type);
4110 return true;
4112 return false;
4115 case VEC_PACK_TRUNC_EXPR:
4116 /* ??? We currently use VEC_PACK_TRUNC_EXPR to simply concat
4117 vector boolean types. */
4118 if (VECTOR_BOOLEAN_TYPE_P (lhs_type)
4119 && VECTOR_BOOLEAN_TYPE_P (rhs1_type)
4120 && types_compatible_p (rhs1_type, rhs2_type)
4121 && known_eq (TYPE_VECTOR_SUBPARTS (lhs_type),
4122 2 * TYPE_VECTOR_SUBPARTS (rhs1_type)))
4123 return false;
4125 /* Fallthru. */
4126 case VEC_PACK_SAT_EXPR:
4127 case VEC_PACK_FIX_TRUNC_EXPR:
4129 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
4130 || TREE_CODE (lhs_type) != VECTOR_TYPE
4131 || !((rhs_code == VEC_PACK_FIX_TRUNC_EXPR
4132 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type))
4133 && INTEGRAL_TYPE_P (TREE_TYPE (lhs_type)))
4134 || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
4135 == INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))))
4136 || !types_compatible_p (rhs1_type, rhs2_type)
4137 || maybe_ne (GET_MODE_SIZE (element_mode (rhs1_type)),
4138 2 * GET_MODE_SIZE (element_mode (lhs_type)))
4139 || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (rhs1_type),
4140 TYPE_VECTOR_SUBPARTS (lhs_type)))
4142 error ("type mismatch in %qs", code_name);
4143 debug_generic_expr (lhs_type);
4144 debug_generic_expr (rhs1_type);
4145 debug_generic_expr (rhs2_type);
4146 return true;
4149 return false;
4152 case VEC_PACK_FLOAT_EXPR:
4153 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
4154 || TREE_CODE (lhs_type) != VECTOR_TYPE
4155 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
4156 || !SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type))
4157 || !types_compatible_p (rhs1_type, rhs2_type)
4158 || maybe_ne (GET_MODE_SIZE (element_mode (rhs1_type)),
4159 2 * GET_MODE_SIZE (element_mode (lhs_type)))
4160 || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (rhs1_type),
4161 TYPE_VECTOR_SUBPARTS (lhs_type)))
4163 error ("type mismatch in %qs", code_name);
4164 debug_generic_expr (lhs_type);
4165 debug_generic_expr (rhs1_type);
4166 debug_generic_expr (rhs2_type);
4167 return true;
4170 return false;
4172 case MULT_EXPR:
4173 case MULT_HIGHPART_EXPR:
4174 case TRUNC_DIV_EXPR:
4175 case CEIL_DIV_EXPR:
4176 case FLOOR_DIV_EXPR:
4177 case ROUND_DIV_EXPR:
4178 case TRUNC_MOD_EXPR:
4179 case CEIL_MOD_EXPR:
4180 case FLOOR_MOD_EXPR:
4181 case ROUND_MOD_EXPR:
4182 case RDIV_EXPR:
4183 case EXACT_DIV_EXPR:
4184 /* Disallow pointer and offset types for many of the binary gimple. */
4185 if (POINTER_TYPE_P (lhs_type)
4186 || TREE_CODE (lhs_type) == OFFSET_TYPE)
4188 error ("invalid types for %qs", code_name);
4189 debug_generic_expr (lhs_type);
4190 debug_generic_expr (rhs1_type);
4191 debug_generic_expr (rhs2_type);
4192 return true;
4194 /* Continue with generic binary expression handling. */
4195 break;
4197 case MIN_EXPR:
4198 case MAX_EXPR:
4199 case BIT_IOR_EXPR:
4200 case BIT_XOR_EXPR:
4201 case BIT_AND_EXPR:
4202 /* Continue with generic binary expression handling. */
4203 break;
4205 case VEC_SERIES_EXPR:
4206 if (!useless_type_conversion_p (rhs1_type, rhs2_type))
4208 error ("type mismatch in %qs", code_name);
4209 debug_generic_expr (rhs1_type);
4210 debug_generic_expr (rhs2_type);
4211 return true;
4213 if (TREE_CODE (lhs_type) != VECTOR_TYPE
4214 || !useless_type_conversion_p (TREE_TYPE (lhs_type), rhs1_type))
4216 error ("vector type expected in %qs", code_name);
4217 debug_generic_expr (lhs_type);
4218 return true;
4220 return false;
4222 default:
4223 gcc_unreachable ();
4226 if (!useless_type_conversion_p (lhs_type, rhs1_type)
4227 || !useless_type_conversion_p (lhs_type, rhs2_type))
4229 error ("type mismatch in binary expression");
4230 debug_generic_stmt (lhs_type);
4231 debug_generic_stmt (rhs1_type);
4232 debug_generic_stmt (rhs2_type);
4233 return true;
4236 return false;
4239 /* Verify a gimple assignment statement STMT with a ternary rhs.
4240 Returns true if anything is wrong. */
4242 static bool
4243 verify_gimple_assign_ternary (gassign *stmt)
4245 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
4246 tree lhs = gimple_assign_lhs (stmt);
4247 tree lhs_type = TREE_TYPE (lhs);
4248 tree rhs1 = gimple_assign_rhs1 (stmt);
4249 tree rhs1_type = TREE_TYPE (rhs1);
4250 tree rhs2 = gimple_assign_rhs2 (stmt);
4251 tree rhs2_type = TREE_TYPE (rhs2);
4252 tree rhs3 = gimple_assign_rhs3 (stmt);
4253 tree rhs3_type = TREE_TYPE (rhs3);
4255 if (!is_gimple_reg (lhs))
4257 error ("non-register as LHS of ternary operation");
4258 return true;
4261 if ((rhs_code == COND_EXPR
4262 ? !is_gimple_condexpr (rhs1) : !is_gimple_val (rhs1))
4263 || !is_gimple_val (rhs2)
4264 || !is_gimple_val (rhs3))
4266 error ("invalid operands in ternary operation");
4267 return true;
4270 const char* const code_name = get_tree_code_name (rhs_code);
4272 /* First handle operations that involve different types. */
4273 switch (rhs_code)
4275 case WIDEN_MULT_PLUS_EXPR:
4276 case WIDEN_MULT_MINUS_EXPR:
4277 if ((!INTEGRAL_TYPE_P (rhs1_type)
4278 && !FIXED_POINT_TYPE_P (rhs1_type))
4279 || !useless_type_conversion_p (rhs1_type, rhs2_type)
4280 || !useless_type_conversion_p (lhs_type, rhs3_type)
4281 || 2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type)
4282 || TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (rhs2_type))
4284 error ("type mismatch in %qs", code_name);
4285 debug_generic_expr (lhs_type);
4286 debug_generic_expr (rhs1_type);
4287 debug_generic_expr (rhs2_type);
4288 debug_generic_expr (rhs3_type);
4289 return true;
4291 break;
4293 case VEC_COND_EXPR:
4294 if (!VECTOR_BOOLEAN_TYPE_P (rhs1_type)
4295 || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs1_type),
4296 TYPE_VECTOR_SUBPARTS (lhs_type)))
4298 error ("the first argument of a %qs must be of a "
4299 "boolean vector type of the same number of elements "
4300 "as the result", code_name);
4301 debug_generic_expr (lhs_type);
4302 debug_generic_expr (rhs1_type);
4303 return true;
4305 if (!is_gimple_val (rhs1))
4306 return true;
4307 /* Fallthrough. */
4308 case COND_EXPR:
4309 if (!is_gimple_val (rhs1)
4310 && verify_gimple_comparison (TREE_TYPE (rhs1),
4311 TREE_OPERAND (rhs1, 0),
4312 TREE_OPERAND (rhs1, 1),
4313 TREE_CODE (rhs1)))
4314 return true;
4315 if (!useless_type_conversion_p (lhs_type, rhs2_type)
4316 || !useless_type_conversion_p (lhs_type, rhs3_type))
4318 error ("type mismatch in %qs", code_name);
4319 debug_generic_expr (lhs_type);
4320 debug_generic_expr (rhs2_type);
4321 debug_generic_expr (rhs3_type);
4322 return true;
4324 break;
4326 case VEC_PERM_EXPR:
4327 if (!useless_type_conversion_p (lhs_type, rhs1_type)
4328 || !useless_type_conversion_p (lhs_type, rhs2_type))
4330 error ("type mismatch in %qs", code_name);
4331 debug_generic_expr (lhs_type);
4332 debug_generic_expr (rhs1_type);
4333 debug_generic_expr (rhs2_type);
4334 debug_generic_expr (rhs3_type);
4335 return true;
4338 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
4339 || TREE_CODE (rhs2_type) != VECTOR_TYPE
4340 || TREE_CODE (rhs3_type) != VECTOR_TYPE)
4342 error ("vector types expected in %qs", code_name);
4343 debug_generic_expr (lhs_type);
4344 debug_generic_expr (rhs1_type);
4345 debug_generic_expr (rhs2_type);
4346 debug_generic_expr (rhs3_type);
4347 return true;
4350 if (maybe_ne (TYPE_VECTOR_SUBPARTS (rhs1_type),
4351 TYPE_VECTOR_SUBPARTS (rhs2_type))
4352 || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs2_type),
4353 TYPE_VECTOR_SUBPARTS (rhs3_type))
4354 || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs3_type),
4355 TYPE_VECTOR_SUBPARTS (lhs_type)))
4357 error ("vectors with different element number found in %qs",
4358 code_name);
4359 debug_generic_expr (lhs_type);
4360 debug_generic_expr (rhs1_type);
4361 debug_generic_expr (rhs2_type);
4362 debug_generic_expr (rhs3_type);
4363 return true;
4366 if (TREE_CODE (TREE_TYPE (rhs3_type)) != INTEGER_TYPE
4367 || (TREE_CODE (rhs3) != VECTOR_CST
4368 && (GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE
4369 (TREE_TYPE (rhs3_type)))
4370 != GET_MODE_BITSIZE (SCALAR_TYPE_MODE
4371 (TREE_TYPE (rhs1_type))))))
4373 error ("invalid mask type in %qs", code_name);
4374 debug_generic_expr (lhs_type);
4375 debug_generic_expr (rhs1_type);
4376 debug_generic_expr (rhs2_type);
4377 debug_generic_expr (rhs3_type);
4378 return true;
4381 return false;
4383 case SAD_EXPR:
4384 if (!useless_type_conversion_p (rhs1_type, rhs2_type)
4385 || !useless_type_conversion_p (lhs_type, rhs3_type)
4386 || 2 * GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type)))
4387 > GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (lhs_type))))
4389 error ("type mismatch in %qs", code_name);
4390 debug_generic_expr (lhs_type);
4391 debug_generic_expr (rhs1_type);
4392 debug_generic_expr (rhs2_type);
4393 debug_generic_expr (rhs3_type);
4394 return true;
4397 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
4398 || TREE_CODE (rhs2_type) != VECTOR_TYPE
4399 || TREE_CODE (rhs3_type) != VECTOR_TYPE)
4401 error ("vector types expected in %qs", code_name);
4402 debug_generic_expr (lhs_type);
4403 debug_generic_expr (rhs1_type);
4404 debug_generic_expr (rhs2_type);
4405 debug_generic_expr (rhs3_type);
4406 return true;
4409 return false;
4411 case BIT_INSERT_EXPR:
4412 if (! useless_type_conversion_p (lhs_type, rhs1_type))
4414 error ("type mismatch in %qs", code_name);
4415 debug_generic_expr (lhs_type);
4416 debug_generic_expr (rhs1_type);
4417 return true;
4419 if (! ((INTEGRAL_TYPE_P (rhs1_type)
4420 && INTEGRAL_TYPE_P (rhs2_type))
4421 /* Vector element insert. */
4422 || (VECTOR_TYPE_P (rhs1_type)
4423 && types_compatible_p (TREE_TYPE (rhs1_type), rhs2_type))
4424 /* Aligned sub-vector insert. */
4425 || (VECTOR_TYPE_P (rhs1_type)
4426 && VECTOR_TYPE_P (rhs2_type)
4427 && types_compatible_p (TREE_TYPE (rhs1_type),
4428 TREE_TYPE (rhs2_type))
4429 && multiple_p (TYPE_VECTOR_SUBPARTS (rhs1_type),
4430 TYPE_VECTOR_SUBPARTS (rhs2_type))
4431 && multiple_of_p (bitsizetype, rhs3, TYPE_SIZE (rhs2_type)))))
4433 error ("not allowed type combination in %qs", code_name);
4434 debug_generic_expr (rhs1_type);
4435 debug_generic_expr (rhs2_type);
4436 return true;
4438 if (! tree_fits_uhwi_p (rhs3)
4439 || ! types_compatible_p (bitsizetype, TREE_TYPE (rhs3))
4440 || ! tree_fits_uhwi_p (TYPE_SIZE (rhs2_type)))
4442 error ("invalid position or size in %qs", code_name);
4443 return true;
4445 if (INTEGRAL_TYPE_P (rhs1_type)
4446 && !type_has_mode_precision_p (rhs1_type))
4448 error ("%qs into non-mode-precision operand", code_name);
4449 return true;
4451 if (INTEGRAL_TYPE_P (rhs1_type))
4453 unsigned HOST_WIDE_INT bitpos = tree_to_uhwi (rhs3);
4454 if (bitpos >= TYPE_PRECISION (rhs1_type)
4455 || (bitpos + TYPE_PRECISION (rhs2_type)
4456 > TYPE_PRECISION (rhs1_type)))
4458 error ("insertion out of range in %qs", code_name);
4459 return true;
4462 else if (VECTOR_TYPE_P (rhs1_type))
4464 unsigned HOST_WIDE_INT bitpos = tree_to_uhwi (rhs3);
4465 unsigned HOST_WIDE_INT bitsize = tree_to_uhwi (TYPE_SIZE (rhs2_type));
4466 if (bitpos % bitsize != 0)
4468 error ("%qs not at element boundary", code_name);
4469 return true;
4472 return false;
4474 case DOT_PROD_EXPR:
4476 if (((TREE_CODE (rhs1_type) != VECTOR_TYPE
4477 || TREE_CODE (lhs_type) != VECTOR_TYPE)
4478 && ((!INTEGRAL_TYPE_P (rhs1_type)
4479 && !SCALAR_FLOAT_TYPE_P (rhs1_type))
4480 || (!INTEGRAL_TYPE_P (lhs_type)
4481 && !SCALAR_FLOAT_TYPE_P (lhs_type))))
4482 /* rhs1_type and rhs2_type may differ in sign. */
4483 || !tree_nop_conversion_p (rhs1_type, rhs2_type)
4484 || !useless_type_conversion_p (lhs_type, rhs3_type)
4485 || maybe_lt (GET_MODE_SIZE (element_mode (rhs3_type)),
4486 2 * GET_MODE_SIZE (element_mode (rhs1_type))))
4488 error ("type mismatch in %qs", code_name);
4489 debug_generic_expr (lhs_type);
4490 debug_generic_expr (rhs1_type);
4491 debug_generic_expr (rhs2_type);
4492 return true;
4494 return false;
4497 case REALIGN_LOAD_EXPR:
4498 /* FIXME. */
4499 return false;
4501 default:
4502 gcc_unreachable ();
4504 return false;
4507 /* Verify a gimple assignment statement STMT with a single rhs.
4508 Returns true if anything is wrong. */
4510 static bool
4511 verify_gimple_assign_single (gassign *stmt)
4513 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
4514 tree lhs = gimple_assign_lhs (stmt);
4515 tree lhs_type = TREE_TYPE (lhs);
4516 tree rhs1 = gimple_assign_rhs1 (stmt);
4517 tree rhs1_type = TREE_TYPE (rhs1);
4518 bool res = false;
4520 const char* const code_name = get_tree_code_name (rhs_code);
4522 if (!useless_type_conversion_p (lhs_type, rhs1_type))
4524 error ("non-trivial conversion in %qs", code_name);
4525 debug_generic_expr (lhs_type);
4526 debug_generic_expr (rhs1_type);
4527 return true;
4530 if (gimple_clobber_p (stmt)
4531 && !(DECL_P (lhs) || TREE_CODE (lhs) == MEM_REF))
4533 error ("%qs LHS in clobber statement",
4534 get_tree_code_name (TREE_CODE (lhs)));
4535 debug_generic_expr (lhs);
4536 return true;
4539 if (TREE_CODE (lhs) == WITH_SIZE_EXPR)
4541 error ("%qs LHS in assignment statement",
4542 get_tree_code_name (TREE_CODE (lhs)));
4543 debug_generic_expr (lhs);
4544 return true;
4547 if (handled_component_p (lhs)
4548 || TREE_CODE (lhs) == MEM_REF
4549 || TREE_CODE (lhs) == TARGET_MEM_REF)
4550 res |= verify_types_in_gimple_reference (lhs, true);
4552 /* Special codes we cannot handle via their class. */
4553 switch (rhs_code)
4555 case ADDR_EXPR:
4557 tree op = TREE_OPERAND (rhs1, 0);
4558 if (!is_gimple_addressable (op))
4560 error ("invalid operand in %qs", code_name);
4561 return true;
4564 /* Technically there is no longer a need for matching types, but
4565 gimple hygiene asks for this check. In LTO we can end up
4566 combining incompatible units and thus end up with addresses
4567 of globals that change their type to a common one. */
4568 if (!in_lto_p
4569 && !types_compatible_p (TREE_TYPE (op),
4570 TREE_TYPE (TREE_TYPE (rhs1)))
4571 && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1),
4572 TREE_TYPE (op)))
4574 error ("type mismatch in %qs", code_name);
4575 debug_generic_stmt (TREE_TYPE (rhs1));
4576 debug_generic_stmt (TREE_TYPE (op));
4577 return true;
4580 return (verify_address (rhs1, true)
4581 || verify_types_in_gimple_reference (op, true));
4584 /* tcc_reference */
4585 case INDIRECT_REF:
4586 error ("%qs in gimple IL", code_name);
4587 return true;
4589 case COMPONENT_REF:
4590 case BIT_FIELD_REF:
4591 case ARRAY_REF:
4592 case ARRAY_RANGE_REF:
4593 case VIEW_CONVERT_EXPR:
4594 case REALPART_EXPR:
4595 case IMAGPART_EXPR:
4596 case TARGET_MEM_REF:
4597 case MEM_REF:
4598 if (!is_gimple_reg (lhs)
4599 && is_gimple_reg_type (TREE_TYPE (lhs)))
4601 error ("invalid RHS for gimple memory store: %qs", code_name);
4602 debug_generic_stmt (lhs);
4603 debug_generic_stmt (rhs1);
4604 return true;
4606 return res || verify_types_in_gimple_reference (rhs1, false);
4608 /* tcc_constant */
4609 case SSA_NAME:
4610 case INTEGER_CST:
4611 case REAL_CST:
4612 case FIXED_CST:
4613 case COMPLEX_CST:
4614 case VECTOR_CST:
4615 case STRING_CST:
4616 return res;
4618 /* tcc_declaration */
4619 case CONST_DECL:
4620 return res;
4621 case VAR_DECL:
4622 case PARM_DECL:
4623 if (!is_gimple_reg (lhs)
4624 && !is_gimple_reg (rhs1)
4625 && is_gimple_reg_type (TREE_TYPE (lhs)))
4627 error ("invalid RHS for gimple memory store: %qs", code_name);
4628 debug_generic_stmt (lhs);
4629 debug_generic_stmt (rhs1);
4630 return true;
4632 return res;
4634 case CONSTRUCTOR:
4635 if (TREE_CODE (rhs1_type) == VECTOR_TYPE)
4637 unsigned int i;
4638 tree elt_i, elt_v, elt_t = NULL_TREE;
4640 if (CONSTRUCTOR_NELTS (rhs1) == 0)
4641 return res;
4642 /* For vector CONSTRUCTORs we require that either it is empty
4643 CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
4644 (then the element count must be correct to cover the whole
4645 outer vector and index must be NULL on all elements, or it is
4646 a CONSTRUCTOR of scalar elements, where we as an exception allow
4647 smaller number of elements (assuming zero filling) and
4648 consecutive indexes as compared to NULL indexes (such
4649 CONSTRUCTORs can appear in the IL from FEs). */
4650 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1), i, elt_i, elt_v)
4652 if (elt_t == NULL_TREE)
4654 elt_t = TREE_TYPE (elt_v);
4655 if (TREE_CODE (elt_t) == VECTOR_TYPE)
4657 tree elt_t = TREE_TYPE (elt_v);
4658 if (!useless_type_conversion_p (TREE_TYPE (rhs1_type),
4659 TREE_TYPE (elt_t)))
4661 error ("incorrect type of vector %qs elements",
4662 code_name);
4663 debug_generic_stmt (rhs1);
4664 return true;
4666 else if (maybe_ne (CONSTRUCTOR_NELTS (rhs1)
4667 * TYPE_VECTOR_SUBPARTS (elt_t),
4668 TYPE_VECTOR_SUBPARTS (rhs1_type)))
4670 error ("incorrect number of vector %qs elements",
4671 code_name);
4672 debug_generic_stmt (rhs1);
4673 return true;
4676 else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type),
4677 elt_t))
4679 error ("incorrect type of vector %qs elements",
4680 code_name);
4681 debug_generic_stmt (rhs1);
4682 return true;
4684 else if (maybe_gt (CONSTRUCTOR_NELTS (rhs1),
4685 TYPE_VECTOR_SUBPARTS (rhs1_type)))
4687 error ("incorrect number of vector %qs elements",
4688 code_name);
4689 debug_generic_stmt (rhs1);
4690 return true;
4693 else if (!useless_type_conversion_p (elt_t, TREE_TYPE (elt_v)))
4695 error ("incorrect type of vector CONSTRUCTOR elements");
4696 debug_generic_stmt (rhs1);
4697 return true;
4699 if (elt_i != NULL_TREE
4700 && (TREE_CODE (elt_t) == VECTOR_TYPE
4701 || TREE_CODE (elt_i) != INTEGER_CST
4702 || compare_tree_int (elt_i, i) != 0))
4704 error ("vector %qs with non-NULL element index",
4705 code_name);
4706 debug_generic_stmt (rhs1);
4707 return true;
4709 if (!is_gimple_val (elt_v))
4711 error ("vector %qs element is not a GIMPLE value",
4712 code_name);
4713 debug_generic_stmt (rhs1);
4714 return true;
4718 else if (CONSTRUCTOR_NELTS (rhs1) != 0)
4720 error ("non-vector %qs with elements", code_name);
4721 debug_generic_stmt (rhs1);
4722 return true;
4724 return res;
4726 case ASSERT_EXPR:
4727 /* FIXME. */
4728 rhs1 = fold (ASSERT_EXPR_COND (rhs1));
4729 if (rhs1 == boolean_false_node)
4731 error ("%qs with an always-false condition", code_name);
4732 debug_generic_stmt (rhs1);
4733 return true;
4735 break;
4737 case WITH_SIZE_EXPR:
4738 error ("%qs RHS in assignment statement",
4739 get_tree_code_name (rhs_code));
4740 debug_generic_expr (rhs1);
4741 return true;
4743 case OBJ_TYPE_REF:
4744 /* FIXME. */
4745 return res;
4747 default:;
4750 return res;
4753 /* Verify the contents of a GIMPLE_ASSIGN STMT. Returns true when there
4754 is a problem, otherwise false. */
4756 static bool
4757 verify_gimple_assign (gassign *stmt)
4759 switch (gimple_assign_rhs_class (stmt))
4761 case GIMPLE_SINGLE_RHS:
4762 return verify_gimple_assign_single (stmt);
4764 case GIMPLE_UNARY_RHS:
4765 return verify_gimple_assign_unary (stmt);
4767 case GIMPLE_BINARY_RHS:
4768 return verify_gimple_assign_binary (stmt);
4770 case GIMPLE_TERNARY_RHS:
4771 return verify_gimple_assign_ternary (stmt);
4773 default:
4774 gcc_unreachable ();
4778 /* Verify the contents of a GIMPLE_RETURN STMT. Returns true when there
4779 is a problem, otherwise false. */
4781 static bool
4782 verify_gimple_return (greturn *stmt)
4784 tree op = gimple_return_retval (stmt);
4785 tree restype = TREE_TYPE (TREE_TYPE (cfun->decl));
4787 /* We cannot test for present return values as we do not fix up missing
4788 return values from the original source. */
4789 if (op == NULL)
4790 return false;
4792 if (!is_gimple_val (op)
4793 && TREE_CODE (op) != RESULT_DECL)
4795 error ("invalid operand in return statement");
4796 debug_generic_stmt (op);
4797 return true;
4800 if ((TREE_CODE (op) == RESULT_DECL
4801 && DECL_BY_REFERENCE (op))
4802 || (TREE_CODE (op) == SSA_NAME
4803 && SSA_NAME_VAR (op)
4804 && TREE_CODE (SSA_NAME_VAR (op)) == RESULT_DECL
4805 && DECL_BY_REFERENCE (SSA_NAME_VAR (op))))
4806 op = TREE_TYPE (op);
4808 if (!useless_type_conversion_p (restype, TREE_TYPE (op)))
4810 error ("invalid conversion in return statement");
4811 debug_generic_stmt (restype);
4812 debug_generic_stmt (TREE_TYPE (op));
4813 return true;
4816 return false;
4820 /* Verify the contents of a GIMPLE_GOTO STMT. Returns true when there
4821 is a problem, otherwise false. */
4823 static bool
4824 verify_gimple_goto (ggoto *stmt)
4826 tree dest = gimple_goto_dest (stmt);
4828 /* ??? We have two canonical forms of direct goto destinations, a
4829 bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
4830 if (TREE_CODE (dest) != LABEL_DECL
4831 && (!is_gimple_val (dest)
4832 || !POINTER_TYPE_P (TREE_TYPE (dest))))
4834 error ("goto destination is neither a label nor a pointer");
4835 return true;
4838 return false;
4841 /* Verify the contents of a GIMPLE_SWITCH STMT. Returns true when there
4842 is a problem, otherwise false. */
4844 static bool
4845 verify_gimple_switch (gswitch *stmt)
4847 unsigned int i, n;
4848 tree elt, prev_upper_bound = NULL_TREE;
4849 tree index_type, elt_type = NULL_TREE;
4851 if (!is_gimple_val (gimple_switch_index (stmt)))
4853 error ("invalid operand to switch statement");
4854 debug_generic_stmt (gimple_switch_index (stmt));
4855 return true;
4858 index_type = TREE_TYPE (gimple_switch_index (stmt));
4859 if (! INTEGRAL_TYPE_P (index_type))
4861 error ("non-integral type switch statement");
4862 debug_generic_expr (index_type);
4863 return true;
4866 elt = gimple_switch_label (stmt, 0);
4867 if (CASE_LOW (elt) != NULL_TREE
4868 || CASE_HIGH (elt) != NULL_TREE
4869 || CASE_CHAIN (elt) != NULL_TREE)
4871 error ("invalid default case label in switch statement");
4872 debug_generic_expr (elt);
4873 return true;
4876 n = gimple_switch_num_labels (stmt);
4877 for (i = 1; i < n; i++)
4879 elt = gimple_switch_label (stmt, i);
4881 if (CASE_CHAIN (elt))
4883 error ("invalid %<CASE_CHAIN%>");
4884 debug_generic_expr (elt);
4885 return true;
4887 if (! CASE_LOW (elt))
4889 error ("invalid case label in switch statement");
4890 debug_generic_expr (elt);
4891 return true;
4893 if (CASE_HIGH (elt)
4894 && ! tree_int_cst_lt (CASE_LOW (elt), CASE_HIGH (elt)))
4896 error ("invalid case range in switch statement");
4897 debug_generic_expr (elt);
4898 return true;
4901 if (! elt_type)
4903 elt_type = TREE_TYPE (CASE_LOW (elt));
4904 if (TYPE_PRECISION (index_type) < TYPE_PRECISION (elt_type))
4906 error ("type precision mismatch in switch statement");
4907 return true;
4910 if (TREE_TYPE (CASE_LOW (elt)) != elt_type
4911 || (CASE_HIGH (elt) && TREE_TYPE (CASE_HIGH (elt)) != elt_type))
4913 error ("type mismatch for case label in switch statement");
4914 debug_generic_expr (elt);
4915 return true;
4918 if (prev_upper_bound)
4920 if (! tree_int_cst_lt (prev_upper_bound, CASE_LOW (elt)))
4922 error ("case labels not sorted in switch statement");
4923 return true;
4927 prev_upper_bound = CASE_HIGH (elt);
4928 if (! prev_upper_bound)
4929 prev_upper_bound = CASE_LOW (elt);
4932 return false;
4935 /* Verify a gimple debug statement STMT.
4936 Returns true if anything is wrong. */
4938 static bool
4939 verify_gimple_debug (gimple *stmt ATTRIBUTE_UNUSED)
4941 /* There isn't much that could be wrong in a gimple debug stmt. A
4942 gimple debug bind stmt, for example, maps a tree, that's usually
4943 a VAR_DECL or a PARM_DECL, but that could also be some scalarized
4944 component or member of an aggregate type, to another tree, that
4945 can be an arbitrary expression. These stmts expand into debug
4946 insns, and are converted to debug notes by var-tracking.c. */
4947 return false;
4950 /* Verify a gimple label statement STMT.
4951 Returns true if anything is wrong. */
4953 static bool
4954 verify_gimple_label (glabel *stmt)
4956 tree decl = gimple_label_label (stmt);
4957 int uid;
4958 bool err = false;
4960 if (TREE_CODE (decl) != LABEL_DECL)
4961 return true;
4962 if (!DECL_NONLOCAL (decl) && !FORCED_LABEL (decl)
4963 && DECL_CONTEXT (decl) != current_function_decl)
4965 error ("label context is not the current function declaration");
4966 err |= true;
4969 uid = LABEL_DECL_UID (decl);
4970 if (cfun->cfg
4971 && (uid == -1
4972 || (*label_to_block_map_for_fn (cfun))[uid] != gimple_bb (stmt)))
4974 error ("incorrect entry in %<label_to_block_map%>");
4975 err |= true;
4978 uid = EH_LANDING_PAD_NR (decl);
4979 if (uid)
4981 eh_landing_pad lp = get_eh_landing_pad_from_number (uid);
4982 if (decl != lp->post_landing_pad)
4984 error ("incorrect setting of landing pad number");
4985 err |= true;
4989 return err;
4992 /* Verify a gimple cond statement STMT.
4993 Returns true if anything is wrong. */
4995 static bool
4996 verify_gimple_cond (gcond *stmt)
4998 if (TREE_CODE_CLASS (gimple_cond_code (stmt)) != tcc_comparison)
5000 error ("invalid comparison code in gimple cond");
5001 return true;
5003 if (!(!gimple_cond_true_label (stmt)
5004 || TREE_CODE (gimple_cond_true_label (stmt)) == LABEL_DECL)
5005 || !(!gimple_cond_false_label (stmt)
5006 || TREE_CODE (gimple_cond_false_label (stmt)) == LABEL_DECL))
5008 error ("invalid labels in gimple cond");
5009 return true;
5012 return verify_gimple_comparison (boolean_type_node,
5013 gimple_cond_lhs (stmt),
5014 gimple_cond_rhs (stmt),
5015 gimple_cond_code (stmt));
5018 /* Verify the GIMPLE statement STMT. Returns true if there is an
5019 error, otherwise false. */
5021 static bool
5022 verify_gimple_stmt (gimple *stmt)
5024 switch (gimple_code (stmt))
5026 case GIMPLE_ASSIGN:
5027 return verify_gimple_assign (as_a <gassign *> (stmt));
5029 case GIMPLE_LABEL:
5030 return verify_gimple_label (as_a <glabel *> (stmt));
5032 case GIMPLE_CALL:
5033 return verify_gimple_call (as_a <gcall *> (stmt));
5035 case GIMPLE_COND:
5036 return verify_gimple_cond (as_a <gcond *> (stmt));
5038 case GIMPLE_GOTO:
5039 return verify_gimple_goto (as_a <ggoto *> (stmt));
5041 case GIMPLE_SWITCH:
5042 return verify_gimple_switch (as_a <gswitch *> (stmt));
5044 case GIMPLE_RETURN:
5045 return verify_gimple_return (as_a <greturn *> (stmt));
5047 case GIMPLE_ASM:
5048 return false;
5050 case GIMPLE_TRANSACTION:
5051 return verify_gimple_transaction (as_a <gtransaction *> (stmt));
5053 /* Tuples that do not have tree operands. */
5054 case GIMPLE_NOP:
5055 case GIMPLE_PREDICT:
5056 case GIMPLE_RESX:
5057 case GIMPLE_EH_DISPATCH:
5058 case GIMPLE_EH_MUST_NOT_THROW:
5059 return false;
5061 CASE_GIMPLE_OMP:
5062 /* OpenMP directives are validated by the FE and never operated
5063 on by the optimizers. Furthermore, GIMPLE_OMP_FOR may contain
5064 non-gimple expressions when the main index variable has had
5065 its address taken. This does not affect the loop itself
5066 because the header of an GIMPLE_OMP_FOR is merely used to determine
5067 how to setup the parallel iteration. */
5068 return false;
5070 case GIMPLE_DEBUG:
5071 return verify_gimple_debug (stmt);
5073 default:
5074 gcc_unreachable ();
5078 /* Verify the contents of a GIMPLE_PHI. Returns true if there is a problem,
5079 and false otherwise. */
5081 static bool
5082 verify_gimple_phi (gphi *phi)
5084 bool err = false;
5085 unsigned i;
5086 tree phi_result = gimple_phi_result (phi);
5087 bool virtual_p;
5089 if (!phi_result)
5091 error ("invalid %<PHI%> result");
5092 return true;
5095 virtual_p = virtual_operand_p (phi_result);
5096 if (TREE_CODE (phi_result) != SSA_NAME
5097 || (virtual_p
5098 && SSA_NAME_VAR (phi_result) != gimple_vop (cfun)))
5100 error ("invalid %<PHI%> result");
5101 err = true;
5104 for (i = 0; i < gimple_phi_num_args (phi); i++)
5106 tree t = gimple_phi_arg_def (phi, i);
5108 if (!t)
5110 error ("missing %<PHI%> def");
5111 err |= true;
5112 continue;
5114 /* Addressable variables do have SSA_NAMEs but they
5115 are not considered gimple values. */
5116 else if ((TREE_CODE (t) == SSA_NAME
5117 && virtual_p != virtual_operand_p (t))
5118 || (virtual_p
5119 && (TREE_CODE (t) != SSA_NAME
5120 || SSA_NAME_VAR (t) != gimple_vop (cfun)))
5121 || (!virtual_p
5122 && !is_gimple_val (t)))
5124 error ("invalid %<PHI%> argument");
5125 debug_generic_expr (t);
5126 err |= true;
5128 #ifdef ENABLE_TYPES_CHECKING
5129 if (!useless_type_conversion_p (TREE_TYPE (phi_result), TREE_TYPE (t)))
5131 error ("incompatible types in %<PHI%> argument %u", i);
5132 debug_generic_stmt (TREE_TYPE (phi_result));
5133 debug_generic_stmt (TREE_TYPE (t));
5134 err |= true;
5136 #endif
5139 return err;
5142 /* Verify the GIMPLE statements inside the sequence STMTS. */
5144 static bool
5145 verify_gimple_in_seq_2 (gimple_seq stmts)
5147 gimple_stmt_iterator ittr;
5148 bool err = false;
5150 for (ittr = gsi_start (stmts); !gsi_end_p (ittr); gsi_next (&ittr))
5152 gimple *stmt = gsi_stmt (ittr);
5154 switch (gimple_code (stmt))
5156 case GIMPLE_BIND:
5157 err |= verify_gimple_in_seq_2 (
5158 gimple_bind_body (as_a <gbind *> (stmt)));
5159 break;
5161 case GIMPLE_TRY:
5162 err |= verify_gimple_in_seq_2 (gimple_try_eval (stmt));
5163 err |= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt));
5164 break;
5166 case GIMPLE_EH_FILTER:
5167 err |= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt));
5168 break;
5170 case GIMPLE_EH_ELSE:
5172 geh_else *eh_else = as_a <geh_else *> (stmt);
5173 err |= verify_gimple_in_seq_2 (gimple_eh_else_n_body (eh_else));
5174 err |= verify_gimple_in_seq_2 (gimple_eh_else_e_body (eh_else));
5176 break;
5178 case GIMPLE_CATCH:
5179 err |= verify_gimple_in_seq_2 (gimple_catch_handler (
5180 as_a <gcatch *> (stmt)));
5181 break;
5183 case GIMPLE_TRANSACTION:
5184 err |= verify_gimple_transaction (as_a <gtransaction *> (stmt));
5185 break;
5187 default:
5189 bool err2 = verify_gimple_stmt (stmt);
5190 if (err2)
5191 debug_gimple_stmt (stmt);
5192 err |= err2;
5197 return err;
5200 /* Verify the contents of a GIMPLE_TRANSACTION. Returns true if there
5201 is a problem, otherwise false. */
5203 static bool
5204 verify_gimple_transaction (gtransaction *stmt)
5206 tree lab;
5208 lab = gimple_transaction_label_norm (stmt);
5209 if (lab != NULL && TREE_CODE (lab) != LABEL_DECL)
5210 return true;
5211 lab = gimple_transaction_label_uninst (stmt);
5212 if (lab != NULL && TREE_CODE (lab) != LABEL_DECL)
5213 return true;
5214 lab = gimple_transaction_label_over (stmt);
5215 if (lab != NULL && TREE_CODE (lab) != LABEL_DECL)
5216 return true;
5218 return verify_gimple_in_seq_2 (gimple_transaction_body (stmt));
5222 /* Verify the GIMPLE statements inside the statement list STMTS. */
5224 DEBUG_FUNCTION void
5225 verify_gimple_in_seq (gimple_seq stmts)
5227 timevar_push (TV_TREE_STMT_VERIFY);
5228 if (verify_gimple_in_seq_2 (stmts))
5229 internal_error ("%<verify_gimple%> failed");
5230 timevar_pop (TV_TREE_STMT_VERIFY);
5233 /* Return true when the T can be shared. */
5235 static bool
5236 tree_node_can_be_shared (tree t)
5238 if (IS_TYPE_OR_DECL_P (t)
5239 || TREE_CODE (t) == SSA_NAME
5240 || TREE_CODE (t) == IDENTIFIER_NODE
5241 || TREE_CODE (t) == CASE_LABEL_EXPR
5242 || is_gimple_min_invariant (t))
5243 return true;
5245 if (t == error_mark_node)
5246 return true;
5248 return false;
5251 /* Called via walk_tree. Verify tree sharing. */
5253 static tree
5254 verify_node_sharing_1 (tree *tp, int *walk_subtrees, void *data)
5256 hash_set<void *> *visited = (hash_set<void *> *) data;
5258 if (tree_node_can_be_shared (*tp))
5260 *walk_subtrees = false;
5261 return NULL;
5264 if (visited->add (*tp))
5265 return *tp;
5267 return NULL;
5270 /* Called via walk_gimple_stmt. Verify tree sharing. */
5272 static tree
5273 verify_node_sharing (tree *tp, int *walk_subtrees, void *data)
5275 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
5276 return verify_node_sharing_1 (tp, walk_subtrees, wi->info);
5279 static bool eh_error_found;
5280 bool
5281 verify_eh_throw_stmt_node (gimple *const &stmt, const int &,
5282 hash_set<gimple *> *visited)
5284 if (!visited->contains (stmt))
5286 error ("dead statement in EH table");
5287 debug_gimple_stmt (stmt);
5288 eh_error_found = true;
5290 return true;
5293 /* Verify if the location LOCs block is in BLOCKS. */
5295 static bool
5296 verify_location (hash_set<tree> *blocks, location_t loc)
5298 tree block = LOCATION_BLOCK (loc);
5299 if (block != NULL_TREE
5300 && !blocks->contains (block))
5302 error ("location references block not in block tree");
5303 return true;
5305 if (block != NULL_TREE)
5306 return verify_location (blocks, BLOCK_SOURCE_LOCATION (block));
5307 return false;
5310 /* Called via walk_tree. Verify that expressions have no blocks. */
5312 static tree
5313 verify_expr_no_block (tree *tp, int *walk_subtrees, void *)
5315 if (!EXPR_P (*tp))
5317 *walk_subtrees = false;
5318 return NULL;
5321 location_t loc = EXPR_LOCATION (*tp);
5322 if (LOCATION_BLOCK (loc) != NULL)
5323 return *tp;
5325 return NULL;
5328 /* Called via walk_tree. Verify locations of expressions. */
5330 static tree
5331 verify_expr_location_1 (tree *tp, int *walk_subtrees, void *data)
5333 hash_set<tree> *blocks = (hash_set<tree> *) data;
5334 tree t = *tp;
5336 /* ??? This doesn't really belong here but there's no good place to
5337 stick this remainder of old verify_expr. */
5338 /* ??? This barfs on debug stmts which contain binds to vars with
5339 different function context. */
5340 #if 0
5341 if (VAR_P (t)
5342 || TREE_CODE (t) == PARM_DECL
5343 || TREE_CODE (t) == RESULT_DECL)
5345 tree context = decl_function_context (t);
5346 if (context != cfun->decl
5347 && !SCOPE_FILE_SCOPE_P (context)
5348 && !TREE_STATIC (t)
5349 && !DECL_EXTERNAL (t))
5351 error ("local declaration from a different function");
5352 return t;
5355 #endif
5357 if (VAR_P (t) && DECL_HAS_DEBUG_EXPR_P (t))
5359 tree x = DECL_DEBUG_EXPR (t);
5360 tree addr = walk_tree (&x, verify_expr_no_block, NULL, NULL);
5361 if (addr)
5362 return addr;
5364 if ((VAR_P (t)
5365 || TREE_CODE (t) == PARM_DECL
5366 || TREE_CODE (t) == RESULT_DECL)
5367 && DECL_HAS_VALUE_EXPR_P (t))
5369 tree x = DECL_VALUE_EXPR (t);
5370 tree addr = walk_tree (&x, verify_expr_no_block, NULL, NULL);
5371 if (addr)
5372 return addr;
5375 if (!EXPR_P (t))
5377 *walk_subtrees = false;
5378 return NULL;
5381 location_t loc = EXPR_LOCATION (t);
5382 if (verify_location (blocks, loc))
5383 return t;
5385 return NULL;
5388 /* Called via walk_gimple_op. Verify locations of expressions. */
5390 static tree
5391 verify_expr_location (tree *tp, int *walk_subtrees, void *data)
5393 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
5394 return verify_expr_location_1 (tp, walk_subtrees, wi->info);
5397 /* Insert all subblocks of BLOCK into BLOCKS and recurse. */
5399 static void
5400 collect_subblocks (hash_set<tree> *blocks, tree block)
5402 tree t;
5403 for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
5405 blocks->add (t);
5406 collect_subblocks (blocks, t);
5410 /* Disable warnings about missing quoting in GCC diagnostics for
5411 the verification errors. Their format strings don't follow
5412 GCC diagnostic conventions and trigger an ICE in the end. */
5413 #if __GNUC__ >= 10
5414 # pragma GCC diagnostic push
5415 # pragma GCC diagnostic ignored "-Wformat-diag"
5416 #endif
5418 /* Verify the GIMPLE statements in the CFG of FN. */
5420 DEBUG_FUNCTION void
5421 verify_gimple_in_cfg (struct function *fn, bool verify_nothrow)
5423 basic_block bb;
5424 bool err = false;
5426 timevar_push (TV_TREE_STMT_VERIFY);
5427 hash_set<void *> visited;
5428 hash_set<gimple *> visited_throwing_stmts;
5430 /* Collect all BLOCKs referenced by the BLOCK tree of FN. */
5431 hash_set<tree> blocks;
5432 if (DECL_INITIAL (fn->decl))
5434 blocks.add (DECL_INITIAL (fn->decl));
5435 collect_subblocks (&blocks, DECL_INITIAL (fn->decl));
5438 FOR_EACH_BB_FN (bb, fn)
5440 gimple_stmt_iterator gsi;
5441 edge_iterator ei;
5442 edge e;
5444 for (gphi_iterator gpi = gsi_start_phis (bb);
5445 !gsi_end_p (gpi);
5446 gsi_next (&gpi))
5448 gphi *phi = gpi.phi ();
5449 bool err2 = false;
5450 unsigned i;
5452 if (gimple_bb (phi) != bb)
5454 error ("gimple_bb (phi) is set to a wrong basic block");
5455 err2 = true;
5458 err2 |= verify_gimple_phi (phi);
5460 /* Only PHI arguments have locations. */
5461 if (gimple_location (phi) != UNKNOWN_LOCATION)
5463 error ("PHI node with location");
5464 err2 = true;
5467 for (i = 0; i < gimple_phi_num_args (phi); i++)
5469 tree arg = gimple_phi_arg_def (phi, i);
5470 tree addr = walk_tree (&arg, verify_node_sharing_1,
5471 &visited, NULL);
5472 if (addr)
5474 error ("incorrect sharing of tree nodes");
5475 debug_generic_expr (addr);
5476 err2 |= true;
5478 location_t loc = gimple_phi_arg_location (phi, i);
5479 if (virtual_operand_p (gimple_phi_result (phi))
5480 && loc != UNKNOWN_LOCATION)
5482 error ("virtual PHI with argument locations");
5483 err2 = true;
5485 addr = walk_tree (&arg, verify_expr_location_1, &blocks, NULL);
5486 if (addr)
5488 debug_generic_expr (addr);
5489 err2 = true;
5491 err2 |= verify_location (&blocks, loc);
5494 if (err2)
5495 debug_gimple_stmt (phi);
5496 err |= err2;
5499 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
5501 gimple *stmt = gsi_stmt (gsi);
5502 bool err2 = false;
5503 struct walk_stmt_info wi;
5504 tree addr;
5505 int lp_nr;
5507 if (gimple_bb (stmt) != bb)
5509 error ("gimple_bb (stmt) is set to a wrong basic block");
5510 err2 = true;
5513 err2 |= verify_gimple_stmt (stmt);
5514 err2 |= verify_location (&blocks, gimple_location (stmt));
5516 memset (&wi, 0, sizeof (wi));
5517 wi.info = (void *) &visited;
5518 addr = walk_gimple_op (stmt, verify_node_sharing, &wi);
5519 if (addr)
5521 error ("incorrect sharing of tree nodes");
5522 debug_generic_expr (addr);
5523 err2 |= true;
5526 memset (&wi, 0, sizeof (wi));
5527 wi.info = (void *) &blocks;
5528 addr = walk_gimple_op (stmt, verify_expr_location, &wi);
5529 if (addr)
5531 debug_generic_expr (addr);
5532 err2 |= true;
5535 /* If the statement is marked as part of an EH region, then it is
5536 expected that the statement could throw. Verify that when we
5537 have optimizations that simplify statements such that we prove
5538 that they cannot throw, that we update other data structures
5539 to match. */
5540 lp_nr = lookup_stmt_eh_lp (stmt);
5541 if (lp_nr != 0)
5542 visited_throwing_stmts.add (stmt);
5543 if (lp_nr > 0)
5545 if (!stmt_could_throw_p (cfun, stmt))
5547 if (verify_nothrow)
5549 error ("statement marked for throw, but doesn%'t");
5550 err2 |= true;
5553 else if (!gsi_one_before_end_p (gsi))
5555 error ("statement marked for throw in middle of block");
5556 err2 |= true;
5560 if (err2)
5561 debug_gimple_stmt (stmt);
5562 err |= err2;
5565 FOR_EACH_EDGE (e, ei, bb->succs)
5566 if (e->goto_locus != UNKNOWN_LOCATION)
5567 err |= verify_location (&blocks, e->goto_locus);
5570 hash_map<gimple *, int> *eh_table = get_eh_throw_stmt_table (cfun);
5571 eh_error_found = false;
5572 if (eh_table)
5573 eh_table->traverse<hash_set<gimple *> *, verify_eh_throw_stmt_node>
5574 (&visited_throwing_stmts);
5576 if (err || eh_error_found)
5577 internal_error ("verify_gimple failed");
5579 verify_histograms ();
5580 timevar_pop (TV_TREE_STMT_VERIFY);
5584 /* Verifies that the flow information is OK. */
5586 static int
5587 gimple_verify_flow_info (void)
5589 int err = 0;
5590 basic_block bb;
5591 gimple_stmt_iterator gsi;
5592 gimple *stmt;
5593 edge e;
5594 edge_iterator ei;
5596 if (ENTRY_BLOCK_PTR_FOR_FN (cfun)->il.gimple.seq
5597 || ENTRY_BLOCK_PTR_FOR_FN (cfun)->il.gimple.phi_nodes)
5599 error ("ENTRY_BLOCK has IL associated with it");
5600 err = 1;
5603 if (EXIT_BLOCK_PTR_FOR_FN (cfun)->il.gimple.seq
5604 || EXIT_BLOCK_PTR_FOR_FN (cfun)->il.gimple.phi_nodes)
5606 error ("EXIT_BLOCK has IL associated with it");
5607 err = 1;
5610 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
5611 if (e->flags & EDGE_FALLTHRU)
5613 error ("fallthru to exit from bb %d", e->src->index);
5614 err = 1;
5617 FOR_EACH_BB_FN (bb, cfun)
5619 bool found_ctrl_stmt = false;
5621 stmt = NULL;
5623 /* Skip labels on the start of basic block. */
5624 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
5626 tree label;
5627 gimple *prev_stmt = stmt;
5629 stmt = gsi_stmt (gsi);
5631 if (gimple_code (stmt) != GIMPLE_LABEL)
5632 break;
5634 label = gimple_label_label (as_a <glabel *> (stmt));
5635 if (prev_stmt && DECL_NONLOCAL (label))
5637 error ("nonlocal label %qD is not first in a sequence "
5638 "of labels in bb %d", label, bb->index);
5639 err = 1;
5642 if (prev_stmt && EH_LANDING_PAD_NR (label) != 0)
5644 error ("EH landing pad label %qD is not first in a sequence "
5645 "of labels in bb %d", label, bb->index);
5646 err = 1;
5649 if (label_to_block (cfun, label) != bb)
5651 error ("label %qD to block does not match in bb %d",
5652 label, bb->index);
5653 err = 1;
5656 if (decl_function_context (label) != current_function_decl)
5658 error ("label %qD has incorrect context in bb %d",
5659 label, bb->index);
5660 err = 1;
5664 /* Verify that body of basic block BB is free of control flow. */
5665 for (; !gsi_end_p (gsi); gsi_next (&gsi))
5667 gimple *stmt = gsi_stmt (gsi);
5669 if (found_ctrl_stmt)
5671 error ("control flow in the middle of basic block %d",
5672 bb->index);
5673 err = 1;
5676 if (stmt_ends_bb_p (stmt))
5677 found_ctrl_stmt = true;
5679 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
5681 error ("label %qD in the middle of basic block %d",
5682 gimple_label_label (label_stmt), bb->index);
5683 err = 1;
5687 gsi = gsi_last_nondebug_bb (bb);
5688 if (gsi_end_p (gsi))
5689 continue;
5691 stmt = gsi_stmt (gsi);
5693 if (gimple_code (stmt) == GIMPLE_LABEL)
5694 continue;
5696 err |= verify_eh_edges (stmt);
5698 if (is_ctrl_stmt (stmt))
5700 FOR_EACH_EDGE (e, ei, bb->succs)
5701 if (e->flags & EDGE_FALLTHRU)
5703 error ("fallthru edge after a control statement in bb %d",
5704 bb->index);
5705 err = 1;
5709 if (gimple_code (stmt) != GIMPLE_COND)
5711 /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
5712 after anything else but if statement. */
5713 FOR_EACH_EDGE (e, ei, bb->succs)
5714 if (e->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE))
5716 error ("true/false edge after a non-GIMPLE_COND in bb %d",
5717 bb->index);
5718 err = 1;
5722 switch (gimple_code (stmt))
5724 case GIMPLE_COND:
5726 edge true_edge;
5727 edge false_edge;
5729 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
5731 if (!true_edge
5732 || !false_edge
5733 || !(true_edge->flags & EDGE_TRUE_VALUE)
5734 || !(false_edge->flags & EDGE_FALSE_VALUE)
5735 || (true_edge->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL))
5736 || (false_edge->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL))
5737 || EDGE_COUNT (bb->succs) >= 3)
5739 error ("wrong outgoing edge flags at end of bb %d",
5740 bb->index);
5741 err = 1;
5744 break;
5746 case GIMPLE_GOTO:
5747 if (simple_goto_p (stmt))
5749 error ("explicit goto at end of bb %d", bb->index);
5750 err = 1;
5752 else
5754 /* FIXME. We should double check that the labels in the
5755 destination blocks have their address taken. */
5756 FOR_EACH_EDGE (e, ei, bb->succs)
5757 if ((e->flags & (EDGE_FALLTHRU | EDGE_TRUE_VALUE
5758 | EDGE_FALSE_VALUE))
5759 || !(e->flags & EDGE_ABNORMAL))
5761 error ("wrong outgoing edge flags at end of bb %d",
5762 bb->index);
5763 err = 1;
5766 break;
5768 case GIMPLE_CALL:
5769 if (!gimple_call_builtin_p (stmt, BUILT_IN_RETURN))
5770 break;
5771 /* fallthru */
5772 case GIMPLE_RETURN:
5773 if (!single_succ_p (bb)
5774 || (single_succ_edge (bb)->flags
5775 & (EDGE_FALLTHRU | EDGE_ABNORMAL
5776 | EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
5778 error ("wrong outgoing edge flags at end of bb %d", bb->index);
5779 err = 1;
5781 if (single_succ (bb) != EXIT_BLOCK_PTR_FOR_FN (cfun))
5783 error ("return edge does not point to exit in bb %d",
5784 bb->index);
5785 err = 1;
5787 break;
5789 case GIMPLE_SWITCH:
5791 gswitch *switch_stmt = as_a <gswitch *> (stmt);
5792 tree prev;
5793 edge e;
5794 size_t i, n;
5796 n = gimple_switch_num_labels (switch_stmt);
5798 /* Mark all the destination basic blocks. */
5799 for (i = 0; i < n; ++i)
5801 basic_block label_bb = gimple_switch_label_bb (cfun, switch_stmt, i);
5802 gcc_assert (!label_bb->aux || label_bb->aux == (void *)1);
5803 label_bb->aux = (void *)1;
5806 /* Verify that the case labels are sorted. */
5807 prev = gimple_switch_label (switch_stmt, 0);
5808 for (i = 1; i < n; ++i)
5810 tree c = gimple_switch_label (switch_stmt, i);
5811 if (!CASE_LOW (c))
5813 error ("found default case not at the start of "
5814 "case vector");
5815 err = 1;
5816 continue;
5818 if (CASE_LOW (prev)
5819 && !tree_int_cst_lt (CASE_LOW (prev), CASE_LOW (c)))
5821 error ("case labels not sorted: ");
5822 print_generic_expr (stderr, prev);
5823 fprintf (stderr," is greater than ");
5824 print_generic_expr (stderr, c);
5825 fprintf (stderr," but comes before it.\n");
5826 err = 1;
5828 prev = c;
5830 /* VRP will remove the default case if it can prove it will
5831 never be executed. So do not verify there always exists
5832 a default case here. */
5834 FOR_EACH_EDGE (e, ei, bb->succs)
5836 if (!e->dest->aux)
5838 error ("extra outgoing edge %d->%d",
5839 bb->index, e->dest->index);
5840 err = 1;
5843 e->dest->aux = (void *)2;
5844 if ((e->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL
5845 | EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
5847 error ("wrong outgoing edge flags at end of bb %d",
5848 bb->index);
5849 err = 1;
5853 /* Check that we have all of them. */
5854 for (i = 0; i < n; ++i)
5856 basic_block label_bb = gimple_switch_label_bb (cfun,
5857 switch_stmt, i);
5859 if (label_bb->aux != (void *)2)
5861 error ("missing edge %i->%i", bb->index, label_bb->index);
5862 err = 1;
5866 FOR_EACH_EDGE (e, ei, bb->succs)
5867 e->dest->aux = (void *)0;
5869 break;
5871 case GIMPLE_EH_DISPATCH:
5872 err |= verify_eh_dispatch_edge (as_a <geh_dispatch *> (stmt));
5873 break;
5875 default:
5876 break;
5880 if (dom_info_state (CDI_DOMINATORS) >= DOM_NO_FAST_QUERY)
5881 verify_dominators (CDI_DOMINATORS);
5883 return err;
5886 #if __GNUC__ >= 10
5887 # pragma GCC diagnostic pop
5888 #endif
5890 /* Updates phi nodes after creating a forwarder block joined
5891 by edge FALLTHRU. */
5893 static void
5894 gimple_make_forwarder_block (edge fallthru)
5896 edge e;
5897 edge_iterator ei;
5898 basic_block dummy, bb;
5899 tree var;
5900 gphi_iterator gsi;
5901 bool forward_location_p;
5903 dummy = fallthru->src;
5904 bb = fallthru->dest;
5906 if (single_pred_p (bb))
5907 return;
5909 /* We can forward location info if we have only one predecessor. */
5910 forward_location_p = single_pred_p (dummy);
5912 /* If we redirected a branch we must create new PHI nodes at the
5913 start of BB. */
5914 for (gsi = gsi_start_phis (dummy); !gsi_end_p (gsi); gsi_next (&gsi))
5916 gphi *phi, *new_phi;
5918 phi = gsi.phi ();
5919 var = gimple_phi_result (phi);
5920 new_phi = create_phi_node (var, bb);
5921 gimple_phi_set_result (phi, copy_ssa_name (var, phi));
5922 add_phi_arg (new_phi, gimple_phi_result (phi), fallthru,
5923 forward_location_p
5924 ? gimple_phi_arg_location (phi, 0) : UNKNOWN_LOCATION);
5927 /* Add the arguments we have stored on edges. */
5928 FOR_EACH_EDGE (e, ei, bb->preds)
5930 if (e == fallthru)
5931 continue;
5933 flush_pending_stmts (e);
5938 /* Return a non-special label in the head of basic block BLOCK.
5939 Create one if it doesn't exist. */
5941 tree
5942 gimple_block_label (basic_block bb)
5944 gimple_stmt_iterator i, s = gsi_start_bb (bb);
5945 bool first = true;
5946 tree label;
5947 glabel *stmt;
5949 for (i = s; !gsi_end_p (i); first = false, gsi_next (&i))
5951 stmt = dyn_cast <glabel *> (gsi_stmt (i));
5952 if (!stmt)
5953 break;
5954 label = gimple_label_label (stmt);
5955 if (!DECL_NONLOCAL (label))
5957 if (!first)
5958 gsi_move_before (&i, &s);
5959 return label;
5963 label = create_artificial_label (UNKNOWN_LOCATION);
5964 stmt = gimple_build_label (label);
5965 gsi_insert_before (&s, stmt, GSI_NEW_STMT);
5966 return label;
5970 /* Attempt to perform edge redirection by replacing a possibly complex
5971 jump instruction by a goto or by removing the jump completely.
5972 This can apply only if all edges now point to the same block. The
5973 parameters and return values are equivalent to
5974 redirect_edge_and_branch. */
5976 static edge
5977 gimple_try_redirect_by_replacing_jump (edge e, basic_block target)
5979 basic_block src = e->src;
5980 gimple_stmt_iterator i;
5981 gimple *stmt;
5983 /* We can replace or remove a complex jump only when we have exactly
5984 two edges. */
5985 if (EDGE_COUNT (src->succs) != 2
5986 /* Verify that all targets will be TARGET. Specifically, the
5987 edge that is not E must also go to TARGET. */
5988 || EDGE_SUCC (src, EDGE_SUCC (src, 0) == e)->dest != target)
5989 return NULL;
5991 i = gsi_last_bb (src);
5992 if (gsi_end_p (i))
5993 return NULL;
5995 stmt = gsi_stmt (i);
5997 if (gimple_code (stmt) == GIMPLE_COND || gimple_code (stmt) == GIMPLE_SWITCH)
5999 gsi_remove (&i, true);
6000 e = ssa_redirect_edge (e, target);
6001 e->flags = EDGE_FALLTHRU;
6002 return e;
6005 return NULL;
6009 /* Redirect E to DEST. Return NULL on failure. Otherwise, return the
6010 edge representing the redirected branch. */
6012 static edge
6013 gimple_redirect_edge_and_branch (edge e, basic_block dest)
6015 basic_block bb = e->src;
6016 gimple_stmt_iterator gsi;
6017 edge ret;
6018 gimple *stmt;
6020 if (e->flags & EDGE_ABNORMAL)
6021 return NULL;
6023 if (e->dest == dest)
6024 return NULL;
6026 if (e->flags & EDGE_EH)
6027 return redirect_eh_edge (e, dest);
6029 if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun))
6031 ret = gimple_try_redirect_by_replacing_jump (e, dest);
6032 if (ret)
6033 return ret;
6036 gsi = gsi_last_nondebug_bb (bb);
6037 stmt = gsi_end_p (gsi) ? NULL : gsi_stmt (gsi);
6039 switch (stmt ? gimple_code (stmt) : GIMPLE_ERROR_MARK)
6041 case GIMPLE_COND:
6042 /* For COND_EXPR, we only need to redirect the edge. */
6043 break;
6045 case GIMPLE_GOTO:
6046 /* No non-abnormal edges should lead from a non-simple goto, and
6047 simple ones should be represented implicitly. */
6048 gcc_unreachable ();
6050 case GIMPLE_SWITCH:
6052 gswitch *switch_stmt = as_a <gswitch *> (stmt);
6053 tree label = gimple_block_label (dest);
6054 tree cases = get_cases_for_edge (e, switch_stmt);
6056 /* If we have a list of cases associated with E, then use it
6057 as it's a lot faster than walking the entire case vector. */
6058 if (cases)
6060 edge e2 = find_edge (e->src, dest);
6061 tree last, first;
6063 first = cases;
6064 while (cases)
6066 last = cases;
6067 CASE_LABEL (cases) = label;
6068 cases = CASE_CHAIN (cases);
6071 /* If there was already an edge in the CFG, then we need
6072 to move all the cases associated with E to E2. */
6073 if (e2)
6075 tree cases2 = get_cases_for_edge (e2, switch_stmt);
6077 CASE_CHAIN (last) = CASE_CHAIN (cases2);
6078 CASE_CHAIN (cases2) = first;
6080 bitmap_set_bit (touched_switch_bbs, gimple_bb (stmt)->index);
6082 else
6084 size_t i, n = gimple_switch_num_labels (switch_stmt);
6086 for (i = 0; i < n; i++)
6088 tree elt = gimple_switch_label (switch_stmt, i);
6089 if (label_to_block (cfun, CASE_LABEL (elt)) == e->dest)
6090 CASE_LABEL (elt) = label;
6094 break;
6096 case GIMPLE_ASM:
6098 gasm *asm_stmt = as_a <gasm *> (stmt);
6099 int i, n = gimple_asm_nlabels (asm_stmt);
6100 tree label = NULL;
6102 for (i = 0; i < n; ++i)
6104 tree cons = gimple_asm_label_op (asm_stmt, i);
6105 if (label_to_block (cfun, TREE_VALUE (cons)) == e->dest)
6107 if (!label)
6108 label = gimple_block_label (dest);
6109 TREE_VALUE (cons) = label;
6113 /* If we didn't find any label matching the former edge in the
6114 asm labels, we must be redirecting the fallthrough
6115 edge. */
6116 gcc_assert (label || (e->flags & EDGE_FALLTHRU));
6118 break;
6120 case GIMPLE_RETURN:
6121 gsi_remove (&gsi, true);
6122 e->flags |= EDGE_FALLTHRU;
6123 break;
6125 case GIMPLE_OMP_RETURN:
6126 case GIMPLE_OMP_CONTINUE:
6127 case GIMPLE_OMP_SECTIONS_SWITCH:
6128 case GIMPLE_OMP_FOR:
6129 /* The edges from OMP constructs can be simply redirected. */
6130 break;
6132 case GIMPLE_EH_DISPATCH:
6133 if (!(e->flags & EDGE_FALLTHRU))
6134 redirect_eh_dispatch_edge (as_a <geh_dispatch *> (stmt), e, dest);
6135 break;
6137 case GIMPLE_TRANSACTION:
6138 if (e->flags & EDGE_TM_ABORT)
6139 gimple_transaction_set_label_over (as_a <gtransaction *> (stmt),
6140 gimple_block_label (dest));
6141 else if (e->flags & EDGE_TM_UNINSTRUMENTED)
6142 gimple_transaction_set_label_uninst (as_a <gtransaction *> (stmt),
6143 gimple_block_label (dest));
6144 else
6145 gimple_transaction_set_label_norm (as_a <gtransaction *> (stmt),
6146 gimple_block_label (dest));
6147 break;
6149 default:
6150 /* Otherwise it must be a fallthru edge, and we don't need to
6151 do anything besides redirecting it. */
6152 gcc_assert (e->flags & EDGE_FALLTHRU);
6153 break;
6156 /* Update/insert PHI nodes as necessary. */
6158 /* Now update the edges in the CFG. */
6159 e = ssa_redirect_edge (e, dest);
6161 return e;
6164 /* Returns true if it is possible to remove edge E by redirecting
6165 it to the destination of the other edge from E->src. */
6167 static bool
6168 gimple_can_remove_branch_p (const_edge e)
6170 if (e->flags & (EDGE_ABNORMAL | EDGE_EH))
6171 return false;
6173 return true;
6176 /* Simple wrapper, as we can always redirect fallthru edges. */
6178 static basic_block
6179 gimple_redirect_edge_and_branch_force (edge e, basic_block dest)
6181 e = gimple_redirect_edge_and_branch (e, dest);
6182 gcc_assert (e);
6184 return NULL;
6188 /* Splits basic block BB after statement STMT (but at least after the
6189 labels). If STMT is NULL, BB is split just after the labels. */
6191 static basic_block
6192 gimple_split_block (basic_block bb, void *stmt)
6194 gimple_stmt_iterator gsi;
6195 gimple_stmt_iterator gsi_tgt;
6196 gimple_seq list;
6197 basic_block new_bb;
6198 edge e;
6199 edge_iterator ei;
6201 new_bb = create_empty_bb (bb);
6203 /* Redirect the outgoing edges. */
6204 new_bb->succs = bb->succs;
6205 bb->succs = NULL;
6206 FOR_EACH_EDGE (e, ei, new_bb->succs)
6207 e->src = new_bb;
6209 /* Get a stmt iterator pointing to the first stmt to move. */
6210 if (!stmt || gimple_code ((gimple *) stmt) == GIMPLE_LABEL)
6211 gsi = gsi_after_labels (bb);
6212 else
6214 gsi = gsi_for_stmt ((gimple *) stmt);
6215 gsi_next (&gsi);
6218 /* Move everything from GSI to the new basic block. */
6219 if (gsi_end_p (gsi))
6220 return new_bb;
6222 /* Split the statement list - avoid re-creating new containers as this
6223 brings ugly quadratic memory consumption in the inliner.
6224 (We are still quadratic since we need to update stmt BB pointers,
6225 sadly.) */
6226 gsi_split_seq_before (&gsi, &list);
6227 set_bb_seq (new_bb, list);
6228 for (gsi_tgt = gsi_start (list);
6229 !gsi_end_p (gsi_tgt); gsi_next (&gsi_tgt))
6230 gimple_set_bb (gsi_stmt (gsi_tgt), new_bb);
6232 return new_bb;
6236 /* Moves basic block BB after block AFTER. */
6238 static bool
6239 gimple_move_block_after (basic_block bb, basic_block after)
6241 if (bb->prev_bb == after)
6242 return true;
6244 unlink_block (bb);
6245 link_block (bb, after);
6247 return true;
6251 /* Return TRUE if block BB has no executable statements, otherwise return
6252 FALSE. */
6254 static bool
6255 gimple_empty_block_p (basic_block bb)
6257 /* BB must have no executable statements. */
6258 gimple_stmt_iterator gsi = gsi_after_labels (bb);
6259 if (phi_nodes (bb))
6260 return false;
6261 while (!gsi_end_p (gsi))
6263 gimple *stmt = gsi_stmt (gsi);
6264 if (is_gimple_debug (stmt))
6266 else if (gimple_code (stmt) == GIMPLE_NOP
6267 || gimple_code (stmt) == GIMPLE_PREDICT)
6269 else
6270 return false;
6271 gsi_next (&gsi);
6273 return true;
6277 /* Split a basic block if it ends with a conditional branch and if the
6278 other part of the block is not empty. */
6280 static basic_block
6281 gimple_split_block_before_cond_jump (basic_block bb)
6283 gimple *last, *split_point;
6284 gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
6285 if (gsi_end_p (gsi))
6286 return NULL;
6287 last = gsi_stmt (gsi);
6288 if (gimple_code (last) != GIMPLE_COND
6289 && gimple_code (last) != GIMPLE_SWITCH)
6290 return NULL;
6291 gsi_prev (&gsi);
6292 split_point = gsi_stmt (gsi);
6293 return split_block (bb, split_point)->dest;
6297 /* Return true if basic_block can be duplicated. */
6299 static bool
6300 gimple_can_duplicate_bb_p (const_basic_block bb)
6302 gimple *last = last_stmt (CONST_CAST_BB (bb));
6304 /* Do checks that can only fail for the last stmt, to minimize the work in the
6305 stmt loop. */
6306 if (last) {
6307 /* A transaction is a single entry multiple exit region. It
6308 must be duplicated in its entirety or not at all. */
6309 if (gimple_code (last) == GIMPLE_TRANSACTION)
6310 return false;
6312 /* An IFN_UNIQUE call must be duplicated as part of its group,
6313 or not at all. */
6314 if (is_gimple_call (last)
6315 && gimple_call_internal_p (last)
6316 && gimple_call_internal_unique_p (last))
6317 return false;
6320 for (gimple_stmt_iterator gsi = gsi_start_bb (CONST_CAST_BB (bb));
6321 !gsi_end_p (gsi); gsi_next (&gsi))
6323 gimple *g = gsi_stmt (gsi);
6325 /* An IFN_GOMP_SIMT_ENTER_ALLOC/IFN_GOMP_SIMT_EXIT call must be
6326 duplicated as part of its group, or not at all.
6327 The IFN_GOMP_SIMT_VOTE_ANY and IFN_GOMP_SIMT_XCHG_* are part of such a
6328 group, so the same holds there. */
6329 if (is_gimple_call (g)
6330 && (gimple_call_internal_p (g, IFN_GOMP_SIMT_ENTER_ALLOC)
6331 || gimple_call_internal_p (g, IFN_GOMP_SIMT_EXIT)
6332 || gimple_call_internal_p (g, IFN_GOMP_SIMT_VOTE_ANY)
6333 || gimple_call_internal_p (g, IFN_GOMP_SIMT_XCHG_BFLY)
6334 || gimple_call_internal_p (g, IFN_GOMP_SIMT_XCHG_IDX)))
6335 return false;
6338 return true;
6341 /* Create a duplicate of the basic block BB. NOTE: This does not
6342 preserve SSA form. */
6344 static basic_block
6345 gimple_duplicate_bb (basic_block bb, copy_bb_data *id)
6347 basic_block new_bb;
6348 gimple_stmt_iterator gsi_tgt;
6350 new_bb = create_empty_bb (EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb);
6352 /* Copy the PHI nodes. We ignore PHI node arguments here because
6353 the incoming edges have not been setup yet. */
6354 for (gphi_iterator gpi = gsi_start_phis (bb);
6355 !gsi_end_p (gpi);
6356 gsi_next (&gpi))
6358 gphi *phi, *copy;
6359 phi = gpi.phi ();
6360 copy = create_phi_node (NULL_TREE, new_bb);
6361 create_new_def_for (gimple_phi_result (phi), copy,
6362 gimple_phi_result_ptr (copy));
6363 gimple_set_uid (copy, gimple_uid (phi));
6366 gsi_tgt = gsi_start_bb (new_bb);
6367 for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
6368 !gsi_end_p (gsi);
6369 gsi_next (&gsi))
6371 def_operand_p def_p;
6372 ssa_op_iter op_iter;
6373 tree lhs;
6374 gimple *stmt, *copy;
6376 stmt = gsi_stmt (gsi);
6377 if (gimple_code (stmt) == GIMPLE_LABEL)
6378 continue;
6380 /* Don't duplicate label debug stmts. */
6381 if (gimple_debug_bind_p (stmt)
6382 && TREE_CODE (gimple_debug_bind_get_var (stmt))
6383 == LABEL_DECL)
6384 continue;
6386 /* Create a new copy of STMT and duplicate STMT's virtual
6387 operands. */
6388 copy = gimple_copy (stmt);
6389 gsi_insert_after (&gsi_tgt, copy, GSI_NEW_STMT);
6391 maybe_duplicate_eh_stmt (copy, stmt);
6392 gimple_duplicate_stmt_histograms (cfun, copy, cfun, stmt);
6394 /* When copying around a stmt writing into a local non-user
6395 aggregate, make sure it won't share stack slot with other
6396 vars. */
6397 lhs = gimple_get_lhs (stmt);
6398 if (lhs && TREE_CODE (lhs) != SSA_NAME)
6400 tree base = get_base_address (lhs);
6401 if (base
6402 && (VAR_P (base) || TREE_CODE (base) == RESULT_DECL)
6403 && DECL_IGNORED_P (base)
6404 && !TREE_STATIC (base)
6405 && !DECL_EXTERNAL (base)
6406 && (!VAR_P (base) || !DECL_HAS_VALUE_EXPR_P (base)))
6407 DECL_NONSHAREABLE (base) = 1;
6410 /* If requested remap dependence info of cliques brought in
6411 via inlining. */
6412 if (id)
6413 for (unsigned i = 0; i < gimple_num_ops (copy); ++i)
6415 tree op = gimple_op (copy, i);
6416 if (!op)
6417 continue;
6418 if (TREE_CODE (op) == ADDR_EXPR
6419 || TREE_CODE (op) == WITH_SIZE_EXPR)
6420 op = TREE_OPERAND (op, 0);
6421 while (handled_component_p (op))
6422 op = TREE_OPERAND (op, 0);
6423 if ((TREE_CODE (op) == MEM_REF
6424 || TREE_CODE (op) == TARGET_MEM_REF)
6425 && MR_DEPENDENCE_CLIQUE (op) > 1
6426 && MR_DEPENDENCE_CLIQUE (op) != bb->loop_father->owned_clique)
6428 if (!id->dependence_map)
6429 id->dependence_map = new hash_map<dependence_hash,
6430 unsigned short>;
6431 bool existed;
6432 unsigned short &newc = id->dependence_map->get_or_insert
6433 (MR_DEPENDENCE_CLIQUE (op), &existed);
6434 if (!existed)
6436 gcc_assert (MR_DEPENDENCE_CLIQUE (op) <= cfun->last_clique);
6437 newc = ++cfun->last_clique;
6439 MR_DEPENDENCE_CLIQUE (op) = newc;
6443 /* Create new names for all the definitions created by COPY and
6444 add replacement mappings for each new name. */
6445 FOR_EACH_SSA_DEF_OPERAND (def_p, copy, op_iter, SSA_OP_ALL_DEFS)
6446 create_new_def_for (DEF_FROM_PTR (def_p), copy, def_p);
6449 return new_bb;
6452 /* Adds phi node arguments for edge E_COPY after basic block duplication. */
6454 static void
6455 add_phi_args_after_copy_edge (edge e_copy)
6457 basic_block bb, bb_copy = e_copy->src, dest;
6458 edge e;
6459 edge_iterator ei;
6460 gphi *phi, *phi_copy;
6461 tree def;
6462 gphi_iterator psi, psi_copy;
6464 if (gimple_seq_empty_p (phi_nodes (e_copy->dest)))
6465 return;
6467 bb = bb_copy->flags & BB_DUPLICATED ? get_bb_original (bb_copy) : bb_copy;
6469 if (e_copy->dest->flags & BB_DUPLICATED)
6470 dest = get_bb_original (e_copy->dest);
6471 else
6472 dest = e_copy->dest;
6474 e = find_edge (bb, dest);
6475 if (!e)
6477 /* During loop unrolling the target of the latch edge is copied.
6478 In this case we are not looking for edge to dest, but to
6479 duplicated block whose original was dest. */
6480 FOR_EACH_EDGE (e, ei, bb->succs)
6482 if ((e->dest->flags & BB_DUPLICATED)
6483 && get_bb_original (e->dest) == dest)
6484 break;
6487 gcc_assert (e != NULL);
6490 for (psi = gsi_start_phis (e->dest),
6491 psi_copy = gsi_start_phis (e_copy->dest);
6492 !gsi_end_p (psi);
6493 gsi_next (&psi), gsi_next (&psi_copy))
6495 phi = psi.phi ();
6496 phi_copy = psi_copy.phi ();
6497 def = PHI_ARG_DEF_FROM_EDGE (phi, e);
6498 add_phi_arg (phi_copy, def, e_copy,
6499 gimple_phi_arg_location_from_edge (phi, e));
6504 /* Basic block BB_COPY was created by code duplication. Add phi node
6505 arguments for edges going out of BB_COPY. The blocks that were
6506 duplicated have BB_DUPLICATED set. */
6508 void
6509 add_phi_args_after_copy_bb (basic_block bb_copy)
6511 edge e_copy;
6512 edge_iterator ei;
6514 FOR_EACH_EDGE (e_copy, ei, bb_copy->succs)
6516 add_phi_args_after_copy_edge (e_copy);
6520 /* Blocks in REGION_COPY array of length N_REGION were created by
6521 duplication of basic blocks. Add phi node arguments for edges
6522 going from these blocks. If E_COPY is not NULL, also add
6523 phi node arguments for its destination.*/
6525 void
6526 add_phi_args_after_copy (basic_block *region_copy, unsigned n_region,
6527 edge e_copy)
6529 unsigned i;
6531 for (i = 0; i < n_region; i++)
6532 region_copy[i]->flags |= BB_DUPLICATED;
6534 for (i = 0; i < n_region; i++)
6535 add_phi_args_after_copy_bb (region_copy[i]);
6536 if (e_copy)
6537 add_phi_args_after_copy_edge (e_copy);
6539 for (i = 0; i < n_region; i++)
6540 region_copy[i]->flags &= ~BB_DUPLICATED;
6543 /* Duplicates a REGION (set of N_REGION basic blocks) with just a single
6544 important exit edge EXIT. By important we mean that no SSA name defined
6545 inside region is live over the other exit edges of the region. All entry
6546 edges to the region must go to ENTRY->dest. The edge ENTRY is redirected
6547 to the duplicate of the region. Dominance and loop information is
6548 updated if UPDATE_DOMINANCE is true, but not the SSA web. If
6549 UPDATE_DOMINANCE is false then we assume that the caller will update the
6550 dominance information after calling this function. The new basic
6551 blocks are stored to REGION_COPY in the same order as they had in REGION,
6552 provided that REGION_COPY is not NULL.
6553 The function returns false if it is unable to copy the region,
6554 true otherwise. */
6556 bool
6557 gimple_duplicate_sese_region (edge entry, edge exit,
6558 basic_block *region, unsigned n_region,
6559 basic_block *region_copy,
6560 bool update_dominance)
6562 unsigned i;
6563 bool free_region_copy = false, copying_header = false;
6564 class loop *loop = entry->dest->loop_father;
6565 edge exit_copy;
6566 edge redirected;
6567 profile_count total_count = profile_count::uninitialized ();
6568 profile_count entry_count = profile_count::uninitialized ();
6570 if (!can_copy_bbs_p (region, n_region))
6571 return false;
6573 /* Some sanity checking. Note that we do not check for all possible
6574 missuses of the functions. I.e. if you ask to copy something weird,
6575 it will work, but the state of structures probably will not be
6576 correct. */
6577 for (i = 0; i < n_region; i++)
6579 /* We do not handle subloops, i.e. all the blocks must belong to the
6580 same loop. */
6581 if (region[i]->loop_father != loop)
6582 return false;
6584 if (region[i] != entry->dest
6585 && region[i] == loop->header)
6586 return false;
6589 /* In case the function is used for loop header copying (which is the primary
6590 use), ensure that EXIT and its copy will be new latch and entry edges. */
6591 if (loop->header == entry->dest)
6593 copying_header = true;
6595 if (!dominated_by_p (CDI_DOMINATORS, loop->latch, exit->src))
6596 return false;
6598 for (i = 0; i < n_region; i++)
6599 if (region[i] != exit->src
6600 && dominated_by_p (CDI_DOMINATORS, region[i], exit->src))
6601 return false;
6604 initialize_original_copy_tables ();
6606 if (copying_header)
6607 set_loop_copy (loop, loop_outer (loop));
6608 else
6609 set_loop_copy (loop, loop);
6611 if (!region_copy)
6613 region_copy = XNEWVEC (basic_block, n_region);
6614 free_region_copy = true;
6617 /* Record blocks outside the region that are dominated by something
6618 inside. */
6619 auto_vec<basic_block> doms;
6620 if (update_dominance)
6622 doms = get_dominated_by_region (CDI_DOMINATORS, region, n_region);
6625 if (entry->dest->count.initialized_p ())
6627 total_count = entry->dest->count;
6628 entry_count = entry->count ();
6629 /* Fix up corner cases, to avoid division by zero or creation of negative
6630 frequencies. */
6631 if (entry_count > total_count)
6632 entry_count = total_count;
6635 copy_bbs (region, n_region, region_copy, &exit, 1, &exit_copy, loop,
6636 split_edge_bb_loc (entry), update_dominance);
6637 if (total_count.initialized_p () && entry_count.initialized_p ())
6639 scale_bbs_frequencies_profile_count (region, n_region,
6640 total_count - entry_count,
6641 total_count);
6642 scale_bbs_frequencies_profile_count (region_copy, n_region, entry_count,
6643 total_count);
6646 if (copying_header)
6648 loop->header = exit->dest;
6649 loop->latch = exit->src;
6652 /* Redirect the entry and add the phi node arguments. */
6653 redirected = redirect_edge_and_branch (entry, get_bb_copy (entry->dest));
6654 gcc_assert (redirected != NULL);
6655 flush_pending_stmts (entry);
6657 /* Concerning updating of dominators: We must recount dominators
6658 for entry block and its copy. Anything that is outside of the
6659 region, but was dominated by something inside needs recounting as
6660 well. */
6661 if (update_dominance)
6663 set_immediate_dominator (CDI_DOMINATORS, entry->dest, entry->src);
6664 doms.safe_push (get_bb_original (entry->dest));
6665 iterate_fix_dominators (CDI_DOMINATORS, doms, false);
6668 /* Add the other PHI node arguments. */
6669 add_phi_args_after_copy (region_copy, n_region, NULL);
6671 if (free_region_copy)
6672 free (region_copy);
6674 free_original_copy_tables ();
6675 return true;
6678 /* Checks if BB is part of the region defined by N_REGION BBS. */
6679 static bool
6680 bb_part_of_region_p (basic_block bb, basic_block* bbs, unsigned n_region)
6682 unsigned int n;
6684 for (n = 0; n < n_region; n++)
6686 if (bb == bbs[n])
6687 return true;
6689 return false;
6692 /* Duplicates REGION consisting of N_REGION blocks. The new blocks
6693 are stored to REGION_COPY in the same order in that they appear
6694 in REGION, if REGION_COPY is not NULL. ENTRY is the entry to
6695 the region, EXIT an exit from it. The condition guarding EXIT
6696 is moved to ENTRY. Returns true if duplication succeeds, false
6697 otherwise.
6699 For example,
6701 some_code;
6702 if (cond)
6704 else
6707 is transformed to
6709 if (cond)
6711 some_code;
6714 else
6716 some_code;
6721 bool
6722 gimple_duplicate_sese_tail (edge entry, edge exit,
6723 basic_block *region, unsigned n_region,
6724 basic_block *region_copy)
6726 unsigned i;
6727 bool free_region_copy = false;
6728 class loop *loop = exit->dest->loop_father;
6729 class loop *orig_loop = entry->dest->loop_father;
6730 basic_block switch_bb, entry_bb, nentry_bb;
6731 profile_count total_count = profile_count::uninitialized (),
6732 exit_count = profile_count::uninitialized ();
6733 edge exits[2], nexits[2], e;
6734 gimple_stmt_iterator gsi;
6735 gimple *cond_stmt;
6736 edge sorig, snew;
6737 basic_block exit_bb;
6738 gphi_iterator psi;
6739 gphi *phi;
6740 tree def;
6741 class loop *target, *aloop, *cloop;
6743 gcc_assert (EDGE_COUNT (exit->src->succs) == 2);
6744 exits[0] = exit;
6745 exits[1] = EDGE_SUCC (exit->src, EDGE_SUCC (exit->src, 0) == exit);
6747 if (!can_copy_bbs_p (region, n_region))
6748 return false;
6750 initialize_original_copy_tables ();
6751 set_loop_copy (orig_loop, loop);
6753 target= loop;
6754 for (aloop = orig_loop->inner; aloop; aloop = aloop->next)
6756 if (bb_part_of_region_p (aloop->header, region, n_region))
6758 cloop = duplicate_loop (aloop, target);
6759 duplicate_subloops (aloop, cloop);
6763 if (!region_copy)
6765 region_copy = XNEWVEC (basic_block, n_region);
6766 free_region_copy = true;
6769 gcc_assert (!need_ssa_update_p (cfun));
6771 /* Record blocks outside the region that are dominated by something
6772 inside. */
6773 auto_vec<basic_block> doms = get_dominated_by_region (CDI_DOMINATORS, region,
6774 n_region);
6776 total_count = exit->src->count;
6777 exit_count = exit->count ();
6778 /* Fix up corner cases, to avoid division by zero or creation of negative
6779 frequencies. */
6780 if (exit_count > total_count)
6781 exit_count = total_count;
6783 copy_bbs (region, n_region, region_copy, exits, 2, nexits, orig_loop,
6784 split_edge_bb_loc (exit), true);
6785 if (total_count.initialized_p () && exit_count.initialized_p ())
6787 scale_bbs_frequencies_profile_count (region, n_region,
6788 total_count - exit_count,
6789 total_count);
6790 scale_bbs_frequencies_profile_count (region_copy, n_region, exit_count,
6791 total_count);
6794 /* Create the switch block, and put the exit condition to it. */
6795 entry_bb = entry->dest;
6796 nentry_bb = get_bb_copy (entry_bb);
6797 if (!last_stmt (entry->src)
6798 || !stmt_ends_bb_p (last_stmt (entry->src)))
6799 switch_bb = entry->src;
6800 else
6801 switch_bb = split_edge (entry);
6802 set_immediate_dominator (CDI_DOMINATORS, nentry_bb, switch_bb);
6804 gsi = gsi_last_bb (switch_bb);
6805 cond_stmt = last_stmt (exit->src);
6806 gcc_assert (gimple_code (cond_stmt) == GIMPLE_COND);
6807 cond_stmt = gimple_copy (cond_stmt);
6809 gsi_insert_after (&gsi, cond_stmt, GSI_NEW_STMT);
6811 sorig = single_succ_edge (switch_bb);
6812 sorig->flags = exits[1]->flags;
6813 sorig->probability = exits[1]->probability;
6814 snew = make_edge (switch_bb, nentry_bb, exits[0]->flags);
6815 snew->probability = exits[0]->probability;
6818 /* Register the new edge from SWITCH_BB in loop exit lists. */
6819 rescan_loop_exit (snew, true, false);
6821 /* Add the PHI node arguments. */
6822 add_phi_args_after_copy (region_copy, n_region, snew);
6824 /* Get rid of now superfluous conditions and associated edges (and phi node
6825 arguments). */
6826 exit_bb = exit->dest;
6828 e = redirect_edge_and_branch (exits[0], exits[1]->dest);
6829 PENDING_STMT (e) = NULL;
6831 /* The latch of ORIG_LOOP was copied, and so was the backedge
6832 to the original header. We redirect this backedge to EXIT_BB. */
6833 for (i = 0; i < n_region; i++)
6834 if (get_bb_original (region_copy[i]) == orig_loop->latch)
6836 gcc_assert (single_succ_edge (region_copy[i]));
6837 e = redirect_edge_and_branch (single_succ_edge (region_copy[i]), exit_bb);
6838 PENDING_STMT (e) = NULL;
6839 for (psi = gsi_start_phis (exit_bb);
6840 !gsi_end_p (psi);
6841 gsi_next (&psi))
6843 phi = psi.phi ();
6844 def = PHI_ARG_DEF (phi, nexits[0]->dest_idx);
6845 add_phi_arg (phi, def, e, gimple_phi_arg_location_from_edge (phi, e));
6848 e = redirect_edge_and_branch (nexits[1], nexits[0]->dest);
6849 PENDING_STMT (e) = NULL;
6851 /* Anything that is outside of the region, but was dominated by something
6852 inside needs to update dominance info. */
6853 iterate_fix_dominators (CDI_DOMINATORS, doms, false);
6854 /* Update the SSA web. */
6855 update_ssa (TODO_update_ssa);
6857 if (free_region_copy)
6858 free (region_copy);
6860 free_original_copy_tables ();
6861 return true;
6864 /* Add all the blocks dominated by ENTRY to the array BBS_P. Stop
6865 adding blocks when the dominator traversal reaches EXIT. This
6866 function silently assumes that ENTRY strictly dominates EXIT. */
6868 void
6869 gather_blocks_in_sese_region (basic_block entry, basic_block exit,
6870 vec<basic_block> *bbs_p)
6872 basic_block son;
6874 for (son = first_dom_son (CDI_DOMINATORS, entry);
6875 son;
6876 son = next_dom_son (CDI_DOMINATORS, son))
6878 bbs_p->safe_push (son);
6879 if (son != exit)
6880 gather_blocks_in_sese_region (son, exit, bbs_p);
6884 /* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
6885 The duplicates are recorded in VARS_MAP. */
6887 static void
6888 replace_by_duplicate_decl (tree *tp, hash_map<tree, tree> *vars_map,
6889 tree to_context)
6891 tree t = *tp, new_t;
6892 struct function *f = DECL_STRUCT_FUNCTION (to_context);
6894 if (DECL_CONTEXT (t) == to_context)
6895 return;
6897 bool existed;
6898 tree &loc = vars_map->get_or_insert (t, &existed);
6900 if (!existed)
6902 if (SSA_VAR_P (t))
6904 new_t = copy_var_decl (t, DECL_NAME (t), TREE_TYPE (t));
6905 add_local_decl (f, new_t);
6907 else
6909 gcc_assert (TREE_CODE (t) == CONST_DECL);
6910 new_t = copy_node (t);
6912 DECL_CONTEXT (new_t) = to_context;
6914 loc = new_t;
6916 else
6917 new_t = loc;
6919 *tp = new_t;
6923 /* Creates an ssa name in TO_CONTEXT equivalent to NAME.
6924 VARS_MAP maps old ssa names and var_decls to the new ones. */
6926 static tree
6927 replace_ssa_name (tree name, hash_map<tree, tree> *vars_map,
6928 tree to_context)
6930 tree new_name;
6932 gcc_assert (!virtual_operand_p (name));
6934 tree *loc = vars_map->get (name);
6936 if (!loc)
6938 tree decl = SSA_NAME_VAR (name);
6939 if (decl)
6941 gcc_assert (!SSA_NAME_IS_DEFAULT_DEF (name));
6942 replace_by_duplicate_decl (&decl, vars_map, to_context);
6943 new_name = make_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context),
6944 decl, SSA_NAME_DEF_STMT (name));
6946 else
6947 new_name = copy_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context),
6948 name, SSA_NAME_DEF_STMT (name));
6950 /* Now that we've used the def stmt to define new_name, make sure it
6951 doesn't define name anymore. */
6952 SSA_NAME_DEF_STMT (name) = NULL;
6954 vars_map->put (name, new_name);
6956 else
6957 new_name = *loc;
6959 return new_name;
6962 struct move_stmt_d
6964 tree orig_block;
6965 tree new_block;
6966 tree from_context;
6967 tree to_context;
6968 hash_map<tree, tree> *vars_map;
6969 htab_t new_label_map;
6970 hash_map<void *, void *> *eh_map;
6971 bool remap_decls_p;
6974 /* Helper for move_block_to_fn. Set TREE_BLOCK in every expression
6975 contained in *TP if it has been ORIG_BLOCK previously and change the
6976 DECL_CONTEXT of every local variable referenced in *TP. */
6978 static tree
6979 move_stmt_op (tree *tp, int *walk_subtrees, void *data)
6981 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
6982 struct move_stmt_d *p = (struct move_stmt_d *) wi->info;
6983 tree t = *tp;
6985 if (EXPR_P (t))
6987 tree block = TREE_BLOCK (t);
6988 if (block == NULL_TREE)
6990 else if (block == p->orig_block
6991 || p->orig_block == NULL_TREE)
6993 /* tree_node_can_be_shared says we can share invariant
6994 addresses but unshare_expr copies them anyways. Make sure
6995 to unshare before adjusting the block in place - we do not
6996 always see a copy here. */
6997 if (TREE_CODE (t) == ADDR_EXPR
6998 && is_gimple_min_invariant (t))
6999 *tp = t = unshare_expr (t);
7000 TREE_SET_BLOCK (t, p->new_block);
7002 else if (flag_checking)
7004 while (block && TREE_CODE (block) == BLOCK && block != p->orig_block)
7005 block = BLOCK_SUPERCONTEXT (block);
7006 gcc_assert (block == p->orig_block);
7009 else if (DECL_P (t) || TREE_CODE (t) == SSA_NAME)
7011 if (TREE_CODE (t) == SSA_NAME)
7012 *tp = replace_ssa_name (t, p->vars_map, p->to_context);
7013 else if (TREE_CODE (t) == PARM_DECL
7014 && gimple_in_ssa_p (cfun))
7015 *tp = *(p->vars_map->get (t));
7016 else if (TREE_CODE (t) == LABEL_DECL)
7018 if (p->new_label_map)
7020 struct tree_map in, *out;
7021 in.base.from = t;
7022 out = (struct tree_map *)
7023 htab_find_with_hash (p->new_label_map, &in, DECL_UID (t));
7024 if (out)
7025 *tp = t = out->to;
7028 /* For FORCED_LABELs we can end up with references from other
7029 functions if some SESE regions are outlined. It is UB to
7030 jump in between them, but they could be used just for printing
7031 addresses etc. In that case, DECL_CONTEXT on the label should
7032 be the function containing the glabel stmt with that LABEL_DECL,
7033 rather than whatever function a reference to the label was seen
7034 last time. */
7035 if (!FORCED_LABEL (t) && !DECL_NONLOCAL (t))
7036 DECL_CONTEXT (t) = p->to_context;
7038 else if (p->remap_decls_p)
7040 /* Replace T with its duplicate. T should no longer appear in the
7041 parent function, so this looks wasteful; however, it may appear
7042 in referenced_vars, and more importantly, as virtual operands of
7043 statements, and in alias lists of other variables. It would be
7044 quite difficult to expunge it from all those places. ??? It might
7045 suffice to do this for addressable variables. */
7046 if ((VAR_P (t) && !is_global_var (t))
7047 || TREE_CODE (t) == CONST_DECL)
7048 replace_by_duplicate_decl (tp, p->vars_map, p->to_context);
7050 *walk_subtrees = 0;
7052 else if (TYPE_P (t))
7053 *walk_subtrees = 0;
7055 return NULL_TREE;
7058 /* Helper for move_stmt_r. Given an EH region number for the source
7059 function, map that to the duplicate EH regio number in the dest. */
7061 static int
7062 move_stmt_eh_region_nr (int old_nr, struct move_stmt_d *p)
7064 eh_region old_r, new_r;
7066 old_r = get_eh_region_from_number (old_nr);
7067 new_r = static_cast<eh_region> (*p->eh_map->get (old_r));
7069 return new_r->index;
7072 /* Similar, but operate on INTEGER_CSTs. */
7074 static tree
7075 move_stmt_eh_region_tree_nr (tree old_t_nr, struct move_stmt_d *p)
7077 int old_nr, new_nr;
7079 old_nr = tree_to_shwi (old_t_nr);
7080 new_nr = move_stmt_eh_region_nr (old_nr, p);
7082 return build_int_cst (integer_type_node, new_nr);
7085 /* Like move_stmt_op, but for gimple statements.
7087 Helper for move_block_to_fn. Set GIMPLE_BLOCK in every expression
7088 contained in the current statement in *GSI_P and change the
7089 DECL_CONTEXT of every local variable referenced in the current
7090 statement. */
7092 static tree
7093 move_stmt_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
7094 struct walk_stmt_info *wi)
7096 struct move_stmt_d *p = (struct move_stmt_d *) wi->info;
7097 gimple *stmt = gsi_stmt (*gsi_p);
7098 tree block = gimple_block (stmt);
7100 if (block == p->orig_block
7101 || (p->orig_block == NULL_TREE
7102 && block != NULL_TREE))
7103 gimple_set_block (stmt, p->new_block);
7105 switch (gimple_code (stmt))
7107 case GIMPLE_CALL:
7108 /* Remap the region numbers for __builtin_eh_{pointer,filter}. */
7110 tree r, fndecl = gimple_call_fndecl (stmt);
7111 if (fndecl && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL))
7112 switch (DECL_FUNCTION_CODE (fndecl))
7114 case BUILT_IN_EH_COPY_VALUES:
7115 r = gimple_call_arg (stmt, 1);
7116 r = move_stmt_eh_region_tree_nr (r, p);
7117 gimple_call_set_arg (stmt, 1, r);
7118 /* FALLTHRU */
7120 case BUILT_IN_EH_POINTER:
7121 case BUILT_IN_EH_FILTER:
7122 r = gimple_call_arg (stmt, 0);
7123 r = move_stmt_eh_region_tree_nr (r, p);
7124 gimple_call_set_arg (stmt, 0, r);
7125 break;
7127 default:
7128 break;
7131 break;
7133 case GIMPLE_RESX:
7135 gresx *resx_stmt = as_a <gresx *> (stmt);
7136 int r = gimple_resx_region (resx_stmt);
7137 r = move_stmt_eh_region_nr (r, p);
7138 gimple_resx_set_region (resx_stmt, r);
7140 break;
7142 case GIMPLE_EH_DISPATCH:
7144 geh_dispatch *eh_dispatch_stmt = as_a <geh_dispatch *> (stmt);
7145 int r = gimple_eh_dispatch_region (eh_dispatch_stmt);
7146 r = move_stmt_eh_region_nr (r, p);
7147 gimple_eh_dispatch_set_region (eh_dispatch_stmt, r);
7149 break;
7151 case GIMPLE_OMP_RETURN:
7152 case GIMPLE_OMP_CONTINUE:
7153 break;
7155 case GIMPLE_LABEL:
7157 /* For FORCED_LABEL, move_stmt_op doesn't adjust DECL_CONTEXT,
7158 so that such labels can be referenced from other regions.
7159 Make sure to update it when seeing a GIMPLE_LABEL though,
7160 that is the owner of the label. */
7161 walk_gimple_op (stmt, move_stmt_op, wi);
7162 *handled_ops_p = true;
7163 tree label = gimple_label_label (as_a <glabel *> (stmt));
7164 if (FORCED_LABEL (label) || DECL_NONLOCAL (label))
7165 DECL_CONTEXT (label) = p->to_context;
7167 break;
7169 default:
7170 if (is_gimple_omp (stmt))
7172 /* Do not remap variables inside OMP directives. Variables
7173 referenced in clauses and directive header belong to the
7174 parent function and should not be moved into the child
7175 function. */
7176 bool save_remap_decls_p = p->remap_decls_p;
7177 p->remap_decls_p = false;
7178 *handled_ops_p = true;
7180 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt), move_stmt_r,
7181 move_stmt_op, wi);
7183 p->remap_decls_p = save_remap_decls_p;
7185 break;
7188 return NULL_TREE;
7191 /* Move basic block BB from function CFUN to function DEST_FN. The
7192 block is moved out of the original linked list and placed after
7193 block AFTER in the new list. Also, the block is removed from the
7194 original array of blocks and placed in DEST_FN's array of blocks.
7195 If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
7196 updated to reflect the moved edges.
7198 The local variables are remapped to new instances, VARS_MAP is used
7199 to record the mapping. */
7201 static void
7202 move_block_to_fn (struct function *dest_cfun, basic_block bb,
7203 basic_block after, bool update_edge_count_p,
7204 struct move_stmt_d *d)
7206 struct control_flow_graph *cfg;
7207 edge_iterator ei;
7208 edge e;
7209 gimple_stmt_iterator si;
7210 unsigned old_len;
7212 /* Remove BB from dominance structures. */
7213 delete_from_dominance_info (CDI_DOMINATORS, bb);
7215 /* Move BB from its current loop to the copy in the new function. */
7216 if (current_loops)
7218 class loop *new_loop = (class loop *)bb->loop_father->aux;
7219 if (new_loop)
7220 bb->loop_father = new_loop;
7223 /* Link BB to the new linked list. */
7224 move_block_after (bb, after);
7226 /* Update the edge count in the corresponding flowgraphs. */
7227 if (update_edge_count_p)
7228 FOR_EACH_EDGE (e, ei, bb->succs)
7230 cfun->cfg->x_n_edges--;
7231 dest_cfun->cfg->x_n_edges++;
7234 /* Remove BB from the original basic block array. */
7235 (*cfun->cfg->x_basic_block_info)[bb->index] = NULL;
7236 cfun->cfg->x_n_basic_blocks--;
7238 /* Grow DEST_CFUN's basic block array if needed. */
7239 cfg = dest_cfun->cfg;
7240 cfg->x_n_basic_blocks++;
7241 if (bb->index >= cfg->x_last_basic_block)
7242 cfg->x_last_basic_block = bb->index + 1;
7244 old_len = vec_safe_length (cfg->x_basic_block_info);
7245 if ((unsigned) cfg->x_last_basic_block >= old_len)
7246 vec_safe_grow_cleared (cfg->x_basic_block_info,
7247 cfg->x_last_basic_block + 1);
7249 (*cfg->x_basic_block_info)[bb->index] = bb;
7251 /* Remap the variables in phi nodes. */
7252 for (gphi_iterator psi = gsi_start_phis (bb);
7253 !gsi_end_p (psi); )
7255 gphi *phi = psi.phi ();
7256 use_operand_p use;
7257 tree op = PHI_RESULT (phi);
7258 ssa_op_iter oi;
7259 unsigned i;
7261 if (virtual_operand_p (op))
7263 /* Remove the phi nodes for virtual operands (alias analysis will be
7264 run for the new function, anyway). But replace all uses that
7265 might be outside of the region we move. */
7266 use_operand_p use_p;
7267 imm_use_iterator iter;
7268 gimple *use_stmt;
7269 FOR_EACH_IMM_USE_STMT (use_stmt, iter, op)
7270 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
7271 SET_USE (use_p, SSA_NAME_VAR (op));
7272 remove_phi_node (&psi, true);
7273 continue;
7276 SET_PHI_RESULT (phi,
7277 replace_ssa_name (op, d->vars_map, dest_cfun->decl));
7278 FOR_EACH_PHI_ARG (use, phi, oi, SSA_OP_USE)
7280 op = USE_FROM_PTR (use);
7281 if (TREE_CODE (op) == SSA_NAME)
7282 SET_USE (use, replace_ssa_name (op, d->vars_map, dest_cfun->decl));
7285 for (i = 0; i < EDGE_COUNT (bb->preds); i++)
7287 location_t locus = gimple_phi_arg_location (phi, i);
7288 tree block = LOCATION_BLOCK (locus);
7290 if (locus == UNKNOWN_LOCATION)
7291 continue;
7292 if (d->orig_block == NULL_TREE || block == d->orig_block)
7294 locus = set_block (locus, d->new_block);
7295 gimple_phi_arg_set_location (phi, i, locus);
7299 gsi_next (&psi);
7302 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
7304 gimple *stmt = gsi_stmt (si);
7305 struct walk_stmt_info wi;
7307 memset (&wi, 0, sizeof (wi));
7308 wi.info = d;
7309 walk_gimple_stmt (&si, move_stmt_r, move_stmt_op, &wi);
7311 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
7313 tree label = gimple_label_label (label_stmt);
7314 int uid = LABEL_DECL_UID (label);
7316 gcc_assert (uid > -1);
7318 old_len = vec_safe_length (cfg->x_label_to_block_map);
7319 if (old_len <= (unsigned) uid)
7320 vec_safe_grow_cleared (cfg->x_label_to_block_map, uid + 1);
7322 (*cfg->x_label_to_block_map)[uid] = bb;
7323 (*cfun->cfg->x_label_to_block_map)[uid] = NULL;
7325 gcc_assert (DECL_CONTEXT (label) == dest_cfun->decl);
7327 if (uid >= dest_cfun->cfg->last_label_uid)
7328 dest_cfun->cfg->last_label_uid = uid + 1;
7331 maybe_duplicate_eh_stmt_fn (dest_cfun, stmt, cfun, stmt, d->eh_map, 0);
7332 remove_stmt_from_eh_lp_fn (cfun, stmt);
7334 gimple_duplicate_stmt_histograms (dest_cfun, stmt, cfun, stmt);
7335 gimple_remove_stmt_histograms (cfun, stmt);
7337 /* We cannot leave any operands allocated from the operand caches of
7338 the current function. */
7339 free_stmt_operands (cfun, stmt);
7340 push_cfun (dest_cfun);
7341 update_stmt (stmt);
7342 if (is_gimple_call (stmt))
7343 notice_special_calls (as_a <gcall *> (stmt));
7344 pop_cfun ();
7347 FOR_EACH_EDGE (e, ei, bb->succs)
7348 if (e->goto_locus != UNKNOWN_LOCATION)
7350 tree block = LOCATION_BLOCK (e->goto_locus);
7351 if (d->orig_block == NULL_TREE
7352 || block == d->orig_block)
7353 e->goto_locus = set_block (e->goto_locus, d->new_block);
7357 /* Examine the statements in BB (which is in SRC_CFUN); find and return
7358 the outermost EH region. Use REGION as the incoming base EH region.
7359 If there is no single outermost region, return NULL and set *ALL to
7360 true. */
7362 static eh_region
7363 find_outermost_region_in_block (struct function *src_cfun,
7364 basic_block bb, eh_region region,
7365 bool *all)
7367 gimple_stmt_iterator si;
7369 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
7371 gimple *stmt = gsi_stmt (si);
7372 eh_region stmt_region;
7373 int lp_nr;
7375 lp_nr = lookup_stmt_eh_lp_fn (src_cfun, stmt);
7376 stmt_region = get_eh_region_from_lp_number_fn (src_cfun, lp_nr);
7377 if (stmt_region)
7379 if (region == NULL)
7380 region = stmt_region;
7381 else if (stmt_region != region)
7383 region = eh_region_outermost (src_cfun, stmt_region, region);
7384 if (region == NULL)
7386 *all = true;
7387 return NULL;
7393 return region;
7396 static tree
7397 new_label_mapper (tree decl, void *data)
7399 htab_t hash = (htab_t) data;
7400 struct tree_map *m;
7401 void **slot;
7403 gcc_assert (TREE_CODE (decl) == LABEL_DECL);
7405 m = XNEW (struct tree_map);
7406 m->hash = DECL_UID (decl);
7407 m->base.from = decl;
7408 m->to = create_artificial_label (UNKNOWN_LOCATION);
7409 LABEL_DECL_UID (m->to) = LABEL_DECL_UID (decl);
7410 if (LABEL_DECL_UID (m->to) >= cfun->cfg->last_label_uid)
7411 cfun->cfg->last_label_uid = LABEL_DECL_UID (m->to) + 1;
7413 slot = htab_find_slot_with_hash (hash, m, m->hash, INSERT);
7414 gcc_assert (*slot == NULL);
7416 *slot = m;
7418 return m->to;
7421 /* Tree walker to replace the decls used inside value expressions by
7422 duplicates. */
7424 static tree
7425 replace_block_vars_by_duplicates_1 (tree *tp, int *walk_subtrees, void *data)
7427 struct replace_decls_d *rd = (struct replace_decls_d *)data;
7429 switch (TREE_CODE (*tp))
7431 case VAR_DECL:
7432 case PARM_DECL:
7433 case RESULT_DECL:
7434 replace_by_duplicate_decl (tp, rd->vars_map, rd->to_context);
7435 break;
7436 default:
7437 break;
7440 if (IS_TYPE_OR_DECL_P (*tp))
7441 *walk_subtrees = false;
7443 return NULL;
7446 /* Change DECL_CONTEXT of all BLOCK_VARS in block, including
7447 subblocks. */
7449 static void
7450 replace_block_vars_by_duplicates (tree block, hash_map<tree, tree> *vars_map,
7451 tree to_context)
7453 tree *tp, t;
7455 for (tp = &BLOCK_VARS (block); *tp; tp = &DECL_CHAIN (*tp))
7457 t = *tp;
7458 if (!VAR_P (t) && TREE_CODE (t) != CONST_DECL)
7459 continue;
7460 replace_by_duplicate_decl (&t, vars_map, to_context);
7461 if (t != *tp)
7463 if (VAR_P (*tp) && DECL_HAS_VALUE_EXPR_P (*tp))
7465 tree x = DECL_VALUE_EXPR (*tp);
7466 struct replace_decls_d rd = { vars_map, to_context };
7467 unshare_expr (x);
7468 walk_tree (&x, replace_block_vars_by_duplicates_1, &rd, NULL);
7469 SET_DECL_VALUE_EXPR (t, x);
7470 DECL_HAS_VALUE_EXPR_P (t) = 1;
7472 DECL_CHAIN (t) = DECL_CHAIN (*tp);
7473 *tp = t;
7477 for (block = BLOCK_SUBBLOCKS (block); block; block = BLOCK_CHAIN (block))
7478 replace_block_vars_by_duplicates (block, vars_map, to_context);
7481 /* Fixup the loop arrays and numbers after moving LOOP and its subloops
7482 from FN1 to FN2. */
7484 static void
7485 fixup_loop_arrays_after_move (struct function *fn1, struct function *fn2,
7486 class loop *loop)
7488 /* Discard it from the old loop array. */
7489 (*get_loops (fn1))[loop->num] = NULL;
7491 /* Place it in the new loop array, assigning it a new number. */
7492 loop->num = number_of_loops (fn2);
7493 vec_safe_push (loops_for_fn (fn2)->larray, loop);
7495 /* Recurse to children. */
7496 for (loop = loop->inner; loop; loop = loop->next)
7497 fixup_loop_arrays_after_move (fn1, fn2, loop);
7500 /* Verify that the blocks in BBS_P are a single-entry, single-exit region
7501 delimited by ENTRY_BB and EXIT_BB, possibly containing noreturn blocks. */
7503 DEBUG_FUNCTION void
7504 verify_sese (basic_block entry, basic_block exit, vec<basic_block> *bbs_p)
7506 basic_block bb;
7507 edge_iterator ei;
7508 edge e;
7509 bitmap bbs = BITMAP_ALLOC (NULL);
7510 int i;
7512 gcc_assert (entry != NULL);
7513 gcc_assert (entry != exit);
7514 gcc_assert (bbs_p != NULL);
7516 gcc_assert (bbs_p->length () > 0);
7518 FOR_EACH_VEC_ELT (*bbs_p, i, bb)
7519 bitmap_set_bit (bbs, bb->index);
7521 gcc_assert (bitmap_bit_p (bbs, entry->index));
7522 gcc_assert (exit == NULL || bitmap_bit_p (bbs, exit->index));
7524 FOR_EACH_VEC_ELT (*bbs_p, i, bb)
7526 if (bb == entry)
7528 gcc_assert (single_pred_p (entry));
7529 gcc_assert (!bitmap_bit_p (bbs, single_pred (entry)->index));
7531 else
7532 for (ei = ei_start (bb->preds); !ei_end_p (ei); ei_next (&ei))
7534 e = ei_edge (ei);
7535 gcc_assert (bitmap_bit_p (bbs, e->src->index));
7538 if (bb == exit)
7540 gcc_assert (single_succ_p (exit));
7541 gcc_assert (!bitmap_bit_p (bbs, single_succ (exit)->index));
7543 else
7544 for (ei = ei_start (bb->succs); !ei_end_p (ei); ei_next (&ei))
7546 e = ei_edge (ei);
7547 gcc_assert (bitmap_bit_p (bbs, e->dest->index));
7551 BITMAP_FREE (bbs);
7554 /* If FROM is an SSA_NAME, mark the version in bitmap DATA. */
7556 bool
7557 gather_ssa_name_hash_map_from (tree const &from, tree const &, void *data)
7559 bitmap release_names = (bitmap)data;
7561 if (TREE_CODE (from) != SSA_NAME)
7562 return true;
7564 bitmap_set_bit (release_names, SSA_NAME_VERSION (from));
7565 return true;
7568 /* Return LOOP_DIST_ALIAS call if present in BB. */
7570 static gimple *
7571 find_loop_dist_alias (basic_block bb)
7573 gimple *g = last_stmt (bb);
7574 if (g == NULL || gimple_code (g) != GIMPLE_COND)
7575 return NULL;
7577 gimple_stmt_iterator gsi = gsi_for_stmt (g);
7578 gsi_prev (&gsi);
7579 if (gsi_end_p (gsi))
7580 return NULL;
7582 g = gsi_stmt (gsi);
7583 if (gimple_call_internal_p (g, IFN_LOOP_DIST_ALIAS))
7584 return g;
7585 return NULL;
7588 /* Fold loop internal call G like IFN_LOOP_VECTORIZED/IFN_LOOP_DIST_ALIAS
7589 to VALUE and update any immediate uses of it's LHS. */
7591 void
7592 fold_loop_internal_call (gimple *g, tree value)
7594 tree lhs = gimple_call_lhs (g);
7595 use_operand_p use_p;
7596 imm_use_iterator iter;
7597 gimple *use_stmt;
7598 gimple_stmt_iterator gsi = gsi_for_stmt (g);
7600 replace_call_with_value (&gsi, value);
7601 FOR_EACH_IMM_USE_STMT (use_stmt, iter, lhs)
7603 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
7604 SET_USE (use_p, value);
7605 update_stmt (use_stmt);
7609 /* Move a single-entry, single-exit region delimited by ENTRY_BB and
7610 EXIT_BB to function DEST_CFUN. The whole region is replaced by a
7611 single basic block in the original CFG and the new basic block is
7612 returned. DEST_CFUN must not have a CFG yet.
7614 Note that the region need not be a pure SESE region. Blocks inside
7615 the region may contain calls to abort/exit. The only restriction
7616 is that ENTRY_BB should be the only entry point and it must
7617 dominate EXIT_BB.
7619 Change TREE_BLOCK of all statements in ORIG_BLOCK to the new
7620 functions outermost BLOCK, move all subblocks of ORIG_BLOCK
7621 to the new function.
7623 All local variables referenced in the region are assumed to be in
7624 the corresponding BLOCK_VARS and unexpanded variable lists
7625 associated with DEST_CFUN.
7627 TODO: investigate whether we can reuse gimple_duplicate_sese_region to
7628 reimplement move_sese_region_to_fn by duplicating the region rather than
7629 moving it. */
7631 basic_block
7632 move_sese_region_to_fn (struct function *dest_cfun, basic_block entry_bb,
7633 basic_block exit_bb, tree orig_block)
7635 vec<basic_block> bbs;
7636 basic_block dom_entry = get_immediate_dominator (CDI_DOMINATORS, entry_bb);
7637 basic_block after, bb, *entry_pred, *exit_succ, abb;
7638 struct function *saved_cfun = cfun;
7639 int *entry_flag, *exit_flag;
7640 profile_probability *entry_prob, *exit_prob;
7641 unsigned i, num_entry_edges, num_exit_edges, num_nodes;
7642 edge e;
7643 edge_iterator ei;
7644 htab_t new_label_map;
7645 hash_map<void *, void *> *eh_map;
7646 class loop *loop = entry_bb->loop_father;
7647 class loop *loop0 = get_loop (saved_cfun, 0);
7648 struct move_stmt_d d;
7650 /* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
7651 region. */
7652 gcc_assert (entry_bb != exit_bb
7653 && (!exit_bb
7654 || dominated_by_p (CDI_DOMINATORS, exit_bb, entry_bb)));
7656 /* Collect all the blocks in the region. Manually add ENTRY_BB
7657 because it won't be added by dfs_enumerate_from. */
7658 bbs.create (0);
7659 bbs.safe_push (entry_bb);
7660 gather_blocks_in_sese_region (entry_bb, exit_bb, &bbs);
7662 if (flag_checking)
7663 verify_sese (entry_bb, exit_bb, &bbs);
7665 /* The blocks that used to be dominated by something in BBS will now be
7666 dominated by the new block. */
7667 auto_vec<basic_block> dom_bbs = get_dominated_by_region (CDI_DOMINATORS,
7668 bbs.address (),
7669 bbs.length ());
7671 /* Detach ENTRY_BB and EXIT_BB from CFUN->CFG. We need to remember
7672 the predecessor edges to ENTRY_BB and the successor edges to
7673 EXIT_BB so that we can re-attach them to the new basic block that
7674 will replace the region. */
7675 num_entry_edges = EDGE_COUNT (entry_bb->preds);
7676 entry_pred = XNEWVEC (basic_block, num_entry_edges);
7677 entry_flag = XNEWVEC (int, num_entry_edges);
7678 entry_prob = XNEWVEC (profile_probability, num_entry_edges);
7679 i = 0;
7680 for (ei = ei_start (entry_bb->preds); (e = ei_safe_edge (ei)) != NULL;)
7682 entry_prob[i] = e->probability;
7683 entry_flag[i] = e->flags;
7684 entry_pred[i++] = e->src;
7685 remove_edge (e);
7688 if (exit_bb)
7690 num_exit_edges = EDGE_COUNT (exit_bb->succs);
7691 exit_succ = XNEWVEC (basic_block, num_exit_edges);
7692 exit_flag = XNEWVEC (int, num_exit_edges);
7693 exit_prob = XNEWVEC (profile_probability, num_exit_edges);
7694 i = 0;
7695 for (ei = ei_start (exit_bb->succs); (e = ei_safe_edge (ei)) != NULL;)
7697 exit_prob[i] = e->probability;
7698 exit_flag[i] = e->flags;
7699 exit_succ[i++] = e->dest;
7700 remove_edge (e);
7703 else
7705 num_exit_edges = 0;
7706 exit_succ = NULL;
7707 exit_flag = NULL;
7708 exit_prob = NULL;
7711 /* Switch context to the child function to initialize DEST_FN's CFG. */
7712 gcc_assert (dest_cfun->cfg == NULL);
7713 push_cfun (dest_cfun);
7715 init_empty_tree_cfg ();
7717 /* Initialize EH information for the new function. */
7718 eh_map = NULL;
7719 new_label_map = NULL;
7720 if (saved_cfun->eh)
7722 eh_region region = NULL;
7723 bool all = false;
7725 FOR_EACH_VEC_ELT (bbs, i, bb)
7727 region = find_outermost_region_in_block (saved_cfun, bb, region, &all);
7728 if (all)
7729 break;
7732 init_eh_for_function ();
7733 if (region != NULL || all)
7735 new_label_map = htab_create (17, tree_map_hash, tree_map_eq, free);
7736 eh_map = duplicate_eh_regions (saved_cfun, region, 0,
7737 new_label_mapper, new_label_map);
7741 /* Initialize an empty loop tree. */
7742 struct loops *loops = ggc_cleared_alloc<struct loops> ();
7743 init_loops_structure (dest_cfun, loops, 1);
7744 loops->state = LOOPS_MAY_HAVE_MULTIPLE_LATCHES;
7745 set_loops_for_fn (dest_cfun, loops);
7747 vec<loop_p, va_gc> *larray = get_loops (saved_cfun)->copy ();
7749 /* Move the outlined loop tree part. */
7750 num_nodes = bbs.length ();
7751 FOR_EACH_VEC_ELT (bbs, i, bb)
7753 if (bb->loop_father->header == bb)
7755 class loop *this_loop = bb->loop_father;
7756 class loop *outer = loop_outer (this_loop);
7757 if (outer == loop
7758 /* If the SESE region contains some bbs ending with
7759 a noreturn call, those are considered to belong
7760 to the outermost loop in saved_cfun, rather than
7761 the entry_bb's loop_father. */
7762 || outer == loop0)
7764 if (outer != loop)
7765 num_nodes -= this_loop->num_nodes;
7766 flow_loop_tree_node_remove (bb->loop_father);
7767 flow_loop_tree_node_add (get_loop (dest_cfun, 0), this_loop);
7768 fixup_loop_arrays_after_move (saved_cfun, cfun, this_loop);
7771 else if (bb->loop_father == loop0 && loop0 != loop)
7772 num_nodes--;
7774 /* Remove loop exits from the outlined region. */
7775 if (loops_for_fn (saved_cfun)->exits)
7776 FOR_EACH_EDGE (e, ei, bb->succs)
7778 struct loops *l = loops_for_fn (saved_cfun);
7779 loop_exit **slot
7780 = l->exits->find_slot_with_hash (e, htab_hash_pointer (e),
7781 NO_INSERT);
7782 if (slot)
7783 l->exits->clear_slot (slot);
7787 /* Adjust the number of blocks in the tree root of the outlined part. */
7788 get_loop (dest_cfun, 0)->num_nodes = bbs.length () + 2;
7790 /* Setup a mapping to be used by move_block_to_fn. */
7791 loop->aux = current_loops->tree_root;
7792 loop0->aux = current_loops->tree_root;
7794 /* Fix up orig_loop_num. If the block referenced in it has been moved
7795 to dest_cfun, update orig_loop_num field, otherwise clear it. */
7796 signed char *moved_orig_loop_num = NULL;
7797 for (auto dloop : loops_list (dest_cfun, 0))
7798 if (dloop->orig_loop_num)
7800 if (moved_orig_loop_num == NULL)
7801 moved_orig_loop_num
7802 = XCNEWVEC (signed char, vec_safe_length (larray));
7803 if ((*larray)[dloop->orig_loop_num] != NULL
7804 && get_loop (saved_cfun, dloop->orig_loop_num) == NULL)
7806 if (moved_orig_loop_num[dloop->orig_loop_num] >= 0
7807 && moved_orig_loop_num[dloop->orig_loop_num] < 2)
7808 moved_orig_loop_num[dloop->orig_loop_num]++;
7809 dloop->orig_loop_num = (*larray)[dloop->orig_loop_num]->num;
7811 else
7813 moved_orig_loop_num[dloop->orig_loop_num] = -1;
7814 dloop->orig_loop_num = 0;
7817 pop_cfun ();
7819 if (moved_orig_loop_num)
7821 FOR_EACH_VEC_ELT (bbs, i, bb)
7823 gimple *g = find_loop_dist_alias (bb);
7824 if (g == NULL)
7825 continue;
7827 int orig_loop_num = tree_to_shwi (gimple_call_arg (g, 0));
7828 gcc_assert (orig_loop_num
7829 && (unsigned) orig_loop_num < vec_safe_length (larray));
7830 if (moved_orig_loop_num[orig_loop_num] == 2)
7832 /* If we have moved both loops with this orig_loop_num into
7833 dest_cfun and the LOOP_DIST_ALIAS call is being moved there
7834 too, update the first argument. */
7835 gcc_assert ((*larray)[orig_loop_num] != NULL
7836 && (get_loop (saved_cfun, orig_loop_num) == NULL));
7837 tree t = build_int_cst (integer_type_node,
7838 (*larray)[orig_loop_num]->num);
7839 gimple_call_set_arg (g, 0, t);
7840 update_stmt (g);
7841 /* Make sure the following loop will not update it. */
7842 moved_orig_loop_num[orig_loop_num] = 0;
7844 else
7845 /* Otherwise at least one of the loops stayed in saved_cfun.
7846 Remove the LOOP_DIST_ALIAS call. */
7847 fold_loop_internal_call (g, gimple_call_arg (g, 1));
7849 FOR_EACH_BB_FN (bb, saved_cfun)
7851 gimple *g = find_loop_dist_alias (bb);
7852 if (g == NULL)
7853 continue;
7854 int orig_loop_num = tree_to_shwi (gimple_call_arg (g, 0));
7855 gcc_assert (orig_loop_num
7856 && (unsigned) orig_loop_num < vec_safe_length (larray));
7857 if (moved_orig_loop_num[orig_loop_num])
7858 /* LOOP_DIST_ALIAS call remained in saved_cfun, if at least one
7859 of the corresponding loops was moved, remove it. */
7860 fold_loop_internal_call (g, gimple_call_arg (g, 1));
7862 XDELETEVEC (moved_orig_loop_num);
7864 ggc_free (larray);
7866 /* Move blocks from BBS into DEST_CFUN. */
7867 gcc_assert (bbs.length () >= 2);
7868 after = dest_cfun->cfg->x_entry_block_ptr;
7869 hash_map<tree, tree> vars_map;
7871 memset (&d, 0, sizeof (d));
7872 d.orig_block = orig_block;
7873 d.new_block = DECL_INITIAL (dest_cfun->decl);
7874 d.from_context = cfun->decl;
7875 d.to_context = dest_cfun->decl;
7876 d.vars_map = &vars_map;
7877 d.new_label_map = new_label_map;
7878 d.eh_map = eh_map;
7879 d.remap_decls_p = true;
7881 if (gimple_in_ssa_p (cfun))
7882 for (tree arg = DECL_ARGUMENTS (d.to_context); arg; arg = DECL_CHAIN (arg))
7884 tree narg = make_ssa_name_fn (dest_cfun, arg, gimple_build_nop ());
7885 set_ssa_default_def (dest_cfun, arg, narg);
7886 vars_map.put (arg, narg);
7889 FOR_EACH_VEC_ELT (bbs, i, bb)
7891 /* No need to update edge counts on the last block. It has
7892 already been updated earlier when we detached the region from
7893 the original CFG. */
7894 move_block_to_fn (dest_cfun, bb, after, bb != exit_bb, &d);
7895 after = bb;
7898 /* Adjust the maximum clique used. */
7899 dest_cfun->last_clique = saved_cfun->last_clique;
7901 loop->aux = NULL;
7902 loop0->aux = NULL;
7903 /* Loop sizes are no longer correct, fix them up. */
7904 loop->num_nodes -= num_nodes;
7905 for (class loop *outer = loop_outer (loop);
7906 outer; outer = loop_outer (outer))
7907 outer->num_nodes -= num_nodes;
7908 loop0->num_nodes -= bbs.length () - num_nodes;
7910 if (saved_cfun->has_simduid_loops || saved_cfun->has_force_vectorize_loops)
7912 class loop *aloop;
7913 for (i = 0; vec_safe_iterate (loops->larray, i, &aloop); i++)
7914 if (aloop != NULL)
7916 if (aloop->simduid)
7918 replace_by_duplicate_decl (&aloop->simduid, d.vars_map,
7919 d.to_context);
7920 dest_cfun->has_simduid_loops = true;
7922 if (aloop->force_vectorize)
7923 dest_cfun->has_force_vectorize_loops = true;
7927 /* Rewire BLOCK_SUBBLOCKS of orig_block. */
7928 if (orig_block)
7930 tree block;
7931 gcc_assert (BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun->decl))
7932 == NULL_TREE);
7933 BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun->decl))
7934 = BLOCK_SUBBLOCKS (orig_block);
7935 for (block = BLOCK_SUBBLOCKS (orig_block);
7936 block; block = BLOCK_CHAIN (block))
7937 BLOCK_SUPERCONTEXT (block) = DECL_INITIAL (dest_cfun->decl);
7938 BLOCK_SUBBLOCKS (orig_block) = NULL_TREE;
7941 replace_block_vars_by_duplicates (DECL_INITIAL (dest_cfun->decl),
7942 &vars_map, dest_cfun->decl);
7944 if (new_label_map)
7945 htab_delete (new_label_map);
7946 if (eh_map)
7947 delete eh_map;
7949 if (gimple_in_ssa_p (cfun))
7951 /* We need to release ssa-names in a defined order, so first find them,
7952 and then iterate in ascending version order. */
7953 bitmap release_names = BITMAP_ALLOC (NULL);
7954 vars_map.traverse<void *, gather_ssa_name_hash_map_from> (release_names);
7955 bitmap_iterator bi;
7956 unsigned i;
7957 EXECUTE_IF_SET_IN_BITMAP (release_names, 0, i, bi)
7958 release_ssa_name (ssa_name (i));
7959 BITMAP_FREE (release_names);
7962 /* Rewire the entry and exit blocks. The successor to the entry
7963 block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
7964 the child function. Similarly, the predecessor of DEST_FN's
7965 EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR. We
7966 need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
7967 various CFG manipulation function get to the right CFG.
7969 FIXME, this is silly. The CFG ought to become a parameter to
7970 these helpers. */
7971 push_cfun (dest_cfun);
7972 ENTRY_BLOCK_PTR_FOR_FN (cfun)->count = entry_bb->count;
7973 make_single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun), entry_bb, EDGE_FALLTHRU);
7974 if (exit_bb)
7976 make_single_succ_edge (exit_bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
7977 EXIT_BLOCK_PTR_FOR_FN (cfun)->count = exit_bb->count;
7979 else
7980 EXIT_BLOCK_PTR_FOR_FN (cfun)->count = profile_count::zero ();
7981 pop_cfun ();
7983 /* Back in the original function, the SESE region has disappeared,
7984 create a new basic block in its place. */
7985 bb = create_empty_bb (entry_pred[0]);
7986 if (current_loops)
7987 add_bb_to_loop (bb, loop);
7988 for (i = 0; i < num_entry_edges; i++)
7990 e = make_edge (entry_pred[i], bb, entry_flag[i]);
7991 e->probability = entry_prob[i];
7994 for (i = 0; i < num_exit_edges; i++)
7996 e = make_edge (bb, exit_succ[i], exit_flag[i]);
7997 e->probability = exit_prob[i];
8000 set_immediate_dominator (CDI_DOMINATORS, bb, dom_entry);
8001 FOR_EACH_VEC_ELT (dom_bbs, i, abb)
8002 set_immediate_dominator (CDI_DOMINATORS, abb, bb);
8004 if (exit_bb)
8006 free (exit_prob);
8007 free (exit_flag);
8008 free (exit_succ);
8010 free (entry_prob);
8011 free (entry_flag);
8012 free (entry_pred);
8013 bbs.release ();
8015 return bb;
8018 /* Dump default def DEF to file FILE using FLAGS and indentation
8019 SPC. */
8021 static void
8022 dump_default_def (FILE *file, tree def, int spc, dump_flags_t flags)
8024 for (int i = 0; i < spc; ++i)
8025 fprintf (file, " ");
8026 dump_ssaname_info_to_file (file, def, spc);
8028 print_generic_expr (file, TREE_TYPE (def), flags);
8029 fprintf (file, " ");
8030 print_generic_expr (file, def, flags);
8031 fprintf (file, " = ");
8032 print_generic_expr (file, SSA_NAME_VAR (def), flags);
8033 fprintf (file, ";\n");
8036 /* Print no_sanitize attribute to FILE for a given attribute VALUE. */
8038 static void
8039 print_no_sanitize_attr_value (FILE *file, tree value)
8041 unsigned int flags = tree_to_uhwi (value);
8042 bool first = true;
8043 for (int i = 0; sanitizer_opts[i].name != NULL; ++i)
8045 if ((sanitizer_opts[i].flag & flags) == sanitizer_opts[i].flag)
8047 if (!first)
8048 fprintf (file, " | ");
8049 fprintf (file, "%s", sanitizer_opts[i].name);
8050 first = false;
8055 /* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in dumpfile.h)
8058 void
8059 dump_function_to_file (tree fndecl, FILE *file, dump_flags_t flags)
8061 tree arg, var, old_current_fndecl = current_function_decl;
8062 struct function *dsf;
8063 bool ignore_topmost_bind = false, any_var = false;
8064 basic_block bb;
8065 tree chain;
8066 bool tmclone = (TREE_CODE (fndecl) == FUNCTION_DECL
8067 && decl_is_tm_clone (fndecl));
8068 struct function *fun = DECL_STRUCT_FUNCTION (fndecl);
8070 tree fntype = TREE_TYPE (fndecl);
8071 tree attrs[] = { DECL_ATTRIBUTES (fndecl), TYPE_ATTRIBUTES (fntype) };
8073 for (int i = 0; i != 2; ++i)
8075 if (!attrs[i])
8076 continue;
8078 fprintf (file, "__attribute__((");
8080 bool first = true;
8081 tree chain;
8082 for (chain = attrs[i]; chain; first = false, chain = TREE_CHAIN (chain))
8084 if (!first)
8085 fprintf (file, ", ");
8087 tree name = get_attribute_name (chain);
8088 print_generic_expr (file, name, dump_flags);
8089 if (TREE_VALUE (chain) != NULL_TREE)
8091 fprintf (file, " (");
8093 if (strstr (IDENTIFIER_POINTER (name), "no_sanitize"))
8094 print_no_sanitize_attr_value (file, TREE_VALUE (chain));
8095 else
8096 print_generic_expr (file, TREE_VALUE (chain), dump_flags);
8097 fprintf (file, ")");
8101 fprintf (file, "))\n");
8104 current_function_decl = fndecl;
8105 if (flags & TDF_GIMPLE)
8107 static bool hotness_bb_param_printed = false;
8108 if (profile_info != NULL
8109 && !hotness_bb_param_printed)
8111 hotness_bb_param_printed = true;
8112 fprintf (file,
8113 "/* --param=gimple-fe-computed-hot-bb-threshold=%" PRId64
8114 " */\n", get_hot_bb_threshold ());
8117 print_generic_expr (file, TREE_TYPE (TREE_TYPE (fndecl)),
8118 dump_flags | TDF_SLIM);
8119 fprintf (file, " __GIMPLE (%s",
8120 (fun->curr_properties & PROP_ssa) ? "ssa"
8121 : (fun->curr_properties & PROP_cfg) ? "cfg"
8122 : "");
8124 if (fun && fun->cfg)
8126 basic_block bb = ENTRY_BLOCK_PTR_FOR_FN (fun);
8127 if (bb->count.initialized_p ())
8128 fprintf (file, ",%s(%" PRIu64 ")",
8129 profile_quality_as_string (bb->count.quality ()),
8130 bb->count.value ());
8131 if (dump_flags & TDF_UID)
8132 fprintf (file, ")\n%sD_%u (", function_name (fun),
8133 DECL_UID (fndecl));
8134 else
8135 fprintf (file, ")\n%s (", function_name (fun));
8138 else
8140 print_generic_expr (file, TREE_TYPE (fntype), dump_flags);
8141 if (dump_flags & TDF_UID)
8142 fprintf (file, " %sD.%u %s(", function_name (fun), DECL_UID (fndecl),
8143 tmclone ? "[tm-clone] " : "");
8144 else
8145 fprintf (file, " %s %s(", function_name (fun),
8146 tmclone ? "[tm-clone] " : "");
8149 arg = DECL_ARGUMENTS (fndecl);
8150 while (arg)
8152 print_generic_expr (file, TREE_TYPE (arg), dump_flags);
8153 fprintf (file, " ");
8154 print_generic_expr (file, arg, dump_flags);
8155 if (DECL_CHAIN (arg))
8156 fprintf (file, ", ");
8157 arg = DECL_CHAIN (arg);
8159 fprintf (file, ")\n");
8161 dsf = DECL_STRUCT_FUNCTION (fndecl);
8162 if (dsf && (flags & TDF_EH))
8163 dump_eh_tree (file, dsf);
8165 if (flags & TDF_RAW && !gimple_has_body_p (fndecl))
8167 dump_node (fndecl, TDF_SLIM | flags, file);
8168 current_function_decl = old_current_fndecl;
8169 return;
8172 /* When GIMPLE is lowered, the variables are no longer available in
8173 BIND_EXPRs, so display them separately. */
8174 if (fun && fun->decl == fndecl && (fun->curr_properties & PROP_gimple_lcf))
8176 unsigned ix;
8177 ignore_topmost_bind = true;
8179 fprintf (file, "{\n");
8180 if (gimple_in_ssa_p (fun)
8181 && (flags & TDF_ALIAS))
8183 for (arg = DECL_ARGUMENTS (fndecl); arg != NULL;
8184 arg = DECL_CHAIN (arg))
8186 tree def = ssa_default_def (fun, arg);
8187 if (def)
8188 dump_default_def (file, def, 2, flags);
8191 tree res = DECL_RESULT (fun->decl);
8192 if (res != NULL_TREE
8193 && DECL_BY_REFERENCE (res))
8195 tree def = ssa_default_def (fun, res);
8196 if (def)
8197 dump_default_def (file, def, 2, flags);
8200 tree static_chain = fun->static_chain_decl;
8201 if (static_chain != NULL_TREE)
8203 tree def = ssa_default_def (fun, static_chain);
8204 if (def)
8205 dump_default_def (file, def, 2, flags);
8209 if (!vec_safe_is_empty (fun->local_decls))
8210 FOR_EACH_LOCAL_DECL (fun, ix, var)
8212 print_generic_decl (file, var, flags);
8213 fprintf (file, "\n");
8215 any_var = true;
8218 tree name;
8220 if (gimple_in_ssa_p (fun))
8221 FOR_EACH_SSA_NAME (ix, name, fun)
8223 if (!SSA_NAME_VAR (name)
8224 /* SSA name with decls without a name still get
8225 dumped as _N, list those explicitely as well even
8226 though we've dumped the decl declaration as D.xxx
8227 above. */
8228 || !SSA_NAME_IDENTIFIER (name))
8230 fprintf (file, " ");
8231 print_generic_expr (file, TREE_TYPE (name), flags);
8232 fprintf (file, " ");
8233 print_generic_expr (file, name, flags);
8234 fprintf (file, ";\n");
8236 any_var = true;
8241 if (fun && fun->decl == fndecl
8242 && fun->cfg
8243 && basic_block_info_for_fn (fun))
8245 /* If the CFG has been built, emit a CFG-based dump. */
8246 if (!ignore_topmost_bind)
8247 fprintf (file, "{\n");
8249 if (any_var && n_basic_blocks_for_fn (fun))
8250 fprintf (file, "\n");
8252 FOR_EACH_BB_FN (bb, fun)
8253 dump_bb (file, bb, 2, flags);
8255 fprintf (file, "}\n");
8257 else if (fun && (fun->curr_properties & PROP_gimple_any))
8259 /* The function is now in GIMPLE form but the CFG has not been
8260 built yet. Emit the single sequence of GIMPLE statements
8261 that make up its body. */
8262 gimple_seq body = gimple_body (fndecl);
8264 if (gimple_seq_first_stmt (body)
8265 && gimple_seq_first_stmt (body) == gimple_seq_last_stmt (body)
8266 && gimple_code (gimple_seq_first_stmt (body)) == GIMPLE_BIND)
8267 print_gimple_seq (file, body, 0, flags);
8268 else
8270 if (!ignore_topmost_bind)
8271 fprintf (file, "{\n");
8273 if (any_var)
8274 fprintf (file, "\n");
8276 print_gimple_seq (file, body, 2, flags);
8277 fprintf (file, "}\n");
8280 else
8282 int indent;
8284 /* Make a tree based dump. */
8285 chain = DECL_SAVED_TREE (fndecl);
8286 if (chain && TREE_CODE (chain) == BIND_EXPR)
8288 if (ignore_topmost_bind)
8290 chain = BIND_EXPR_BODY (chain);
8291 indent = 2;
8293 else
8294 indent = 0;
8296 else
8298 if (!ignore_topmost_bind)
8300 fprintf (file, "{\n");
8301 /* No topmost bind, pretend it's ignored for later. */
8302 ignore_topmost_bind = true;
8304 indent = 2;
8307 if (any_var)
8308 fprintf (file, "\n");
8310 print_generic_stmt_indented (file, chain, flags, indent);
8311 if (ignore_topmost_bind)
8312 fprintf (file, "}\n");
8315 if (flags & TDF_ENUMERATE_LOCALS)
8316 dump_enumerated_decls (file, flags);
8317 fprintf (file, "\n\n");
8319 current_function_decl = old_current_fndecl;
8322 /* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h) */
8324 DEBUG_FUNCTION void
8325 debug_function (tree fn, dump_flags_t flags)
8327 dump_function_to_file (fn, stderr, flags);
8331 /* Print on FILE the indexes for the predecessors of basic_block BB. */
8333 static void
8334 print_pred_bbs (FILE *file, basic_block bb)
8336 edge e;
8337 edge_iterator ei;
8339 FOR_EACH_EDGE (e, ei, bb->preds)
8340 fprintf (file, "bb_%d ", e->src->index);
8344 /* Print on FILE the indexes for the successors of basic_block BB. */
8346 static void
8347 print_succ_bbs (FILE *file, basic_block bb)
8349 edge e;
8350 edge_iterator ei;
8352 FOR_EACH_EDGE (e, ei, bb->succs)
8353 fprintf (file, "bb_%d ", e->dest->index);
8356 /* Print to FILE the basic block BB following the VERBOSITY level. */
8358 void
8359 print_loops_bb (FILE *file, basic_block bb, int indent, int verbosity)
8361 char *s_indent = (char *) alloca ((size_t) indent + 1);
8362 memset ((void *) s_indent, ' ', (size_t) indent);
8363 s_indent[indent] = '\0';
8365 /* Print basic_block's header. */
8366 if (verbosity >= 2)
8368 fprintf (file, "%s bb_%d (preds = {", s_indent, bb->index);
8369 print_pred_bbs (file, bb);
8370 fprintf (file, "}, succs = {");
8371 print_succ_bbs (file, bb);
8372 fprintf (file, "})\n");
8375 /* Print basic_block's body. */
8376 if (verbosity >= 3)
8378 fprintf (file, "%s {\n", s_indent);
8379 dump_bb (file, bb, indent + 4, TDF_VOPS|TDF_MEMSYMS);
8380 fprintf (file, "%s }\n", s_indent);
8384 static void print_loop_and_siblings (FILE *, class loop *, int, int);
8386 /* Pretty print LOOP on FILE, indented INDENT spaces. Following
8387 VERBOSITY level this outputs the contents of the loop, or just its
8388 structure. */
8390 static void
8391 print_loop (FILE *file, class loop *loop, int indent, int verbosity)
8393 char *s_indent;
8394 basic_block bb;
8396 if (loop == NULL)
8397 return;
8399 s_indent = (char *) alloca ((size_t) indent + 1);
8400 memset ((void *) s_indent, ' ', (size_t) indent);
8401 s_indent[indent] = '\0';
8403 /* Print loop's header. */
8404 fprintf (file, "%sloop_%d (", s_indent, loop->num);
8405 if (loop->header)
8406 fprintf (file, "header = %d", loop->header->index);
8407 else
8409 fprintf (file, "deleted)\n");
8410 return;
8412 if (loop->latch)
8413 fprintf (file, ", latch = %d", loop->latch->index);
8414 else
8415 fprintf (file, ", multiple latches");
8416 fprintf (file, ", niter = ");
8417 print_generic_expr (file, loop->nb_iterations);
8419 if (loop->any_upper_bound)
8421 fprintf (file, ", upper_bound = ");
8422 print_decu (loop->nb_iterations_upper_bound, file);
8424 if (loop->any_likely_upper_bound)
8426 fprintf (file, ", likely_upper_bound = ");
8427 print_decu (loop->nb_iterations_likely_upper_bound, file);
8430 if (loop->any_estimate)
8432 fprintf (file, ", estimate = ");
8433 print_decu (loop->nb_iterations_estimate, file);
8435 if (loop->unroll)
8436 fprintf (file, ", unroll = %d", loop->unroll);
8437 fprintf (file, ")\n");
8439 /* Print loop's body. */
8440 if (verbosity >= 1)
8442 fprintf (file, "%s{\n", s_indent);
8443 FOR_EACH_BB_FN (bb, cfun)
8444 if (bb->loop_father == loop)
8445 print_loops_bb (file, bb, indent, verbosity);
8447 print_loop_and_siblings (file, loop->inner, indent + 2, verbosity);
8448 fprintf (file, "%s}\n", s_indent);
8452 /* Print the LOOP and its sibling loops on FILE, indented INDENT
8453 spaces. Following VERBOSITY level this outputs the contents of the
8454 loop, or just its structure. */
8456 static void
8457 print_loop_and_siblings (FILE *file, class loop *loop, int indent,
8458 int verbosity)
8460 if (loop == NULL)
8461 return;
8463 print_loop (file, loop, indent, verbosity);
8464 print_loop_and_siblings (file, loop->next, indent, verbosity);
8467 /* Follow a CFG edge from the entry point of the program, and on entry
8468 of a loop, pretty print the loop structure on FILE. */
8470 void
8471 print_loops (FILE *file, int verbosity)
8473 basic_block bb;
8475 bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
8476 fprintf (file, "\nLoops in function: %s\n", current_function_name ());
8477 if (bb && bb->loop_father)
8478 print_loop_and_siblings (file, bb->loop_father, 0, verbosity);
8481 /* Dump a loop. */
8483 DEBUG_FUNCTION void
8484 debug (class loop &ref)
8486 print_loop (stderr, &ref, 0, /*verbosity*/0);
8489 DEBUG_FUNCTION void
8490 debug (class loop *ptr)
8492 if (ptr)
8493 debug (*ptr);
8494 else
8495 fprintf (stderr, "<nil>\n");
8498 /* Dump a loop verbosely. */
8500 DEBUG_FUNCTION void
8501 debug_verbose (class loop &ref)
8503 print_loop (stderr, &ref, 0, /*verbosity*/3);
8506 DEBUG_FUNCTION void
8507 debug_verbose (class loop *ptr)
8509 if (ptr)
8510 debug (*ptr);
8511 else
8512 fprintf (stderr, "<nil>\n");
8516 /* Debugging loops structure at tree level, at some VERBOSITY level. */
8518 DEBUG_FUNCTION void
8519 debug_loops (int verbosity)
8521 print_loops (stderr, verbosity);
8524 /* Print on stderr the code of LOOP, at some VERBOSITY level. */
8526 DEBUG_FUNCTION void
8527 debug_loop (class loop *loop, int verbosity)
8529 print_loop (stderr, loop, 0, verbosity);
8532 /* Print on stderr the code of loop number NUM, at some VERBOSITY
8533 level. */
8535 DEBUG_FUNCTION void
8536 debug_loop_num (unsigned num, int verbosity)
8538 debug_loop (get_loop (cfun, num), verbosity);
8541 /* Return true if BB ends with a call, possibly followed by some
8542 instructions that must stay with the call. Return false,
8543 otherwise. */
8545 static bool
8546 gimple_block_ends_with_call_p (basic_block bb)
8548 gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
8549 return !gsi_end_p (gsi) && is_gimple_call (gsi_stmt (gsi));
8553 /* Return true if BB ends with a conditional branch. Return false,
8554 otherwise. */
8556 static bool
8557 gimple_block_ends_with_condjump_p (const_basic_block bb)
8559 gimple *stmt = last_stmt (CONST_CAST_BB (bb));
8560 return (stmt && gimple_code (stmt) == GIMPLE_COND);
8564 /* Return true if statement T may terminate execution of BB in ways not
8565 explicitly represtented in the CFG. */
8567 bool
8568 stmt_can_terminate_bb_p (gimple *t)
8570 tree fndecl = NULL_TREE;
8571 int call_flags = 0;
8573 /* Eh exception not handled internally terminates execution of the whole
8574 function. */
8575 if (stmt_can_throw_external (cfun, t))
8576 return true;
8578 /* NORETURN and LONGJMP calls already have an edge to exit.
8579 CONST and PURE calls do not need one.
8580 We don't currently check for CONST and PURE here, although
8581 it would be a good idea, because those attributes are
8582 figured out from the RTL in mark_constant_function, and
8583 the counter incrementation code from -fprofile-arcs
8584 leads to different results from -fbranch-probabilities. */
8585 if (is_gimple_call (t))
8587 fndecl = gimple_call_fndecl (t);
8588 call_flags = gimple_call_flags (t);
8591 if (is_gimple_call (t)
8592 && fndecl
8593 && fndecl_built_in_p (fndecl)
8594 && (call_flags & ECF_NOTHROW)
8595 && !(call_flags & ECF_RETURNS_TWICE)
8596 /* fork() doesn't really return twice, but the effect of
8597 wrapping it in __gcov_fork() which calls __gcov_dump() and
8598 __gcov_reset() and clears the counters before forking has the same
8599 effect as returning twice. Force a fake edge. */
8600 && !fndecl_built_in_p (fndecl, BUILT_IN_FORK))
8601 return false;
8603 if (is_gimple_call (t))
8605 edge_iterator ei;
8606 edge e;
8607 basic_block bb;
8609 if (call_flags & (ECF_PURE | ECF_CONST)
8610 && !(call_flags & ECF_LOOPING_CONST_OR_PURE))
8611 return false;
8613 /* Function call may do longjmp, terminate program or do other things.
8614 Special case noreturn that have non-abnormal edges out as in this case
8615 the fact is sufficiently represented by lack of edges out of T. */
8616 if (!(call_flags & ECF_NORETURN))
8617 return true;
8619 bb = gimple_bb (t);
8620 FOR_EACH_EDGE (e, ei, bb->succs)
8621 if ((e->flags & EDGE_FAKE) == 0)
8622 return true;
8625 if (gasm *asm_stmt = dyn_cast <gasm *> (t))
8626 if (gimple_asm_volatile_p (asm_stmt) || gimple_asm_input_p (asm_stmt))
8627 return true;
8629 return false;
8633 /* Add fake edges to the function exit for any non constant and non
8634 noreturn calls (or noreturn calls with EH/abnormal edges),
8635 volatile inline assembly in the bitmap of blocks specified by BLOCKS
8636 or to the whole CFG if BLOCKS is zero. Return the number of blocks
8637 that were split.
8639 The goal is to expose cases in which entering a basic block does
8640 not imply that all subsequent instructions must be executed. */
8642 static int
8643 gimple_flow_call_edges_add (sbitmap blocks)
8645 int i;
8646 int blocks_split = 0;
8647 int last_bb = last_basic_block_for_fn (cfun);
8648 bool check_last_block = false;
8650 if (n_basic_blocks_for_fn (cfun) == NUM_FIXED_BLOCKS)
8651 return 0;
8653 if (! blocks)
8654 check_last_block = true;
8655 else
8656 check_last_block = bitmap_bit_p (blocks,
8657 EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb->index);
8659 /* In the last basic block, before epilogue generation, there will be
8660 a fallthru edge to EXIT. Special care is required if the last insn
8661 of the last basic block is a call because make_edge folds duplicate
8662 edges, which would result in the fallthru edge also being marked
8663 fake, which would result in the fallthru edge being removed by
8664 remove_fake_edges, which would result in an invalid CFG.
8666 Moreover, we can't elide the outgoing fake edge, since the block
8667 profiler needs to take this into account in order to solve the minimal
8668 spanning tree in the case that the call doesn't return.
8670 Handle this by adding a dummy instruction in a new last basic block. */
8671 if (check_last_block)
8673 basic_block bb = EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb;
8674 gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
8675 gimple *t = NULL;
8677 if (!gsi_end_p (gsi))
8678 t = gsi_stmt (gsi);
8680 if (t && stmt_can_terminate_bb_p (t))
8682 edge e;
8684 e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun));
8685 if (e)
8687 gsi_insert_on_edge (e, gimple_build_nop ());
8688 gsi_commit_edge_inserts ();
8693 /* Now add fake edges to the function exit for any non constant
8694 calls since there is no way that we can determine if they will
8695 return or not... */
8696 for (i = 0; i < last_bb; i++)
8698 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
8699 gimple_stmt_iterator gsi;
8700 gimple *stmt, *last_stmt;
8702 if (!bb)
8703 continue;
8705 if (blocks && !bitmap_bit_p (blocks, i))
8706 continue;
8708 gsi = gsi_last_nondebug_bb (bb);
8709 if (!gsi_end_p (gsi))
8711 last_stmt = gsi_stmt (gsi);
8714 stmt = gsi_stmt (gsi);
8715 if (stmt_can_terminate_bb_p (stmt))
8717 edge e;
8719 /* The handling above of the final block before the
8720 epilogue should be enough to verify that there is
8721 no edge to the exit block in CFG already.
8722 Calling make_edge in such case would cause us to
8723 mark that edge as fake and remove it later. */
8724 if (flag_checking && stmt == last_stmt)
8726 e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun));
8727 gcc_assert (e == NULL);
8730 /* Note that the following may create a new basic block
8731 and renumber the existing basic blocks. */
8732 if (stmt != last_stmt)
8734 e = split_block (bb, stmt);
8735 if (e)
8736 blocks_split++;
8738 e = make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), EDGE_FAKE);
8739 e->probability = profile_probability::guessed_never ();
8741 gsi_prev (&gsi);
8743 while (!gsi_end_p (gsi));
8747 if (blocks_split)
8748 checking_verify_flow_info ();
8750 return blocks_split;
8753 /* Removes edge E and all the blocks dominated by it, and updates dominance
8754 information. The IL in E->src needs to be updated separately.
8755 If dominance info is not available, only the edge E is removed.*/
8757 void
8758 remove_edge_and_dominated_blocks (edge e)
8760 vec<basic_block> bbs_to_fix_dom = vNULL;
8761 edge f;
8762 edge_iterator ei;
8763 bool none_removed = false;
8764 unsigned i;
8765 basic_block bb, dbb;
8766 bitmap_iterator bi;
8768 /* If we are removing a path inside a non-root loop that may change
8769 loop ownership of blocks or remove loops. Mark loops for fixup. */
8770 if (current_loops
8771 && loop_outer (e->src->loop_father) != NULL
8772 && e->src->loop_father == e->dest->loop_father)
8773 loops_state_set (LOOPS_NEED_FIXUP);
8775 if (!dom_info_available_p (CDI_DOMINATORS))
8777 remove_edge (e);
8778 return;
8781 /* No updating is needed for edges to exit. */
8782 if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
8784 if (cfgcleanup_altered_bbs)
8785 bitmap_set_bit (cfgcleanup_altered_bbs, e->src->index);
8786 remove_edge (e);
8787 return;
8790 /* First, we find the basic blocks to remove. If E->dest has a predecessor
8791 that is not dominated by E->dest, then this set is empty. Otherwise,
8792 all the basic blocks dominated by E->dest are removed.
8794 Also, to DF_IDOM we store the immediate dominators of the blocks in
8795 the dominance frontier of E (i.e., of the successors of the
8796 removed blocks, if there are any, and of E->dest otherwise). */
8797 FOR_EACH_EDGE (f, ei, e->dest->preds)
8799 if (f == e)
8800 continue;
8802 if (!dominated_by_p (CDI_DOMINATORS, f->src, e->dest))
8804 none_removed = true;
8805 break;
8809 auto_bitmap df, df_idom;
8810 auto_vec<basic_block> bbs_to_remove;
8811 if (none_removed)
8812 bitmap_set_bit (df_idom,
8813 get_immediate_dominator (CDI_DOMINATORS, e->dest)->index);
8814 else
8816 bbs_to_remove = get_all_dominated_blocks (CDI_DOMINATORS, e->dest);
8817 FOR_EACH_VEC_ELT (bbs_to_remove, i, bb)
8819 FOR_EACH_EDGE (f, ei, bb->succs)
8821 if (f->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
8822 bitmap_set_bit (df, f->dest->index);
8825 FOR_EACH_VEC_ELT (bbs_to_remove, i, bb)
8826 bitmap_clear_bit (df, bb->index);
8828 EXECUTE_IF_SET_IN_BITMAP (df, 0, i, bi)
8830 bb = BASIC_BLOCK_FOR_FN (cfun, i);
8831 bitmap_set_bit (df_idom,
8832 get_immediate_dominator (CDI_DOMINATORS, bb)->index);
8836 if (cfgcleanup_altered_bbs)
8838 /* Record the set of the altered basic blocks. */
8839 bitmap_set_bit (cfgcleanup_altered_bbs, e->src->index);
8840 bitmap_ior_into (cfgcleanup_altered_bbs, df);
8843 /* Remove E and the cancelled blocks. */
8844 if (none_removed)
8845 remove_edge (e);
8846 else
8848 /* Walk backwards so as to get a chance to substitute all
8849 released DEFs into debug stmts. See
8850 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
8851 details. */
8852 for (i = bbs_to_remove.length (); i-- > 0; )
8853 delete_basic_block (bbs_to_remove[i]);
8856 /* Update the dominance information. The immediate dominator may change only
8857 for blocks whose immediate dominator belongs to DF_IDOM:
8859 Suppose that idom(X) = Y before removal of E and idom(X) != Y after the
8860 removal. Let Z the arbitrary block such that idom(Z) = Y and
8861 Z dominates X after the removal. Before removal, there exists a path P
8862 from Y to X that avoids Z. Let F be the last edge on P that is
8863 removed, and let W = F->dest. Before removal, idom(W) = Y (since Y
8864 dominates W, and because of P, Z does not dominate W), and W belongs to
8865 the dominance frontier of E. Therefore, Y belongs to DF_IDOM. */
8866 EXECUTE_IF_SET_IN_BITMAP (df_idom, 0, i, bi)
8868 bb = BASIC_BLOCK_FOR_FN (cfun, i);
8869 for (dbb = first_dom_son (CDI_DOMINATORS, bb);
8870 dbb;
8871 dbb = next_dom_son (CDI_DOMINATORS, dbb))
8872 bbs_to_fix_dom.safe_push (dbb);
8875 iterate_fix_dominators (CDI_DOMINATORS, bbs_to_fix_dom, true);
8877 bbs_to_fix_dom.release ();
8880 /* Purge dead EH edges from basic block BB. */
8882 bool
8883 gimple_purge_dead_eh_edges (basic_block bb)
8885 bool changed = false;
8886 edge e;
8887 edge_iterator ei;
8888 gimple *stmt = last_stmt (bb);
8890 if (stmt && stmt_can_throw_internal (cfun, stmt))
8891 return false;
8893 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
8895 if (e->flags & EDGE_EH)
8897 remove_edge_and_dominated_blocks (e);
8898 changed = true;
8900 else
8901 ei_next (&ei);
8904 return changed;
8907 /* Purge dead EH edges from basic block listed in BLOCKS. */
8909 bool
8910 gimple_purge_all_dead_eh_edges (const_bitmap blocks)
8912 bool changed = false;
8913 unsigned i;
8914 bitmap_iterator bi;
8916 EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
8918 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
8920 /* Earlier gimple_purge_dead_eh_edges could have removed
8921 this basic block already. */
8922 gcc_assert (bb || changed);
8923 if (bb != NULL)
8924 changed |= gimple_purge_dead_eh_edges (bb);
8927 return changed;
8930 /* Purge dead abnormal call edges from basic block BB. */
8932 bool
8933 gimple_purge_dead_abnormal_call_edges (basic_block bb)
8935 bool changed = false;
8936 edge e;
8937 edge_iterator ei;
8938 gimple *stmt = last_stmt (bb);
8940 if (!cfun->has_nonlocal_label
8941 && !cfun->calls_setjmp)
8942 return false;
8944 if (stmt && stmt_can_make_abnormal_goto (stmt))
8945 return false;
8947 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
8949 if (e->flags & EDGE_ABNORMAL)
8951 if (e->flags & EDGE_FALLTHRU)
8952 e->flags &= ~EDGE_ABNORMAL;
8953 else
8954 remove_edge_and_dominated_blocks (e);
8955 changed = true;
8957 else
8958 ei_next (&ei);
8961 return changed;
8964 /* Purge dead abnormal call edges from basic block listed in BLOCKS. */
8966 bool
8967 gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks)
8969 bool changed = false;
8970 unsigned i;
8971 bitmap_iterator bi;
8973 EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
8975 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
8977 /* Earlier gimple_purge_dead_abnormal_call_edges could have removed
8978 this basic block already. */
8979 gcc_assert (bb || changed);
8980 if (bb != NULL)
8981 changed |= gimple_purge_dead_abnormal_call_edges (bb);
8984 return changed;
8987 /* This function is called whenever a new edge is created or
8988 redirected. */
8990 static void
8991 gimple_execute_on_growing_pred (edge e)
8993 basic_block bb = e->dest;
8995 if (!gimple_seq_empty_p (phi_nodes (bb)))
8996 reserve_phi_args_for_new_edge (bb);
8999 /* This function is called immediately before edge E is removed from
9000 the edge vector E->dest->preds. */
9002 static void
9003 gimple_execute_on_shrinking_pred (edge e)
9005 if (!gimple_seq_empty_p (phi_nodes (e->dest)))
9006 remove_phi_args (e);
9009 /*---------------------------------------------------------------------------
9010 Helper functions for Loop versioning
9011 ---------------------------------------------------------------------------*/
9013 /* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy
9014 of 'first'. Both of them are dominated by 'new_head' basic block. When
9015 'new_head' was created by 'second's incoming edge it received phi arguments
9016 on the edge by split_edge(). Later, additional edge 'e' was created to
9017 connect 'new_head' and 'first'. Now this routine adds phi args on this
9018 additional edge 'e' that new_head to second edge received as part of edge
9019 splitting. */
9021 static void
9022 gimple_lv_adjust_loop_header_phi (basic_block first, basic_block second,
9023 basic_block new_head, edge e)
9025 gphi *phi1, *phi2;
9026 gphi_iterator psi1, psi2;
9027 tree def;
9028 edge e2 = find_edge (new_head, second);
9030 /* Because NEW_HEAD has been created by splitting SECOND's incoming
9031 edge, we should always have an edge from NEW_HEAD to SECOND. */
9032 gcc_assert (e2 != NULL);
9034 /* Browse all 'second' basic block phi nodes and add phi args to
9035 edge 'e' for 'first' head. PHI args are always in correct order. */
9037 for (psi2 = gsi_start_phis (second),
9038 psi1 = gsi_start_phis (first);
9039 !gsi_end_p (psi2) && !gsi_end_p (psi1);
9040 gsi_next (&psi2), gsi_next (&psi1))
9042 phi1 = psi1.phi ();
9043 phi2 = psi2.phi ();
9044 def = PHI_ARG_DEF (phi2, e2->dest_idx);
9045 add_phi_arg (phi1, def, e, gimple_phi_arg_location_from_edge (phi2, e2));
9050 /* Adds a if else statement to COND_BB with condition COND_EXPR.
9051 SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
9052 the destination of the ELSE part. */
9054 static void
9055 gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED,
9056 basic_block second_head ATTRIBUTE_UNUSED,
9057 basic_block cond_bb, void *cond_e)
9059 gimple_stmt_iterator gsi;
9060 gimple *new_cond_expr;
9061 tree cond_expr = (tree) cond_e;
9062 edge e0;
9064 /* Build new conditional expr */
9065 new_cond_expr = gimple_build_cond_from_tree (cond_expr,
9066 NULL_TREE, NULL_TREE);
9068 /* Add new cond in cond_bb. */
9069 gsi = gsi_last_bb (cond_bb);
9070 gsi_insert_after (&gsi, new_cond_expr, GSI_NEW_STMT);
9072 /* Adjust edges appropriately to connect new head with first head
9073 as well as second head. */
9074 e0 = single_succ_edge (cond_bb);
9075 e0->flags &= ~EDGE_FALLTHRU;
9076 e0->flags |= EDGE_FALSE_VALUE;
9080 /* Do book-keeping of basic block BB for the profile consistency checker.
9081 Store the counting in RECORD. */
9082 static void
9083 gimple_account_profile_record (basic_block bb,
9084 struct profile_record *record)
9086 gimple_stmt_iterator i;
9087 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
9089 record->size
9090 += estimate_num_insns (gsi_stmt (i), &eni_size_weights);
9091 if (bb->count.initialized_p ())
9092 record->time
9093 += estimate_num_insns (gsi_stmt (i),
9094 &eni_time_weights) * bb->count.to_gcov_type ();
9095 else if (profile_status_for_fn (cfun) == PROFILE_GUESSED)
9096 record->time
9097 += estimate_num_insns (gsi_stmt (i),
9098 &eni_time_weights) * bb->count.to_frequency (cfun);
9102 struct cfg_hooks gimple_cfg_hooks = {
9103 "gimple",
9104 gimple_verify_flow_info,
9105 gimple_dump_bb, /* dump_bb */
9106 gimple_dump_bb_for_graph, /* dump_bb_for_graph */
9107 create_bb, /* create_basic_block */
9108 gimple_redirect_edge_and_branch, /* redirect_edge_and_branch */
9109 gimple_redirect_edge_and_branch_force, /* redirect_edge_and_branch_force */
9110 gimple_can_remove_branch_p, /* can_remove_branch_p */
9111 remove_bb, /* delete_basic_block */
9112 gimple_split_block, /* split_block */
9113 gimple_move_block_after, /* move_block_after */
9114 gimple_can_merge_blocks_p, /* can_merge_blocks_p */
9115 gimple_merge_blocks, /* merge_blocks */
9116 gimple_predict_edge, /* predict_edge */
9117 gimple_predicted_by_p, /* predicted_by_p */
9118 gimple_can_duplicate_bb_p, /* can_duplicate_block_p */
9119 gimple_duplicate_bb, /* duplicate_block */
9120 gimple_split_edge, /* split_edge */
9121 gimple_make_forwarder_block, /* make_forward_block */
9122 NULL, /* tidy_fallthru_edge */
9123 NULL, /* force_nonfallthru */
9124 gimple_block_ends_with_call_p,/* block_ends_with_call_p */
9125 gimple_block_ends_with_condjump_p, /* block_ends_with_condjump_p */
9126 gimple_flow_call_edges_add, /* flow_call_edges_add */
9127 gimple_execute_on_growing_pred, /* execute_on_growing_pred */
9128 gimple_execute_on_shrinking_pred, /* execute_on_shrinking_pred */
9129 gimple_duplicate_loop_to_header_edge, /* duplicate loop for trees */
9130 gimple_lv_add_condition_to_bb, /* lv_add_condition_to_bb */
9131 gimple_lv_adjust_loop_header_phi, /* lv_adjust_loop_header_phi*/
9132 extract_true_false_edges_from_block, /* extract_cond_bb_edges */
9133 flush_pending_stmts, /* flush_pending_stmts */
9134 gimple_empty_block_p, /* block_empty_p */
9135 gimple_split_block_before_cond_jump, /* split_block_before_cond_jump */
9136 gimple_account_profile_record,
9140 /* Split all critical edges. Split some extra (not necessarily critical) edges
9141 if FOR_EDGE_INSERTION_P is true. */
9143 unsigned int
9144 split_critical_edges (bool for_edge_insertion_p /* = false */)
9146 basic_block bb;
9147 edge e;
9148 edge_iterator ei;
9150 /* split_edge can redirect edges out of SWITCH_EXPRs, which can get
9151 expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
9152 mappings around the calls to split_edge. */
9153 start_recording_case_labels ();
9154 FOR_ALL_BB_FN (bb, cfun)
9156 FOR_EACH_EDGE (e, ei, bb->succs)
9158 if (EDGE_CRITICAL_P (e) && !(e->flags & EDGE_ABNORMAL))
9159 split_edge (e);
9160 /* PRE inserts statements to edges and expects that
9161 since split_critical_edges was done beforehand, committing edge
9162 insertions will not split more edges. In addition to critical
9163 edges we must split edges that have multiple successors and
9164 end by control flow statements, such as RESX.
9165 Go ahead and split them too. This matches the logic in
9166 gimple_find_edge_insert_loc. */
9167 else if (for_edge_insertion_p
9168 && (!single_pred_p (e->dest)
9169 || !gimple_seq_empty_p (phi_nodes (e->dest))
9170 || e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
9171 && e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)
9172 && !(e->flags & EDGE_ABNORMAL))
9174 gimple_stmt_iterator gsi;
9176 gsi = gsi_last_bb (e->src);
9177 if (!gsi_end_p (gsi)
9178 && stmt_ends_bb_p (gsi_stmt (gsi))
9179 && (gimple_code (gsi_stmt (gsi)) != GIMPLE_RETURN
9180 && !gimple_call_builtin_p (gsi_stmt (gsi),
9181 BUILT_IN_RETURN)))
9182 split_edge (e);
9186 end_recording_case_labels ();
9187 return 0;
9190 namespace {
9192 const pass_data pass_data_split_crit_edges =
9194 GIMPLE_PASS, /* type */
9195 "crited", /* name */
9196 OPTGROUP_NONE, /* optinfo_flags */
9197 TV_TREE_SPLIT_EDGES, /* tv_id */
9198 PROP_cfg, /* properties_required */
9199 PROP_no_crit_edges, /* properties_provided */
9200 0, /* properties_destroyed */
9201 0, /* todo_flags_start */
9202 0, /* todo_flags_finish */
9205 class pass_split_crit_edges : public gimple_opt_pass
9207 public:
9208 pass_split_crit_edges (gcc::context *ctxt)
9209 : gimple_opt_pass (pass_data_split_crit_edges, ctxt)
9212 /* opt_pass methods: */
9213 virtual unsigned int execute (function *) { return split_critical_edges (); }
9215 opt_pass * clone () { return new pass_split_crit_edges (m_ctxt); }
9216 }; // class pass_split_crit_edges
9218 } // anon namespace
9220 gimple_opt_pass *
9221 make_pass_split_crit_edges (gcc::context *ctxt)
9223 return new pass_split_crit_edges (ctxt);
9227 /* Insert COND expression which is GIMPLE_COND after STMT
9228 in basic block BB with appropriate basic block split
9229 and creation of a new conditionally executed basic block.
9230 Update profile so the new bb is visited with probability PROB.
9231 Return created basic block. */
9232 basic_block
9233 insert_cond_bb (basic_block bb, gimple *stmt, gimple *cond,
9234 profile_probability prob)
9236 edge fall = split_block (bb, stmt);
9237 gimple_stmt_iterator iter = gsi_last_bb (bb);
9238 basic_block new_bb;
9240 /* Insert cond statement. */
9241 gcc_assert (gimple_code (cond) == GIMPLE_COND);
9242 if (gsi_end_p (iter))
9243 gsi_insert_before (&iter, cond, GSI_CONTINUE_LINKING);
9244 else
9245 gsi_insert_after (&iter, cond, GSI_CONTINUE_LINKING);
9247 /* Create conditionally executed block. */
9248 new_bb = create_empty_bb (bb);
9249 edge e = make_edge (bb, new_bb, EDGE_TRUE_VALUE);
9250 e->probability = prob;
9251 new_bb->count = e->count ();
9252 make_single_succ_edge (new_bb, fall->dest, EDGE_FALLTHRU);
9254 /* Fix edge for split bb. */
9255 fall->flags = EDGE_FALSE_VALUE;
9256 fall->probability -= e->probability;
9258 /* Update dominance info. */
9259 if (dom_info_available_p (CDI_DOMINATORS))
9261 set_immediate_dominator (CDI_DOMINATORS, new_bb, bb);
9262 set_immediate_dominator (CDI_DOMINATORS, fall->dest, bb);
9265 /* Update loop info. */
9266 if (current_loops)
9267 add_bb_to_loop (new_bb, bb->loop_father);
9269 return new_bb;
9274 /* Given a basic block B which ends with a conditional and has
9275 precisely two successors, determine which of the edges is taken if
9276 the conditional is true and which is taken if the conditional is
9277 false. Set TRUE_EDGE and FALSE_EDGE appropriately. */
9279 void
9280 extract_true_false_edges_from_block (basic_block b,
9281 edge *true_edge,
9282 edge *false_edge)
9284 edge e = EDGE_SUCC (b, 0);
9286 if (e->flags & EDGE_TRUE_VALUE)
9288 *true_edge = e;
9289 *false_edge = EDGE_SUCC (b, 1);
9291 else
9293 *false_edge = e;
9294 *true_edge = EDGE_SUCC (b, 1);
9299 /* From a controlling predicate in the immediate dominator DOM of
9300 PHIBLOCK determine the edges into PHIBLOCK that are chosen if the
9301 predicate evaluates to true and false and store them to
9302 *TRUE_CONTROLLED_EDGE and *FALSE_CONTROLLED_EDGE if
9303 they are non-NULL. Returns true if the edges can be determined,
9304 else return false. */
9306 bool
9307 extract_true_false_controlled_edges (basic_block dom, basic_block phiblock,
9308 edge *true_controlled_edge,
9309 edge *false_controlled_edge)
9311 basic_block bb = phiblock;
9312 edge true_edge, false_edge, tem;
9313 edge e0 = NULL, e1 = NULL;
9315 /* We have to verify that one edge into the PHI node is dominated
9316 by the true edge of the predicate block and the other edge
9317 dominated by the false edge. This ensures that the PHI argument
9318 we are going to take is completely determined by the path we
9319 take from the predicate block.
9320 We can only use BB dominance checks below if the destination of
9321 the true/false edges are dominated by their edge, thus only
9322 have a single predecessor. */
9323 extract_true_false_edges_from_block (dom, &true_edge, &false_edge);
9324 tem = EDGE_PRED (bb, 0);
9325 if (tem == true_edge
9326 || (single_pred_p (true_edge->dest)
9327 && (tem->src == true_edge->dest
9328 || dominated_by_p (CDI_DOMINATORS,
9329 tem->src, true_edge->dest))))
9330 e0 = tem;
9331 else if (tem == false_edge
9332 || (single_pred_p (false_edge->dest)
9333 && (tem->src == false_edge->dest
9334 || dominated_by_p (CDI_DOMINATORS,
9335 tem->src, false_edge->dest))))
9336 e1 = tem;
9337 else
9338 return false;
9339 tem = EDGE_PRED (bb, 1);
9340 if (tem == true_edge
9341 || (single_pred_p (true_edge->dest)
9342 && (tem->src == true_edge->dest
9343 || dominated_by_p (CDI_DOMINATORS,
9344 tem->src, true_edge->dest))))
9345 e0 = tem;
9346 else if (tem == false_edge
9347 || (single_pred_p (false_edge->dest)
9348 && (tem->src == false_edge->dest
9349 || dominated_by_p (CDI_DOMINATORS,
9350 tem->src, false_edge->dest))))
9351 e1 = tem;
9352 else
9353 return false;
9354 if (!e0 || !e1)
9355 return false;
9357 if (true_controlled_edge)
9358 *true_controlled_edge = e0;
9359 if (false_controlled_edge)
9360 *false_controlled_edge = e1;
9362 return true;
9365 /* Generate a range test LHS CODE RHS that determines whether INDEX is in the
9366 range [low, high]. Place associated stmts before *GSI. */
9368 void
9369 generate_range_test (basic_block bb, tree index, tree low, tree high,
9370 tree *lhs, tree *rhs)
9372 tree type = TREE_TYPE (index);
9373 tree utype = range_check_type (type);
9375 low = fold_convert (utype, low);
9376 high = fold_convert (utype, high);
9378 gimple_seq seq = NULL;
9379 index = gimple_convert (&seq, utype, index);
9380 *lhs = gimple_build (&seq, MINUS_EXPR, utype, index, low);
9381 *rhs = const_binop (MINUS_EXPR, utype, high, low);
9383 gimple_stmt_iterator gsi = gsi_last_bb (bb);
9384 gsi_insert_seq_before (&gsi, seq, GSI_SAME_STMT);
9387 /* Return the basic block that belongs to label numbered INDEX
9388 of a switch statement. */
9390 basic_block
9391 gimple_switch_label_bb (function *ifun, gswitch *gs, unsigned index)
9393 return label_to_block (ifun, CASE_LABEL (gimple_switch_label (gs, index)));
9396 /* Return the default basic block of a switch statement. */
9398 basic_block
9399 gimple_switch_default_bb (function *ifun, gswitch *gs)
9401 return gimple_switch_label_bb (ifun, gs, 0);
9404 /* Return the edge that belongs to label numbered INDEX
9405 of a switch statement. */
9407 edge
9408 gimple_switch_edge (function *ifun, gswitch *gs, unsigned index)
9410 return find_edge (gimple_bb (gs), gimple_switch_label_bb (ifun, gs, index));
9413 /* Return the default edge of a switch statement. */
9415 edge
9416 gimple_switch_default_edge (function *ifun, gswitch *gs)
9418 return gimple_switch_edge (ifun, gs, 0);
9422 /* Emit return warnings. */
9424 namespace {
9426 const pass_data pass_data_warn_function_return =
9428 GIMPLE_PASS, /* type */
9429 "*warn_function_return", /* name */
9430 OPTGROUP_NONE, /* optinfo_flags */
9431 TV_NONE, /* tv_id */
9432 PROP_cfg, /* properties_required */
9433 0, /* properties_provided */
9434 0, /* properties_destroyed */
9435 0, /* todo_flags_start */
9436 0, /* todo_flags_finish */
9439 class pass_warn_function_return : public gimple_opt_pass
9441 public:
9442 pass_warn_function_return (gcc::context *ctxt)
9443 : gimple_opt_pass (pass_data_warn_function_return, ctxt)
9446 /* opt_pass methods: */
9447 virtual unsigned int execute (function *);
9449 }; // class pass_warn_function_return
9451 unsigned int
9452 pass_warn_function_return::execute (function *fun)
9454 location_t location;
9455 gimple *last;
9456 edge e;
9457 edge_iterator ei;
9459 if (!targetm.warn_func_return (fun->decl))
9460 return 0;
9462 /* If we have a path to EXIT, then we do return. */
9463 if (TREE_THIS_VOLATILE (fun->decl)
9464 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) > 0)
9466 location = UNKNOWN_LOCATION;
9467 for (ei = ei_start (EXIT_BLOCK_PTR_FOR_FN (fun)->preds);
9468 (e = ei_safe_edge (ei)); )
9470 last = last_stmt (e->src);
9471 if ((gimple_code (last) == GIMPLE_RETURN
9472 || gimple_call_builtin_p (last, BUILT_IN_RETURN))
9473 && location == UNKNOWN_LOCATION
9474 && ((location = LOCATION_LOCUS (gimple_location (last)))
9475 != UNKNOWN_LOCATION)
9476 && !optimize)
9477 break;
9478 /* When optimizing, replace return stmts in noreturn functions
9479 with __builtin_unreachable () call. */
9480 if (optimize && gimple_code (last) == GIMPLE_RETURN)
9482 tree fndecl = builtin_decl_implicit (BUILT_IN_UNREACHABLE);
9483 gimple *new_stmt = gimple_build_call (fndecl, 0);
9484 gimple_set_location (new_stmt, gimple_location (last));
9485 gimple_stmt_iterator gsi = gsi_for_stmt (last);
9486 gsi_replace (&gsi, new_stmt, true);
9487 remove_edge (e);
9489 else
9490 ei_next (&ei);
9492 if (location == UNKNOWN_LOCATION)
9493 location = cfun->function_end_locus;
9494 warning_at (location, 0, "%<noreturn%> function does return");
9497 /* If we see "return;" in some basic block, then we do reach the end
9498 without returning a value. */
9499 else if (warn_return_type > 0
9500 && !warning_suppressed_p (fun->decl, OPT_Wreturn_type)
9501 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fun->decl))))
9503 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (fun)->preds)
9505 gimple *last = last_stmt (e->src);
9506 greturn *return_stmt = dyn_cast <greturn *> (last);
9507 if (return_stmt
9508 && gimple_return_retval (return_stmt) == NULL
9509 && !warning_suppressed_p (last, OPT_Wreturn_type))
9511 location = gimple_location (last);
9512 if (LOCATION_LOCUS (location) == UNKNOWN_LOCATION)
9513 location = fun->function_end_locus;
9514 if (warning_at (location, OPT_Wreturn_type,
9515 "control reaches end of non-void function"))
9516 suppress_warning (fun->decl, OPT_Wreturn_type);
9517 break;
9520 /* The C++ FE turns fallthrough from the end of non-void function
9521 into __builtin_unreachable () call with BUILTINS_LOCATION.
9522 Recognize those too. */
9523 basic_block bb;
9524 if (!warning_suppressed_p (fun->decl, OPT_Wreturn_type))
9525 FOR_EACH_BB_FN (bb, fun)
9526 if (EDGE_COUNT (bb->succs) == 0)
9528 gimple *last = last_stmt (bb);
9529 const enum built_in_function ubsan_missing_ret
9530 = BUILT_IN_UBSAN_HANDLE_MISSING_RETURN;
9531 if (last
9532 && ((LOCATION_LOCUS (gimple_location (last))
9533 == BUILTINS_LOCATION
9534 && gimple_call_builtin_p (last, BUILT_IN_UNREACHABLE))
9535 || gimple_call_builtin_p (last, ubsan_missing_ret)))
9537 gimple_stmt_iterator gsi = gsi_for_stmt (last);
9538 gsi_prev_nondebug (&gsi);
9539 gimple *prev = gsi_stmt (gsi);
9540 if (prev == NULL)
9541 location = UNKNOWN_LOCATION;
9542 else
9543 location = gimple_location (prev);
9544 if (LOCATION_LOCUS (location) == UNKNOWN_LOCATION)
9545 location = fun->function_end_locus;
9546 if (warning_at (location, OPT_Wreturn_type,
9547 "control reaches end of non-void function"))
9548 suppress_warning (fun->decl, OPT_Wreturn_type);
9549 break;
9553 return 0;
9556 } // anon namespace
9558 gimple_opt_pass *
9559 make_pass_warn_function_return (gcc::context *ctxt)
9561 return new pass_warn_function_return (ctxt);
9564 /* Walk a gimplified function and warn for functions whose return value is
9565 ignored and attribute((warn_unused_result)) is set. This is done before
9566 inlining, so we don't have to worry about that. */
9568 static void
9569 do_warn_unused_result (gimple_seq seq)
9571 tree fdecl, ftype;
9572 gimple_stmt_iterator i;
9574 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
9576 gimple *g = gsi_stmt (i);
9578 switch (gimple_code (g))
9580 case GIMPLE_BIND:
9581 do_warn_unused_result (gimple_bind_body (as_a <gbind *>(g)));
9582 break;
9583 case GIMPLE_TRY:
9584 do_warn_unused_result (gimple_try_eval (g));
9585 do_warn_unused_result (gimple_try_cleanup (g));
9586 break;
9587 case GIMPLE_CATCH:
9588 do_warn_unused_result (gimple_catch_handler (
9589 as_a <gcatch *> (g)));
9590 break;
9591 case GIMPLE_EH_FILTER:
9592 do_warn_unused_result (gimple_eh_filter_failure (g));
9593 break;
9595 case GIMPLE_CALL:
9596 if (gimple_call_lhs (g))
9597 break;
9598 if (gimple_call_internal_p (g))
9599 break;
9601 /* This is a naked call, as opposed to a GIMPLE_CALL with an
9602 LHS. All calls whose value is ignored should be
9603 represented like this. Look for the attribute. */
9604 fdecl = gimple_call_fndecl (g);
9605 ftype = gimple_call_fntype (g);
9607 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
9609 location_t loc = gimple_location (g);
9611 if (fdecl)
9612 warning_at (loc, OPT_Wunused_result,
9613 "ignoring return value of %qD "
9614 "declared with attribute %<warn_unused_result%>",
9615 fdecl);
9616 else
9617 warning_at (loc, OPT_Wunused_result,
9618 "ignoring return value of function "
9619 "declared with attribute %<warn_unused_result%>");
9621 break;
9623 default:
9624 /* Not a container, not a call, or a call whose value is used. */
9625 break;
9630 namespace {
9632 const pass_data pass_data_warn_unused_result =
9634 GIMPLE_PASS, /* type */
9635 "*warn_unused_result", /* name */
9636 OPTGROUP_NONE, /* optinfo_flags */
9637 TV_NONE, /* tv_id */
9638 PROP_gimple_any, /* properties_required */
9639 0, /* properties_provided */
9640 0, /* properties_destroyed */
9641 0, /* todo_flags_start */
9642 0, /* todo_flags_finish */
9645 class pass_warn_unused_result : public gimple_opt_pass
9647 public:
9648 pass_warn_unused_result (gcc::context *ctxt)
9649 : gimple_opt_pass (pass_data_warn_unused_result, ctxt)
9652 /* opt_pass methods: */
9653 virtual bool gate (function *) { return flag_warn_unused_result; }
9654 virtual unsigned int execute (function *)
9656 do_warn_unused_result (gimple_body (current_function_decl));
9657 return 0;
9660 }; // class pass_warn_unused_result
9662 } // anon namespace
9664 gimple_opt_pass *
9665 make_pass_warn_unused_result (gcc::context *ctxt)
9667 return new pass_warn_unused_result (ctxt);
9670 /* Maybe Remove stores to variables we marked write-only.
9671 Return true if a store was removed. */
9672 static bool
9673 maybe_remove_writeonly_store (gimple_stmt_iterator &gsi, gimple *stmt,
9674 bitmap dce_ssa_names)
9676 /* Keep access when store has side effect, i.e. in case when source
9677 is volatile. */
9678 if (!gimple_store_p (stmt)
9679 || gimple_has_side_effects (stmt)
9680 || optimize_debug)
9681 return false;
9683 tree lhs = get_base_address (gimple_get_lhs (stmt));
9685 if (!VAR_P (lhs)
9686 || (!TREE_STATIC (lhs) && !DECL_EXTERNAL (lhs))
9687 || !varpool_node::get (lhs)->writeonly)
9688 return false;
9690 if (dump_file && (dump_flags & TDF_DETAILS))
9692 fprintf (dump_file, "Removing statement, writes"
9693 " to write only var:\n");
9694 print_gimple_stmt (dump_file, stmt, 0,
9695 TDF_VOPS|TDF_MEMSYMS);
9698 /* Mark ssa name defining to be checked for simple dce. */
9699 if (gimple_assign_single_p (stmt))
9701 tree rhs = gimple_assign_rhs1 (stmt);
9702 if (TREE_CODE (rhs) == SSA_NAME
9703 && !SSA_NAME_IS_DEFAULT_DEF (rhs))
9704 bitmap_set_bit (dce_ssa_names, SSA_NAME_VERSION (rhs));
9706 unlink_stmt_vdef (stmt);
9707 gsi_remove (&gsi, true);
9708 release_defs (stmt);
9709 return true;
9712 /* IPA passes, compilation of earlier functions or inlining
9713 might have changed some properties, such as marked functions nothrow,
9714 pure, const or noreturn.
9715 Remove redundant edges and basic blocks, and create new ones if necessary. */
9717 unsigned int
9718 execute_fixup_cfg (void)
9720 basic_block bb;
9721 gimple_stmt_iterator gsi;
9722 int todo = 0;
9723 cgraph_node *node = cgraph_node::get (current_function_decl);
9724 /* Same scaling is also done by ipa_merge_profiles. */
9725 profile_count num = node->count;
9726 profile_count den = ENTRY_BLOCK_PTR_FOR_FN (cfun)->count;
9727 bool scale = num.initialized_p () && !(num == den);
9728 auto_bitmap dce_ssa_names;
9730 if (scale)
9732 profile_count::adjust_for_ipa_scaling (&num, &den);
9733 ENTRY_BLOCK_PTR_FOR_FN (cfun)->count = node->count;
9734 EXIT_BLOCK_PTR_FOR_FN (cfun)->count
9735 = EXIT_BLOCK_PTR_FOR_FN (cfun)->count.apply_scale (num, den);
9738 FOR_EACH_BB_FN (bb, cfun)
9740 if (scale)
9741 bb->count = bb->count.apply_scale (num, den);
9742 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
9744 gimple *stmt = gsi_stmt (gsi);
9745 tree decl = is_gimple_call (stmt)
9746 ? gimple_call_fndecl (stmt)
9747 : NULL;
9748 if (decl)
9750 int flags = gimple_call_flags (stmt);
9751 if (flags & (ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE))
9753 if (gimple_purge_dead_abnormal_call_edges (bb))
9754 todo |= TODO_cleanup_cfg;
9756 if (gimple_in_ssa_p (cfun))
9758 todo |= TODO_update_ssa | TODO_cleanup_cfg;
9759 update_stmt (stmt);
9763 if (flags & ECF_NORETURN
9764 && fixup_noreturn_call (stmt))
9765 todo |= TODO_cleanup_cfg;
9768 /* Remove stores to variables we marked write-only. */
9769 if (maybe_remove_writeonly_store (gsi, stmt, dce_ssa_names))
9771 todo |= TODO_update_ssa | TODO_cleanup_cfg;
9772 continue;
9775 /* For calls we can simply remove LHS when it is known
9776 to be write-only. */
9777 if (is_gimple_call (stmt)
9778 && gimple_get_lhs (stmt))
9780 tree lhs = get_base_address (gimple_get_lhs (stmt));
9782 if (VAR_P (lhs)
9783 && (TREE_STATIC (lhs) || DECL_EXTERNAL (lhs))
9784 && varpool_node::get (lhs)->writeonly)
9786 gimple_call_set_lhs (stmt, NULL);
9787 update_stmt (stmt);
9788 todo |= TODO_update_ssa | TODO_cleanup_cfg;
9792 if (maybe_clean_eh_stmt (stmt)
9793 && gimple_purge_dead_eh_edges (bb))
9794 todo |= TODO_cleanup_cfg;
9795 gsi_next (&gsi);
9798 /* If we have a basic block with no successors that does not
9799 end with a control statement or a noreturn call end it with
9800 a call to __builtin_unreachable. This situation can occur
9801 when inlining a noreturn call that does in fact return. */
9802 if (EDGE_COUNT (bb->succs) == 0)
9804 gimple *stmt = last_stmt (bb);
9805 if (!stmt
9806 || (!is_ctrl_stmt (stmt)
9807 && (!is_gimple_call (stmt)
9808 || !gimple_call_noreturn_p (stmt))))
9810 if (stmt && is_gimple_call (stmt))
9811 gimple_call_set_ctrl_altering (stmt, false);
9812 tree fndecl = builtin_decl_implicit (BUILT_IN_UNREACHABLE);
9813 stmt = gimple_build_call (fndecl, 0);
9814 gimple_stmt_iterator gsi = gsi_last_bb (bb);
9815 gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
9816 if (!cfun->after_inlining)
9818 gcall *call_stmt = dyn_cast <gcall *> (stmt);
9819 node->create_edge (cgraph_node::get_create (fndecl),
9820 call_stmt, bb->count);
9825 if (scale)
9827 update_max_bb_count ();
9828 compute_function_frequency ();
9831 if (current_loops
9832 && (todo & TODO_cleanup_cfg))
9833 loops_state_set (LOOPS_NEED_FIXUP);
9835 simple_dce_from_worklist (dce_ssa_names);
9837 return todo;
9840 namespace {
9842 const pass_data pass_data_fixup_cfg =
9844 GIMPLE_PASS, /* type */
9845 "fixup_cfg", /* name */
9846 OPTGROUP_NONE, /* optinfo_flags */
9847 TV_NONE, /* tv_id */
9848 PROP_cfg, /* properties_required */
9849 0, /* properties_provided */
9850 0, /* properties_destroyed */
9851 0, /* todo_flags_start */
9852 0, /* todo_flags_finish */
9855 class pass_fixup_cfg : public gimple_opt_pass
9857 public:
9858 pass_fixup_cfg (gcc::context *ctxt)
9859 : gimple_opt_pass (pass_data_fixup_cfg, ctxt)
9862 /* opt_pass methods: */
9863 opt_pass * clone () { return new pass_fixup_cfg (m_ctxt); }
9864 virtual unsigned int execute (function *) { return execute_fixup_cfg (); }
9866 }; // class pass_fixup_cfg
9868 } // anon namespace
9870 gimple_opt_pass *
9871 make_pass_fixup_cfg (gcc::context *ctxt)
9873 return new pass_fixup_cfg (ctxt);
9876 /* Garbage collection support for edge_def. */
9878 extern void gt_ggc_mx (tree&);
9879 extern void gt_ggc_mx (gimple *&);
9880 extern void gt_ggc_mx (rtx&);
9881 extern void gt_ggc_mx (basic_block&);
9883 static void
9884 gt_ggc_mx (rtx_insn *& x)
9886 if (x)
9887 gt_ggc_mx_rtx_def ((void *) x);
9890 void
9891 gt_ggc_mx (edge_def *e)
9893 tree block = LOCATION_BLOCK (e->goto_locus);
9894 gt_ggc_mx (e->src);
9895 gt_ggc_mx (e->dest);
9896 if (current_ir_type () == IR_GIMPLE)
9897 gt_ggc_mx (e->insns.g);
9898 else
9899 gt_ggc_mx (e->insns.r);
9900 gt_ggc_mx (block);
9903 /* PCH support for edge_def. */
9905 extern void gt_pch_nx (tree&);
9906 extern void gt_pch_nx (gimple *&);
9907 extern void gt_pch_nx (rtx&);
9908 extern void gt_pch_nx (basic_block&);
9910 static void
9911 gt_pch_nx (rtx_insn *& x)
9913 if (x)
9914 gt_pch_nx_rtx_def ((void *) x);
9917 void
9918 gt_pch_nx (edge_def *e)
9920 tree block = LOCATION_BLOCK (e->goto_locus);
9921 gt_pch_nx (e->src);
9922 gt_pch_nx (e->dest);
9923 if (current_ir_type () == IR_GIMPLE)
9924 gt_pch_nx (e->insns.g);
9925 else
9926 gt_pch_nx (e->insns.r);
9927 gt_pch_nx (block);
9930 void
9931 gt_pch_nx (edge_def *e, gt_pointer_operator op, void *cookie)
9933 tree block = LOCATION_BLOCK (e->goto_locus);
9934 op (&(e->src), cookie);
9935 op (&(e->dest), cookie);
9936 if (current_ir_type () == IR_GIMPLE)
9937 op (&(e->insns.g), cookie);
9938 else
9939 op (&(e->insns.r), cookie);
9940 op (&(block), cookie);
9943 #if CHECKING_P
9945 namespace selftest {
9947 /* Helper function for CFG selftests: create a dummy function decl
9948 and push it as cfun. */
9950 static tree
9951 push_fndecl (const char *name)
9953 tree fn_type = build_function_type_array (integer_type_node, 0, NULL);
9954 /* FIXME: this uses input_location: */
9955 tree fndecl = build_fn_decl (name, fn_type);
9956 tree retval = build_decl (UNKNOWN_LOCATION, RESULT_DECL,
9957 NULL_TREE, integer_type_node);
9958 DECL_RESULT (fndecl) = retval;
9959 push_struct_function (fndecl);
9960 function *fun = DECL_STRUCT_FUNCTION (fndecl);
9961 ASSERT_TRUE (fun != NULL);
9962 init_empty_tree_cfg_for_function (fun);
9963 ASSERT_EQ (2, n_basic_blocks_for_fn (fun));
9964 ASSERT_EQ (0, n_edges_for_fn (fun));
9965 return fndecl;
9968 /* These tests directly create CFGs.
9969 Compare with the static fns within tree-cfg.c:
9970 - build_gimple_cfg
9971 - make_blocks: calls create_basic_block (seq, bb);
9972 - make_edges. */
9974 /* Verify a simple cfg of the form:
9975 ENTRY -> A -> B -> C -> EXIT. */
9977 static void
9978 test_linear_chain ()
9980 gimple_register_cfg_hooks ();
9982 tree fndecl = push_fndecl ("cfg_test_linear_chain");
9983 function *fun = DECL_STRUCT_FUNCTION (fndecl);
9985 /* Create some empty blocks. */
9986 basic_block bb_a = create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun));
9987 basic_block bb_b = create_empty_bb (bb_a);
9988 basic_block bb_c = create_empty_bb (bb_b);
9990 ASSERT_EQ (5, n_basic_blocks_for_fn (fun));
9991 ASSERT_EQ (0, n_edges_for_fn (fun));
9993 /* Create some edges: a simple linear chain of BBs. */
9994 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun), bb_a, EDGE_FALLTHRU);
9995 make_edge (bb_a, bb_b, 0);
9996 make_edge (bb_b, bb_c, 0);
9997 make_edge (bb_c, EXIT_BLOCK_PTR_FOR_FN (fun), 0);
9999 /* Verify the edges. */
10000 ASSERT_EQ (4, n_edges_for_fn (fun));
10001 ASSERT_EQ (NULL, ENTRY_BLOCK_PTR_FOR_FN (fun)->preds);
10002 ASSERT_EQ (1, ENTRY_BLOCK_PTR_FOR_FN (fun)->succs->length ());
10003 ASSERT_EQ (1, bb_a->preds->length ());
10004 ASSERT_EQ (1, bb_a->succs->length ());
10005 ASSERT_EQ (1, bb_b->preds->length ());
10006 ASSERT_EQ (1, bb_b->succs->length ());
10007 ASSERT_EQ (1, bb_c->preds->length ());
10008 ASSERT_EQ (1, bb_c->succs->length ());
10009 ASSERT_EQ (1, EXIT_BLOCK_PTR_FOR_FN (fun)->preds->length ());
10010 ASSERT_EQ (NULL, EXIT_BLOCK_PTR_FOR_FN (fun)->succs);
10012 /* Verify the dominance information
10013 Each BB in our simple chain should be dominated by the one before
10014 it. */
10015 calculate_dominance_info (CDI_DOMINATORS);
10016 ASSERT_EQ (bb_a, get_immediate_dominator (CDI_DOMINATORS, bb_b));
10017 ASSERT_EQ (bb_b, get_immediate_dominator (CDI_DOMINATORS, bb_c));
10018 auto_vec<basic_block> dom_by_b = get_dominated_by (CDI_DOMINATORS, bb_b);
10019 ASSERT_EQ (1, dom_by_b.length ());
10020 ASSERT_EQ (bb_c, dom_by_b[0]);
10021 free_dominance_info (CDI_DOMINATORS);
10023 /* Similarly for post-dominance: each BB in our chain is post-dominated
10024 by the one after it. */
10025 calculate_dominance_info (CDI_POST_DOMINATORS);
10026 ASSERT_EQ (bb_b, get_immediate_dominator (CDI_POST_DOMINATORS, bb_a));
10027 ASSERT_EQ (bb_c, get_immediate_dominator (CDI_POST_DOMINATORS, bb_b));
10028 auto_vec<basic_block> postdom_by_b = get_dominated_by (CDI_POST_DOMINATORS, bb_b);
10029 ASSERT_EQ (1, postdom_by_b.length ());
10030 ASSERT_EQ (bb_a, postdom_by_b[0]);
10031 free_dominance_info (CDI_POST_DOMINATORS);
10033 pop_cfun ();
10036 /* Verify a simple CFG of the form:
10037 ENTRY
10041 /t \f
10047 EXIT. */
10049 static void
10050 test_diamond ()
10052 gimple_register_cfg_hooks ();
10054 tree fndecl = push_fndecl ("cfg_test_diamond");
10055 function *fun = DECL_STRUCT_FUNCTION (fndecl);
10057 /* Create some empty blocks. */
10058 basic_block bb_a = create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun));
10059 basic_block bb_b = create_empty_bb (bb_a);
10060 basic_block bb_c = create_empty_bb (bb_a);
10061 basic_block bb_d = create_empty_bb (bb_b);
10063 ASSERT_EQ (6, n_basic_blocks_for_fn (fun));
10064 ASSERT_EQ (0, n_edges_for_fn (fun));
10066 /* Create the edges. */
10067 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun), bb_a, EDGE_FALLTHRU);
10068 make_edge (bb_a, bb_b, EDGE_TRUE_VALUE);
10069 make_edge (bb_a, bb_c, EDGE_FALSE_VALUE);
10070 make_edge (bb_b, bb_d, 0);
10071 make_edge (bb_c, bb_d, 0);
10072 make_edge (bb_d, EXIT_BLOCK_PTR_FOR_FN (fun), 0);
10074 /* Verify the edges. */
10075 ASSERT_EQ (6, n_edges_for_fn (fun));
10076 ASSERT_EQ (1, bb_a->preds->length ());
10077 ASSERT_EQ (2, bb_a->succs->length ());
10078 ASSERT_EQ (1, bb_b->preds->length ());
10079 ASSERT_EQ (1, bb_b->succs->length ());
10080 ASSERT_EQ (1, bb_c->preds->length ());
10081 ASSERT_EQ (1, bb_c->succs->length ());
10082 ASSERT_EQ (2, bb_d->preds->length ());
10083 ASSERT_EQ (1, bb_d->succs->length ());
10085 /* Verify the dominance information. */
10086 calculate_dominance_info (CDI_DOMINATORS);
10087 ASSERT_EQ (bb_a, get_immediate_dominator (CDI_DOMINATORS, bb_b));
10088 ASSERT_EQ (bb_a, get_immediate_dominator (CDI_DOMINATORS, bb_c));
10089 ASSERT_EQ (bb_a, get_immediate_dominator (CDI_DOMINATORS, bb_d));
10090 auto_vec<basic_block> dom_by_a = get_dominated_by (CDI_DOMINATORS, bb_a);
10091 ASSERT_EQ (3, dom_by_a.length ()); /* B, C, D, in some order. */
10092 dom_by_a.release ();
10093 auto_vec<basic_block> dom_by_b = get_dominated_by (CDI_DOMINATORS, bb_b);
10094 ASSERT_EQ (0, dom_by_b.length ());
10095 dom_by_b.release ();
10096 free_dominance_info (CDI_DOMINATORS);
10098 /* Similarly for post-dominance. */
10099 calculate_dominance_info (CDI_POST_DOMINATORS);
10100 ASSERT_EQ (bb_d, get_immediate_dominator (CDI_POST_DOMINATORS, bb_a));
10101 ASSERT_EQ (bb_d, get_immediate_dominator (CDI_POST_DOMINATORS, bb_b));
10102 ASSERT_EQ (bb_d, get_immediate_dominator (CDI_POST_DOMINATORS, bb_c));
10103 auto_vec<basic_block> postdom_by_d = get_dominated_by (CDI_POST_DOMINATORS, bb_d);
10104 ASSERT_EQ (3, postdom_by_d.length ()); /* A, B, C in some order. */
10105 postdom_by_d.release ();
10106 auto_vec<basic_block> postdom_by_b = get_dominated_by (CDI_POST_DOMINATORS, bb_b);
10107 ASSERT_EQ (0, postdom_by_b.length ());
10108 postdom_by_b.release ();
10109 free_dominance_info (CDI_POST_DOMINATORS);
10111 pop_cfun ();
10114 /* Verify that we can handle a CFG containing a "complete" aka
10115 fully-connected subgraph (where A B C D below all have edges
10116 pointing to each other node, also to themselves).
10117 e.g.:
10118 ENTRY EXIT
10124 A<--->B
10125 ^^ ^^
10126 | \ / |
10127 | X |
10128 | / \ |
10129 VV VV
10130 C<--->D
10133 static void
10134 test_fully_connected ()
10136 gimple_register_cfg_hooks ();
10138 tree fndecl = push_fndecl ("cfg_fully_connected");
10139 function *fun = DECL_STRUCT_FUNCTION (fndecl);
10141 const int n = 4;
10143 /* Create some empty blocks. */
10144 auto_vec <basic_block> subgraph_nodes;
10145 for (int i = 0; i < n; i++)
10146 subgraph_nodes.safe_push (create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun)));
10148 ASSERT_EQ (n + 2, n_basic_blocks_for_fn (fun));
10149 ASSERT_EQ (0, n_edges_for_fn (fun));
10151 /* Create the edges. */
10152 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun), subgraph_nodes[0], EDGE_FALLTHRU);
10153 make_edge (subgraph_nodes[0], EXIT_BLOCK_PTR_FOR_FN (fun), 0);
10154 for (int i = 0; i < n; i++)
10155 for (int j = 0; j < n; j++)
10156 make_edge (subgraph_nodes[i], subgraph_nodes[j], 0);
10158 /* Verify the edges. */
10159 ASSERT_EQ (2 + (n * n), n_edges_for_fn (fun));
10160 /* The first one is linked to ENTRY/EXIT as well as itself and
10161 everything else. */
10162 ASSERT_EQ (n + 1, subgraph_nodes[0]->preds->length ());
10163 ASSERT_EQ (n + 1, subgraph_nodes[0]->succs->length ());
10164 /* The other ones in the subgraph are linked to everything in
10165 the subgraph (including themselves). */
10166 for (int i = 1; i < n; i++)
10168 ASSERT_EQ (n, subgraph_nodes[i]->preds->length ());
10169 ASSERT_EQ (n, subgraph_nodes[i]->succs->length ());
10172 /* Verify the dominance information. */
10173 calculate_dominance_info (CDI_DOMINATORS);
10174 /* The initial block in the subgraph should be dominated by ENTRY. */
10175 ASSERT_EQ (ENTRY_BLOCK_PTR_FOR_FN (fun),
10176 get_immediate_dominator (CDI_DOMINATORS,
10177 subgraph_nodes[0]));
10178 /* Every other block in the subgraph should be dominated by the
10179 initial block. */
10180 for (int i = 1; i < n; i++)
10181 ASSERT_EQ (subgraph_nodes[0],
10182 get_immediate_dominator (CDI_DOMINATORS,
10183 subgraph_nodes[i]));
10184 free_dominance_info (CDI_DOMINATORS);
10186 /* Similarly for post-dominance. */
10187 calculate_dominance_info (CDI_POST_DOMINATORS);
10188 /* The initial block in the subgraph should be postdominated by EXIT. */
10189 ASSERT_EQ (EXIT_BLOCK_PTR_FOR_FN (fun),
10190 get_immediate_dominator (CDI_POST_DOMINATORS,
10191 subgraph_nodes[0]));
10192 /* Every other block in the subgraph should be postdominated by the
10193 initial block, since that leads to EXIT. */
10194 for (int i = 1; i < n; i++)
10195 ASSERT_EQ (subgraph_nodes[0],
10196 get_immediate_dominator (CDI_POST_DOMINATORS,
10197 subgraph_nodes[i]));
10198 free_dominance_info (CDI_POST_DOMINATORS);
10200 pop_cfun ();
10203 /* Run all of the selftests within this file. */
10205 void
10206 tree_cfg_c_tests ()
10208 test_linear_chain ();
10209 test_diamond ();
10210 test_fully_connected ();
10213 } // namespace selftest
10215 /* TODO: test the dominator/postdominator logic with various graphs/nodes:
10216 - loop
10217 - nested loops
10218 - switch statement (a block with many out-edges)
10219 - something that jumps to itself
10220 - etc */
10222 #endif /* CHECKING_P */