1 /* Control flow functions for trees.
2 Copyright (C) 2001-2015 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)
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/>. */
23 #include "coretypes.h"
24 #include "hash-table.h"
30 #include "double-int.h"
37 #include "fold-const.h"
38 #include "trans-mem.h"
39 #include "stor-layout.h"
40 #include "print-tree.h"
43 #include "hard-reg-set.h"
45 #include "dominance.h"
48 #include "basic-block.h"
50 #include "gimple-pretty-print.h"
51 #include "tree-ssa-alias.h"
52 #include "internal-fn.h"
53 #include "gimple-fold.h"
55 #include "gimple-expr.h"
58 #include "gimple-iterator.h"
59 #include "gimplify-me.h"
60 #include "gimple-walk.h"
61 #include "gimple-ssa.h"
62 #include "plugin-api.h"
66 #include "tree-phinodes.h"
67 #include "ssa-iterators.h"
68 #include "stringpool.h"
69 #include "tree-ssanames.h"
70 #include "tree-ssa-loop-manip.h"
71 #include "tree-ssa-loop-niter.h"
72 #include "tree-into-ssa.h"
75 #include "statistics.h"
77 #include "fixed-value.h"
78 #include "insn-config.h"
89 #include "tree-dump.h"
90 #include "tree-pass.h"
91 #include "diagnostic-core.h"
94 #include "tree-ssa-propagate.h"
95 #include "value-prof.h"
96 #include "tree-inline.h"
98 #include "tree-ssa-live.h"
100 #include "tree-cfgcleanup.h"
101 #include "wide-int-print.h"
103 /* This file contains functions for building the Control Flow Graph (CFG)
104 for a function tree. */
106 /* Local declarations. */
108 /* Initial capacity for the basic block array. */
109 static const int initial_cfg_capacity = 20;
111 /* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
112 which use a particular edge. The CASE_LABEL_EXPRs are chained together
113 via their CASE_CHAIN field, which we clear after we're done with the
114 hash table to prevent problems with duplication of GIMPLE_SWITCHes.
116 Access to this list of CASE_LABEL_EXPRs allows us to efficiently
117 update the case vector in response to edge redirections.
119 Right now this table is set up and torn down at key points in the
120 compilation process. It would be nice if we could make the table
121 more persistent. The key is getting notification of changes to
122 the CFG (particularly edge removal, creation and redirection). */
124 static hash_map<edge, tree> *edge_to_cases;
126 /* If we record edge_to_cases, this bitmap will hold indexes
127 of basic blocks that end in a GIMPLE_SWITCH which we touched
128 due to edge manipulations. */
130 static bitmap touched_switch_bbs;
132 /* CFG statistics. */
135 long num_merged_labels;
138 static struct cfg_stats_d cfg_stats;
140 /* Hash table to store last discriminator assigned for each locus. */
141 struct locus_discrim_map
147 /* Hashtable helpers. */
149 struct locus_discrim_hasher : typed_free_remove <locus_discrim_map>
151 typedef locus_discrim_map value_type;
152 typedef locus_discrim_map compare_type;
153 static inline hashval_t hash (const value_type *);
154 static inline bool equal (const value_type *, const compare_type *);
157 /* Trivial hash function for a location_t. ITEM is a pointer to
158 a hash table entry that maps a location_t to a discriminator. */
161 locus_discrim_hasher::hash (const value_type *item)
163 return LOCATION_LINE (item->locus);
166 /* Equality function for the locus-to-discriminator map. A and B
167 point to the two hash table entries to compare. */
170 locus_discrim_hasher::equal (const value_type *a, const compare_type *b)
172 return LOCATION_LINE (a->locus) == LOCATION_LINE (b->locus);
175 static hash_table<locus_discrim_hasher> *discriminator_per_locus;
177 /* Basic blocks and flowgraphs. */
178 static void make_blocks (gimple_seq);
181 static void make_edges (void);
182 static void assign_discriminators (void);
183 static void make_cond_expr_edges (basic_block);
184 static void make_gimple_switch_edges (gswitch *, basic_block);
185 static bool make_goto_expr_edges (basic_block);
186 static void make_gimple_asm_edges (basic_block);
187 static edge gimple_redirect_edge_and_branch (edge, basic_block);
188 static edge gimple_try_redirect_by_replacing_jump (edge, basic_block);
190 /* Various helpers. */
191 static inline bool stmt_starts_bb_p (gimple, gimple);
192 static int gimple_verify_flow_info (void);
193 static void gimple_make_forwarder_block (edge);
194 static gimple first_non_label_stmt (basic_block);
195 static bool verify_gimple_transaction (gtransaction *);
196 static bool call_can_make_abnormal_goto (gimple);
198 /* Flowgraph optimization and cleanup. */
199 static void gimple_merge_blocks (basic_block, basic_block);
200 static bool gimple_can_merge_blocks_p (basic_block, basic_block);
201 static void remove_bb (basic_block);
202 static edge find_taken_edge_computed_goto (basic_block, tree);
203 static edge find_taken_edge_cond_expr (basic_block, tree);
204 static edge find_taken_edge_switch_expr (gswitch *, basic_block, tree);
205 static tree find_case_label_for_value (gswitch *, tree);
208 init_empty_tree_cfg_for_function (struct function *fn)
210 /* Initialize the basic block array. */
212 profile_status_for_fn (fn) = PROFILE_ABSENT;
213 n_basic_blocks_for_fn (fn) = NUM_FIXED_BLOCKS;
214 last_basic_block_for_fn (fn) = NUM_FIXED_BLOCKS;
215 vec_alloc (basic_block_info_for_fn (fn), initial_cfg_capacity);
216 vec_safe_grow_cleared (basic_block_info_for_fn (fn),
217 initial_cfg_capacity);
219 /* Build a mapping of labels to their associated blocks. */
220 vec_alloc (label_to_block_map_for_fn (fn), initial_cfg_capacity);
221 vec_safe_grow_cleared (label_to_block_map_for_fn (fn),
222 initial_cfg_capacity);
224 SET_BASIC_BLOCK_FOR_FN (fn, ENTRY_BLOCK, ENTRY_BLOCK_PTR_FOR_FN (fn));
225 SET_BASIC_BLOCK_FOR_FN (fn, EXIT_BLOCK, EXIT_BLOCK_PTR_FOR_FN (fn));
227 ENTRY_BLOCK_PTR_FOR_FN (fn)->next_bb
228 = EXIT_BLOCK_PTR_FOR_FN (fn);
229 EXIT_BLOCK_PTR_FOR_FN (fn)->prev_bb
230 = ENTRY_BLOCK_PTR_FOR_FN (fn);
234 init_empty_tree_cfg (void)
236 init_empty_tree_cfg_for_function (cfun);
239 /*---------------------------------------------------------------------------
241 ---------------------------------------------------------------------------*/
243 /* Entry point to the CFG builder for trees. SEQ is the sequence of
244 statements to be added to the flowgraph. */
247 build_gimple_cfg (gimple_seq seq)
249 /* Register specific gimple functions. */
250 gimple_register_cfg_hooks ();
252 memset ((void *) &cfg_stats, 0, sizeof (cfg_stats));
254 init_empty_tree_cfg ();
258 /* Make sure there is always at least one block, even if it's empty. */
259 if (n_basic_blocks_for_fn (cfun) == NUM_FIXED_BLOCKS)
260 create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun));
262 /* Adjust the size of the array. */
263 if (basic_block_info_for_fn (cfun)->length ()
264 < (size_t) n_basic_blocks_for_fn (cfun))
265 vec_safe_grow_cleared (basic_block_info_for_fn (cfun),
266 n_basic_blocks_for_fn (cfun));
268 /* To speed up statement iterator walks, we first purge dead labels. */
269 cleanup_dead_labels ();
271 /* Group case nodes to reduce the number of edges.
272 We do this after cleaning up dead labels because otherwise we miss
273 a lot of obvious case merging opportunities. */
274 group_case_labels ();
276 /* Create the edges of the flowgraph. */
277 discriminator_per_locus = new hash_table<locus_discrim_hasher> (13);
279 assign_discriminators ();
280 cleanup_dead_labels ();
281 delete discriminator_per_locus;
282 discriminator_per_locus = NULL;
285 /* Look for ANNOTATE calls with loop annotation kind in BB; if found, remove
286 them and propagate the information to LOOP. We assume that the annotations
287 come immediately before the condition in BB, if any. */
290 replace_loop_annotate_in_block (basic_block bb, struct loop *loop)
292 gimple_stmt_iterator gsi = gsi_last_bb (bb);
293 gimple stmt = gsi_stmt (gsi);
295 if (!(stmt && gimple_code (stmt) == GIMPLE_COND))
298 for (gsi_prev_nondebug (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
300 stmt = gsi_stmt (gsi);
301 if (gimple_code (stmt) != GIMPLE_CALL)
303 if (!gimple_call_internal_p (stmt)
304 || gimple_call_internal_fn (stmt) != IFN_ANNOTATE)
307 switch ((annot_expr_kind) tree_to_shwi (gimple_call_arg (stmt, 1)))
309 case annot_expr_ivdep_kind:
310 loop->safelen = INT_MAX;
312 case annot_expr_no_vector_kind:
313 loop->dont_vectorize = true;
315 case annot_expr_vector_kind:
316 loop->force_vectorize = true;
317 cfun->has_force_vectorize_loops = true;
323 stmt = gimple_build_assign (gimple_call_lhs (stmt),
324 gimple_call_arg (stmt, 0));
325 gsi_replace (&gsi, stmt, true);
329 /* Look for ANNOTATE calls with loop annotation kind; if found, remove
330 them and propagate the information to the loop. We assume that the
331 annotations come immediately before the condition of the loop. */
334 replace_loop_annotate (void)
338 gimple_stmt_iterator gsi;
341 FOR_EACH_LOOP (loop, 0)
343 /* First look into the header. */
344 replace_loop_annotate_in_block (loop->header, loop);
346 /* Then look into the latch, if any. */
348 replace_loop_annotate_in_block (loop->latch, loop);
351 /* Remove IFN_ANNOTATE. Safeguard for the case loop->latch == NULL. */
352 FOR_EACH_BB_FN (bb, cfun)
354 for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
356 stmt = gsi_stmt (gsi);
357 if (gimple_code (stmt) != GIMPLE_CALL)
359 if (!gimple_call_internal_p (stmt)
360 || gimple_call_internal_fn (stmt) != IFN_ANNOTATE)
363 switch ((annot_expr_kind) tree_to_shwi (gimple_call_arg (stmt, 1)))
365 case annot_expr_ivdep_kind:
366 case annot_expr_no_vector_kind:
367 case annot_expr_vector_kind:
373 warning_at (gimple_location (stmt), 0, "ignoring loop annotation");
374 stmt = gimple_build_assign (gimple_call_lhs (stmt),
375 gimple_call_arg (stmt, 0));
376 gsi_replace (&gsi, stmt, true);
383 execute_build_cfg (void)
385 gimple_seq body = gimple_body (current_function_decl);
387 build_gimple_cfg (body);
388 gimple_set_body (current_function_decl, NULL);
389 if (dump_file && (dump_flags & TDF_DETAILS))
391 fprintf (dump_file, "Scope blocks:\n");
392 dump_scope_blocks (dump_file, dump_flags);
395 loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
396 replace_loop_annotate ();
402 const pass_data pass_data_build_cfg =
404 GIMPLE_PASS, /* type */
406 OPTGROUP_NONE, /* optinfo_flags */
407 TV_TREE_CFG, /* tv_id */
408 PROP_gimple_leh, /* properties_required */
409 ( PROP_cfg | PROP_loops ), /* properties_provided */
410 0, /* properties_destroyed */
411 0, /* todo_flags_start */
412 0, /* todo_flags_finish */
415 class pass_build_cfg : public gimple_opt_pass
418 pass_build_cfg (gcc::context *ctxt)
419 : gimple_opt_pass (pass_data_build_cfg, ctxt)
422 /* opt_pass methods: */
423 virtual unsigned int execute (function *) { return execute_build_cfg (); }
425 }; // class pass_build_cfg
430 make_pass_build_cfg (gcc::context *ctxt)
432 return new pass_build_cfg (ctxt);
436 /* Return true if T is a computed goto. */
439 computed_goto_p (gimple t)
441 return (gimple_code (t) == GIMPLE_GOTO
442 && TREE_CODE (gimple_goto_dest (t)) != LABEL_DECL);
445 /* Returns true for edge E where e->src ends with a GIMPLE_COND and
446 the other edge points to a bb with just __builtin_unreachable ().
447 I.e. return true for C->M edge in:
455 __builtin_unreachable ();
459 assert_unreachable_fallthru_edge_p (edge e)
461 basic_block pred_bb = e->src;
462 gimple last = last_stmt (pred_bb);
463 if (last && gimple_code (last) == GIMPLE_COND)
465 basic_block other_bb = EDGE_SUCC (pred_bb, 0)->dest;
466 if (other_bb == e->dest)
467 other_bb = EDGE_SUCC (pred_bb, 1)->dest;
468 if (EDGE_COUNT (other_bb->succs) == 0)
470 gimple_stmt_iterator gsi = gsi_after_labels (other_bb);
475 stmt = gsi_stmt (gsi);
476 while (is_gimple_debug (stmt) || gimple_clobber_p (stmt))
481 stmt = gsi_stmt (gsi);
483 return gimple_call_builtin_p (stmt, BUILT_IN_UNREACHABLE);
490 /* Initialize GF_CALL_CTRL_ALTERING flag, which indicates the call
491 could alter control flow except via eh. We initialize the flag at
492 CFG build time and only ever clear it later. */
495 gimple_call_initialize_ctrl_altering (gimple stmt)
497 int flags = gimple_call_flags (stmt);
499 /* A call alters control flow if it can make an abnormal goto. */
500 if (call_can_make_abnormal_goto (stmt)
501 /* A call also alters control flow if it does not return. */
502 || flags & ECF_NORETURN
503 /* TM ending statements have backedges out of the transaction.
504 Return true so we split the basic block containing them.
505 Note that the TM_BUILTIN test is merely an optimization. */
506 || ((flags & ECF_TM_BUILTIN)
507 && is_tm_ending_fndecl (gimple_call_fndecl (stmt)))
508 /* BUILT_IN_RETURN call is same as return statement. */
509 || gimple_call_builtin_p (stmt, BUILT_IN_RETURN))
510 gimple_call_set_ctrl_altering (stmt, true);
512 gimple_call_set_ctrl_altering (stmt, false);
516 /* Build a flowgraph for the sequence of stmts SEQ. */
519 make_blocks (gimple_seq seq)
521 gimple_stmt_iterator i = gsi_start (seq);
523 bool start_new_block = true;
524 bool first_stmt_of_seq = true;
525 basic_block bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
527 while (!gsi_end_p (i))
534 if (stmt && is_gimple_call (stmt))
535 gimple_call_initialize_ctrl_altering (stmt);
537 /* If the statement starts a new basic block or if we have determined
538 in a previous pass that we need to create a new block for STMT, do
540 if (start_new_block || stmt_starts_bb_p (stmt, prev_stmt))
542 if (!first_stmt_of_seq)
543 gsi_split_seq_before (&i, &seq);
544 bb = create_basic_block (seq, NULL, bb);
545 start_new_block = false;
548 /* Now add STMT to BB and create the subgraphs for special statement
550 gimple_set_bb (stmt, bb);
552 /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
554 if (stmt_ends_bb_p (stmt))
556 /* If the stmt can make abnormal goto use a new temporary
557 for the assignment to the LHS. This makes sure the old value
558 of the LHS is available on the abnormal edge. Otherwise
559 we will end up with overlapping life-ranges for abnormal
561 if (gimple_has_lhs (stmt)
562 && stmt_can_make_abnormal_goto (stmt)
563 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt))))
565 tree lhs = gimple_get_lhs (stmt);
566 tree tmp = create_tmp_var (TREE_TYPE (lhs));
567 gimple s = gimple_build_assign (lhs, tmp);
568 gimple_set_location (s, gimple_location (stmt));
569 gimple_set_block (s, gimple_block (stmt));
570 gimple_set_lhs (stmt, tmp);
571 if (TREE_CODE (TREE_TYPE (tmp)) == COMPLEX_TYPE
572 || TREE_CODE (TREE_TYPE (tmp)) == VECTOR_TYPE)
573 DECL_GIMPLE_REG_P (tmp) = 1;
574 gsi_insert_after (&i, s, GSI_SAME_STMT);
576 start_new_block = true;
580 first_stmt_of_seq = false;
585 /* Create and return a new empty basic block after bb AFTER. */
588 create_bb (void *h, void *e, basic_block after)
594 /* Create and initialize a new basic block. Since alloc_block uses
595 GC allocation that clears memory to allocate a basic block, we do
596 not have to clear the newly allocated basic block here. */
599 bb->index = last_basic_block_for_fn (cfun);
601 set_bb_seq (bb, h ? (gimple_seq) h : NULL);
603 /* Add the new block to the linked list of blocks. */
604 link_block (bb, after);
606 /* Grow the basic block array if needed. */
607 if ((size_t) last_basic_block_for_fn (cfun)
608 == basic_block_info_for_fn (cfun)->length ())
611 (last_basic_block_for_fn (cfun)
612 + (last_basic_block_for_fn (cfun) + 3) / 4);
613 vec_safe_grow_cleared (basic_block_info_for_fn (cfun), new_size);
616 /* Add the newly created block to the array. */
617 SET_BASIC_BLOCK_FOR_FN (cfun, last_basic_block_for_fn (cfun), bb);
619 n_basic_blocks_for_fn (cfun)++;
620 last_basic_block_for_fn (cfun)++;
626 /*---------------------------------------------------------------------------
628 ---------------------------------------------------------------------------*/
630 /* Fold COND_EXPR_COND of each COND_EXPR. */
633 fold_cond_expr_cond (void)
637 FOR_EACH_BB_FN (bb, cfun)
639 gimple stmt = last_stmt (bb);
641 if (stmt && gimple_code (stmt) == GIMPLE_COND)
643 gcond *cond_stmt = as_a <gcond *> (stmt);
644 location_t loc = gimple_location (stmt);
648 fold_defer_overflow_warnings ();
649 cond = fold_binary_loc (loc, gimple_cond_code (cond_stmt),
651 gimple_cond_lhs (cond_stmt),
652 gimple_cond_rhs (cond_stmt));
655 zerop = integer_zerop (cond);
656 onep = integer_onep (cond);
659 zerop = onep = false;
661 fold_undefer_overflow_warnings (zerop || onep,
663 WARN_STRICT_OVERFLOW_CONDITIONAL);
665 gimple_cond_make_false (cond_stmt);
667 gimple_cond_make_true (cond_stmt);
672 /* If basic block BB has an abnormal edge to a basic block
673 containing IFN_ABNORMAL_DISPATCHER internal call, return
674 that the dispatcher's basic block, otherwise return NULL. */
677 get_abnormal_succ_dispatcher (basic_block bb)
682 FOR_EACH_EDGE (e, ei, bb->succs)
683 if ((e->flags & (EDGE_ABNORMAL | EDGE_EH)) == EDGE_ABNORMAL)
685 gimple_stmt_iterator gsi
686 = gsi_start_nondebug_after_labels_bb (e->dest);
687 gimple g = gsi_stmt (gsi);
689 && is_gimple_call (g)
690 && gimple_call_internal_p (g)
691 && gimple_call_internal_fn (g) == IFN_ABNORMAL_DISPATCHER)
697 /* Helper function for make_edges. Create a basic block with
698 with ABNORMAL_DISPATCHER internal call in it if needed, and
699 create abnormal edges from BBS to it and from it to FOR_BB
700 if COMPUTED_GOTO is false, otherwise factor the computed gotos. */
703 handle_abnormal_edges (basic_block *dispatcher_bbs,
704 basic_block for_bb, int *bb_to_omp_idx,
705 auto_vec<basic_block> *bbs, bool computed_goto)
707 basic_block *dispatcher = dispatcher_bbs + (computed_goto ? 1 : 0);
708 unsigned int idx = 0;
714 dispatcher = dispatcher_bbs + 2 * bb_to_omp_idx[for_bb->index];
715 if (bb_to_omp_idx[for_bb->index] != 0)
719 /* If the dispatcher has been created already, then there are basic
720 blocks with abnormal edges to it, so just make a new edge to
722 if (*dispatcher == NULL)
724 /* Check if there are any basic blocks that need to have
725 abnormal edges to this dispatcher. If there are none, return
727 if (bb_to_omp_idx == NULL)
729 if (bbs->is_empty ())
734 FOR_EACH_VEC_ELT (*bbs, idx, bb)
735 if (bb_to_omp_idx[bb->index] == bb_to_omp_idx[for_bb->index])
741 /* Create the dispatcher bb. */
742 *dispatcher = create_basic_block (NULL, NULL, for_bb);
745 /* Factor computed gotos into a common computed goto site. Also
746 record the location of that site so that we can un-factor the
747 gotos after we have converted back to normal form. */
748 gimple_stmt_iterator gsi = gsi_start_bb (*dispatcher);
750 /* Create the destination of the factored goto. Each original
751 computed goto will put its desired destination into this
752 variable and jump to the label we create immediately below. */
753 tree var = create_tmp_var (ptr_type_node, "gotovar");
755 /* Build a label for the new block which will contain the
756 factored computed goto. */
757 tree factored_label_decl
758 = create_artificial_label (UNKNOWN_LOCATION);
759 gimple factored_computed_goto_label
760 = gimple_build_label (factored_label_decl);
761 gsi_insert_after (&gsi, factored_computed_goto_label, GSI_NEW_STMT);
763 /* Build our new computed goto. */
764 gimple factored_computed_goto = gimple_build_goto (var);
765 gsi_insert_after (&gsi, factored_computed_goto, GSI_NEW_STMT);
767 FOR_EACH_VEC_ELT (*bbs, idx, bb)
770 && bb_to_omp_idx[bb->index] != bb_to_omp_idx[for_bb->index])
773 gsi = gsi_last_bb (bb);
774 gimple last = gsi_stmt (gsi);
776 gcc_assert (computed_goto_p (last));
778 /* Copy the original computed goto's destination into VAR. */
780 = gimple_build_assign (var, gimple_goto_dest (last));
781 gsi_insert_before (&gsi, assignment, GSI_SAME_STMT);
783 edge e = make_edge (bb, *dispatcher, EDGE_FALLTHRU);
784 e->goto_locus = gimple_location (last);
785 gsi_remove (&gsi, true);
790 tree arg = inner ? boolean_true_node : boolean_false_node;
791 gimple g = gimple_build_call_internal (IFN_ABNORMAL_DISPATCHER,
793 gimple_stmt_iterator gsi = gsi_after_labels (*dispatcher);
794 gsi_insert_after (&gsi, g, GSI_NEW_STMT);
796 /* Create predecessor edges of the dispatcher. */
797 FOR_EACH_VEC_ELT (*bbs, idx, bb)
800 && bb_to_omp_idx[bb->index] != bb_to_omp_idx[for_bb->index])
802 make_edge (bb, *dispatcher, EDGE_ABNORMAL);
807 make_edge (*dispatcher, for_bb, EDGE_ABNORMAL);
810 /* Join all the blocks in the flowgraph. */
816 struct omp_region *cur_region = NULL;
817 auto_vec<basic_block> ab_edge_goto;
818 auto_vec<basic_block> ab_edge_call;
819 int *bb_to_omp_idx = NULL;
820 int cur_omp_region_idx = 0;
822 /* Create an edge from entry to the first block with executable
824 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun),
825 BASIC_BLOCK_FOR_FN (cfun, NUM_FIXED_BLOCKS),
828 /* Traverse the basic block array placing edges. */
829 FOR_EACH_BB_FN (bb, cfun)
831 gimple last = last_stmt (bb);
835 bb_to_omp_idx[bb->index] = cur_omp_region_idx;
839 enum gimple_code code = gimple_code (last);
843 if (make_goto_expr_edges (bb))
844 ab_edge_goto.safe_push (bb);
849 edge e = make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
850 e->goto_locus = gimple_location (last);
855 make_cond_expr_edges (bb);
859 make_gimple_switch_edges (as_a <gswitch *> (last), bb);
863 make_eh_edges (last);
866 case GIMPLE_EH_DISPATCH:
867 fallthru = make_eh_dispatch_edges (as_a <geh_dispatch *> (last));
871 /* If this function receives a nonlocal goto, then we need to
872 make edges from this call site to all the nonlocal goto
874 if (stmt_can_make_abnormal_goto (last))
875 ab_edge_call.safe_push (bb);
877 /* If this statement has reachable exception handlers, then
878 create abnormal edges to them. */
879 make_eh_edges (last);
881 /* BUILTIN_RETURN is really a return statement. */
882 if (gimple_call_builtin_p (last, BUILT_IN_RETURN))
884 make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
887 /* Some calls are known not to return. */
889 fallthru = !(gimple_call_flags (last) & ECF_NORETURN);
893 /* A GIMPLE_ASSIGN may throw internally and thus be considered
895 if (is_ctrl_altering_stmt (last))
896 make_eh_edges (last);
901 make_gimple_asm_edges (bb);
906 fallthru = make_gimple_omp_edges (bb, &cur_region,
907 &cur_omp_region_idx);
908 if (cur_region && bb_to_omp_idx == NULL)
909 bb_to_omp_idx = XCNEWVEC (int, n_basic_blocks_for_fn (cfun));
912 case GIMPLE_TRANSACTION:
915 = gimple_transaction_label (as_a <gtransaction *> (last));
917 make_edge (bb, label_to_block (abort_label), EDGE_TM_ABORT);
923 gcc_assert (!stmt_ends_bb_p (last));
931 make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
934 /* Computed gotos are hell to deal with, especially if there are
935 lots of them with a large number of destinations. So we factor
936 them to a common computed goto location before we build the
937 edge list. After we convert back to normal form, we will un-factor
938 the computed gotos since factoring introduces an unwanted jump.
939 For non-local gotos and abnormal edges from calls to calls that return
940 twice or forced labels, factor the abnormal edges too, by having all
941 abnormal edges from the calls go to a common artificial basic block
942 with ABNORMAL_DISPATCHER internal call and abnormal edges from that
943 basic block to all forced labels and calls returning twice.
944 We do this per-OpenMP structured block, because those regions
945 are guaranteed to be single entry single exit by the standard,
946 so it is not allowed to enter or exit such regions abnormally this way,
947 thus all computed gotos, non-local gotos and setjmp/longjmp calls
948 must not transfer control across SESE region boundaries. */
949 if (!ab_edge_goto.is_empty () || !ab_edge_call.is_empty ())
951 gimple_stmt_iterator gsi;
952 basic_block dispatcher_bb_array[2] = { NULL, NULL };
953 basic_block *dispatcher_bbs = dispatcher_bb_array;
954 int count = n_basic_blocks_for_fn (cfun);
957 dispatcher_bbs = XCNEWVEC (basic_block, 2 * count);
959 FOR_EACH_BB_FN (bb, cfun)
961 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
963 glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
969 target = gimple_label_label (label_stmt);
971 /* Make an edge to every label block that has been marked as a
972 potential target for a computed goto or a non-local goto. */
973 if (FORCED_LABEL (target))
974 handle_abnormal_edges (dispatcher_bbs, bb, bb_to_omp_idx,
975 &ab_edge_goto, true);
976 if (DECL_NONLOCAL (target))
978 handle_abnormal_edges (dispatcher_bbs, bb, bb_to_omp_idx,
979 &ab_edge_call, false);
984 if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
985 gsi_next_nondebug (&gsi);
986 if (!gsi_end_p (gsi))
988 /* Make an edge to every setjmp-like call. */
989 gimple call_stmt = gsi_stmt (gsi);
990 if (is_gimple_call (call_stmt)
991 && ((gimple_call_flags (call_stmt) & ECF_RETURNS_TWICE)
992 || gimple_call_builtin_p (call_stmt,
993 BUILT_IN_SETJMP_RECEIVER)))
994 handle_abnormal_edges (dispatcher_bbs, bb, bb_to_omp_idx,
995 &ab_edge_call, false);
1000 XDELETE (dispatcher_bbs);
1003 XDELETE (bb_to_omp_idx);
1005 free_omp_regions ();
1007 /* Fold COND_EXPR_COND of each COND_EXPR. */
1008 fold_cond_expr_cond ();
1011 /* Find the next available discriminator value for LOCUS. The
1012 discriminator distinguishes among several basic blocks that
1013 share a common locus, allowing for more accurate sample-based
1017 next_discriminator_for_locus (location_t locus)
1019 struct locus_discrim_map item;
1020 struct locus_discrim_map **slot;
1023 item.discriminator = 0;
1024 slot = discriminator_per_locus->find_slot_with_hash (
1025 &item, LOCATION_LINE (locus), INSERT);
1027 if (*slot == HTAB_EMPTY_ENTRY)
1029 *slot = XNEW (struct locus_discrim_map);
1031 (*slot)->locus = locus;
1032 (*slot)->discriminator = 0;
1034 (*slot)->discriminator++;
1035 return (*slot)->discriminator;
1038 /* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line. */
1041 same_line_p (location_t locus1, location_t locus2)
1043 expanded_location from, to;
1045 if (locus1 == locus2)
1048 from = expand_location (locus1);
1049 to = expand_location (locus2);
1051 if (from.line != to.line)
1053 if (from.file == to.file)
1055 return (from.file != NULL
1057 && filename_cmp (from.file, to.file) == 0);
1060 /* Assign discriminators to each basic block. */
1063 assign_discriminators (void)
1067 FOR_EACH_BB_FN (bb, cfun)
1071 gimple last = last_stmt (bb);
1072 location_t locus = last ? gimple_location (last) : UNKNOWN_LOCATION;
1074 if (locus == UNKNOWN_LOCATION)
1077 FOR_EACH_EDGE (e, ei, bb->succs)
1079 gimple first = first_non_label_stmt (e->dest);
1080 gimple last = last_stmt (e->dest);
1081 if ((first && same_line_p (locus, gimple_location (first)))
1082 || (last && same_line_p (locus, gimple_location (last))))
1084 if (e->dest->discriminator != 0 && bb->discriminator == 0)
1085 bb->discriminator = next_discriminator_for_locus (locus);
1087 e->dest->discriminator = next_discriminator_for_locus (locus);
1093 /* Create the edges for a GIMPLE_COND starting at block BB. */
1096 make_cond_expr_edges (basic_block bb)
1098 gcond *entry = as_a <gcond *> (last_stmt (bb));
1099 gimple then_stmt, else_stmt;
1100 basic_block then_bb, else_bb;
1101 tree then_label, else_label;
1105 gcc_assert (gimple_code (entry) == GIMPLE_COND);
1107 /* Entry basic blocks for each component. */
1108 then_label = gimple_cond_true_label (entry);
1109 else_label = gimple_cond_false_label (entry);
1110 then_bb = label_to_block (then_label);
1111 else_bb = label_to_block (else_label);
1112 then_stmt = first_stmt (then_bb);
1113 else_stmt = first_stmt (else_bb);
1115 e = make_edge (bb, then_bb, EDGE_TRUE_VALUE);
1116 e->goto_locus = gimple_location (then_stmt);
1117 e = make_edge (bb, else_bb, EDGE_FALSE_VALUE);
1119 e->goto_locus = gimple_location (else_stmt);
1121 /* We do not need the labels anymore. */
1122 gimple_cond_set_true_label (entry, NULL_TREE);
1123 gimple_cond_set_false_label (entry, NULL_TREE);
1127 /* Called for each element in the hash table (P) as we delete the
1128 edge to cases hash table.
1130 Clear all the TREE_CHAINs to prevent problems with copying of
1131 SWITCH_EXPRs and structure sharing rules, then free the hash table
1135 edge_to_cases_cleanup (edge const &, tree const &value, void *)
1139 for (t = value; t; t = next)
1141 next = CASE_CHAIN (t);
1142 CASE_CHAIN (t) = NULL;
1148 /* Start recording information mapping edges to case labels. */
1151 start_recording_case_labels (void)
1153 gcc_assert (edge_to_cases == NULL);
1154 edge_to_cases = new hash_map<edge, tree>;
1155 touched_switch_bbs = BITMAP_ALLOC (NULL);
1158 /* Return nonzero if we are recording information for case labels. */
1161 recording_case_labels_p (void)
1163 return (edge_to_cases != NULL);
1166 /* Stop recording information mapping edges to case labels and
1167 remove any information we have recorded. */
1169 end_recording_case_labels (void)
1173 edge_to_cases->traverse<void *, edge_to_cases_cleanup> (NULL);
1174 delete edge_to_cases;
1175 edge_to_cases = NULL;
1176 EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs, 0, i, bi)
1178 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
1181 gimple stmt = last_stmt (bb);
1182 if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
1183 group_case_labels_stmt (as_a <gswitch *> (stmt));
1186 BITMAP_FREE (touched_switch_bbs);
1189 /* If we are inside a {start,end}_recording_cases block, then return
1190 a chain of CASE_LABEL_EXPRs from T which reference E.
1192 Otherwise return NULL. */
1195 get_cases_for_edge (edge e, gswitch *t)
1200 /* If we are not recording cases, then we do not have CASE_LABEL_EXPR
1201 chains available. Return NULL so the caller can detect this case. */
1202 if (!recording_case_labels_p ())
1205 slot = edge_to_cases->get (e);
1209 /* If we did not find E in the hash table, then this must be the first
1210 time we have been queried for information about E & T. Add all the
1211 elements from T to the hash table then perform the query again. */
1213 n = gimple_switch_num_labels (t);
1214 for (i = 0; i < n; i++)
1216 tree elt = gimple_switch_label (t, i);
1217 tree lab = CASE_LABEL (elt);
1218 basic_block label_bb = label_to_block (lab);
1219 edge this_edge = find_edge (e->src, label_bb);
1221 /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
1223 tree &s = edge_to_cases->get_or_insert (this_edge);
1224 CASE_CHAIN (elt) = s;
1228 return *edge_to_cases->get (e);
1231 /* Create the edges for a GIMPLE_SWITCH starting at block BB. */
1234 make_gimple_switch_edges (gswitch *entry, basic_block bb)
1238 n = gimple_switch_num_labels (entry);
1240 for (i = 0; i < n; ++i)
1242 tree lab = CASE_LABEL (gimple_switch_label (entry, i));
1243 basic_block label_bb = label_to_block (lab);
1244 make_edge (bb, label_bb, 0);
1249 /* Return the basic block holding label DEST. */
1252 label_to_block_fn (struct function *ifun, tree dest)
1254 int uid = LABEL_DECL_UID (dest);
1256 /* We would die hard when faced by an undefined label. Emit a label to
1257 the very first basic block. This will hopefully make even the dataflow
1258 and undefined variable warnings quite right. */
1259 if (seen_error () && uid < 0)
1261 gimple_stmt_iterator gsi =
1262 gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun, NUM_FIXED_BLOCKS));
1265 stmt = gimple_build_label (dest);
1266 gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
1267 uid = LABEL_DECL_UID (dest);
1269 if (vec_safe_length (ifun->cfg->x_label_to_block_map) <= (unsigned int) uid)
1271 return (*ifun->cfg->x_label_to_block_map)[uid];
1274 /* Create edges for a goto statement at block BB. Returns true
1275 if abnormal edges should be created. */
1278 make_goto_expr_edges (basic_block bb)
1280 gimple_stmt_iterator last = gsi_last_bb (bb);
1281 gimple goto_t = gsi_stmt (last);
1283 /* A simple GOTO creates normal edges. */
1284 if (simple_goto_p (goto_t))
1286 tree dest = gimple_goto_dest (goto_t);
1287 basic_block label_bb = label_to_block (dest);
1288 edge e = make_edge (bb, label_bb, EDGE_FALLTHRU);
1289 e->goto_locus = gimple_location (goto_t);
1290 gsi_remove (&last, true);
1294 /* A computed GOTO creates abnormal edges. */
1298 /* Create edges for an asm statement with labels at block BB. */
1301 make_gimple_asm_edges (basic_block bb)
1303 gasm *stmt = as_a <gasm *> (last_stmt (bb));
1304 int i, n = gimple_asm_nlabels (stmt);
1306 for (i = 0; i < n; ++i)
1308 tree label = TREE_VALUE (gimple_asm_label_op (stmt, i));
1309 basic_block label_bb = label_to_block (label);
1310 make_edge (bb, label_bb, 0);
1314 /*---------------------------------------------------------------------------
1316 ---------------------------------------------------------------------------*/
1318 /* Cleanup useless labels in basic blocks. This is something we wish
1319 to do early because it allows us to group case labels before creating
1320 the edges for the CFG, and it speeds up block statement iterators in
1321 all passes later on.
1322 We rerun this pass after CFG is created, to get rid of the labels that
1323 are no longer referenced. After then we do not run it any more, since
1324 (almost) no new labels should be created. */
1326 /* A map from basic block index to the leading label of that block. */
1327 static struct label_record
1332 /* True if the label is referenced from somewhere. */
1336 /* Given LABEL return the first label in the same basic block. */
1339 main_block_label (tree label)
1341 basic_block bb = label_to_block (label);
1342 tree main_label = label_for_bb[bb->index].label;
1344 /* label_to_block possibly inserted undefined label into the chain. */
1347 label_for_bb[bb->index].label = label;
1351 label_for_bb[bb->index].used = true;
1355 /* Clean up redundant labels within the exception tree. */
1358 cleanup_dead_labels_eh (void)
1365 if (cfun->eh == NULL)
1368 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
1369 if (lp && lp->post_landing_pad)
1371 lab = main_block_label (lp->post_landing_pad);
1372 if (lab != lp->post_landing_pad)
1374 EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
1375 EH_LANDING_PAD_NR (lab) = lp->index;
1379 FOR_ALL_EH_REGION (r)
1383 case ERT_MUST_NOT_THROW:
1389 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
1393 c->label = main_block_label (lab);
1398 case ERT_ALLOWED_EXCEPTIONS:
1399 lab = r->u.allowed.label;
1401 r->u.allowed.label = main_block_label (lab);
1407 /* Cleanup redundant labels. This is a three-step process:
1408 1) Find the leading label for each block.
1409 2) Redirect all references to labels to the leading labels.
1410 3) Cleanup all useless labels. */
1413 cleanup_dead_labels (void)
1416 label_for_bb = XCNEWVEC (struct label_record, last_basic_block_for_fn (cfun));
1418 /* Find a suitable label for each block. We use the first user-defined
1419 label if there is one, or otherwise just the first label we see. */
1420 FOR_EACH_BB_FN (bb, cfun)
1422 gimple_stmt_iterator i;
1424 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
1427 glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (i));
1432 label = gimple_label_label (label_stmt);
1434 /* If we have not yet seen a label for the current block,
1435 remember this one and see if there are more labels. */
1436 if (!label_for_bb[bb->index].label)
1438 label_for_bb[bb->index].label = label;
1442 /* If we did see a label for the current block already, but it
1443 is an artificially created label, replace it if the current
1444 label is a user defined label. */
1445 if (!DECL_ARTIFICIAL (label)
1446 && DECL_ARTIFICIAL (label_for_bb[bb->index].label))
1448 label_for_bb[bb->index].label = label;
1454 /* Now redirect all jumps/branches to the selected label.
1455 First do so for each block ending in a control statement. */
1456 FOR_EACH_BB_FN (bb, cfun)
1458 gimple stmt = last_stmt (bb);
1459 tree label, new_label;
1464 switch (gimple_code (stmt))
1468 gcond *cond_stmt = as_a <gcond *> (stmt);
1469 label = gimple_cond_true_label (cond_stmt);
1472 new_label = main_block_label (label);
1473 if (new_label != label)
1474 gimple_cond_set_true_label (cond_stmt, new_label);
1477 label = gimple_cond_false_label (cond_stmt);
1480 new_label = main_block_label (label);
1481 if (new_label != label)
1482 gimple_cond_set_false_label (cond_stmt, new_label);
1489 gswitch *switch_stmt = as_a <gswitch *> (stmt);
1490 size_t i, n = gimple_switch_num_labels (switch_stmt);
1492 /* Replace all destination labels. */
1493 for (i = 0; i < n; ++i)
1495 tree case_label = gimple_switch_label (switch_stmt, i);
1496 label = CASE_LABEL (case_label);
1497 new_label = main_block_label (label);
1498 if (new_label != label)
1499 CASE_LABEL (case_label) = new_label;
1506 gasm *asm_stmt = as_a <gasm *> (stmt);
1507 int i, n = gimple_asm_nlabels (asm_stmt);
1509 for (i = 0; i < n; ++i)
1511 tree cons = gimple_asm_label_op (asm_stmt, i);
1512 tree label = main_block_label (TREE_VALUE (cons));
1513 TREE_VALUE (cons) = label;
1518 /* We have to handle gotos until they're removed, and we don't
1519 remove them until after we've created the CFG edges. */
1521 if (!computed_goto_p (stmt))
1523 ggoto *goto_stmt = as_a <ggoto *> (stmt);
1524 label = gimple_goto_dest (goto_stmt);
1525 new_label = main_block_label (label);
1526 if (new_label != label)
1527 gimple_goto_set_dest (goto_stmt, new_label);
1531 case GIMPLE_TRANSACTION:
1533 gtransaction *trans_stmt = as_a <gtransaction *> (stmt);
1534 tree label = gimple_transaction_label (trans_stmt);
1537 tree new_label = main_block_label (label);
1538 if (new_label != label)
1539 gimple_transaction_set_label (trans_stmt, new_label);
1549 /* Do the same for the exception region tree labels. */
1550 cleanup_dead_labels_eh ();
1552 /* Finally, purge dead labels. All user-defined labels and labels that
1553 can be the target of non-local gotos and labels which have their
1554 address taken are preserved. */
1555 FOR_EACH_BB_FN (bb, cfun)
1557 gimple_stmt_iterator i;
1558 tree label_for_this_bb = label_for_bb[bb->index].label;
1560 if (!label_for_this_bb)
1563 /* If the main label of the block is unused, we may still remove it. */
1564 if (!label_for_bb[bb->index].used)
1565 label_for_this_bb = NULL;
1567 for (i = gsi_start_bb (bb); !gsi_end_p (i); )
1570 glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (i));
1575 label = gimple_label_label (label_stmt);
1577 if (label == label_for_this_bb
1578 || !DECL_ARTIFICIAL (label)
1579 || DECL_NONLOCAL (label)
1580 || FORCED_LABEL (label))
1583 gsi_remove (&i, true);
1587 free (label_for_bb);
1590 /* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
1591 the ones jumping to the same label.
1592 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
1595 group_case_labels_stmt (gswitch *stmt)
1597 int old_size = gimple_switch_num_labels (stmt);
1598 int i, j, new_size = old_size;
1599 basic_block default_bb = NULL;
1601 default_bb = label_to_block (CASE_LABEL (gimple_switch_default_label (stmt)));
1603 /* Look for possible opportunities to merge cases. */
1605 while (i < old_size)
1607 tree base_case, base_high;
1608 basic_block base_bb;
1610 base_case = gimple_switch_label (stmt, i);
1612 gcc_assert (base_case);
1613 base_bb = label_to_block (CASE_LABEL (base_case));
1615 /* Discard cases that have the same destination as the
1617 if (base_bb == default_bb)
1619 gimple_switch_set_label (stmt, i, NULL_TREE);
1625 base_high = CASE_HIGH (base_case)
1626 ? CASE_HIGH (base_case)
1627 : CASE_LOW (base_case);
1630 /* Try to merge case labels. Break out when we reach the end
1631 of the label vector or when we cannot merge the next case
1632 label with the current one. */
1633 while (i < old_size)
1635 tree merge_case = gimple_switch_label (stmt, i);
1636 basic_block merge_bb = label_to_block (CASE_LABEL (merge_case));
1637 wide_int bhp1 = wi::add (base_high, 1);
1639 /* Merge the cases if they jump to the same place,
1640 and their ranges are consecutive. */
1641 if (merge_bb == base_bb
1642 && wi::eq_p (CASE_LOW (merge_case), bhp1))
1644 base_high = CASE_HIGH (merge_case) ?
1645 CASE_HIGH (merge_case) : CASE_LOW (merge_case);
1646 CASE_HIGH (base_case) = base_high;
1647 gimple_switch_set_label (stmt, i, NULL_TREE);
1656 /* Compress the case labels in the label vector, and adjust the
1657 length of the vector. */
1658 for (i = 0, j = 0; i < new_size; i++)
1660 while (! gimple_switch_label (stmt, j))
1662 gimple_switch_set_label (stmt, i,
1663 gimple_switch_label (stmt, j++));
1666 gcc_assert (new_size <= old_size);
1667 gimple_switch_set_num_labels (stmt, new_size);
1670 /* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
1671 and scan the sorted vector of cases. Combine the ones jumping to the
1675 group_case_labels (void)
1679 FOR_EACH_BB_FN (bb, cfun)
1681 gimple stmt = last_stmt (bb);
1682 if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
1683 group_case_labels_stmt (as_a <gswitch *> (stmt));
1687 /* Checks whether we can merge block B into block A. */
1690 gimple_can_merge_blocks_p (basic_block a, basic_block b)
1694 if (!single_succ_p (a))
1697 if (single_succ_edge (a)->flags & EDGE_COMPLEX)
1700 if (single_succ (a) != b)
1703 if (!single_pred_p (b))
1706 if (b == EXIT_BLOCK_PTR_FOR_FN (cfun))
1709 /* If A ends by a statement causing exceptions or something similar, we
1710 cannot merge the blocks. */
1711 stmt = last_stmt (a);
1712 if (stmt && stmt_ends_bb_p (stmt))
1715 /* Do not allow a block with only a non-local label to be merged. */
1717 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
1718 if (DECL_NONLOCAL (gimple_label_label (label_stmt)))
1721 /* Examine the labels at the beginning of B. */
1722 for (gimple_stmt_iterator gsi = gsi_start_bb (b); !gsi_end_p (gsi);
1726 glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
1729 lab = gimple_label_label (label_stmt);
1731 /* Do not remove user forced labels or for -O0 any user labels. */
1732 if (!DECL_ARTIFICIAL (lab) && (!optimize || FORCED_LABEL (lab)))
1736 /* Protect simple loop latches. We only want to avoid merging
1737 the latch with the loop header or with a block in another
1738 loop in this case. */
1740 && b->loop_father->latch == b
1741 && loops_state_satisfies_p (LOOPS_HAVE_SIMPLE_LATCHES)
1742 && (b->loop_father->header == a
1743 || b->loop_father != a->loop_father))
1746 /* It must be possible to eliminate all phi nodes in B. If ssa form
1747 is not up-to-date and a name-mapping is registered, we cannot eliminate
1748 any phis. Symbols marked for renaming are never a problem though. */
1749 for (gphi_iterator gsi = gsi_start_phis (b); !gsi_end_p (gsi);
1752 gphi *phi = gsi.phi ();
1753 /* Technically only new names matter. */
1754 if (name_registered_for_update_p (PHI_RESULT (phi)))
1758 /* When not optimizing, don't merge if we'd lose goto_locus. */
1760 && single_succ_edge (a)->goto_locus != UNKNOWN_LOCATION)
1762 location_t goto_locus = single_succ_edge (a)->goto_locus;
1763 gimple_stmt_iterator prev, next;
1764 prev = gsi_last_nondebug_bb (a);
1765 next = gsi_after_labels (b);
1766 if (!gsi_end_p (next) && is_gimple_debug (gsi_stmt (next)))
1767 gsi_next_nondebug (&next);
1768 if ((gsi_end_p (prev)
1769 || gimple_location (gsi_stmt (prev)) != goto_locus)
1770 && (gsi_end_p (next)
1771 || gimple_location (gsi_stmt (next)) != goto_locus))
1778 /* Replaces all uses of NAME by VAL. */
1781 replace_uses_by (tree name, tree val)
1783 imm_use_iterator imm_iter;
1788 FOR_EACH_IMM_USE_STMT (stmt, imm_iter, name)
1790 /* Mark the block if we change the last stmt in it. */
1791 if (cfgcleanup_altered_bbs
1792 && stmt_ends_bb_p (stmt))
1793 bitmap_set_bit (cfgcleanup_altered_bbs, gimple_bb (stmt)->index);
1795 FOR_EACH_IMM_USE_ON_STMT (use, imm_iter)
1797 replace_exp (use, val);
1799 if (gimple_code (stmt) == GIMPLE_PHI)
1801 e = gimple_phi_arg_edge (as_a <gphi *> (stmt),
1802 PHI_ARG_INDEX_FROM_USE (use));
1803 if (e->flags & EDGE_ABNORMAL
1804 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val))
1806 /* This can only occur for virtual operands, since
1807 for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
1808 would prevent replacement. */
1809 gcc_checking_assert (virtual_operand_p (name));
1810 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val) = 1;
1815 if (gimple_code (stmt) != GIMPLE_PHI)
1817 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
1818 gimple orig_stmt = stmt;
1821 /* FIXME. It shouldn't be required to keep TREE_CONSTANT
1822 on ADDR_EXPRs up-to-date on GIMPLE. Propagation will
1823 only change sth from non-invariant to invariant, and only
1824 when propagating constants. */
1825 if (is_gimple_min_invariant (val))
1826 for (i = 0; i < gimple_num_ops (stmt); i++)
1828 tree op = gimple_op (stmt, i);
1829 /* Operands may be empty here. For example, the labels
1830 of a GIMPLE_COND are nulled out following the creation
1831 of the corresponding CFG edges. */
1832 if (op && TREE_CODE (op) == ADDR_EXPR)
1833 recompute_tree_invariant_for_addr_expr (op);
1836 if (fold_stmt (&gsi))
1837 stmt = gsi_stmt (gsi);
1839 if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt))
1840 gimple_purge_dead_eh_edges (gimple_bb (stmt));
1846 gcc_checking_assert (has_zero_uses (name));
1848 /* Also update the trees stored in loop structures. */
1853 FOR_EACH_LOOP (loop, 0)
1855 substitute_in_loop_info (loop, name, val);
1860 /* Merge block B into block A. */
1863 gimple_merge_blocks (basic_block a, basic_block b)
1865 gimple_stmt_iterator last, gsi;
1869 fprintf (dump_file, "Merging blocks %d and %d\n", a->index, b->index);
1871 /* Remove all single-valued PHI nodes from block B of the form
1872 V_i = PHI <V_j> by propagating V_j to all the uses of V_i. */
1873 gsi = gsi_last_bb (a);
1874 for (psi = gsi_start_phis (b); !gsi_end_p (psi); )
1876 gimple phi = gsi_stmt (psi);
1877 tree def = gimple_phi_result (phi), use = gimple_phi_arg_def (phi, 0);
1879 bool may_replace_uses = (virtual_operand_p (def)
1880 || may_propagate_copy (def, use));
1882 /* In case we maintain loop closed ssa form, do not propagate arguments
1883 of loop exit phi nodes. */
1885 && loops_state_satisfies_p (LOOP_CLOSED_SSA)
1886 && !virtual_operand_p (def)
1887 && TREE_CODE (use) == SSA_NAME
1888 && a->loop_father != b->loop_father)
1889 may_replace_uses = false;
1891 if (!may_replace_uses)
1893 gcc_assert (!virtual_operand_p (def));
1895 /* Note that just emitting the copies is fine -- there is no problem
1896 with ordering of phi nodes. This is because A is the single
1897 predecessor of B, therefore results of the phi nodes cannot
1898 appear as arguments of the phi nodes. */
1899 copy = gimple_build_assign (def, use);
1900 gsi_insert_after (&gsi, copy, GSI_NEW_STMT);
1901 remove_phi_node (&psi, false);
1905 /* If we deal with a PHI for virtual operands, we can simply
1906 propagate these without fussing with folding or updating
1908 if (virtual_operand_p (def))
1910 imm_use_iterator iter;
1911 use_operand_p use_p;
1914 FOR_EACH_IMM_USE_STMT (stmt, iter, def)
1915 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
1916 SET_USE (use_p, use);
1918 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
1919 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use) = 1;
1922 replace_uses_by (def, use);
1924 remove_phi_node (&psi, true);
1928 /* Ensure that B follows A. */
1929 move_block_after (b, a);
1931 gcc_assert (single_succ_edge (a)->flags & EDGE_FALLTHRU);
1932 gcc_assert (!last_stmt (a) || !stmt_ends_bb_p (last_stmt (a)));
1934 /* Remove labels from B and set gimple_bb to A for other statements. */
1935 for (gsi = gsi_start_bb (b); !gsi_end_p (gsi);)
1937 gimple stmt = gsi_stmt (gsi);
1938 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
1940 tree label = gimple_label_label (label_stmt);
1943 gsi_remove (&gsi, false);
1945 /* Now that we can thread computed gotos, we might have
1946 a situation where we have a forced label in block B
1947 However, the label at the start of block B might still be
1948 used in other ways (think about the runtime checking for
1949 Fortran assigned gotos). So we can not just delete the
1950 label. Instead we move the label to the start of block A. */
1951 if (FORCED_LABEL (label))
1953 gimple_stmt_iterator dest_gsi = gsi_start_bb (a);
1954 gsi_insert_before (&dest_gsi, stmt, GSI_NEW_STMT);
1956 /* Other user labels keep around in a form of a debug stmt. */
1957 else if (!DECL_ARTIFICIAL (label) && MAY_HAVE_DEBUG_STMTS)
1959 gimple dbg = gimple_build_debug_bind (label,
1962 gimple_debug_bind_reset_value (dbg);
1963 gsi_insert_before (&gsi, dbg, GSI_SAME_STMT);
1966 lp_nr = EH_LANDING_PAD_NR (label);
1969 eh_landing_pad lp = get_eh_landing_pad_from_number (lp_nr);
1970 lp->post_landing_pad = NULL;
1975 gimple_set_bb (stmt, a);
1980 /* When merging two BBs, if their counts are different, the larger count
1981 is selected as the new bb count. This is to handle inconsistent
1983 if (a->loop_father == b->loop_father)
1985 a->count = MAX (a->count, b->count);
1986 a->frequency = MAX (a->frequency, b->frequency);
1989 /* Merge the sequences. */
1990 last = gsi_last_bb (a);
1991 gsi_insert_seq_after (&last, bb_seq (b), GSI_NEW_STMT);
1992 set_bb_seq (b, NULL);
1994 if (cfgcleanup_altered_bbs)
1995 bitmap_set_bit (cfgcleanup_altered_bbs, a->index);
1999 /* Return the one of two successors of BB that is not reachable by a
2000 complex edge, if there is one. Else, return BB. We use
2001 this in optimizations that use post-dominators for their heuristics,
2002 to catch the cases in C++ where function calls are involved. */
2005 single_noncomplex_succ (basic_block bb)
2008 if (EDGE_COUNT (bb->succs) != 2)
2011 e0 = EDGE_SUCC (bb, 0);
2012 e1 = EDGE_SUCC (bb, 1);
2013 if (e0->flags & EDGE_COMPLEX)
2015 if (e1->flags & EDGE_COMPLEX)
2021 /* T is CALL_EXPR. Set current_function_calls_* flags. */
2024 notice_special_calls (gcall *call)
2026 int flags = gimple_call_flags (call);
2028 if (flags & ECF_MAY_BE_ALLOCA)
2029 cfun->calls_alloca = true;
2030 if (flags & ECF_RETURNS_TWICE)
2031 cfun->calls_setjmp = true;
2035 /* Clear flags set by notice_special_calls. Used by dead code removal
2036 to update the flags. */
2039 clear_special_calls (void)
2041 cfun->calls_alloca = false;
2042 cfun->calls_setjmp = false;
2045 /* Remove PHI nodes associated with basic block BB and all edges out of BB. */
2048 remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb)
2050 /* Since this block is no longer reachable, we can just delete all
2051 of its PHI nodes. */
2052 remove_phi_nodes (bb);
2054 /* Remove edges to BB's successors. */
2055 while (EDGE_COUNT (bb->succs) > 0)
2056 remove_edge (EDGE_SUCC (bb, 0));
2060 /* Remove statements of basic block BB. */
2063 remove_bb (basic_block bb)
2065 gimple_stmt_iterator i;
2069 fprintf (dump_file, "Removing basic block %d\n", bb->index);
2070 if (dump_flags & TDF_DETAILS)
2072 dump_bb (dump_file, bb, 0, TDF_BLOCKS);
2073 fprintf (dump_file, "\n");
2079 struct loop *loop = bb->loop_father;
2081 /* If a loop gets removed, clean up the information associated
2083 if (loop->latch == bb
2084 || loop->header == bb)
2085 free_numbers_of_iterations_estimates_loop (loop);
2088 /* Remove all the instructions in the block. */
2089 if (bb_seq (bb) != NULL)
2091 /* Walk backwards so as to get a chance to substitute all
2092 released DEFs into debug stmts. See
2093 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
2095 for (i = gsi_last_bb (bb); !gsi_end_p (i);)
2097 gimple stmt = gsi_stmt (i);
2098 glabel *label_stmt = dyn_cast <glabel *> (stmt);
2100 && (FORCED_LABEL (gimple_label_label (label_stmt))
2101 || DECL_NONLOCAL (gimple_label_label (label_stmt))))
2104 gimple_stmt_iterator new_gsi;
2106 /* A non-reachable non-local label may still be referenced.
2107 But it no longer needs to carry the extra semantics of
2109 if (DECL_NONLOCAL (gimple_label_label (label_stmt)))
2111 DECL_NONLOCAL (gimple_label_label (label_stmt)) = 0;
2112 FORCED_LABEL (gimple_label_label (label_stmt)) = 1;
2115 new_bb = bb->prev_bb;
2116 new_gsi = gsi_start_bb (new_bb);
2117 gsi_remove (&i, false);
2118 gsi_insert_before (&new_gsi, stmt, GSI_NEW_STMT);
2122 /* Release SSA definitions if we are in SSA. Note that we
2123 may be called when not in SSA. For example,
2124 final_cleanup calls this function via
2125 cleanup_tree_cfg. */
2126 if (gimple_in_ssa_p (cfun))
2127 release_defs (stmt);
2129 gsi_remove (&i, true);
2133 i = gsi_last_bb (bb);
2139 remove_phi_nodes_and_edges_for_unreachable_block (bb);
2140 bb->il.gimple.seq = NULL;
2141 bb->il.gimple.phi_nodes = NULL;
2145 /* Given a basic block BB ending with COND_EXPR or SWITCH_EXPR, and a
2146 predicate VAL, return the edge that will be taken out of the block.
2147 If VAL does not match a unique edge, NULL is returned. */
2150 find_taken_edge (basic_block bb, tree val)
2154 stmt = last_stmt (bb);
2157 gcc_assert (is_ctrl_stmt (stmt));
2162 if (!is_gimple_min_invariant (val))
2165 if (gimple_code (stmt) == GIMPLE_COND)
2166 return find_taken_edge_cond_expr (bb, val);
2168 if (gimple_code (stmt) == GIMPLE_SWITCH)
2169 return find_taken_edge_switch_expr (as_a <gswitch *> (stmt), bb, val);
2171 if (computed_goto_p (stmt))
2173 /* Only optimize if the argument is a label, if the argument is
2174 not a label then we can not construct a proper CFG.
2176 It may be the case that we only need to allow the LABEL_REF to
2177 appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
2178 appear inside a LABEL_EXPR just to be safe. */
2179 if ((TREE_CODE (val) == ADDR_EXPR || TREE_CODE (val) == LABEL_EXPR)
2180 && TREE_CODE (TREE_OPERAND (val, 0)) == LABEL_DECL)
2181 return find_taken_edge_computed_goto (bb, TREE_OPERAND (val, 0));
2188 /* Given a constant value VAL and the entry block BB to a GOTO_EXPR
2189 statement, determine which of the outgoing edges will be taken out of the
2190 block. Return NULL if either edge may be taken. */
2193 find_taken_edge_computed_goto (basic_block bb, tree val)
2198 dest = label_to_block (val);
2201 e = find_edge (bb, dest);
2202 gcc_assert (e != NULL);
2208 /* Given a constant value VAL and the entry block BB to a COND_EXPR
2209 statement, determine which of the two edges will be taken out of the
2210 block. Return NULL if either edge may be taken. */
2213 find_taken_edge_cond_expr (basic_block bb, tree val)
2215 edge true_edge, false_edge;
2217 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
2219 gcc_assert (TREE_CODE (val) == INTEGER_CST);
2220 return (integer_zerop (val) ? false_edge : true_edge);
2223 /* Given an INTEGER_CST VAL and the entry block BB to a SWITCH_EXPR
2224 statement, determine which edge will be taken out of the block. Return
2225 NULL if any edge may be taken. */
2228 find_taken_edge_switch_expr (gswitch *switch_stmt, basic_block bb,
2231 basic_block dest_bb;
2235 taken_case = find_case_label_for_value (switch_stmt, val);
2236 dest_bb = label_to_block (CASE_LABEL (taken_case));
2238 e = find_edge (bb, dest_bb);
2244 /* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
2245 We can make optimal use here of the fact that the case labels are
2246 sorted: We can do a binary search for a case matching VAL. */
2249 find_case_label_for_value (gswitch *switch_stmt, tree val)
2251 size_t low, high, n = gimple_switch_num_labels (switch_stmt);
2252 tree default_case = gimple_switch_default_label (switch_stmt);
2254 for (low = 0, high = n; high - low > 1; )
2256 size_t i = (high + low) / 2;
2257 tree t = gimple_switch_label (switch_stmt, i);
2260 /* Cache the result of comparing CASE_LOW and val. */
2261 cmp = tree_int_cst_compare (CASE_LOW (t), val);
2268 if (CASE_HIGH (t) == NULL)
2270 /* A singe-valued case label. */
2276 /* A case range. We can only handle integer ranges. */
2277 if (cmp <= 0 && tree_int_cst_compare (CASE_HIGH (t), val) >= 0)
2282 return default_case;
2286 /* Dump a basic block on stderr. */
2289 gimple_debug_bb (basic_block bb)
2291 dump_bb (stderr, bb, 0, TDF_VOPS|TDF_MEMSYMS|TDF_BLOCKS);
2295 /* Dump basic block with index N on stderr. */
2298 gimple_debug_bb_n (int n)
2300 gimple_debug_bb (BASIC_BLOCK_FOR_FN (cfun, n));
2301 return BASIC_BLOCK_FOR_FN (cfun, n);
2305 /* Dump the CFG on stderr.
2307 FLAGS are the same used by the tree dumping functions
2308 (see TDF_* in dumpfile.h). */
2311 gimple_debug_cfg (int flags)
2313 gimple_dump_cfg (stderr, flags);
2317 /* Dump the program showing basic block boundaries on the given FILE.
2319 FLAGS are the same used by the tree dumping functions (see TDF_* in
2323 gimple_dump_cfg (FILE *file, int flags)
2325 if (flags & TDF_DETAILS)
2327 dump_function_header (file, current_function_decl, flags);
2328 fprintf (file, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
2329 n_basic_blocks_for_fn (cfun), n_edges_for_fn (cfun),
2330 last_basic_block_for_fn (cfun));
2332 brief_dump_cfg (file, flags | TDF_COMMENT);
2333 fprintf (file, "\n");
2336 if (flags & TDF_STATS)
2337 dump_cfg_stats (file);
2339 dump_function_to_file (current_function_decl, file, flags | TDF_BLOCKS);
2343 /* Dump CFG statistics on FILE. */
2346 dump_cfg_stats (FILE *file)
2348 static long max_num_merged_labels = 0;
2349 unsigned long size, total = 0;
2352 const char * const fmt_str = "%-30s%-13s%12s\n";
2353 const char * const fmt_str_1 = "%-30s%13d%11lu%c\n";
2354 const char * const fmt_str_2 = "%-30s%13ld%11lu%c\n";
2355 const char * const fmt_str_3 = "%-43s%11lu%c\n";
2356 const char *funcname = current_function_name ();
2358 fprintf (file, "\nCFG Statistics for %s\n\n", funcname);
2360 fprintf (file, "---------------------------------------------------------\n");
2361 fprintf (file, fmt_str, "", " Number of ", "Memory");
2362 fprintf (file, fmt_str, "", " instances ", "used ");
2363 fprintf (file, "---------------------------------------------------------\n");
2365 size = n_basic_blocks_for_fn (cfun) * sizeof (struct basic_block_def);
2367 fprintf (file, fmt_str_1, "Basic blocks", n_basic_blocks_for_fn (cfun),
2368 SCALE (size), LABEL (size));
2371 FOR_EACH_BB_FN (bb, cfun)
2372 num_edges += EDGE_COUNT (bb->succs);
2373 size = num_edges * sizeof (struct edge_def);
2375 fprintf (file, fmt_str_2, "Edges", num_edges, SCALE (size), LABEL (size));
2377 fprintf (file, "---------------------------------------------------------\n");
2378 fprintf (file, fmt_str_3, "Total memory used by CFG data", SCALE (total),
2380 fprintf (file, "---------------------------------------------------------\n");
2381 fprintf (file, "\n");
2383 if (cfg_stats.num_merged_labels > max_num_merged_labels)
2384 max_num_merged_labels = cfg_stats.num_merged_labels;
2386 fprintf (file, "Coalesced label blocks: %ld (Max so far: %ld)\n",
2387 cfg_stats.num_merged_labels, max_num_merged_labels);
2389 fprintf (file, "\n");
2393 /* Dump CFG statistics on stderr. Keep extern so that it's always
2394 linked in the final executable. */
2397 debug_cfg_stats (void)
2399 dump_cfg_stats (stderr);
2402 /*---------------------------------------------------------------------------
2403 Miscellaneous helpers
2404 ---------------------------------------------------------------------------*/
2406 /* Return true if T, a GIMPLE_CALL, can make an abnormal transfer of control
2407 flow. Transfers of control flow associated with EH are excluded. */
2410 call_can_make_abnormal_goto (gimple t)
2412 /* If the function has no non-local labels, then a call cannot make an
2413 abnormal transfer of control. */
2414 if (!cfun->has_nonlocal_label
2415 && !cfun->calls_setjmp)
2418 /* Likewise if the call has no side effects. */
2419 if (!gimple_has_side_effects (t))
2422 /* Likewise if the called function is leaf. */
2423 if (gimple_call_flags (t) & ECF_LEAF)
2430 /* Return true if T can make an abnormal transfer of control flow.
2431 Transfers of control flow associated with EH are excluded. */
2434 stmt_can_make_abnormal_goto (gimple t)
2436 if (computed_goto_p (t))
2438 if (is_gimple_call (t))
2439 return call_can_make_abnormal_goto (t);
2444 /* Return true if T represents a stmt that always transfers control. */
2447 is_ctrl_stmt (gimple t)
2449 switch (gimple_code (t))
2463 /* Return true if T is a statement that may alter the flow of control
2464 (e.g., a call to a non-returning function). */
2467 is_ctrl_altering_stmt (gimple t)
2471 switch (gimple_code (t))
2474 /* Per stmt call flag indicates whether the call could alter
2476 if (gimple_call_ctrl_altering_p (t))
2480 case GIMPLE_EH_DISPATCH:
2481 /* EH_DISPATCH branches to the individual catch handlers at
2482 this level of a try or allowed-exceptions region. It can
2483 fallthru to the next statement as well. */
2487 if (gimple_asm_nlabels (as_a <gasm *> (t)) > 0)
2492 /* OpenMP directives alter control flow. */
2495 case GIMPLE_TRANSACTION:
2496 /* A transaction start alters control flow. */
2503 /* If a statement can throw, it alters control flow. */
2504 return stmt_can_throw_internal (t);
2508 /* Return true if T is a simple local goto. */
2511 simple_goto_p (gimple t)
2513 return (gimple_code (t) == GIMPLE_GOTO
2514 && TREE_CODE (gimple_goto_dest (t)) == LABEL_DECL);
2518 /* Return true if STMT should start a new basic block. PREV_STMT is
2519 the statement preceding STMT. It is used when STMT is a label or a
2520 case label. Labels should only start a new basic block if their
2521 previous statement wasn't a label. Otherwise, sequence of labels
2522 would generate unnecessary basic blocks that only contain a single
2526 stmt_starts_bb_p (gimple stmt, gimple prev_stmt)
2531 /* Labels start a new basic block only if the preceding statement
2532 wasn't a label of the same type. This prevents the creation of
2533 consecutive blocks that have nothing but a single label. */
2534 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
2536 /* Nonlocal and computed GOTO targets always start a new block. */
2537 if (DECL_NONLOCAL (gimple_label_label (label_stmt))
2538 || FORCED_LABEL (gimple_label_label (label_stmt)))
2541 if (prev_stmt && gimple_code (prev_stmt) == GIMPLE_LABEL)
2543 if (DECL_NONLOCAL (gimple_label_label (
2544 as_a <glabel *> (prev_stmt))))
2547 cfg_stats.num_merged_labels++;
2553 else if (gimple_code (stmt) == GIMPLE_CALL
2554 && gimple_call_flags (stmt) & ECF_RETURNS_TWICE)
2555 /* setjmp acts similar to a nonlocal GOTO target and thus should
2556 start a new block. */
2563 /* Return true if T should end a basic block. */
2566 stmt_ends_bb_p (gimple t)
2568 return is_ctrl_stmt (t) || is_ctrl_altering_stmt (t);
2571 /* Remove block annotations and other data structures. */
2574 delete_tree_cfg_annotations (void)
2576 vec_free (label_to_block_map_for_fn (cfun));
2580 /* Return the first statement in basic block BB. */
2583 first_stmt (basic_block bb)
2585 gimple_stmt_iterator i = gsi_start_bb (bb);
2588 while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
2596 /* Return the first non-label statement in basic block BB. */
2599 first_non_label_stmt (basic_block bb)
2601 gimple_stmt_iterator i = gsi_start_bb (bb);
2602 while (!gsi_end_p (i) && gimple_code (gsi_stmt (i)) == GIMPLE_LABEL)
2604 return !gsi_end_p (i) ? gsi_stmt (i) : NULL;
2607 /* Return the last statement in basic block BB. */
2610 last_stmt (basic_block bb)
2612 gimple_stmt_iterator i = gsi_last_bb (bb);
2615 while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
2623 /* Return the last statement of an otherwise empty block. Return NULL
2624 if the block is totally empty, or if it contains more than one
2628 last_and_only_stmt (basic_block bb)
2630 gimple_stmt_iterator i = gsi_last_nondebug_bb (bb);
2636 last = gsi_stmt (i);
2637 gsi_prev_nondebug (&i);
2641 /* Empty statements should no longer appear in the instruction stream.
2642 Everything that might have appeared before should be deleted by
2643 remove_useless_stmts, and the optimizers should just gsi_remove
2644 instead of smashing with build_empty_stmt.
2646 Thus the only thing that should appear here in a block containing
2647 one executable statement is a label. */
2648 prev = gsi_stmt (i);
2649 if (gimple_code (prev) == GIMPLE_LABEL)
2655 /* Reinstall those PHI arguments queued in OLD_EDGE to NEW_EDGE. */
2658 reinstall_phi_args (edge new_edge, edge old_edge)
2664 vec<edge_var_map> *v = redirect_edge_var_map_vector (old_edge);
2668 for (i = 0, phis = gsi_start_phis (new_edge->dest);
2669 v->iterate (i, &vm) && !gsi_end_p (phis);
2670 i++, gsi_next (&phis))
2672 gphi *phi = phis.phi ();
2673 tree result = redirect_edge_var_map_result (vm);
2674 tree arg = redirect_edge_var_map_def (vm);
2676 gcc_assert (result == gimple_phi_result (phi));
2678 add_phi_arg (phi, arg, new_edge, redirect_edge_var_map_location (vm));
2681 redirect_edge_var_map_clear (old_edge);
2684 /* Returns the basic block after which the new basic block created
2685 by splitting edge EDGE_IN should be placed. Tries to keep the new block
2686 near its "logical" location. This is of most help to humans looking
2687 at debugging dumps. */
2690 split_edge_bb_loc (edge edge_in)
2692 basic_block dest = edge_in->dest;
2693 basic_block dest_prev = dest->prev_bb;
2697 edge e = find_edge (dest_prev, dest);
2698 if (e && !(e->flags & EDGE_COMPLEX))
2699 return edge_in->src;
2704 /* Split a (typically critical) edge EDGE_IN. Return the new block.
2705 Abort on abnormal edges. */
2708 gimple_split_edge (edge edge_in)
2710 basic_block new_bb, after_bb, dest;
2713 /* Abnormal edges cannot be split. */
2714 gcc_assert (!(edge_in->flags & EDGE_ABNORMAL));
2716 dest = edge_in->dest;
2718 after_bb = split_edge_bb_loc (edge_in);
2720 new_bb = create_empty_bb (after_bb);
2721 new_bb->frequency = EDGE_FREQUENCY (edge_in);
2722 new_bb->count = edge_in->count;
2723 new_edge = make_edge (new_bb, dest, EDGE_FALLTHRU);
2724 new_edge->probability = REG_BR_PROB_BASE;
2725 new_edge->count = edge_in->count;
2727 e = redirect_edge_and_branch (edge_in, new_bb);
2728 gcc_assert (e == edge_in);
2729 reinstall_phi_args (new_edge, e);
2735 /* Verify properties of the address expression T with base object BASE. */
2738 verify_address (tree t, tree base)
2741 bool old_side_effects;
2743 bool new_side_effects;
2745 old_constant = TREE_CONSTANT (t);
2746 old_side_effects = TREE_SIDE_EFFECTS (t);
2748 recompute_tree_invariant_for_addr_expr (t);
2749 new_side_effects = TREE_SIDE_EFFECTS (t);
2750 new_constant = TREE_CONSTANT (t);
2752 if (old_constant != new_constant)
2754 error ("constant not recomputed when ADDR_EXPR changed");
2757 if (old_side_effects != new_side_effects)
2759 error ("side effects not recomputed when ADDR_EXPR changed");
2763 if (!(TREE_CODE (base) == VAR_DECL
2764 || TREE_CODE (base) == PARM_DECL
2765 || TREE_CODE (base) == RESULT_DECL))
2768 if (DECL_GIMPLE_REG_P (base))
2770 error ("DECL_GIMPLE_REG_P set on a variable with address taken");
2777 /* Callback for walk_tree, check that all elements with address taken are
2778 properly noticed as such. The DATA is an int* that is 1 if TP was seen
2779 inside a PHI node. */
2782 verify_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
2789 /* Check operand N for being valid GIMPLE and give error MSG if not. */
2790 #define CHECK_OP(N, MSG) \
2791 do { if (!is_gimple_val (TREE_OPERAND (t, N))) \
2792 { error (MSG); return TREE_OPERAND (t, N); }} while (0)
2794 switch (TREE_CODE (t))
2797 if (SSA_NAME_IN_FREE_LIST (t))
2799 error ("SSA name in freelist but still referenced");
2805 error ("INDIRECT_REF in gimple IL");
2809 x = TREE_OPERAND (t, 0);
2810 if (!POINTER_TYPE_P (TREE_TYPE (x))
2811 || !is_gimple_mem_ref_addr (x))
2813 error ("invalid first operand of MEM_REF");
2816 if (TREE_CODE (TREE_OPERAND (t, 1)) != INTEGER_CST
2817 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 1))))
2819 error ("invalid offset operand of MEM_REF");
2820 return TREE_OPERAND (t, 1);
2822 if (TREE_CODE (x) == ADDR_EXPR
2823 && (x = verify_address (x, TREE_OPERAND (x, 0))))
2829 x = fold (ASSERT_EXPR_COND (t));
2830 if (x == boolean_false_node)
2832 error ("ASSERT_EXPR with an always-false condition");
2838 error ("MODIFY_EXPR not expected while having tuples");
2845 gcc_assert (is_gimple_address (t));
2847 /* Skip any references (they will be checked when we recurse down the
2848 tree) and ensure that any variable used as a prefix is marked
2850 for (x = TREE_OPERAND (t, 0);
2851 handled_component_p (x);
2852 x = TREE_OPERAND (x, 0))
2855 if ((tem = verify_address (t, x)))
2858 if (!(TREE_CODE (x) == VAR_DECL
2859 || TREE_CODE (x) == PARM_DECL
2860 || TREE_CODE (x) == RESULT_DECL))
2863 if (!TREE_ADDRESSABLE (x))
2865 error ("address taken, but ADDRESSABLE bit not set");
2873 x = COND_EXPR_COND (t);
2874 if (!INTEGRAL_TYPE_P (TREE_TYPE (x)))
2876 error ("non-integral used in condition");
2879 if (!is_gimple_condexpr (x))
2881 error ("invalid conditional operand");
2886 case NON_LVALUE_EXPR:
2887 case TRUTH_NOT_EXPR:
2891 case FIX_TRUNC_EXPR:
2896 CHECK_OP (0, "invalid operand to unary operator");
2902 if (!is_gimple_reg_type (TREE_TYPE (t)))
2904 error ("non-scalar BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR");
2908 if (TREE_CODE (t) == BIT_FIELD_REF)
2910 tree t0 = TREE_OPERAND (t, 0);
2911 tree t1 = TREE_OPERAND (t, 1);
2912 tree t2 = TREE_OPERAND (t, 2);
2913 if (!tree_fits_uhwi_p (t1)
2914 || !tree_fits_uhwi_p (t2))
2916 error ("invalid position or size operand to BIT_FIELD_REF");
2919 if (INTEGRAL_TYPE_P (TREE_TYPE (t))
2920 && (TYPE_PRECISION (TREE_TYPE (t))
2921 != tree_to_uhwi (t1)))
2923 error ("integral result type precision does not match "
2924 "field size of BIT_FIELD_REF");
2927 else if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
2928 && TYPE_MODE (TREE_TYPE (t)) != BLKmode
2929 && (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (t)))
2930 != tree_to_uhwi (t1)))
2932 error ("mode precision of non-integral result does not "
2933 "match field size of BIT_FIELD_REF");
2936 if (!AGGREGATE_TYPE_P (TREE_TYPE (t0))
2937 && (tree_to_uhwi (t1) + tree_to_uhwi (t2)
2938 > tree_to_uhwi (TYPE_SIZE (TREE_TYPE (t0)))))
2940 error ("position plus size exceeds size of referenced object in "
2945 t = TREE_OPERAND (t, 0);
2950 case ARRAY_RANGE_REF:
2951 case VIEW_CONVERT_EXPR:
2952 /* We have a nest of references. Verify that each of the operands
2953 that determine where to reference is either a constant or a variable,
2954 verify that the base is valid, and then show we've already checked
2956 while (handled_component_p (t))
2958 if (TREE_CODE (t) == COMPONENT_REF && TREE_OPERAND (t, 2))
2959 CHECK_OP (2, "invalid COMPONENT_REF offset operator");
2960 else if (TREE_CODE (t) == ARRAY_REF
2961 || TREE_CODE (t) == ARRAY_RANGE_REF)
2963 CHECK_OP (1, "invalid array index");
2964 if (TREE_OPERAND (t, 2))
2965 CHECK_OP (2, "invalid array lower bound");
2966 if (TREE_OPERAND (t, 3))
2967 CHECK_OP (3, "invalid array stride");
2969 else if (TREE_CODE (t) == BIT_FIELD_REF
2970 || TREE_CODE (t) == REALPART_EXPR
2971 || TREE_CODE (t) == IMAGPART_EXPR)
2973 error ("non-top-level BIT_FIELD_REF, IMAGPART_EXPR or "
2978 t = TREE_OPERAND (t, 0);
2981 if (!is_gimple_min_invariant (t) && !is_gimple_lvalue (t))
2983 error ("invalid reference prefix");
2990 /* PLUS_EXPR and MINUS_EXPR don't work on pointers, they should be done using
2991 POINTER_PLUS_EXPR. */
2992 if (POINTER_TYPE_P (TREE_TYPE (t)))
2994 error ("invalid operand to plus/minus, type is a pointer");
2997 CHECK_OP (0, "invalid operand to binary operator");
2998 CHECK_OP (1, "invalid operand to binary operator");
3001 case POINTER_PLUS_EXPR:
3002 /* Check to make sure the first operand is a pointer or reference type. */
3003 if (!POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0))))
3005 error ("invalid operand to pointer plus, first operand is not a pointer");
3008 /* Check to make sure the second operand is a ptrofftype. */
3009 if (!ptrofftype_p (TREE_TYPE (TREE_OPERAND (t, 1))))
3011 error ("invalid operand to pointer plus, second operand is not an "
3012 "integer type of appropriate width");
3022 case UNORDERED_EXPR:
3031 case TRUNC_DIV_EXPR:
3033 case FLOOR_DIV_EXPR:
3034 case ROUND_DIV_EXPR:
3035 case TRUNC_MOD_EXPR:
3037 case FLOOR_MOD_EXPR:
3038 case ROUND_MOD_EXPR:
3040 case EXACT_DIV_EXPR:
3050 CHECK_OP (0, "invalid operand to binary operator");
3051 CHECK_OP (1, "invalid operand to binary operator");
3055 if (TREE_CONSTANT (t) && TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
3059 case CASE_LABEL_EXPR:
3062 error ("invalid CASE_CHAIN");
3076 /* Verify if EXPR is either a GIMPLE ID or a GIMPLE indirect reference.
3077 Returns true if there is an error, otherwise false. */
3080 verify_types_in_gimple_min_lval (tree expr)
3084 if (is_gimple_id (expr))
3087 if (TREE_CODE (expr) != TARGET_MEM_REF
3088 && TREE_CODE (expr) != MEM_REF)
3090 error ("invalid expression for min lvalue");
3094 /* TARGET_MEM_REFs are strange beasts. */
3095 if (TREE_CODE (expr) == TARGET_MEM_REF)
3098 op = TREE_OPERAND (expr, 0);
3099 if (!is_gimple_val (op))
3101 error ("invalid operand in indirect reference");
3102 debug_generic_stmt (op);
3105 /* Memory references now generally can involve a value conversion. */
3110 /* Verify if EXPR is a valid GIMPLE reference expression. If
3111 REQUIRE_LVALUE is true verifies it is an lvalue. Returns true
3112 if there is an error, otherwise false. */
3115 verify_types_in_gimple_reference (tree expr, bool require_lvalue)
3117 while (handled_component_p (expr))
3119 tree op = TREE_OPERAND (expr, 0);
3121 if (TREE_CODE (expr) == ARRAY_REF
3122 || TREE_CODE (expr) == ARRAY_RANGE_REF)
3124 if (!is_gimple_val (TREE_OPERAND (expr, 1))
3125 || (TREE_OPERAND (expr, 2)
3126 && !is_gimple_val (TREE_OPERAND (expr, 2)))
3127 || (TREE_OPERAND (expr, 3)
3128 && !is_gimple_val (TREE_OPERAND (expr, 3))))
3130 error ("invalid operands to array reference");
3131 debug_generic_stmt (expr);
3136 /* Verify if the reference array element types are compatible. */
3137 if (TREE_CODE (expr) == ARRAY_REF
3138 && !useless_type_conversion_p (TREE_TYPE (expr),
3139 TREE_TYPE (TREE_TYPE (op))))
3141 error ("type mismatch in array reference");
3142 debug_generic_stmt (TREE_TYPE (expr));
3143 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
3146 if (TREE_CODE (expr) == ARRAY_RANGE_REF
3147 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr)),
3148 TREE_TYPE (TREE_TYPE (op))))
3150 error ("type mismatch in array range reference");
3151 debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr)));
3152 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
3156 if ((TREE_CODE (expr) == REALPART_EXPR
3157 || TREE_CODE (expr) == IMAGPART_EXPR)
3158 && !useless_type_conversion_p (TREE_TYPE (expr),
3159 TREE_TYPE (TREE_TYPE (op))))
3161 error ("type mismatch in real/imagpart reference");
3162 debug_generic_stmt (TREE_TYPE (expr));
3163 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
3167 if (TREE_CODE (expr) == COMPONENT_REF
3168 && !useless_type_conversion_p (TREE_TYPE (expr),
3169 TREE_TYPE (TREE_OPERAND (expr, 1))))
3171 error ("type mismatch in component reference");
3172 debug_generic_stmt (TREE_TYPE (expr));
3173 debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr, 1)));
3177 if (TREE_CODE (expr) == VIEW_CONVERT_EXPR)
3179 /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
3180 that their operand is not an SSA name or an invariant when
3181 requiring an lvalue (this usually means there is a SRA or IPA-SRA
3182 bug). Otherwise there is nothing to verify, gross mismatches at
3183 most invoke undefined behavior. */
3185 && (TREE_CODE (op) == SSA_NAME
3186 || is_gimple_min_invariant (op)))
3188 error ("conversion of an SSA_NAME on the left hand side");
3189 debug_generic_stmt (expr);
3192 else if (TREE_CODE (op) == SSA_NAME
3193 && TYPE_SIZE (TREE_TYPE (expr)) != TYPE_SIZE (TREE_TYPE (op)))
3195 error ("conversion of register to a different size");
3196 debug_generic_stmt (expr);
3199 else if (!handled_component_p (op))
3206 if (TREE_CODE (expr) == MEM_REF)
3208 if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr, 0)))
3210 error ("invalid address operand in MEM_REF");
3211 debug_generic_stmt (expr);
3214 if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
3215 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 1))))
3217 error ("invalid offset operand in MEM_REF");
3218 debug_generic_stmt (expr);
3222 else if (TREE_CODE (expr) == TARGET_MEM_REF)
3224 if (!TMR_BASE (expr)
3225 || !is_gimple_mem_ref_addr (TMR_BASE (expr)))
3227 error ("invalid address operand in TARGET_MEM_REF");
3230 if (!TMR_OFFSET (expr)
3231 || TREE_CODE (TMR_OFFSET (expr)) != INTEGER_CST
3232 || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr))))
3234 error ("invalid offset operand in TARGET_MEM_REF");
3235 debug_generic_stmt (expr);
3240 return ((require_lvalue || !is_gimple_min_invariant (expr))
3241 && verify_types_in_gimple_min_lval (expr));
3244 /* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
3245 list of pointer-to types that is trivially convertible to DEST. */
3248 one_pointer_to_useless_type_conversion_p (tree dest, tree src_obj)
3252 if (!TYPE_POINTER_TO (src_obj))
3255 for (src = TYPE_POINTER_TO (src_obj); src; src = TYPE_NEXT_PTR_TO (src))
3256 if (useless_type_conversion_p (dest, src))
3262 /* Return true if TYPE1 is a fixed-point type and if conversions to and
3263 from TYPE2 can be handled by FIXED_CONVERT_EXPR. */
3266 valid_fixed_convert_types_p (tree type1, tree type2)
3268 return (FIXED_POINT_TYPE_P (type1)
3269 && (INTEGRAL_TYPE_P (type2)
3270 || SCALAR_FLOAT_TYPE_P (type2)
3271 || FIXED_POINT_TYPE_P (type2)));
3274 /* Verify the contents of a GIMPLE_CALL STMT. Returns true when there
3275 is a problem, otherwise false. */
3278 verify_gimple_call (gcall *stmt)
3280 tree fn = gimple_call_fn (stmt);
3281 tree fntype, fndecl;
3284 if (gimple_call_internal_p (stmt))
3288 error ("gimple call has two targets");
3289 debug_generic_stmt (fn);
3297 error ("gimple call has no target");
3302 if (fn && !is_gimple_call_addr (fn))
3304 error ("invalid function in gimple call");
3305 debug_generic_stmt (fn);
3310 && (!POINTER_TYPE_P (TREE_TYPE (fn))
3311 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn))) != FUNCTION_TYPE
3312 && TREE_CODE (TREE_TYPE (TREE_TYPE (fn))) != METHOD_TYPE)))
3314 error ("non-function in gimple call");
3318 fndecl = gimple_call_fndecl (stmt);
3320 && TREE_CODE (fndecl) == FUNCTION_DECL
3321 && DECL_LOOPING_CONST_OR_PURE_P (fndecl)
3322 && !DECL_PURE_P (fndecl)
3323 && !TREE_READONLY (fndecl))
3325 error ("invalid pure const state for function");
3329 if (gimple_call_lhs (stmt)
3330 && (!is_gimple_lvalue (gimple_call_lhs (stmt))
3331 || verify_types_in_gimple_reference (gimple_call_lhs (stmt), true)))
3333 error ("invalid LHS in gimple call");
3337 if (gimple_call_lhs (stmt) && gimple_call_noreturn_p (stmt))
3339 error ("LHS in noreturn call");
3343 fntype = gimple_call_fntype (stmt);
3345 && gimple_call_lhs (stmt)
3346 && !useless_type_conversion_p (TREE_TYPE (gimple_call_lhs (stmt)),
3348 /* ??? At least C++ misses conversions at assignments from
3349 void * call results.
3350 ??? Java is completely off. Especially with functions
3351 returning java.lang.Object.
3352 For now simply allow arbitrary pointer type conversions. */
3353 && !(POINTER_TYPE_P (TREE_TYPE (gimple_call_lhs (stmt)))
3354 && POINTER_TYPE_P (TREE_TYPE (fntype))))
3356 error ("invalid conversion in gimple call");
3357 debug_generic_stmt (TREE_TYPE (gimple_call_lhs (stmt)));
3358 debug_generic_stmt (TREE_TYPE (fntype));
3362 if (gimple_call_chain (stmt)
3363 && !is_gimple_val (gimple_call_chain (stmt)))
3365 error ("invalid static chain in gimple call");
3366 debug_generic_stmt (gimple_call_chain (stmt));
3370 /* If there is a static chain argument, the call should either be
3371 indirect, or the decl should have DECL_STATIC_CHAIN set. */
3372 if (gimple_call_chain (stmt)
3374 && !DECL_STATIC_CHAIN (fndecl))
3376 error ("static chain with function that doesn%'t use one");
3380 /* ??? The C frontend passes unpromoted arguments in case it
3381 didn't see a function declaration before the call. So for now
3382 leave the call arguments mostly unverified. Once we gimplify
3383 unit-at-a-time we have a chance to fix this. */
3385 for (i = 0; i < gimple_call_num_args (stmt); ++i)
3387 tree arg = gimple_call_arg (stmt, i);
3388 if ((is_gimple_reg_type (TREE_TYPE (arg))
3389 && !is_gimple_val (arg))
3390 || (!is_gimple_reg_type (TREE_TYPE (arg))
3391 && !is_gimple_lvalue (arg)))
3393 error ("invalid argument to gimple call");
3394 debug_generic_expr (arg);
3402 /* Verifies the gimple comparison with the result type TYPE and
3403 the operands OP0 and OP1. */
3406 verify_gimple_comparison (tree type, tree op0, tree op1)
3408 tree op0_type = TREE_TYPE (op0);
3409 tree op1_type = TREE_TYPE (op1);
3411 if (!is_gimple_val (op0) || !is_gimple_val (op1))
3413 error ("invalid operands in gimple comparison");
3417 /* For comparisons we do not have the operations type as the
3418 effective type the comparison is carried out in. Instead
3419 we require that either the first operand is trivially
3420 convertible into the second, or the other way around.
3421 Because we special-case pointers to void we allow
3422 comparisons of pointers with the same mode as well. */
3423 if (!useless_type_conversion_p (op0_type, op1_type)
3424 && !useless_type_conversion_p (op1_type, op0_type)
3425 && (!POINTER_TYPE_P (op0_type)
3426 || !POINTER_TYPE_P (op1_type)
3427 || TYPE_MODE (op0_type) != TYPE_MODE (op1_type)))
3429 error ("mismatching comparison operand types");
3430 debug_generic_expr (op0_type);
3431 debug_generic_expr (op1_type);
3435 /* The resulting type of a comparison may be an effective boolean type. */
3436 if (INTEGRAL_TYPE_P (type)
3437 && (TREE_CODE (type) == BOOLEAN_TYPE
3438 || TYPE_PRECISION (type) == 1))
3440 if (TREE_CODE (op0_type) == VECTOR_TYPE
3441 || TREE_CODE (op1_type) == VECTOR_TYPE)
3443 error ("vector comparison returning a boolean");
3444 debug_generic_expr (op0_type);
3445 debug_generic_expr (op1_type);
3449 /* Or an integer vector type with the same size and element count
3450 as the comparison operand types. */
3451 else if (TREE_CODE (type) == VECTOR_TYPE
3452 && TREE_CODE (TREE_TYPE (type)) == INTEGER_TYPE)
3454 if (TREE_CODE (op0_type) != VECTOR_TYPE
3455 || TREE_CODE (op1_type) != VECTOR_TYPE)
3457 error ("non-vector operands in vector comparison");
3458 debug_generic_expr (op0_type);
3459 debug_generic_expr (op1_type);
3463 if (TYPE_VECTOR_SUBPARTS (type) != TYPE_VECTOR_SUBPARTS (op0_type)
3464 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (type)))
3465 != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0_type))))
3466 /* The result of a vector comparison is of signed
3468 || TYPE_UNSIGNED (TREE_TYPE (type)))
3470 error ("invalid vector comparison resulting type");
3471 debug_generic_expr (type);
3477 error ("bogus comparison result type");
3478 debug_generic_expr (type);
3485 /* Verify a gimple assignment statement STMT with an unary rhs.
3486 Returns true if anything is wrong. */
3489 verify_gimple_assign_unary (gassign *stmt)
3491 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
3492 tree lhs = gimple_assign_lhs (stmt);
3493 tree lhs_type = TREE_TYPE (lhs);
3494 tree rhs1 = gimple_assign_rhs1 (stmt);
3495 tree rhs1_type = TREE_TYPE (rhs1);
3497 if (!is_gimple_reg (lhs))
3499 error ("non-register as LHS of unary operation");
3503 if (!is_gimple_val (rhs1))
3505 error ("invalid operand in unary operation");
3509 /* First handle conversions. */
3514 /* Allow conversions from pointer type to integral type only if
3515 there is no sign or zero extension involved.
3516 For targets were the precision of ptrofftype doesn't match that
3517 of pointers we need to allow arbitrary conversions to ptrofftype. */
3518 if ((POINTER_TYPE_P (lhs_type)
3519 && INTEGRAL_TYPE_P (rhs1_type))
3520 || (POINTER_TYPE_P (rhs1_type)
3521 && INTEGRAL_TYPE_P (lhs_type)
3522 && (TYPE_PRECISION (rhs1_type) >= TYPE_PRECISION (lhs_type)
3523 || ptrofftype_p (sizetype))))
3526 /* Allow conversion from integral to offset type and vice versa. */
3527 if ((TREE_CODE (lhs_type) == OFFSET_TYPE
3528 && INTEGRAL_TYPE_P (rhs1_type))
3529 || (INTEGRAL_TYPE_P (lhs_type)
3530 && TREE_CODE (rhs1_type) == OFFSET_TYPE))
3533 /* Otherwise assert we are converting between types of the
3535 if (INTEGRAL_TYPE_P (lhs_type) != INTEGRAL_TYPE_P (rhs1_type))
3537 error ("invalid types in nop conversion");
3538 debug_generic_expr (lhs_type);
3539 debug_generic_expr (rhs1_type);
3546 case ADDR_SPACE_CONVERT_EXPR:
3548 if (!POINTER_TYPE_P (rhs1_type) || !POINTER_TYPE_P (lhs_type)
3549 || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type))
3550 == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type))))
3552 error ("invalid types in address space conversion");
3553 debug_generic_expr (lhs_type);
3554 debug_generic_expr (rhs1_type);
3561 case FIXED_CONVERT_EXPR:
3563 if (!valid_fixed_convert_types_p (lhs_type, rhs1_type)
3564 && !valid_fixed_convert_types_p (rhs1_type, lhs_type))
3566 error ("invalid types in fixed-point conversion");
3567 debug_generic_expr (lhs_type);
3568 debug_generic_expr (rhs1_type);
3577 if ((!INTEGRAL_TYPE_P (rhs1_type) || !SCALAR_FLOAT_TYPE_P (lhs_type))
3578 && (!VECTOR_INTEGER_TYPE_P (rhs1_type)
3579 || !VECTOR_FLOAT_TYPE_P (lhs_type)))
3581 error ("invalid types in conversion to floating point");
3582 debug_generic_expr (lhs_type);
3583 debug_generic_expr (rhs1_type);
3590 case FIX_TRUNC_EXPR:
3592 if ((!INTEGRAL_TYPE_P (lhs_type) || !SCALAR_FLOAT_TYPE_P (rhs1_type))
3593 && (!VECTOR_INTEGER_TYPE_P (lhs_type)
3594 || !VECTOR_FLOAT_TYPE_P (rhs1_type)))
3596 error ("invalid types in conversion to integer");
3597 debug_generic_expr (lhs_type);
3598 debug_generic_expr (rhs1_type);
3604 case REDUC_MAX_EXPR:
3605 case REDUC_MIN_EXPR:
3606 case REDUC_PLUS_EXPR:
3607 if (!VECTOR_TYPE_P (rhs1_type)
3608 || !useless_type_conversion_p (lhs_type, TREE_TYPE (rhs1_type)))
3610 error ("reduction should convert from vector to element type");
3611 debug_generic_expr (lhs_type);
3612 debug_generic_expr (rhs1_type);
3617 case VEC_UNPACK_HI_EXPR:
3618 case VEC_UNPACK_LO_EXPR:
3619 case VEC_UNPACK_FLOAT_HI_EXPR:
3620 case VEC_UNPACK_FLOAT_LO_EXPR:
3635 /* For the remaining codes assert there is no conversion involved. */
3636 if (!useless_type_conversion_p (lhs_type, rhs1_type))
3638 error ("non-trivial conversion in unary operation");
3639 debug_generic_expr (lhs_type);
3640 debug_generic_expr (rhs1_type);
3647 /* Verify a gimple assignment statement STMT with a binary rhs.
3648 Returns true if anything is wrong. */
3651 verify_gimple_assign_binary (gassign *stmt)
3653 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
3654 tree lhs = gimple_assign_lhs (stmt);
3655 tree lhs_type = TREE_TYPE (lhs);
3656 tree rhs1 = gimple_assign_rhs1 (stmt);
3657 tree rhs1_type = TREE_TYPE (rhs1);
3658 tree rhs2 = gimple_assign_rhs2 (stmt);
3659 tree rhs2_type = TREE_TYPE (rhs2);
3661 if (!is_gimple_reg (lhs))
3663 error ("non-register as LHS of binary operation");
3667 if (!is_gimple_val (rhs1)
3668 || !is_gimple_val (rhs2))
3670 error ("invalid operands in binary operation");
3674 /* First handle operations that involve different types. */
3679 if (TREE_CODE (lhs_type) != COMPLEX_TYPE
3680 || !(INTEGRAL_TYPE_P (rhs1_type)
3681 || SCALAR_FLOAT_TYPE_P (rhs1_type))
3682 || !(INTEGRAL_TYPE_P (rhs2_type)
3683 || SCALAR_FLOAT_TYPE_P (rhs2_type)))
3685 error ("type mismatch in complex expression");
3686 debug_generic_expr (lhs_type);
3687 debug_generic_expr (rhs1_type);
3688 debug_generic_expr (rhs2_type);
3700 /* Shifts and rotates are ok on integral types, fixed point
3701 types and integer vector types. */
3702 if ((!INTEGRAL_TYPE_P (rhs1_type)
3703 && !FIXED_POINT_TYPE_P (rhs1_type)
3704 && !(TREE_CODE (rhs1_type) == VECTOR_TYPE
3705 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))))
3706 || (!INTEGRAL_TYPE_P (rhs2_type)
3707 /* Vector shifts of vectors are also ok. */
3708 && !(TREE_CODE (rhs1_type) == VECTOR_TYPE
3709 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
3710 && TREE_CODE (rhs2_type) == VECTOR_TYPE
3711 && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type))))
3712 || !useless_type_conversion_p (lhs_type, rhs1_type))
3714 error ("type mismatch in shift expression");
3715 debug_generic_expr (lhs_type);
3716 debug_generic_expr (rhs1_type);
3717 debug_generic_expr (rhs2_type);
3724 case WIDEN_LSHIFT_EXPR:
3726 if (!INTEGRAL_TYPE_P (lhs_type)
3727 || !INTEGRAL_TYPE_P (rhs1_type)
3728 || TREE_CODE (rhs2) != INTEGER_CST
3729 || (2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type)))
3731 error ("type mismatch in widening vector shift expression");
3732 debug_generic_expr (lhs_type);
3733 debug_generic_expr (rhs1_type);
3734 debug_generic_expr (rhs2_type);
3741 case VEC_WIDEN_LSHIFT_HI_EXPR:
3742 case VEC_WIDEN_LSHIFT_LO_EXPR:
3744 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
3745 || TREE_CODE (lhs_type) != VECTOR_TYPE
3746 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
3747 || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))
3748 || TREE_CODE (rhs2) != INTEGER_CST
3749 || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type))
3750 > TYPE_PRECISION (TREE_TYPE (lhs_type))))
3752 error ("type mismatch in widening vector shift expression");
3753 debug_generic_expr (lhs_type);
3754 debug_generic_expr (rhs1_type);
3755 debug_generic_expr (rhs2_type);
3765 tree lhs_etype = lhs_type;
3766 tree rhs1_etype = rhs1_type;
3767 tree rhs2_etype = rhs2_type;
3768 if (TREE_CODE (lhs_type) == VECTOR_TYPE)
3770 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
3771 || TREE_CODE (rhs2_type) != VECTOR_TYPE)
3773 error ("invalid non-vector operands to vector valued plus");
3776 lhs_etype = TREE_TYPE (lhs_type);
3777 rhs1_etype = TREE_TYPE (rhs1_type);
3778 rhs2_etype = TREE_TYPE (rhs2_type);
3780 if (POINTER_TYPE_P (lhs_etype)
3781 || POINTER_TYPE_P (rhs1_etype)
3782 || POINTER_TYPE_P (rhs2_etype))
3784 error ("invalid (pointer) operands to plus/minus");
3788 /* Continue with generic binary expression handling. */
3792 case POINTER_PLUS_EXPR:
3794 if (!POINTER_TYPE_P (rhs1_type)
3795 || !useless_type_conversion_p (lhs_type, rhs1_type)
3796 || !ptrofftype_p (rhs2_type))
3798 error ("type mismatch in pointer plus expression");
3799 debug_generic_stmt (lhs_type);
3800 debug_generic_stmt (rhs1_type);
3801 debug_generic_stmt (rhs2_type);
3808 case TRUTH_ANDIF_EXPR:
3809 case TRUTH_ORIF_EXPR:
3810 case TRUTH_AND_EXPR:
3812 case TRUTH_XOR_EXPR:
3822 case UNORDERED_EXPR:
3830 /* Comparisons are also binary, but the result type is not
3831 connected to the operand types. */
3832 return verify_gimple_comparison (lhs_type, rhs1, rhs2);
3834 case WIDEN_MULT_EXPR:
3835 if (TREE_CODE (lhs_type) != INTEGER_TYPE)
3837 return ((2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type))
3838 || (TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (rhs2_type)));
3840 case WIDEN_SUM_EXPR:
3841 case VEC_WIDEN_MULT_HI_EXPR:
3842 case VEC_WIDEN_MULT_LO_EXPR:
3843 case VEC_WIDEN_MULT_EVEN_EXPR:
3844 case VEC_WIDEN_MULT_ODD_EXPR:
3845 case VEC_PACK_TRUNC_EXPR:
3846 case VEC_PACK_SAT_EXPR:
3847 case VEC_PACK_FIX_TRUNC_EXPR:
3852 case MULT_HIGHPART_EXPR:
3853 case TRUNC_DIV_EXPR:
3855 case FLOOR_DIV_EXPR:
3856 case ROUND_DIV_EXPR:
3857 case TRUNC_MOD_EXPR:
3859 case FLOOR_MOD_EXPR:
3860 case ROUND_MOD_EXPR:
3862 case EXACT_DIV_EXPR:
3868 /* Continue with generic binary expression handling. */
3875 if (!useless_type_conversion_p (lhs_type, rhs1_type)
3876 || !useless_type_conversion_p (lhs_type, rhs2_type))
3878 error ("type mismatch in binary expression");
3879 debug_generic_stmt (lhs_type);
3880 debug_generic_stmt (rhs1_type);
3881 debug_generic_stmt (rhs2_type);
3888 /* Verify a gimple assignment statement STMT with a ternary rhs.
3889 Returns true if anything is wrong. */
3892 verify_gimple_assign_ternary (gassign *stmt)
3894 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
3895 tree lhs = gimple_assign_lhs (stmt);
3896 tree lhs_type = TREE_TYPE (lhs);
3897 tree rhs1 = gimple_assign_rhs1 (stmt);
3898 tree rhs1_type = TREE_TYPE (rhs1);
3899 tree rhs2 = gimple_assign_rhs2 (stmt);
3900 tree rhs2_type = TREE_TYPE (rhs2);
3901 tree rhs3 = gimple_assign_rhs3 (stmt);
3902 tree rhs3_type = TREE_TYPE (rhs3);
3904 if (!is_gimple_reg (lhs))
3906 error ("non-register as LHS of ternary operation");
3910 if (((rhs_code == VEC_COND_EXPR || rhs_code == COND_EXPR)
3911 ? !is_gimple_condexpr (rhs1) : !is_gimple_val (rhs1))
3912 || !is_gimple_val (rhs2)
3913 || !is_gimple_val (rhs3))
3915 error ("invalid operands in ternary operation");
3919 /* First handle operations that involve different types. */
3922 case WIDEN_MULT_PLUS_EXPR:
3923 case WIDEN_MULT_MINUS_EXPR:
3924 if ((!INTEGRAL_TYPE_P (rhs1_type)
3925 && !FIXED_POINT_TYPE_P (rhs1_type))
3926 || !useless_type_conversion_p (rhs1_type, rhs2_type)
3927 || !useless_type_conversion_p (lhs_type, rhs3_type)
3928 || 2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type)
3929 || TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (rhs2_type))
3931 error ("type mismatch in widening multiply-accumulate expression");
3932 debug_generic_expr (lhs_type);
3933 debug_generic_expr (rhs1_type);
3934 debug_generic_expr (rhs2_type);
3935 debug_generic_expr (rhs3_type);
3941 if (!useless_type_conversion_p (lhs_type, rhs1_type)
3942 || !useless_type_conversion_p (lhs_type, rhs2_type)
3943 || !useless_type_conversion_p (lhs_type, rhs3_type))
3945 error ("type mismatch in fused multiply-add expression");
3946 debug_generic_expr (lhs_type);
3947 debug_generic_expr (rhs1_type);
3948 debug_generic_expr (rhs2_type);
3949 debug_generic_expr (rhs3_type);
3956 if (!useless_type_conversion_p (lhs_type, rhs2_type)
3957 || !useless_type_conversion_p (lhs_type, rhs3_type))
3959 error ("type mismatch in conditional expression");
3960 debug_generic_expr (lhs_type);
3961 debug_generic_expr (rhs2_type);
3962 debug_generic_expr (rhs3_type);
3968 if (!useless_type_conversion_p (lhs_type, rhs1_type)
3969 || !useless_type_conversion_p (lhs_type, rhs2_type))
3971 error ("type mismatch in vector permute expression");
3972 debug_generic_expr (lhs_type);
3973 debug_generic_expr (rhs1_type);
3974 debug_generic_expr (rhs2_type);
3975 debug_generic_expr (rhs3_type);
3979 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
3980 || TREE_CODE (rhs2_type) != VECTOR_TYPE
3981 || TREE_CODE (rhs3_type) != VECTOR_TYPE)
3983 error ("vector types expected in vector permute expression");
3984 debug_generic_expr (lhs_type);
3985 debug_generic_expr (rhs1_type);
3986 debug_generic_expr (rhs2_type);
3987 debug_generic_expr (rhs3_type);
3991 if (TYPE_VECTOR_SUBPARTS (rhs1_type) != TYPE_VECTOR_SUBPARTS (rhs2_type)
3992 || TYPE_VECTOR_SUBPARTS (rhs2_type)
3993 != TYPE_VECTOR_SUBPARTS (rhs3_type)
3994 || TYPE_VECTOR_SUBPARTS (rhs3_type)
3995 != TYPE_VECTOR_SUBPARTS (lhs_type))
3997 error ("vectors with different element number found "
3998 "in vector permute expression");
3999 debug_generic_expr (lhs_type);
4000 debug_generic_expr (rhs1_type);
4001 debug_generic_expr (rhs2_type);
4002 debug_generic_expr (rhs3_type);
4006 if (TREE_CODE (TREE_TYPE (rhs3_type)) != INTEGER_TYPE
4007 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs3_type)))
4008 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type))))
4010 error ("invalid mask type in vector permute expression");
4011 debug_generic_expr (lhs_type);
4012 debug_generic_expr (rhs1_type);
4013 debug_generic_expr (rhs2_type);
4014 debug_generic_expr (rhs3_type);
4021 if (!useless_type_conversion_p (rhs1_type, rhs2_type)
4022 || !useless_type_conversion_p (lhs_type, rhs3_type)
4023 || 2 * GET_MODE_BITSIZE (GET_MODE_INNER
4024 (TYPE_MODE (TREE_TYPE (rhs1_type))))
4025 > GET_MODE_BITSIZE (GET_MODE_INNER
4026 (TYPE_MODE (TREE_TYPE (lhs_type)))))
4028 error ("type mismatch in sad expression");
4029 debug_generic_expr (lhs_type);
4030 debug_generic_expr (rhs1_type);
4031 debug_generic_expr (rhs2_type);
4032 debug_generic_expr (rhs3_type);
4036 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
4037 || TREE_CODE (rhs2_type) != VECTOR_TYPE
4038 || TREE_CODE (rhs3_type) != VECTOR_TYPE)
4040 error ("vector types expected in sad expression");
4041 debug_generic_expr (lhs_type);
4042 debug_generic_expr (rhs1_type);
4043 debug_generic_expr (rhs2_type);
4044 debug_generic_expr (rhs3_type);
4051 case REALIGN_LOAD_EXPR:
4061 /* Verify a gimple assignment statement STMT with a single rhs.
4062 Returns true if anything is wrong. */
4065 verify_gimple_assign_single (gassign *stmt)
4067 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
4068 tree lhs = gimple_assign_lhs (stmt);
4069 tree lhs_type = TREE_TYPE (lhs);
4070 tree rhs1 = gimple_assign_rhs1 (stmt);
4071 tree rhs1_type = TREE_TYPE (rhs1);
4074 if (!useless_type_conversion_p (lhs_type, rhs1_type))
4076 error ("non-trivial conversion at assignment");
4077 debug_generic_expr (lhs_type);
4078 debug_generic_expr (rhs1_type);
4082 if (gimple_clobber_p (stmt)
4083 && !(DECL_P (lhs) || TREE_CODE (lhs) == MEM_REF))
4085 error ("non-decl/MEM_REF LHS in clobber statement");
4086 debug_generic_expr (lhs);
4090 if (handled_component_p (lhs)
4091 || TREE_CODE (lhs) == MEM_REF
4092 || TREE_CODE (lhs) == TARGET_MEM_REF)
4093 res |= verify_types_in_gimple_reference (lhs, true);
4095 /* Special codes we cannot handle via their class. */
4100 tree op = TREE_OPERAND (rhs1, 0);
4101 if (!is_gimple_addressable (op))
4103 error ("invalid operand in unary expression");
4107 /* Technically there is no longer a need for matching types, but
4108 gimple hygiene asks for this check. In LTO we can end up
4109 combining incompatible units and thus end up with addresses
4110 of globals that change their type to a common one. */
4112 && !types_compatible_p (TREE_TYPE (op),
4113 TREE_TYPE (TREE_TYPE (rhs1)))
4114 && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1),
4117 error ("type mismatch in address expression");
4118 debug_generic_stmt (TREE_TYPE (rhs1));
4119 debug_generic_stmt (TREE_TYPE (op));
4123 return verify_types_in_gimple_reference (op, true);
4128 error ("INDIRECT_REF in gimple IL");
4134 case ARRAY_RANGE_REF:
4135 case VIEW_CONVERT_EXPR:
4138 case TARGET_MEM_REF:
4140 if (!is_gimple_reg (lhs)
4141 && is_gimple_reg_type (TREE_TYPE (lhs)))
4143 error ("invalid rhs for gimple memory store");
4144 debug_generic_stmt (lhs);
4145 debug_generic_stmt (rhs1);
4148 return res || verify_types_in_gimple_reference (rhs1, false);
4160 /* tcc_declaration */
4165 if (!is_gimple_reg (lhs)
4166 && !is_gimple_reg (rhs1)
4167 && is_gimple_reg_type (TREE_TYPE (lhs)))
4169 error ("invalid rhs for gimple memory store");
4170 debug_generic_stmt (lhs);
4171 debug_generic_stmt (rhs1);
4177 if (TREE_CODE (rhs1_type) == VECTOR_TYPE)
4180 tree elt_i, elt_v, elt_t = NULL_TREE;
4182 if (CONSTRUCTOR_NELTS (rhs1) == 0)
4184 /* For vector CONSTRUCTORs we require that either it is empty
4185 CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
4186 (then the element count must be correct to cover the whole
4187 outer vector and index must be NULL on all elements, or it is
4188 a CONSTRUCTOR of scalar elements, where we as an exception allow
4189 smaller number of elements (assuming zero filling) and
4190 consecutive indexes as compared to NULL indexes (such
4191 CONSTRUCTORs can appear in the IL from FEs). */
4192 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1), i, elt_i, elt_v)
4194 if (elt_t == NULL_TREE)
4196 elt_t = TREE_TYPE (elt_v);
4197 if (TREE_CODE (elt_t) == VECTOR_TYPE)
4199 tree elt_t = TREE_TYPE (elt_v);
4200 if (!useless_type_conversion_p (TREE_TYPE (rhs1_type),
4203 error ("incorrect type of vector CONSTRUCTOR"
4205 debug_generic_stmt (rhs1);
4208 else if (CONSTRUCTOR_NELTS (rhs1)
4209 * TYPE_VECTOR_SUBPARTS (elt_t)
4210 != TYPE_VECTOR_SUBPARTS (rhs1_type))
4212 error ("incorrect number of vector CONSTRUCTOR"
4214 debug_generic_stmt (rhs1);
4218 else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type),
4221 error ("incorrect type of vector CONSTRUCTOR elements");
4222 debug_generic_stmt (rhs1);
4225 else if (CONSTRUCTOR_NELTS (rhs1)
4226 > TYPE_VECTOR_SUBPARTS (rhs1_type))
4228 error ("incorrect number of vector CONSTRUCTOR elements");
4229 debug_generic_stmt (rhs1);
4233 else if (!useless_type_conversion_p (elt_t, TREE_TYPE (elt_v)))
4235 error ("incorrect type of vector CONSTRUCTOR elements");
4236 debug_generic_stmt (rhs1);
4239 if (elt_i != NULL_TREE
4240 && (TREE_CODE (elt_t) == VECTOR_TYPE
4241 || TREE_CODE (elt_i) != INTEGER_CST
4242 || compare_tree_int (elt_i, i) != 0))
4244 error ("vector CONSTRUCTOR with non-NULL element index");
4245 debug_generic_stmt (rhs1);
4248 if (!is_gimple_val (elt_v))
4250 error ("vector CONSTRUCTOR element is not a GIMPLE value");
4251 debug_generic_stmt (rhs1);
4256 else if (CONSTRUCTOR_NELTS (rhs1) != 0)
4258 error ("non-vector CONSTRUCTOR with elements");
4259 debug_generic_stmt (rhs1);
4265 case WITH_SIZE_EXPR:
4275 /* Verify the contents of a GIMPLE_ASSIGN STMT. Returns true when there
4276 is a problem, otherwise false. */
4279 verify_gimple_assign (gassign *stmt)
4281 switch (gimple_assign_rhs_class (stmt))
4283 case GIMPLE_SINGLE_RHS:
4284 return verify_gimple_assign_single (stmt);
4286 case GIMPLE_UNARY_RHS:
4287 return verify_gimple_assign_unary (stmt);
4289 case GIMPLE_BINARY_RHS:
4290 return verify_gimple_assign_binary (stmt);
4292 case GIMPLE_TERNARY_RHS:
4293 return verify_gimple_assign_ternary (stmt);
4300 /* Verify the contents of a GIMPLE_RETURN STMT. Returns true when there
4301 is a problem, otherwise false. */
4304 verify_gimple_return (greturn *stmt)
4306 tree op = gimple_return_retval (stmt);
4307 tree restype = TREE_TYPE (TREE_TYPE (cfun->decl));
4309 /* We cannot test for present return values as we do not fix up missing
4310 return values from the original source. */
4314 if (!is_gimple_val (op)
4315 && TREE_CODE (op) != RESULT_DECL)
4317 error ("invalid operand in return statement");
4318 debug_generic_stmt (op);
4322 if ((TREE_CODE (op) == RESULT_DECL
4323 && DECL_BY_REFERENCE (op))
4324 || (TREE_CODE (op) == SSA_NAME
4325 && SSA_NAME_VAR (op)
4326 && TREE_CODE (SSA_NAME_VAR (op)) == RESULT_DECL
4327 && DECL_BY_REFERENCE (SSA_NAME_VAR (op))))
4328 op = TREE_TYPE (op);
4330 if (!useless_type_conversion_p (restype, TREE_TYPE (op)))
4332 error ("invalid conversion in return statement");
4333 debug_generic_stmt (restype);
4334 debug_generic_stmt (TREE_TYPE (op));
4342 /* Verify the contents of a GIMPLE_GOTO STMT. Returns true when there
4343 is a problem, otherwise false. */
4346 verify_gimple_goto (ggoto *stmt)
4348 tree dest = gimple_goto_dest (stmt);
4350 /* ??? We have two canonical forms of direct goto destinations, a
4351 bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
4352 if (TREE_CODE (dest) != LABEL_DECL
4353 && (!is_gimple_val (dest)
4354 || !POINTER_TYPE_P (TREE_TYPE (dest))))
4356 error ("goto destination is neither a label nor a pointer");
4363 /* Verify the contents of a GIMPLE_SWITCH STMT. Returns true when there
4364 is a problem, otherwise false. */
4367 verify_gimple_switch (gswitch *stmt)
4370 tree elt, prev_upper_bound = NULL_TREE;
4371 tree index_type, elt_type = NULL_TREE;
4373 if (!is_gimple_val (gimple_switch_index (stmt)))
4375 error ("invalid operand to switch statement");
4376 debug_generic_stmt (gimple_switch_index (stmt));
4380 index_type = TREE_TYPE (gimple_switch_index (stmt));
4381 if (! INTEGRAL_TYPE_P (index_type))
4383 error ("non-integral type switch statement");
4384 debug_generic_expr (index_type);
4388 elt = gimple_switch_label (stmt, 0);
4389 if (CASE_LOW (elt) != NULL_TREE || CASE_HIGH (elt) != NULL_TREE)
4391 error ("invalid default case label in switch statement");
4392 debug_generic_expr (elt);
4396 n = gimple_switch_num_labels (stmt);
4397 for (i = 1; i < n; i++)
4399 elt = gimple_switch_label (stmt, i);
4401 if (! CASE_LOW (elt))
4403 error ("invalid case label in switch statement");
4404 debug_generic_expr (elt);
4408 && ! tree_int_cst_lt (CASE_LOW (elt), CASE_HIGH (elt)))
4410 error ("invalid case range in switch statement");
4411 debug_generic_expr (elt);
4417 if (TREE_TYPE (CASE_LOW (elt)) != elt_type
4418 || (CASE_HIGH (elt) && TREE_TYPE (CASE_HIGH (elt)) != elt_type))
4420 error ("type mismatch for case label in switch statement");
4421 debug_generic_expr (elt);
4427 elt_type = TREE_TYPE (CASE_LOW (elt));
4428 if (TYPE_PRECISION (index_type) < TYPE_PRECISION (elt_type))
4430 error ("type precision mismatch in switch statement");
4435 if (prev_upper_bound)
4437 if (! tree_int_cst_lt (prev_upper_bound, CASE_LOW (elt)))
4439 error ("case labels not sorted in switch statement");
4444 prev_upper_bound = CASE_HIGH (elt);
4445 if (! prev_upper_bound)
4446 prev_upper_bound = CASE_LOW (elt);
4452 /* Verify a gimple debug statement STMT.
4453 Returns true if anything is wrong. */
4456 verify_gimple_debug (gimple stmt ATTRIBUTE_UNUSED)
4458 /* There isn't much that could be wrong in a gimple debug stmt. A
4459 gimple debug bind stmt, for example, maps a tree, that's usually
4460 a VAR_DECL or a PARM_DECL, but that could also be some scalarized
4461 component or member of an aggregate type, to another tree, that
4462 can be an arbitrary expression. These stmts expand into debug
4463 insns, and are converted to debug notes by var-tracking.c. */
4467 /* Verify a gimple label statement STMT.
4468 Returns true if anything is wrong. */
4471 verify_gimple_label (glabel *stmt)
4473 tree decl = gimple_label_label (stmt);
4477 if (TREE_CODE (decl) != LABEL_DECL)
4479 if (!DECL_NONLOCAL (decl) && !FORCED_LABEL (decl)
4480 && DECL_CONTEXT (decl) != current_function_decl)
4482 error ("label's context is not the current function decl");
4486 uid = LABEL_DECL_UID (decl);
4489 || (*label_to_block_map_for_fn (cfun))[uid] != gimple_bb (stmt)))
4491 error ("incorrect entry in label_to_block_map");
4495 uid = EH_LANDING_PAD_NR (decl);
4498 eh_landing_pad lp = get_eh_landing_pad_from_number (uid);
4499 if (decl != lp->post_landing_pad)
4501 error ("incorrect setting of landing pad number");
4509 /* Verify a gimple cond statement STMT.
4510 Returns true if anything is wrong. */
4513 verify_gimple_cond (gcond *stmt)
4515 if (TREE_CODE_CLASS (gimple_cond_code (stmt)) != tcc_comparison)
4517 error ("invalid comparison code in gimple cond");
4520 if (!(!gimple_cond_true_label (stmt)
4521 || TREE_CODE (gimple_cond_true_label (stmt)) == LABEL_DECL)
4522 || !(!gimple_cond_false_label (stmt)
4523 || TREE_CODE (gimple_cond_false_label (stmt)) == LABEL_DECL))
4525 error ("invalid labels in gimple cond");
4529 return verify_gimple_comparison (boolean_type_node,
4530 gimple_cond_lhs (stmt),
4531 gimple_cond_rhs (stmt));
4534 /* Verify the GIMPLE statement STMT. Returns true if there is an
4535 error, otherwise false. */
4538 verify_gimple_stmt (gimple stmt)
4540 switch (gimple_code (stmt))
4543 return verify_gimple_assign (as_a <gassign *> (stmt));
4546 return verify_gimple_label (as_a <glabel *> (stmt));
4549 return verify_gimple_call (as_a <gcall *> (stmt));
4552 return verify_gimple_cond (as_a <gcond *> (stmt));
4555 return verify_gimple_goto (as_a <ggoto *> (stmt));
4558 return verify_gimple_switch (as_a <gswitch *> (stmt));
4561 return verify_gimple_return (as_a <greturn *> (stmt));
4566 case GIMPLE_TRANSACTION:
4567 return verify_gimple_transaction (as_a <gtransaction *> (stmt));
4569 /* Tuples that do not have tree operands. */
4571 case GIMPLE_PREDICT:
4573 case GIMPLE_EH_DISPATCH:
4574 case GIMPLE_EH_MUST_NOT_THROW:
4578 /* OpenMP directives are validated by the FE and never operated
4579 on by the optimizers. Furthermore, GIMPLE_OMP_FOR may contain
4580 non-gimple expressions when the main index variable has had
4581 its address taken. This does not affect the loop itself
4582 because the header of an GIMPLE_OMP_FOR is merely used to determine
4583 how to setup the parallel iteration. */
4587 return verify_gimple_debug (stmt);
4594 /* Verify the contents of a GIMPLE_PHI. Returns true if there is a problem,
4595 and false otherwise. */
4598 verify_gimple_phi (gimple phi)
4602 tree phi_result = gimple_phi_result (phi);
4607 error ("invalid PHI result");
4611 virtual_p = virtual_operand_p (phi_result);
4612 if (TREE_CODE (phi_result) != SSA_NAME
4614 && SSA_NAME_VAR (phi_result) != gimple_vop (cfun)))
4616 error ("invalid PHI result");
4620 for (i = 0; i < gimple_phi_num_args (phi); i++)
4622 tree t = gimple_phi_arg_def (phi, i);
4626 error ("missing PHI def");
4630 /* Addressable variables do have SSA_NAMEs but they
4631 are not considered gimple values. */
4632 else if ((TREE_CODE (t) == SSA_NAME
4633 && virtual_p != virtual_operand_p (t))
4635 && (TREE_CODE (t) != SSA_NAME
4636 || SSA_NAME_VAR (t) != gimple_vop (cfun)))
4638 && !is_gimple_val (t)))
4640 error ("invalid PHI argument");
4641 debug_generic_expr (t);
4644 #ifdef ENABLE_TYPES_CHECKING
4645 if (!useless_type_conversion_p (TREE_TYPE (phi_result), TREE_TYPE (t)))
4647 error ("incompatible types in PHI argument %u", i);
4648 debug_generic_stmt (TREE_TYPE (phi_result));
4649 debug_generic_stmt (TREE_TYPE (t));
4658 /* Verify the GIMPLE statements inside the sequence STMTS. */
4661 verify_gimple_in_seq_2 (gimple_seq stmts)
4663 gimple_stmt_iterator ittr;
4666 for (ittr = gsi_start (stmts); !gsi_end_p (ittr); gsi_next (&ittr))
4668 gimple stmt = gsi_stmt (ittr);
4670 switch (gimple_code (stmt))
4673 err |= verify_gimple_in_seq_2 (
4674 gimple_bind_body (as_a <gbind *> (stmt)));
4678 err |= verify_gimple_in_seq_2 (gimple_try_eval (stmt));
4679 err |= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt));
4682 case GIMPLE_EH_FILTER:
4683 err |= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt));
4686 case GIMPLE_EH_ELSE:
4688 geh_else *eh_else = as_a <geh_else *> (stmt);
4689 err |= verify_gimple_in_seq_2 (gimple_eh_else_n_body (eh_else));
4690 err |= verify_gimple_in_seq_2 (gimple_eh_else_e_body (eh_else));
4695 err |= verify_gimple_in_seq_2 (gimple_catch_handler (
4696 as_a <gcatch *> (stmt)));
4699 case GIMPLE_TRANSACTION:
4700 err |= verify_gimple_transaction (as_a <gtransaction *> (stmt));
4705 bool err2 = verify_gimple_stmt (stmt);
4707 debug_gimple_stmt (stmt);
4716 /* Verify the contents of a GIMPLE_TRANSACTION. Returns true if there
4717 is a problem, otherwise false. */
4720 verify_gimple_transaction (gtransaction *stmt)
4722 tree lab = gimple_transaction_label (stmt);
4723 if (lab != NULL && TREE_CODE (lab) != LABEL_DECL)
4725 return verify_gimple_in_seq_2 (gimple_transaction_body (stmt));
4729 /* Verify the GIMPLE statements inside the statement list STMTS. */
4732 verify_gimple_in_seq (gimple_seq stmts)
4734 timevar_push (TV_TREE_STMT_VERIFY);
4735 if (verify_gimple_in_seq_2 (stmts))
4736 internal_error ("verify_gimple failed");
4737 timevar_pop (TV_TREE_STMT_VERIFY);
4740 /* Return true when the T can be shared. */
4743 tree_node_can_be_shared (tree t)
4745 if (IS_TYPE_OR_DECL_P (t)
4746 || is_gimple_min_invariant (t)
4747 || TREE_CODE (t) == SSA_NAME
4748 || t == error_mark_node
4749 || TREE_CODE (t) == IDENTIFIER_NODE)
4752 if (TREE_CODE (t) == CASE_LABEL_EXPR)
4761 /* Called via walk_tree. Verify tree sharing. */
4764 verify_node_sharing_1 (tree *tp, int *walk_subtrees, void *data)
4766 hash_set<void *> *visited = (hash_set<void *> *) data;
4768 if (tree_node_can_be_shared (*tp))
4770 *walk_subtrees = false;
4774 if (visited->add (*tp))
4780 /* Called via walk_gimple_stmt. Verify tree sharing. */
4783 verify_node_sharing (tree *tp, int *walk_subtrees, void *data)
4785 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
4786 return verify_node_sharing_1 (tp, walk_subtrees, wi->info);
4789 static bool eh_error_found;
4791 verify_eh_throw_stmt_node (const gimple &stmt, const int &,
4792 hash_set<gimple> *visited)
4794 if (!visited->contains (stmt))
4796 error ("dead STMT in EH table");
4797 debug_gimple_stmt (stmt);
4798 eh_error_found = true;
4803 /* Verify if the location LOCs block is in BLOCKS. */
4806 verify_location (hash_set<tree> *blocks, location_t loc)
4808 tree block = LOCATION_BLOCK (loc);
4809 if (block != NULL_TREE
4810 && !blocks->contains (block))
4812 error ("location references block not in block tree");
4815 if (block != NULL_TREE)
4816 return verify_location (blocks, BLOCK_SOURCE_LOCATION (block));
4820 /* Called via walk_tree. Verify that expressions have no blocks. */
4823 verify_expr_no_block (tree *tp, int *walk_subtrees, void *)
4827 *walk_subtrees = false;
4831 location_t loc = EXPR_LOCATION (*tp);
4832 if (LOCATION_BLOCK (loc) != NULL)
4838 /* Called via walk_tree. Verify locations of expressions. */
4841 verify_expr_location_1 (tree *tp, int *walk_subtrees, void *data)
4843 hash_set<tree> *blocks = (hash_set<tree> *) data;
4845 if (TREE_CODE (*tp) == VAR_DECL
4846 && DECL_HAS_DEBUG_EXPR_P (*tp))
4848 tree t = DECL_DEBUG_EXPR (*tp);
4849 tree addr = walk_tree (&t, verify_expr_no_block, NULL, NULL);
4853 if ((TREE_CODE (*tp) == VAR_DECL
4854 || TREE_CODE (*tp) == PARM_DECL
4855 || TREE_CODE (*tp) == RESULT_DECL)
4856 && DECL_HAS_VALUE_EXPR_P (*tp))
4858 tree t = DECL_VALUE_EXPR (*tp);
4859 tree addr = walk_tree (&t, verify_expr_no_block, NULL, NULL);
4866 *walk_subtrees = false;
4870 location_t loc = EXPR_LOCATION (*tp);
4871 if (verify_location (blocks, loc))
4877 /* Called via walk_gimple_op. Verify locations of expressions. */
4880 verify_expr_location (tree *tp, int *walk_subtrees, void *data)
4882 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
4883 return verify_expr_location_1 (tp, walk_subtrees, wi->info);
4886 /* Insert all subblocks of BLOCK into BLOCKS and recurse. */
4889 collect_subblocks (hash_set<tree> *blocks, tree block)
4892 for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
4895 collect_subblocks (blocks, t);
4899 /* Verify the GIMPLE statements in the CFG of FN. */
4902 verify_gimple_in_cfg (struct function *fn, bool verify_nothrow)
4907 timevar_push (TV_TREE_STMT_VERIFY);
4908 hash_set<void *> visited;
4909 hash_set<gimple> visited_stmts;
4911 /* Collect all BLOCKs referenced by the BLOCK tree of FN. */
4912 hash_set<tree> blocks;
4913 if (DECL_INITIAL (fn->decl))
4915 blocks.add (DECL_INITIAL (fn->decl));
4916 collect_subblocks (&blocks, DECL_INITIAL (fn->decl));
4919 FOR_EACH_BB_FN (bb, fn)
4921 gimple_stmt_iterator gsi;
4923 for (gphi_iterator gpi = gsi_start_phis (bb);
4927 gphi *phi = gpi.phi ();
4931 visited_stmts.add (phi);
4933 if (gimple_bb (phi) != bb)
4935 error ("gimple_bb (phi) is set to a wrong basic block");
4939 err2 |= verify_gimple_phi (phi);
4941 /* Only PHI arguments have locations. */
4942 if (gimple_location (phi) != UNKNOWN_LOCATION)
4944 error ("PHI node with location");
4948 for (i = 0; i < gimple_phi_num_args (phi); i++)
4950 tree arg = gimple_phi_arg_def (phi, i);
4951 tree addr = walk_tree (&arg, verify_node_sharing_1,
4955 error ("incorrect sharing of tree nodes");
4956 debug_generic_expr (addr);
4959 location_t loc = gimple_phi_arg_location (phi, i);
4960 if (virtual_operand_p (gimple_phi_result (phi))
4961 && loc != UNKNOWN_LOCATION)
4963 error ("virtual PHI with argument locations");
4966 addr = walk_tree (&arg, verify_expr_location_1, &blocks, NULL);
4969 debug_generic_expr (addr);
4972 err2 |= verify_location (&blocks, loc);
4976 debug_gimple_stmt (phi);
4980 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
4982 gimple stmt = gsi_stmt (gsi);
4984 struct walk_stmt_info wi;
4988 visited_stmts.add (stmt);
4990 if (gimple_bb (stmt) != bb)
4992 error ("gimple_bb (stmt) is set to a wrong basic block");
4996 err2 |= verify_gimple_stmt (stmt);
4997 err2 |= verify_location (&blocks, gimple_location (stmt));
4999 memset (&wi, 0, sizeof (wi));
5000 wi.info = (void *) &visited;
5001 addr = walk_gimple_op (stmt, verify_node_sharing, &wi);
5004 error ("incorrect sharing of tree nodes");
5005 debug_generic_expr (addr);
5009 memset (&wi, 0, sizeof (wi));
5010 wi.info = (void *) &blocks;
5011 addr = walk_gimple_op (stmt, verify_expr_location, &wi);
5014 debug_generic_expr (addr);
5018 /* ??? Instead of not checking these stmts at all the walker
5019 should know its context via wi. */
5020 if (!is_gimple_debug (stmt)
5021 && !is_gimple_omp (stmt))
5023 memset (&wi, 0, sizeof (wi));
5024 addr = walk_gimple_op (stmt, verify_expr, &wi);
5027 debug_generic_expr (addr);
5028 inform (gimple_location (stmt), "in statement");
5033 /* If the statement is marked as part of an EH region, then it is
5034 expected that the statement could throw. Verify that when we
5035 have optimizations that simplify statements such that we prove
5036 that they cannot throw, that we update other data structures
5038 lp_nr = lookup_stmt_eh_lp (stmt);
5041 if (!stmt_could_throw_p (stmt))
5045 error ("statement marked for throw, but doesn%'t");
5049 else if (!gsi_one_before_end_p (gsi))
5051 error ("statement marked for throw in middle of block");
5057 debug_gimple_stmt (stmt);
5062 eh_error_found = false;
5063 hash_map<gimple, int> *eh_table = get_eh_throw_stmt_table (cfun);
5065 eh_table->traverse<hash_set<gimple> *, verify_eh_throw_stmt_node>
5068 if (err || eh_error_found)
5069 internal_error ("verify_gimple failed");
5071 verify_histograms ();
5072 timevar_pop (TV_TREE_STMT_VERIFY);
5076 /* Verifies that the flow information is OK. */
5079 gimple_verify_flow_info (void)
5083 gimple_stmt_iterator gsi;
5088 if (ENTRY_BLOCK_PTR_FOR_FN (cfun)->il.gimple.seq
5089 || ENTRY_BLOCK_PTR_FOR_FN (cfun)->il.gimple.phi_nodes)
5091 error ("ENTRY_BLOCK has IL associated with it");
5095 if (EXIT_BLOCK_PTR_FOR_FN (cfun)->il.gimple.seq
5096 || EXIT_BLOCK_PTR_FOR_FN (cfun)->il.gimple.phi_nodes)
5098 error ("EXIT_BLOCK has IL associated with it");
5102 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
5103 if (e->flags & EDGE_FALLTHRU)
5105 error ("fallthru to exit from bb %d", e->src->index);
5109 FOR_EACH_BB_FN (bb, cfun)
5111 bool found_ctrl_stmt = false;
5115 /* Skip labels on the start of basic block. */
5116 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
5119 gimple prev_stmt = stmt;
5121 stmt = gsi_stmt (gsi);
5123 if (gimple_code (stmt) != GIMPLE_LABEL)
5126 label = gimple_label_label (as_a <glabel *> (stmt));
5127 if (prev_stmt && DECL_NONLOCAL (label))
5129 error ("nonlocal label ");
5130 print_generic_expr (stderr, label, 0);
5131 fprintf (stderr, " is not first in a sequence of labels in bb %d",
5136 if (prev_stmt && EH_LANDING_PAD_NR (label) != 0)
5138 error ("EH landing pad label ");
5139 print_generic_expr (stderr, label, 0);
5140 fprintf (stderr, " is not first in a sequence of labels in bb %d",
5145 if (label_to_block (label) != bb)
5148 print_generic_expr (stderr, label, 0);
5149 fprintf (stderr, " to block does not match in bb %d",
5154 if (decl_function_context (label) != current_function_decl)
5157 print_generic_expr (stderr, label, 0);
5158 fprintf (stderr, " has incorrect context in bb %d",
5164 /* Verify that body of basic block BB is free of control flow. */
5165 for (; !gsi_end_p (gsi); gsi_next (&gsi))
5167 gimple stmt = gsi_stmt (gsi);
5169 if (found_ctrl_stmt)
5171 error ("control flow in the middle of basic block %d",
5176 if (stmt_ends_bb_p (stmt))
5177 found_ctrl_stmt = true;
5179 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
5182 print_generic_expr (stderr, gimple_label_label (label_stmt), 0);
5183 fprintf (stderr, " in the middle of basic block %d", bb->index);
5188 gsi = gsi_last_bb (bb);
5189 if (gsi_end_p (gsi))
5192 stmt = gsi_stmt (gsi);
5194 if (gimple_code (stmt) == GIMPLE_LABEL)
5197 err |= verify_eh_edges (stmt);
5199 if (is_ctrl_stmt (stmt))
5201 FOR_EACH_EDGE (e, ei, bb->succs)
5202 if (e->flags & EDGE_FALLTHRU)
5204 error ("fallthru edge after a control statement in bb %d",
5210 if (gimple_code (stmt) != GIMPLE_COND)
5212 /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
5213 after anything else but if statement. */
5214 FOR_EACH_EDGE (e, ei, bb->succs)
5215 if (e->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE))
5217 error ("true/false edge after a non-GIMPLE_COND in bb %d",
5223 switch (gimple_code (stmt))
5230 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
5234 || !(true_edge->flags & EDGE_TRUE_VALUE)
5235 || !(false_edge->flags & EDGE_FALSE_VALUE)
5236 || (true_edge->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL))
5237 || (false_edge->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL))
5238 || EDGE_COUNT (bb->succs) >= 3)
5240 error ("wrong outgoing edge flags at end of bb %d",
5248 if (simple_goto_p (stmt))
5250 error ("explicit goto at end of bb %d", bb->index);
5255 /* FIXME. We should double check that the labels in the
5256 destination blocks have their address taken. */
5257 FOR_EACH_EDGE (e, ei, bb->succs)
5258 if ((e->flags & (EDGE_FALLTHRU | EDGE_TRUE_VALUE
5259 | EDGE_FALSE_VALUE))
5260 || !(e->flags & EDGE_ABNORMAL))
5262 error ("wrong outgoing edge flags at end of bb %d",
5270 if (!gimple_call_builtin_p (stmt, BUILT_IN_RETURN))
5272 /* ... fallthru ... */
5274 if (!single_succ_p (bb)
5275 || (single_succ_edge (bb)->flags
5276 & (EDGE_FALLTHRU | EDGE_ABNORMAL
5277 | EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
5279 error ("wrong outgoing edge flags at end of bb %d", bb->index);
5282 if (single_succ (bb) != EXIT_BLOCK_PTR_FOR_FN (cfun))
5284 error ("return edge does not point to exit in bb %d",
5292 gswitch *switch_stmt = as_a <gswitch *> (stmt);
5297 n = gimple_switch_num_labels (switch_stmt);
5299 /* Mark all the destination basic blocks. */
5300 for (i = 0; i < n; ++i)
5302 tree lab = CASE_LABEL (gimple_switch_label (switch_stmt, i));
5303 basic_block label_bb = label_to_block (lab);
5304 gcc_assert (!label_bb->aux || label_bb->aux == (void *)1);
5305 label_bb->aux = (void *)1;
5308 /* Verify that the case labels are sorted. */
5309 prev = gimple_switch_label (switch_stmt, 0);
5310 for (i = 1; i < n; ++i)
5312 tree c = gimple_switch_label (switch_stmt, i);
5315 error ("found default case not at the start of "
5321 && !tree_int_cst_lt (CASE_LOW (prev), CASE_LOW (c)))
5323 error ("case labels not sorted: ");
5324 print_generic_expr (stderr, prev, 0);
5325 fprintf (stderr," is greater than ");
5326 print_generic_expr (stderr, c, 0);
5327 fprintf (stderr," but comes before it.\n");
5332 /* VRP will remove the default case if it can prove it will
5333 never be executed. So do not verify there always exists
5334 a default case here. */
5336 FOR_EACH_EDGE (e, ei, bb->succs)
5340 error ("extra outgoing edge %d->%d",
5341 bb->index, e->dest->index);
5345 e->dest->aux = (void *)2;
5346 if ((e->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL
5347 | EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
5349 error ("wrong outgoing edge flags at end of bb %d",
5355 /* Check that we have all of them. */
5356 for (i = 0; i < n; ++i)
5358 tree lab = CASE_LABEL (gimple_switch_label (switch_stmt, i));
5359 basic_block label_bb = label_to_block (lab);
5361 if (label_bb->aux != (void *)2)
5363 error ("missing edge %i->%i", bb->index, label_bb->index);
5368 FOR_EACH_EDGE (e, ei, bb->succs)
5369 e->dest->aux = (void *)0;
5373 case GIMPLE_EH_DISPATCH:
5374 err |= verify_eh_dispatch_edge (as_a <geh_dispatch *> (stmt));
5382 if (dom_info_state (CDI_DOMINATORS) >= DOM_NO_FAST_QUERY)
5383 verify_dominators (CDI_DOMINATORS);
5389 /* Updates phi nodes after creating a forwarder block joined
5390 by edge FALLTHRU. */
5393 gimple_make_forwarder_block (edge fallthru)
5397 basic_block dummy, bb;
5401 dummy = fallthru->src;
5402 bb = fallthru->dest;
5404 if (single_pred_p (bb))
5407 /* If we redirected a branch we must create new PHI nodes at the
5409 for (gsi = gsi_start_phis (dummy); !gsi_end_p (gsi); gsi_next (&gsi))
5411 gphi *phi, *new_phi;
5414 var = gimple_phi_result (phi);
5415 new_phi = create_phi_node (var, bb);
5416 gimple_phi_set_result (phi, copy_ssa_name (var, phi));
5417 add_phi_arg (new_phi, gimple_phi_result (phi), fallthru,
5421 /* Add the arguments we have stored on edges. */
5422 FOR_EACH_EDGE (e, ei, bb->preds)
5427 flush_pending_stmts (e);
5432 /* Return a non-special label in the head of basic block BLOCK.
5433 Create one if it doesn't exist. */
5436 gimple_block_label (basic_block bb)
5438 gimple_stmt_iterator i, s = gsi_start_bb (bb);
5443 for (i = s; !gsi_end_p (i); first = false, gsi_next (&i))
5445 stmt = dyn_cast <glabel *> (gsi_stmt (i));
5448 label = gimple_label_label (stmt);
5449 if (!DECL_NONLOCAL (label))
5452 gsi_move_before (&i, &s);
5457 label = create_artificial_label (UNKNOWN_LOCATION);
5458 stmt = gimple_build_label (label);
5459 gsi_insert_before (&s, stmt, GSI_NEW_STMT);
5464 /* Attempt to perform edge redirection by replacing a possibly complex
5465 jump instruction by a goto or by removing the jump completely.
5466 This can apply only if all edges now point to the same block. The
5467 parameters and return values are equivalent to
5468 redirect_edge_and_branch. */
5471 gimple_try_redirect_by_replacing_jump (edge e, basic_block target)
5473 basic_block src = e->src;
5474 gimple_stmt_iterator i;
5477 /* We can replace or remove a complex jump only when we have exactly
5479 if (EDGE_COUNT (src->succs) != 2
5480 /* Verify that all targets will be TARGET. Specifically, the
5481 edge that is not E must also go to TARGET. */
5482 || EDGE_SUCC (src, EDGE_SUCC (src, 0) == e)->dest != target)
5485 i = gsi_last_bb (src);
5489 stmt = gsi_stmt (i);
5491 if (gimple_code (stmt) == GIMPLE_COND || gimple_code (stmt) == GIMPLE_SWITCH)
5493 gsi_remove (&i, true);
5494 e = ssa_redirect_edge (e, target);
5495 e->flags = EDGE_FALLTHRU;
5503 /* Redirect E to DEST. Return NULL on failure. Otherwise, return the
5504 edge representing the redirected branch. */
5507 gimple_redirect_edge_and_branch (edge e, basic_block dest)
5509 basic_block bb = e->src;
5510 gimple_stmt_iterator gsi;
5514 if (e->flags & EDGE_ABNORMAL)
5517 if (e->dest == dest)
5520 if (e->flags & EDGE_EH)
5521 return redirect_eh_edge (e, dest);
5523 if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun))
5525 ret = gimple_try_redirect_by_replacing_jump (e, dest);
5530 gsi = gsi_last_bb (bb);
5531 stmt = gsi_end_p (gsi) ? NULL : gsi_stmt (gsi);
5533 switch (stmt ? gimple_code (stmt) : GIMPLE_ERROR_MARK)
5536 /* For COND_EXPR, we only need to redirect the edge. */
5540 /* No non-abnormal edges should lead from a non-simple goto, and
5541 simple ones should be represented implicitly. */
5546 gswitch *switch_stmt = as_a <gswitch *> (stmt);
5547 tree label = gimple_block_label (dest);
5548 tree cases = get_cases_for_edge (e, switch_stmt);
5550 /* If we have a list of cases associated with E, then use it
5551 as it's a lot faster than walking the entire case vector. */
5554 edge e2 = find_edge (e->src, dest);
5561 CASE_LABEL (cases) = label;
5562 cases = CASE_CHAIN (cases);
5565 /* If there was already an edge in the CFG, then we need
5566 to move all the cases associated with E to E2. */
5569 tree cases2 = get_cases_for_edge (e2, switch_stmt);
5571 CASE_CHAIN (last) = CASE_CHAIN (cases2);
5572 CASE_CHAIN (cases2) = first;
5574 bitmap_set_bit (touched_switch_bbs, gimple_bb (stmt)->index);
5578 size_t i, n = gimple_switch_num_labels (switch_stmt);
5580 for (i = 0; i < n; i++)
5582 tree elt = gimple_switch_label (switch_stmt, i);
5583 if (label_to_block (CASE_LABEL (elt)) == e->dest)
5584 CASE_LABEL (elt) = label;
5592 gasm *asm_stmt = as_a <gasm *> (stmt);
5593 int i, n = gimple_asm_nlabels (asm_stmt);
5596 for (i = 0; i < n; ++i)
5598 tree cons = gimple_asm_label_op (asm_stmt, i);
5599 if (label_to_block (TREE_VALUE (cons)) == e->dest)
5602 label = gimple_block_label (dest);
5603 TREE_VALUE (cons) = label;
5607 /* If we didn't find any label matching the former edge in the
5608 asm labels, we must be redirecting the fallthrough
5610 gcc_assert (label || (e->flags & EDGE_FALLTHRU));
5615 gsi_remove (&gsi, true);
5616 e->flags |= EDGE_FALLTHRU;
5619 case GIMPLE_OMP_RETURN:
5620 case GIMPLE_OMP_CONTINUE:
5621 case GIMPLE_OMP_SECTIONS_SWITCH:
5622 case GIMPLE_OMP_FOR:
5623 /* The edges from OMP constructs can be simply redirected. */
5626 case GIMPLE_EH_DISPATCH:
5627 if (!(e->flags & EDGE_FALLTHRU))
5628 redirect_eh_dispatch_edge (as_a <geh_dispatch *> (stmt), e, dest);
5631 case GIMPLE_TRANSACTION:
5632 /* The ABORT edge has a stored label associated with it, otherwise
5633 the edges are simply redirectable. */
5635 gimple_transaction_set_label (as_a <gtransaction *> (stmt),
5636 gimple_block_label (dest));
5640 /* Otherwise it must be a fallthru edge, and we don't need to
5641 do anything besides redirecting it. */
5642 gcc_assert (e->flags & EDGE_FALLTHRU);
5646 /* Update/insert PHI nodes as necessary. */
5648 /* Now update the edges in the CFG. */
5649 e = ssa_redirect_edge (e, dest);
5654 /* Returns true if it is possible to remove edge E by redirecting
5655 it to the destination of the other edge from E->src. */
5658 gimple_can_remove_branch_p (const_edge e)
5660 if (e->flags & (EDGE_ABNORMAL | EDGE_EH))
5666 /* Simple wrapper, as we can always redirect fallthru edges. */
5669 gimple_redirect_edge_and_branch_force (edge e, basic_block dest)
5671 e = gimple_redirect_edge_and_branch (e, dest);
5678 /* Splits basic block BB after statement STMT (but at least after the
5679 labels). If STMT is NULL, BB is split just after the labels. */
5682 gimple_split_block (basic_block bb, void *stmt)
5684 gimple_stmt_iterator gsi;
5685 gimple_stmt_iterator gsi_tgt;
5691 new_bb = create_empty_bb (bb);
5693 /* Redirect the outgoing edges. */
5694 new_bb->succs = bb->succs;
5696 FOR_EACH_EDGE (e, ei, new_bb->succs)
5699 /* Get a stmt iterator pointing to the first stmt to move. */
5700 if (!stmt || gimple_code ((gimple) stmt) == GIMPLE_LABEL)
5701 gsi = gsi_after_labels (bb);
5704 gsi = gsi_for_stmt ((gimple) stmt);
5708 /* Move everything from GSI to the new basic block. */
5709 if (gsi_end_p (gsi))
5712 /* Split the statement list - avoid re-creating new containers as this
5713 brings ugly quadratic memory consumption in the inliner.
5714 (We are still quadratic since we need to update stmt BB pointers,
5716 gsi_split_seq_before (&gsi, &list);
5717 set_bb_seq (new_bb, list);
5718 for (gsi_tgt = gsi_start (list);
5719 !gsi_end_p (gsi_tgt); gsi_next (&gsi_tgt))
5720 gimple_set_bb (gsi_stmt (gsi_tgt), new_bb);
5726 /* Moves basic block BB after block AFTER. */
5729 gimple_move_block_after (basic_block bb, basic_block after)
5731 if (bb->prev_bb == after)
5735 link_block (bb, after);
5741 /* Return TRUE if block BB has no executable statements, otherwise return
5745 gimple_empty_block_p (basic_block bb)
5747 /* BB must have no executable statements. */
5748 gimple_stmt_iterator gsi = gsi_after_labels (bb);
5751 if (gsi_end_p (gsi))
5753 if (is_gimple_debug (gsi_stmt (gsi)))
5754 gsi_next_nondebug (&gsi);
5755 return gsi_end_p (gsi);
5759 /* Split a basic block if it ends with a conditional branch and if the
5760 other part of the block is not empty. */
5763 gimple_split_block_before_cond_jump (basic_block bb)
5765 gimple last, split_point;
5766 gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
5767 if (gsi_end_p (gsi))
5769 last = gsi_stmt (gsi);
5770 if (gimple_code (last) != GIMPLE_COND
5771 && gimple_code (last) != GIMPLE_SWITCH)
5773 gsi_prev_nondebug (&gsi);
5774 split_point = gsi_stmt (gsi);
5775 return split_block (bb, split_point)->dest;
5779 /* Return true if basic_block can be duplicated. */
5782 gimple_can_duplicate_bb_p (const_basic_block bb ATTRIBUTE_UNUSED)
5787 /* Create a duplicate of the basic block BB. NOTE: This does not
5788 preserve SSA form. */
5791 gimple_duplicate_bb (basic_block bb)
5794 gimple_stmt_iterator gsi_tgt;
5796 new_bb = create_empty_bb (EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb);
5798 /* Copy the PHI nodes. We ignore PHI node arguments here because
5799 the incoming edges have not been setup yet. */
5800 for (gphi_iterator gpi = gsi_start_phis (bb);
5806 copy = create_phi_node (NULL_TREE, new_bb);
5807 create_new_def_for (gimple_phi_result (phi), copy,
5808 gimple_phi_result_ptr (copy));
5809 gimple_set_uid (copy, gimple_uid (phi));
5812 gsi_tgt = gsi_start_bb (new_bb);
5813 for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
5817 def_operand_p def_p;
5818 ssa_op_iter op_iter;
5822 stmt = gsi_stmt (gsi);
5823 if (gimple_code (stmt) == GIMPLE_LABEL)
5826 /* Don't duplicate label debug stmts. */
5827 if (gimple_debug_bind_p (stmt)
5828 && TREE_CODE (gimple_debug_bind_get_var (stmt))
5832 /* Create a new copy of STMT and duplicate STMT's virtual
5834 copy = gimple_copy (stmt);
5835 gsi_insert_after (&gsi_tgt, copy, GSI_NEW_STMT);
5837 maybe_duplicate_eh_stmt (copy, stmt);
5838 gimple_duplicate_stmt_histograms (cfun, copy, cfun, stmt);
5840 /* When copying around a stmt writing into a local non-user
5841 aggregate, make sure it won't share stack slot with other
5843 lhs = gimple_get_lhs (stmt);
5844 if (lhs && TREE_CODE (lhs) != SSA_NAME)
5846 tree base = get_base_address (lhs);
5848 && (TREE_CODE (base) == VAR_DECL
5849 || TREE_CODE (base) == RESULT_DECL)
5850 && DECL_IGNORED_P (base)
5851 && !TREE_STATIC (base)
5852 && !DECL_EXTERNAL (base)
5853 && (TREE_CODE (base) != VAR_DECL
5854 || !DECL_HAS_VALUE_EXPR_P (base)))
5855 DECL_NONSHAREABLE (base) = 1;
5858 /* Create new names for all the definitions created by COPY and
5859 add replacement mappings for each new name. */
5860 FOR_EACH_SSA_DEF_OPERAND (def_p, copy, op_iter, SSA_OP_ALL_DEFS)
5861 create_new_def_for (DEF_FROM_PTR (def_p), copy, def_p);
5867 /* Adds phi node arguments for edge E_COPY after basic block duplication. */
5870 add_phi_args_after_copy_edge (edge e_copy)
5872 basic_block bb, bb_copy = e_copy->src, dest;
5875 gphi *phi, *phi_copy;
5877 gphi_iterator psi, psi_copy;
5879 if (gimple_seq_empty_p (phi_nodes (e_copy->dest)))
5882 bb = bb_copy->flags & BB_DUPLICATED ? get_bb_original (bb_copy) : bb_copy;
5884 if (e_copy->dest->flags & BB_DUPLICATED)
5885 dest = get_bb_original (e_copy->dest);
5887 dest = e_copy->dest;
5889 e = find_edge (bb, dest);
5892 /* During loop unrolling the target of the latch edge is copied.
5893 In this case we are not looking for edge to dest, but to
5894 duplicated block whose original was dest. */
5895 FOR_EACH_EDGE (e, ei, bb->succs)
5897 if ((e->dest->flags & BB_DUPLICATED)
5898 && get_bb_original (e->dest) == dest)
5902 gcc_assert (e != NULL);
5905 for (psi = gsi_start_phis (e->dest),
5906 psi_copy = gsi_start_phis (e_copy->dest);
5908 gsi_next (&psi), gsi_next (&psi_copy))
5911 phi_copy = psi_copy.phi ();
5912 def = PHI_ARG_DEF_FROM_EDGE (phi, e);
5913 add_phi_arg (phi_copy, def, e_copy,
5914 gimple_phi_arg_location_from_edge (phi, e));
5919 /* Basic block BB_COPY was created by code duplication. Add phi node
5920 arguments for edges going out of BB_COPY. The blocks that were
5921 duplicated have BB_DUPLICATED set. */
5924 add_phi_args_after_copy_bb (basic_block bb_copy)
5929 FOR_EACH_EDGE (e_copy, ei, bb_copy->succs)
5931 add_phi_args_after_copy_edge (e_copy);
5935 /* Blocks in REGION_COPY array of length N_REGION were created by
5936 duplication of basic blocks. Add phi node arguments for edges
5937 going from these blocks. If E_COPY is not NULL, also add
5938 phi node arguments for its destination.*/
5941 add_phi_args_after_copy (basic_block *region_copy, unsigned n_region,
5946 for (i = 0; i < n_region; i++)
5947 region_copy[i]->flags |= BB_DUPLICATED;
5949 for (i = 0; i < n_region; i++)
5950 add_phi_args_after_copy_bb (region_copy[i]);
5952 add_phi_args_after_copy_edge (e_copy);
5954 for (i = 0; i < n_region; i++)
5955 region_copy[i]->flags &= ~BB_DUPLICATED;
5958 /* Duplicates a REGION (set of N_REGION basic blocks) with just a single
5959 important exit edge EXIT. By important we mean that no SSA name defined
5960 inside region is live over the other exit edges of the region. All entry
5961 edges to the region must go to ENTRY->dest. The edge ENTRY is redirected
5962 to the duplicate of the region. Dominance and loop information is
5963 updated if UPDATE_DOMINANCE is true, but not the SSA web. If
5964 UPDATE_DOMINANCE is false then we assume that the caller will update the
5965 dominance information after calling this function. The new basic
5966 blocks are stored to REGION_COPY in the same order as they had in REGION,
5967 provided that REGION_COPY is not NULL.
5968 The function returns false if it is unable to copy the region,
5972 gimple_duplicate_sese_region (edge entry, edge exit,
5973 basic_block *region, unsigned n_region,
5974 basic_block *region_copy,
5975 bool update_dominance)
5978 bool free_region_copy = false, copying_header = false;
5979 struct loop *loop = entry->dest->loop_father;
5981 vec<basic_block> doms;
5983 int total_freq = 0, entry_freq = 0;
5984 gcov_type total_count = 0, entry_count = 0;
5986 if (!can_copy_bbs_p (region, n_region))
5989 /* Some sanity checking. Note that we do not check for all possible
5990 missuses of the functions. I.e. if you ask to copy something weird,
5991 it will work, but the state of structures probably will not be
5993 for (i = 0; i < n_region; i++)
5995 /* We do not handle subloops, i.e. all the blocks must belong to the
5997 if (region[i]->loop_father != loop)
6000 if (region[i] != entry->dest
6001 && region[i] == loop->header)
6005 /* In case the function is used for loop header copying (which is the primary
6006 use), ensure that EXIT and its copy will be new latch and entry edges. */
6007 if (loop->header == entry->dest)
6009 copying_header = true;
6011 if (!dominated_by_p (CDI_DOMINATORS, loop->latch, exit->src))
6014 for (i = 0; i < n_region; i++)
6015 if (region[i] != exit->src
6016 && dominated_by_p (CDI_DOMINATORS, region[i], exit->src))
6020 initialize_original_copy_tables ();
6023 set_loop_copy (loop, loop_outer (loop));
6025 set_loop_copy (loop, loop);
6029 region_copy = XNEWVEC (basic_block, n_region);
6030 free_region_copy = true;
6033 /* Record blocks outside the region that are dominated by something
6035 if (update_dominance)
6038 doms = get_dominated_by_region (CDI_DOMINATORS, region, n_region);
6041 if (entry->dest->count)
6043 total_count = entry->dest->count;
6044 entry_count = entry->count;
6045 /* Fix up corner cases, to avoid division by zero or creation of negative
6047 if (entry_count > total_count)
6048 entry_count = total_count;
6052 total_freq = entry->dest->frequency;
6053 entry_freq = EDGE_FREQUENCY (entry);
6054 /* Fix up corner cases, to avoid division by zero or creation of negative
6056 if (total_freq == 0)
6058 else if (entry_freq > total_freq)
6059 entry_freq = total_freq;
6062 copy_bbs (region, n_region, region_copy, &exit, 1, &exit_copy, loop,
6063 split_edge_bb_loc (entry), update_dominance);
6066 scale_bbs_frequencies_gcov_type (region, n_region,
6067 total_count - entry_count,
6069 scale_bbs_frequencies_gcov_type (region_copy, n_region, entry_count,
6074 scale_bbs_frequencies_int (region, n_region, total_freq - entry_freq,
6076 scale_bbs_frequencies_int (region_copy, n_region, entry_freq, total_freq);
6081 loop->header = exit->dest;
6082 loop->latch = exit->src;
6085 /* Redirect the entry and add the phi node arguments. */
6086 redirected = redirect_edge_and_branch (entry, get_bb_copy (entry->dest));
6087 gcc_assert (redirected != NULL);
6088 flush_pending_stmts (entry);
6090 /* Concerning updating of dominators: We must recount dominators
6091 for entry block and its copy. Anything that is outside of the
6092 region, but was dominated by something inside needs recounting as
6094 if (update_dominance)
6096 set_immediate_dominator (CDI_DOMINATORS, entry->dest, entry->src);
6097 doms.safe_push (get_bb_original (entry->dest));
6098 iterate_fix_dominators (CDI_DOMINATORS, doms, false);
6102 /* Add the other PHI node arguments. */
6103 add_phi_args_after_copy (region_copy, n_region, NULL);
6105 if (free_region_copy)
6108 free_original_copy_tables ();
6112 /* Checks if BB is part of the region defined by N_REGION BBS. */
6114 bb_part_of_region_p (basic_block bb, basic_block* bbs, unsigned n_region)
6118 for (n = 0; n < n_region; n++)
6126 /* Duplicates REGION consisting of N_REGION blocks. The new blocks
6127 are stored to REGION_COPY in the same order in that they appear
6128 in REGION, if REGION_COPY is not NULL. ENTRY is the entry to
6129 the region, EXIT an exit from it. The condition guarding EXIT
6130 is moved to ENTRY. Returns true if duplication succeeds, false
6156 gimple_duplicate_sese_tail (edge entry ATTRIBUTE_UNUSED, edge exit ATTRIBUTE_UNUSED,
6157 basic_block *region ATTRIBUTE_UNUSED, unsigned n_region ATTRIBUTE_UNUSED,
6158 basic_block *region_copy ATTRIBUTE_UNUSED)
6161 bool free_region_copy = false;
6162 struct loop *loop = exit->dest->loop_father;
6163 struct loop *orig_loop = entry->dest->loop_father;
6164 basic_block switch_bb, entry_bb, nentry_bb;
6165 vec<basic_block> doms;
6166 int total_freq = 0, exit_freq = 0;
6167 gcov_type total_count = 0, exit_count = 0;
6168 edge exits[2], nexits[2], e;
6169 gimple_stmt_iterator gsi;
6172 basic_block exit_bb;
6176 struct loop *target, *aloop, *cloop;
6178 gcc_assert (EDGE_COUNT (exit->src->succs) == 2);
6180 exits[1] = EDGE_SUCC (exit->src, EDGE_SUCC (exit->src, 0) == exit);
6182 if (!can_copy_bbs_p (region, n_region))
6185 initialize_original_copy_tables ();
6186 set_loop_copy (orig_loop, loop);
6189 for (aloop = orig_loop->inner; aloop; aloop = aloop->next)
6191 if (bb_part_of_region_p (aloop->header, region, n_region))
6193 cloop = duplicate_loop (aloop, target);
6194 duplicate_subloops (aloop, cloop);
6200 region_copy = XNEWVEC (basic_block, n_region);
6201 free_region_copy = true;
6204 gcc_assert (!need_ssa_update_p (cfun));
6206 /* Record blocks outside the region that are dominated by something
6208 doms = get_dominated_by_region (CDI_DOMINATORS, region, n_region);
6210 if (exit->src->count)
6212 total_count = exit->src->count;
6213 exit_count = exit->count;
6214 /* Fix up corner cases, to avoid division by zero or creation of negative
6216 if (exit_count > total_count)
6217 exit_count = total_count;
6221 total_freq = exit->src->frequency;
6222 exit_freq = EDGE_FREQUENCY (exit);
6223 /* Fix up corner cases, to avoid division by zero or creation of negative
6225 if (total_freq == 0)
6227 if (exit_freq > total_freq)
6228 exit_freq = total_freq;
6231 copy_bbs (region, n_region, region_copy, exits, 2, nexits, orig_loop,
6232 split_edge_bb_loc (exit), true);
6235 scale_bbs_frequencies_gcov_type (region, n_region,
6236 total_count - exit_count,
6238 scale_bbs_frequencies_gcov_type (region_copy, n_region, exit_count,
6243 scale_bbs_frequencies_int (region, n_region, total_freq - exit_freq,
6245 scale_bbs_frequencies_int (region_copy, n_region, exit_freq, total_freq);
6248 /* Create the switch block, and put the exit condition to it. */
6249 entry_bb = entry->dest;
6250 nentry_bb = get_bb_copy (entry_bb);
6251 if (!last_stmt (entry->src)
6252 || !stmt_ends_bb_p (last_stmt (entry->src)))
6253 switch_bb = entry->src;
6255 switch_bb = split_edge (entry);
6256 set_immediate_dominator (CDI_DOMINATORS, nentry_bb, switch_bb);
6258 gsi = gsi_last_bb (switch_bb);
6259 cond_stmt = last_stmt (exit->src);
6260 gcc_assert (gimple_code (cond_stmt) == GIMPLE_COND);
6261 cond_stmt = gimple_copy (cond_stmt);
6263 gsi_insert_after (&gsi, cond_stmt, GSI_NEW_STMT);
6265 sorig = single_succ_edge (switch_bb);
6266 sorig->flags = exits[1]->flags;
6267 snew = make_edge (switch_bb, nentry_bb, exits[0]->flags);
6269 /* Register the new edge from SWITCH_BB in loop exit lists. */
6270 rescan_loop_exit (snew, true, false);
6272 /* Add the PHI node arguments. */
6273 add_phi_args_after_copy (region_copy, n_region, snew);
6275 /* Get rid of now superfluous conditions and associated edges (and phi node
6277 exit_bb = exit->dest;
6279 e = redirect_edge_and_branch (exits[0], exits[1]->dest);
6280 PENDING_STMT (e) = NULL;
6282 /* The latch of ORIG_LOOP was copied, and so was the backedge
6283 to the original header. We redirect this backedge to EXIT_BB. */
6284 for (i = 0; i < n_region; i++)
6285 if (get_bb_original (region_copy[i]) == orig_loop->latch)
6287 gcc_assert (single_succ_edge (region_copy[i]));
6288 e = redirect_edge_and_branch (single_succ_edge (region_copy[i]), exit_bb);
6289 PENDING_STMT (e) = NULL;
6290 for (psi = gsi_start_phis (exit_bb);
6295 def = PHI_ARG_DEF (phi, nexits[0]->dest_idx);
6296 add_phi_arg (phi, def, e, gimple_phi_arg_location_from_edge (phi, e));
6299 e = redirect_edge_and_branch (nexits[1], nexits[0]->dest);
6300 PENDING_STMT (e) = NULL;
6302 /* Anything that is outside of the region, but was dominated by something
6303 inside needs to update dominance info. */
6304 iterate_fix_dominators (CDI_DOMINATORS, doms, false);
6306 /* Update the SSA web. */
6307 update_ssa (TODO_update_ssa);
6309 if (free_region_copy)
6312 free_original_copy_tables ();
6316 /* Add all the blocks dominated by ENTRY to the array BBS_P. Stop
6317 adding blocks when the dominator traversal reaches EXIT. This
6318 function silently assumes that ENTRY strictly dominates EXIT. */
6321 gather_blocks_in_sese_region (basic_block entry, basic_block exit,
6322 vec<basic_block> *bbs_p)
6326 for (son = first_dom_son (CDI_DOMINATORS, entry);
6328 son = next_dom_son (CDI_DOMINATORS, son))
6330 bbs_p->safe_push (son);
6332 gather_blocks_in_sese_region (son, exit, bbs_p);
6336 /* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
6337 The duplicates are recorded in VARS_MAP. */
6340 replace_by_duplicate_decl (tree *tp, hash_map<tree, tree> *vars_map,
6343 tree t = *tp, new_t;
6344 struct function *f = DECL_STRUCT_FUNCTION (to_context);
6346 if (DECL_CONTEXT (t) == to_context)
6350 tree &loc = vars_map->get_or_insert (t, &existed);
6356 new_t = copy_var_decl (t, DECL_NAME (t), TREE_TYPE (t));
6357 add_local_decl (f, new_t);
6361 gcc_assert (TREE_CODE (t) == CONST_DECL);
6362 new_t = copy_node (t);
6364 DECL_CONTEXT (new_t) = to_context;
6375 /* Creates an ssa name in TO_CONTEXT equivalent to NAME.
6376 VARS_MAP maps old ssa names and var_decls to the new ones. */
6379 replace_ssa_name (tree name, hash_map<tree, tree> *vars_map,
6384 gcc_assert (!virtual_operand_p (name));
6386 tree *loc = vars_map->get (name);
6390 tree decl = SSA_NAME_VAR (name);
6393 replace_by_duplicate_decl (&decl, vars_map, to_context);
6394 new_name = make_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context),
6395 decl, SSA_NAME_DEF_STMT (name));
6396 if (SSA_NAME_IS_DEFAULT_DEF (name))
6397 set_ssa_default_def (DECL_STRUCT_FUNCTION (to_context),
6401 new_name = copy_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context),
6402 name, SSA_NAME_DEF_STMT (name));
6404 vars_map->put (name, new_name);
6418 hash_map<tree, tree> *vars_map;
6419 htab_t new_label_map;
6420 hash_map<void *, void *> *eh_map;
6424 /* Helper for move_block_to_fn. Set TREE_BLOCK in every expression
6425 contained in *TP if it has been ORIG_BLOCK previously and change the
6426 DECL_CONTEXT of every local variable referenced in *TP. */
6429 move_stmt_op (tree *tp, int *walk_subtrees, void *data)
6431 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
6432 struct move_stmt_d *p = (struct move_stmt_d *) wi->info;
6437 tree block = TREE_BLOCK (t);
6438 if (block == p->orig_block
6439 || (p->orig_block == NULL_TREE
6440 && block != NULL_TREE))
6441 TREE_SET_BLOCK (t, p->new_block);
6442 #ifdef ENABLE_CHECKING
6443 else if (block != NULL_TREE)
6445 while (block && TREE_CODE (block) == BLOCK && block != p->orig_block)
6446 block = BLOCK_SUPERCONTEXT (block);
6447 gcc_assert (block == p->orig_block);
6451 else if (DECL_P (t) || TREE_CODE (t) == SSA_NAME)
6453 if (TREE_CODE (t) == SSA_NAME)
6454 *tp = replace_ssa_name (t, p->vars_map, p->to_context);
6455 else if (TREE_CODE (t) == LABEL_DECL)
6457 if (p->new_label_map)
6459 struct tree_map in, *out;
6461 out = (struct tree_map *)
6462 htab_find_with_hash (p->new_label_map, &in, DECL_UID (t));
6467 DECL_CONTEXT (t) = p->to_context;
6469 else if (p->remap_decls_p)
6471 /* Replace T with its duplicate. T should no longer appear in the
6472 parent function, so this looks wasteful; however, it may appear
6473 in referenced_vars, and more importantly, as virtual operands of
6474 statements, and in alias lists of other variables. It would be
6475 quite difficult to expunge it from all those places. ??? It might
6476 suffice to do this for addressable variables. */
6477 if ((TREE_CODE (t) == VAR_DECL
6478 && !is_global_var (t))
6479 || TREE_CODE (t) == CONST_DECL)
6480 replace_by_duplicate_decl (tp, p->vars_map, p->to_context);
6484 else if (TYPE_P (t))
6490 /* Helper for move_stmt_r. Given an EH region number for the source
6491 function, map that to the duplicate EH regio number in the dest. */
6494 move_stmt_eh_region_nr (int old_nr, struct move_stmt_d *p)
6496 eh_region old_r, new_r;
6498 old_r = get_eh_region_from_number (old_nr);
6499 new_r = static_cast<eh_region> (*p->eh_map->get (old_r));
6501 return new_r->index;
6504 /* Similar, but operate on INTEGER_CSTs. */
6507 move_stmt_eh_region_tree_nr (tree old_t_nr, struct move_stmt_d *p)
6511 old_nr = tree_to_shwi (old_t_nr);
6512 new_nr = move_stmt_eh_region_nr (old_nr, p);
6514 return build_int_cst (integer_type_node, new_nr);
6517 /* Like move_stmt_op, but for gimple statements.
6519 Helper for move_block_to_fn. Set GIMPLE_BLOCK in every expression
6520 contained in the current statement in *GSI_P and change the
6521 DECL_CONTEXT of every local variable referenced in the current
6525 move_stmt_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
6526 struct walk_stmt_info *wi)
6528 struct move_stmt_d *p = (struct move_stmt_d *) wi->info;
6529 gimple stmt = gsi_stmt (*gsi_p);
6530 tree block = gimple_block (stmt);
6532 if (block == p->orig_block
6533 || (p->orig_block == NULL_TREE
6534 && block != NULL_TREE))
6535 gimple_set_block (stmt, p->new_block);
6537 switch (gimple_code (stmt))
6540 /* Remap the region numbers for __builtin_eh_{pointer,filter}. */
6542 tree r, fndecl = gimple_call_fndecl (stmt);
6543 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
6544 switch (DECL_FUNCTION_CODE (fndecl))
6546 case BUILT_IN_EH_COPY_VALUES:
6547 r = gimple_call_arg (stmt, 1);
6548 r = move_stmt_eh_region_tree_nr (r, p);
6549 gimple_call_set_arg (stmt, 1, r);
6552 case BUILT_IN_EH_POINTER:
6553 case BUILT_IN_EH_FILTER:
6554 r = gimple_call_arg (stmt, 0);
6555 r = move_stmt_eh_region_tree_nr (r, p);
6556 gimple_call_set_arg (stmt, 0, r);
6567 gresx *resx_stmt = as_a <gresx *> (stmt);
6568 int r = gimple_resx_region (resx_stmt);
6569 r = move_stmt_eh_region_nr (r, p);
6570 gimple_resx_set_region (resx_stmt, r);
6574 case GIMPLE_EH_DISPATCH:
6576 geh_dispatch *eh_dispatch_stmt = as_a <geh_dispatch *> (stmt);
6577 int r = gimple_eh_dispatch_region (eh_dispatch_stmt);
6578 r = move_stmt_eh_region_nr (r, p);
6579 gimple_eh_dispatch_set_region (eh_dispatch_stmt, r);
6583 case GIMPLE_OMP_RETURN:
6584 case GIMPLE_OMP_CONTINUE:
6587 if (is_gimple_omp (stmt))
6589 /* Do not remap variables inside OMP directives. Variables
6590 referenced in clauses and directive header belong to the
6591 parent function and should not be moved into the child
6593 bool save_remap_decls_p = p->remap_decls_p;
6594 p->remap_decls_p = false;
6595 *handled_ops_p = true;
6597 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt), move_stmt_r,
6600 p->remap_decls_p = save_remap_decls_p;
6608 /* Move basic block BB from function CFUN to function DEST_FN. The
6609 block is moved out of the original linked list and placed after
6610 block AFTER in the new list. Also, the block is removed from the
6611 original array of blocks and placed in DEST_FN's array of blocks.
6612 If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
6613 updated to reflect the moved edges.
6615 The local variables are remapped to new instances, VARS_MAP is used
6616 to record the mapping. */
6619 move_block_to_fn (struct function *dest_cfun, basic_block bb,
6620 basic_block after, bool update_edge_count_p,
6621 struct move_stmt_d *d)
6623 struct control_flow_graph *cfg;
6626 gimple_stmt_iterator si;
6627 unsigned old_len, new_len;
6629 /* Remove BB from dominance structures. */
6630 delete_from_dominance_info (CDI_DOMINATORS, bb);
6632 /* Move BB from its current loop to the copy in the new function. */
6635 struct loop *new_loop = (struct loop *)bb->loop_father->aux;
6637 bb->loop_father = new_loop;
6640 /* Link BB to the new linked list. */
6641 move_block_after (bb, after);
6643 /* Update the edge count in the corresponding flowgraphs. */
6644 if (update_edge_count_p)
6645 FOR_EACH_EDGE (e, ei, bb->succs)
6647 cfun->cfg->x_n_edges--;
6648 dest_cfun->cfg->x_n_edges++;
6651 /* Remove BB from the original basic block array. */
6652 (*cfun->cfg->x_basic_block_info)[bb->index] = NULL;
6653 cfun->cfg->x_n_basic_blocks--;
6655 /* Grow DEST_CFUN's basic block array if needed. */
6656 cfg = dest_cfun->cfg;
6657 cfg->x_n_basic_blocks++;
6658 if (bb->index >= cfg->x_last_basic_block)
6659 cfg->x_last_basic_block = bb->index + 1;
6661 old_len = vec_safe_length (cfg->x_basic_block_info);
6662 if ((unsigned) cfg->x_last_basic_block >= old_len)
6664 new_len = cfg->x_last_basic_block + (cfg->x_last_basic_block + 3) / 4;
6665 vec_safe_grow_cleared (cfg->x_basic_block_info, new_len);
6668 (*cfg->x_basic_block_info)[bb->index] = bb;
6670 /* Remap the variables in phi nodes. */
6671 for (gphi_iterator psi = gsi_start_phis (bb);
6674 gphi *phi = psi.phi ();
6676 tree op = PHI_RESULT (phi);
6680 if (virtual_operand_p (op))
6682 /* Remove the phi nodes for virtual operands (alias analysis will be
6683 run for the new function, anyway). */
6684 remove_phi_node (&psi, true);
6688 SET_PHI_RESULT (phi,
6689 replace_ssa_name (op, d->vars_map, dest_cfun->decl));
6690 FOR_EACH_PHI_ARG (use, phi, oi, SSA_OP_USE)
6692 op = USE_FROM_PTR (use);
6693 if (TREE_CODE (op) == SSA_NAME)
6694 SET_USE (use, replace_ssa_name (op, d->vars_map, dest_cfun->decl));
6697 for (i = 0; i < EDGE_COUNT (bb->preds); i++)
6699 location_t locus = gimple_phi_arg_location (phi, i);
6700 tree block = LOCATION_BLOCK (locus);
6702 if (locus == UNKNOWN_LOCATION)
6704 if (d->orig_block == NULL_TREE || block == d->orig_block)
6706 if (d->new_block == NULL_TREE)
6707 locus = LOCATION_LOCUS (locus);
6709 locus = COMBINE_LOCATION_DATA (line_table, locus, d->new_block);
6710 gimple_phi_arg_set_location (phi, i, locus);
6717 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
6719 gimple stmt = gsi_stmt (si);
6720 struct walk_stmt_info wi;
6722 memset (&wi, 0, sizeof (wi));
6724 walk_gimple_stmt (&si, move_stmt_r, move_stmt_op, &wi);
6726 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
6728 tree label = gimple_label_label (label_stmt);
6729 int uid = LABEL_DECL_UID (label);
6731 gcc_assert (uid > -1);
6733 old_len = vec_safe_length (cfg->x_label_to_block_map);
6734 if (old_len <= (unsigned) uid)
6736 new_len = 3 * uid / 2 + 1;
6737 vec_safe_grow_cleared (cfg->x_label_to_block_map, new_len);
6740 (*cfg->x_label_to_block_map)[uid] = bb;
6741 (*cfun->cfg->x_label_to_block_map)[uid] = NULL;
6743 gcc_assert (DECL_CONTEXT (label) == dest_cfun->decl);
6745 if (uid >= dest_cfun->cfg->last_label_uid)
6746 dest_cfun->cfg->last_label_uid = uid + 1;
6749 maybe_duplicate_eh_stmt_fn (dest_cfun, stmt, cfun, stmt, d->eh_map, 0);
6750 remove_stmt_from_eh_lp_fn (cfun, stmt);
6752 gimple_duplicate_stmt_histograms (dest_cfun, stmt, cfun, stmt);
6753 gimple_remove_stmt_histograms (cfun, stmt);
6755 /* We cannot leave any operands allocated from the operand caches of
6756 the current function. */
6757 free_stmt_operands (cfun, stmt);
6758 push_cfun (dest_cfun);
6763 FOR_EACH_EDGE (e, ei, bb->succs)
6764 if (e->goto_locus != UNKNOWN_LOCATION)
6766 tree block = LOCATION_BLOCK (e->goto_locus);
6767 if (d->orig_block == NULL_TREE
6768 || block == d->orig_block)
6769 e->goto_locus = d->new_block ?
6770 COMBINE_LOCATION_DATA (line_table, e->goto_locus, d->new_block) :
6771 LOCATION_LOCUS (e->goto_locus);
6775 /* Examine the statements in BB (which is in SRC_CFUN); find and return
6776 the outermost EH region. Use REGION as the incoming base EH region. */
6779 find_outermost_region_in_block (struct function *src_cfun,
6780 basic_block bb, eh_region region)
6782 gimple_stmt_iterator si;
6784 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
6786 gimple stmt = gsi_stmt (si);
6787 eh_region stmt_region;
6790 lp_nr = lookup_stmt_eh_lp_fn (src_cfun, stmt);
6791 stmt_region = get_eh_region_from_lp_number_fn (src_cfun, lp_nr);
6795 region = stmt_region;
6796 else if (stmt_region != region)
6798 region = eh_region_outermost (src_cfun, stmt_region, region);
6799 gcc_assert (region != NULL);
6808 new_label_mapper (tree decl, void *data)
6810 htab_t hash = (htab_t) data;
6814 gcc_assert (TREE_CODE (decl) == LABEL_DECL);
6816 m = XNEW (struct tree_map);
6817 m->hash = DECL_UID (decl);
6818 m->base.from = decl;
6819 m->to = create_artificial_label (UNKNOWN_LOCATION);
6820 LABEL_DECL_UID (m->to) = LABEL_DECL_UID (decl);
6821 if (LABEL_DECL_UID (m->to) >= cfun->cfg->last_label_uid)
6822 cfun->cfg->last_label_uid = LABEL_DECL_UID (m->to) + 1;
6824 slot = htab_find_slot_with_hash (hash, m, m->hash, INSERT);
6825 gcc_assert (*slot == NULL);
6832 /* Change DECL_CONTEXT of all BLOCK_VARS in block, including
6836 replace_block_vars_by_duplicates (tree block, hash_map<tree, tree> *vars_map,
6841 for (tp = &BLOCK_VARS (block); *tp; tp = &DECL_CHAIN (*tp))
6844 if (TREE_CODE (t) != VAR_DECL && TREE_CODE (t) != CONST_DECL)
6846 replace_by_duplicate_decl (&t, vars_map, to_context);
6849 if (TREE_CODE (*tp) == VAR_DECL && DECL_HAS_VALUE_EXPR_P (*tp))
6851 SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (*tp));
6852 DECL_HAS_VALUE_EXPR_P (t) = 1;
6854 DECL_CHAIN (t) = DECL_CHAIN (*tp);
6859 for (block = BLOCK_SUBBLOCKS (block); block; block = BLOCK_CHAIN (block))
6860 replace_block_vars_by_duplicates (block, vars_map, to_context);
6863 /* Fixup the loop arrays and numbers after moving LOOP and its subloops
6867 fixup_loop_arrays_after_move (struct function *fn1, struct function *fn2,
6870 /* Discard it from the old loop array. */
6871 (*get_loops (fn1))[loop->num] = NULL;
6873 /* Place it in the new loop array, assigning it a new number. */
6874 loop->num = number_of_loops (fn2);
6875 vec_safe_push (loops_for_fn (fn2)->larray, loop);
6877 /* Recurse to children. */
6878 for (loop = loop->inner; loop; loop = loop->next)
6879 fixup_loop_arrays_after_move (fn1, fn2, loop);
6882 /* Verify that the blocks in BBS_P are a single-entry, single-exit region
6883 delimited by ENTRY_BB and EXIT_BB, possibly containing noreturn blocks. */
6886 verify_sese (basic_block entry, basic_block exit, vec<basic_block> *bbs_p)
6891 bitmap bbs = BITMAP_ALLOC (NULL);
6894 gcc_assert (entry != NULL);
6895 gcc_assert (entry != exit);
6896 gcc_assert (bbs_p != NULL);
6898 gcc_assert (bbs_p->length () > 0);
6900 FOR_EACH_VEC_ELT (*bbs_p, i, bb)
6901 bitmap_set_bit (bbs, bb->index);
6903 gcc_assert (bitmap_bit_p (bbs, entry->index));
6904 gcc_assert (exit == NULL || bitmap_bit_p (bbs, exit->index));
6906 FOR_EACH_VEC_ELT (*bbs_p, i, bb)
6910 gcc_assert (single_pred_p (entry));
6911 gcc_assert (!bitmap_bit_p (bbs, single_pred (entry)->index));
6914 for (ei = ei_start (bb->preds); !ei_end_p (ei); ei_next (&ei))
6917 gcc_assert (bitmap_bit_p (bbs, e->src->index));
6922 gcc_assert (single_succ_p (exit));
6923 gcc_assert (!bitmap_bit_p (bbs, single_succ (exit)->index));
6926 for (ei = ei_start (bb->succs); !ei_end_p (ei); ei_next (&ei))
6929 gcc_assert (bitmap_bit_p (bbs, e->dest->index));
6937 /* Move a single-entry, single-exit region delimited by ENTRY_BB and
6938 EXIT_BB to function DEST_CFUN. The whole region is replaced by a
6939 single basic block in the original CFG and the new basic block is
6940 returned. DEST_CFUN must not have a CFG yet.
6942 Note that the region need not be a pure SESE region. Blocks inside
6943 the region may contain calls to abort/exit. The only restriction
6944 is that ENTRY_BB should be the only entry point and it must
6947 Change TREE_BLOCK of all statements in ORIG_BLOCK to the new
6948 functions outermost BLOCK, move all subblocks of ORIG_BLOCK
6949 to the new function.
6951 All local variables referenced in the region are assumed to be in
6952 the corresponding BLOCK_VARS and unexpanded variable lists
6953 associated with DEST_CFUN. */
6956 move_sese_region_to_fn (struct function *dest_cfun, basic_block entry_bb,
6957 basic_block exit_bb, tree orig_block)
6959 vec<basic_block> bbs, dom_bbs;
6960 basic_block dom_entry = get_immediate_dominator (CDI_DOMINATORS, entry_bb);
6961 basic_block after, bb, *entry_pred, *exit_succ, abb;
6962 struct function *saved_cfun = cfun;
6963 int *entry_flag, *exit_flag;
6964 unsigned *entry_prob, *exit_prob;
6965 unsigned i, num_entry_edges, num_exit_edges, num_nodes;
6968 htab_t new_label_map;
6969 hash_map<void *, void *> *eh_map;
6970 struct loop *loop = entry_bb->loop_father;
6971 struct loop *loop0 = get_loop (saved_cfun, 0);
6972 struct move_stmt_d d;
6974 /* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
6976 gcc_assert (entry_bb != exit_bb
6978 || dominated_by_p (CDI_DOMINATORS, exit_bb, entry_bb)));
6980 /* Collect all the blocks in the region. Manually add ENTRY_BB
6981 because it won't be added by dfs_enumerate_from. */
6983 bbs.safe_push (entry_bb);
6984 gather_blocks_in_sese_region (entry_bb, exit_bb, &bbs);
6985 #ifdef ENABLE_CHECKING
6986 verify_sese (entry_bb, exit_bb, &bbs);
6989 /* The blocks that used to be dominated by something in BBS will now be
6990 dominated by the new block. */
6991 dom_bbs = get_dominated_by_region (CDI_DOMINATORS,
6995 /* Detach ENTRY_BB and EXIT_BB from CFUN->CFG. We need to remember
6996 the predecessor edges to ENTRY_BB and the successor edges to
6997 EXIT_BB so that we can re-attach them to the new basic block that
6998 will replace the region. */
6999 num_entry_edges = EDGE_COUNT (entry_bb->preds);
7000 entry_pred = XNEWVEC (basic_block, num_entry_edges);
7001 entry_flag = XNEWVEC (int, num_entry_edges);
7002 entry_prob = XNEWVEC (unsigned, num_entry_edges);
7004 for (ei = ei_start (entry_bb->preds); (e = ei_safe_edge (ei)) != NULL;)
7006 entry_prob[i] = e->probability;
7007 entry_flag[i] = e->flags;
7008 entry_pred[i++] = e->src;
7014 num_exit_edges = EDGE_COUNT (exit_bb->succs);
7015 exit_succ = XNEWVEC (basic_block, num_exit_edges);
7016 exit_flag = XNEWVEC (int, num_exit_edges);
7017 exit_prob = XNEWVEC (unsigned, num_exit_edges);
7019 for (ei = ei_start (exit_bb->succs); (e = ei_safe_edge (ei)) != NULL;)
7021 exit_prob[i] = e->probability;
7022 exit_flag[i] = e->flags;
7023 exit_succ[i++] = e->dest;
7035 /* Switch context to the child function to initialize DEST_FN's CFG. */
7036 gcc_assert (dest_cfun->cfg == NULL);
7037 push_cfun (dest_cfun);
7039 init_empty_tree_cfg ();
7041 /* Initialize EH information for the new function. */
7043 new_label_map = NULL;
7046 eh_region region = NULL;
7048 FOR_EACH_VEC_ELT (bbs, i, bb)
7049 region = find_outermost_region_in_block (saved_cfun, bb, region);
7051 init_eh_for_function ();
7054 new_label_map = htab_create (17, tree_map_hash, tree_map_eq, free);
7055 eh_map = duplicate_eh_regions (saved_cfun, region, 0,
7056 new_label_mapper, new_label_map);
7060 /* Initialize an empty loop tree. */
7061 struct loops *loops = ggc_cleared_alloc<struct loops> ();
7062 init_loops_structure (dest_cfun, loops, 1);
7063 loops->state = LOOPS_MAY_HAVE_MULTIPLE_LATCHES;
7064 set_loops_for_fn (dest_cfun, loops);
7066 /* Move the outlined loop tree part. */
7067 num_nodes = bbs.length ();
7068 FOR_EACH_VEC_ELT (bbs, i, bb)
7070 if (bb->loop_father->header == bb)
7072 struct loop *this_loop = bb->loop_father;
7073 struct loop *outer = loop_outer (this_loop);
7075 /* If the SESE region contains some bbs ending with
7076 a noreturn call, those are considered to belong
7077 to the outermost loop in saved_cfun, rather than
7078 the entry_bb's loop_father. */
7082 num_nodes -= this_loop->num_nodes;
7083 flow_loop_tree_node_remove (bb->loop_father);
7084 flow_loop_tree_node_add (get_loop (dest_cfun, 0), this_loop);
7085 fixup_loop_arrays_after_move (saved_cfun, cfun, this_loop);
7088 else if (bb->loop_father == loop0 && loop0 != loop)
7091 /* Remove loop exits from the outlined region. */
7092 if (loops_for_fn (saved_cfun)->exits)
7093 FOR_EACH_EDGE (e, ei, bb->succs)
7095 struct loops *l = loops_for_fn (saved_cfun);
7097 = l->exits->find_slot_with_hash (e, htab_hash_pointer (e),
7100 l->exits->clear_slot (slot);
7105 /* Adjust the number of blocks in the tree root of the outlined part. */
7106 get_loop (dest_cfun, 0)->num_nodes = bbs.length () + 2;
7108 /* Setup a mapping to be used by move_block_to_fn. */
7109 loop->aux = current_loops->tree_root;
7110 loop0->aux = current_loops->tree_root;
7114 /* Move blocks from BBS into DEST_CFUN. */
7115 gcc_assert (bbs.length () >= 2);
7116 after = dest_cfun->cfg->x_entry_block_ptr;
7117 hash_map<tree, tree> vars_map;
7119 memset (&d, 0, sizeof (d));
7120 d.orig_block = orig_block;
7121 d.new_block = DECL_INITIAL (dest_cfun->decl);
7122 d.from_context = cfun->decl;
7123 d.to_context = dest_cfun->decl;
7124 d.vars_map = &vars_map;
7125 d.new_label_map = new_label_map;
7127 d.remap_decls_p = true;
7129 FOR_EACH_VEC_ELT (bbs, i, bb)
7131 /* No need to update edge counts on the last block. It has
7132 already been updated earlier when we detached the region from
7133 the original CFG. */
7134 move_block_to_fn (dest_cfun, bb, after, bb != exit_bb, &d);
7140 /* Loop sizes are no longer correct, fix them up. */
7141 loop->num_nodes -= num_nodes;
7142 for (struct loop *outer = loop_outer (loop);
7143 outer; outer = loop_outer (outer))
7144 outer->num_nodes -= num_nodes;
7145 loop0->num_nodes -= bbs.length () - num_nodes;
7147 if (saved_cfun->has_simduid_loops || saved_cfun->has_force_vectorize_loops)
7150 for (i = 0; vec_safe_iterate (loops->larray, i, &aloop); i++)
7155 replace_by_duplicate_decl (&aloop->simduid, d.vars_map,
7157 dest_cfun->has_simduid_loops = true;
7159 if (aloop->force_vectorize)
7160 dest_cfun->has_force_vectorize_loops = true;
7164 /* Rewire BLOCK_SUBBLOCKS of orig_block. */
7168 gcc_assert (BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun->decl))
7170 BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun->decl))
7171 = BLOCK_SUBBLOCKS (orig_block);
7172 for (block = BLOCK_SUBBLOCKS (orig_block);
7173 block; block = BLOCK_CHAIN (block))
7174 BLOCK_SUPERCONTEXT (block) = DECL_INITIAL (dest_cfun->decl);
7175 BLOCK_SUBBLOCKS (orig_block) = NULL_TREE;
7178 replace_block_vars_by_duplicates (DECL_INITIAL (dest_cfun->decl),
7179 &vars_map, dest_cfun->decl);
7182 htab_delete (new_label_map);
7186 /* Rewire the entry and exit blocks. The successor to the entry
7187 block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
7188 the child function. Similarly, the predecessor of DEST_FN's
7189 EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR. We
7190 need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
7191 various CFG manipulation function get to the right CFG.
7193 FIXME, this is silly. The CFG ought to become a parameter to
7195 push_cfun (dest_cfun);
7196 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun), entry_bb, EDGE_FALLTHRU);
7198 make_edge (exit_bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
7201 /* Back in the original function, the SESE region has disappeared,
7202 create a new basic block in its place. */
7203 bb = create_empty_bb (entry_pred[0]);
7205 add_bb_to_loop (bb, loop);
7206 for (i = 0; i < num_entry_edges; i++)
7208 e = make_edge (entry_pred[i], bb, entry_flag[i]);
7209 e->probability = entry_prob[i];
7212 for (i = 0; i < num_exit_edges; i++)
7214 e = make_edge (bb, exit_succ[i], exit_flag[i]);
7215 e->probability = exit_prob[i];
7218 set_immediate_dominator (CDI_DOMINATORS, bb, dom_entry);
7219 FOR_EACH_VEC_ELT (dom_bbs, i, abb)
7220 set_immediate_dominator (CDI_DOMINATORS, abb, bb);
7238 /* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in dumpfile.h)
7242 dump_function_to_file (tree fndecl, FILE *file, int flags)
7244 tree arg, var, old_current_fndecl = current_function_decl;
7245 struct function *dsf;
7246 bool ignore_topmost_bind = false, any_var = false;
7249 bool tmclone = (TREE_CODE (fndecl) == FUNCTION_DECL
7250 && decl_is_tm_clone (fndecl));
7251 struct function *fun = DECL_STRUCT_FUNCTION (fndecl);
7253 current_function_decl = fndecl;
7254 fprintf (file, "%s %s(", function_name (fun), tmclone ? "[tm-clone] " : "");
7256 arg = DECL_ARGUMENTS (fndecl);
7259 print_generic_expr (file, TREE_TYPE (arg), dump_flags);
7260 fprintf (file, " ");
7261 print_generic_expr (file, arg, dump_flags);
7262 if (flags & TDF_VERBOSE)
7263 print_node (file, "", arg, 4);
7264 if (DECL_CHAIN (arg))
7265 fprintf (file, ", ");
7266 arg = DECL_CHAIN (arg);
7268 fprintf (file, ")\n");
7270 if (flags & TDF_VERBOSE)
7271 print_node (file, "", fndecl, 2);
7273 dsf = DECL_STRUCT_FUNCTION (fndecl);
7274 if (dsf && (flags & TDF_EH))
7275 dump_eh_tree (file, dsf);
7277 if (flags & TDF_RAW && !gimple_has_body_p (fndecl))
7279 dump_node (fndecl, TDF_SLIM | flags, file);
7280 current_function_decl = old_current_fndecl;
7284 /* When GIMPLE is lowered, the variables are no longer available in
7285 BIND_EXPRs, so display them separately. */
7286 if (fun && fun->decl == fndecl && (fun->curr_properties & PROP_gimple_lcf))
7289 ignore_topmost_bind = true;
7291 fprintf (file, "{\n");
7292 if (!vec_safe_is_empty (fun->local_decls))
7293 FOR_EACH_LOCAL_DECL (fun, ix, var)
7295 print_generic_decl (file, var, flags);
7296 if (flags & TDF_VERBOSE)
7297 print_node (file, "", var, 4);
7298 fprintf (file, "\n");
7302 if (gimple_in_ssa_p (cfun))
7303 for (ix = 1; ix < num_ssa_names; ++ix)
7305 tree name = ssa_name (ix);
7306 if (name && !SSA_NAME_VAR (name))
7308 fprintf (file, " ");
7309 print_generic_expr (file, TREE_TYPE (name), flags);
7310 fprintf (file, " ");
7311 print_generic_expr (file, name, flags);
7312 fprintf (file, ";\n");
7319 if (fun && fun->decl == fndecl
7321 && basic_block_info_for_fn (fun))
7323 /* If the CFG has been built, emit a CFG-based dump. */
7324 if (!ignore_topmost_bind)
7325 fprintf (file, "{\n");
7327 if (any_var && n_basic_blocks_for_fn (fun))
7328 fprintf (file, "\n");
7330 FOR_EACH_BB_FN (bb, fun)
7331 dump_bb (file, bb, 2, flags | TDF_COMMENT);
7333 fprintf (file, "}\n");
7335 else if (DECL_SAVED_TREE (fndecl) == NULL)
7337 /* The function is now in GIMPLE form but the CFG has not been
7338 built yet. Emit the single sequence of GIMPLE statements
7339 that make up its body. */
7340 gimple_seq body = gimple_body (fndecl);
7342 if (gimple_seq_first_stmt (body)
7343 && gimple_seq_first_stmt (body) == gimple_seq_last_stmt (body)
7344 && gimple_code (gimple_seq_first_stmt (body)) == GIMPLE_BIND)
7345 print_gimple_seq (file, body, 0, flags);
7348 if (!ignore_topmost_bind)
7349 fprintf (file, "{\n");
7352 fprintf (file, "\n");
7354 print_gimple_seq (file, body, 2, flags);
7355 fprintf (file, "}\n");
7362 /* Make a tree based dump. */
7363 chain = DECL_SAVED_TREE (fndecl);
7364 if (chain && TREE_CODE (chain) == BIND_EXPR)
7366 if (ignore_topmost_bind)
7368 chain = BIND_EXPR_BODY (chain);
7376 if (!ignore_topmost_bind)
7377 fprintf (file, "{\n");
7382 fprintf (file, "\n");
7384 print_generic_stmt_indented (file, chain, flags, indent);
7385 if (ignore_topmost_bind)
7386 fprintf (file, "}\n");
7389 if (flags & TDF_ENUMERATE_LOCALS)
7390 dump_enumerated_decls (file, flags);
7391 fprintf (file, "\n\n");
7393 current_function_decl = old_current_fndecl;
7396 /* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h) */
7399 debug_function (tree fn, int flags)
7401 dump_function_to_file (fn, stderr, flags);
7405 /* Print on FILE the indexes for the predecessors of basic_block BB. */
7408 print_pred_bbs (FILE *file, basic_block bb)
7413 FOR_EACH_EDGE (e, ei, bb->preds)
7414 fprintf (file, "bb_%d ", e->src->index);
7418 /* Print on FILE the indexes for the successors of basic_block BB. */
7421 print_succ_bbs (FILE *file, basic_block bb)
7426 FOR_EACH_EDGE (e, ei, bb->succs)
7427 fprintf (file, "bb_%d ", e->dest->index);
7430 /* Print to FILE the basic block BB following the VERBOSITY level. */
7433 print_loops_bb (FILE *file, basic_block bb, int indent, int verbosity)
7435 char *s_indent = (char *) alloca ((size_t) indent + 1);
7436 memset ((void *) s_indent, ' ', (size_t) indent);
7437 s_indent[indent] = '\0';
7439 /* Print basic_block's header. */
7442 fprintf (file, "%s bb_%d (preds = {", s_indent, bb->index);
7443 print_pred_bbs (file, bb);
7444 fprintf (file, "}, succs = {");
7445 print_succ_bbs (file, bb);
7446 fprintf (file, "})\n");
7449 /* Print basic_block's body. */
7452 fprintf (file, "%s {\n", s_indent);
7453 dump_bb (file, bb, indent + 4, TDF_VOPS|TDF_MEMSYMS);
7454 fprintf (file, "%s }\n", s_indent);
7458 static void print_loop_and_siblings (FILE *, struct loop *, int, int);
7460 /* Pretty print LOOP on FILE, indented INDENT spaces. Following
7461 VERBOSITY level this outputs the contents of the loop, or just its
7465 print_loop (FILE *file, struct loop *loop, int indent, int verbosity)
7473 s_indent = (char *) alloca ((size_t) indent + 1);
7474 memset ((void *) s_indent, ' ', (size_t) indent);
7475 s_indent[indent] = '\0';
7477 /* Print loop's header. */
7478 fprintf (file, "%sloop_%d (", s_indent, loop->num);
7480 fprintf (file, "header = %d", loop->header->index);
7483 fprintf (file, "deleted)\n");
7487 fprintf (file, ", latch = %d", loop->latch->index);
7489 fprintf (file, ", multiple latches");
7490 fprintf (file, ", niter = ");
7491 print_generic_expr (file, loop->nb_iterations, 0);
7493 if (loop->any_upper_bound)
7495 fprintf (file, ", upper_bound = ");
7496 print_decu (loop->nb_iterations_upper_bound, file);
7499 if (loop->any_estimate)
7501 fprintf (file, ", estimate = ");
7502 print_decu (loop->nb_iterations_estimate, file);
7504 fprintf (file, ")\n");
7506 /* Print loop's body. */
7509 fprintf (file, "%s{\n", s_indent);
7510 FOR_EACH_BB_FN (bb, cfun)
7511 if (bb->loop_father == loop)
7512 print_loops_bb (file, bb, indent, verbosity);
7514 print_loop_and_siblings (file, loop->inner, indent + 2, verbosity);
7515 fprintf (file, "%s}\n", s_indent);
7519 /* Print the LOOP and its sibling loops on FILE, indented INDENT
7520 spaces. Following VERBOSITY level this outputs the contents of the
7521 loop, or just its structure. */
7524 print_loop_and_siblings (FILE *file, struct loop *loop, int indent,
7530 print_loop (file, loop, indent, verbosity);
7531 print_loop_and_siblings (file, loop->next, indent, verbosity);
7534 /* Follow a CFG edge from the entry point of the program, and on entry
7535 of a loop, pretty print the loop structure on FILE. */
7538 print_loops (FILE *file, int verbosity)
7542 bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
7543 if (bb && bb->loop_father)
7544 print_loop_and_siblings (file, bb->loop_father, 0, verbosity);
7550 debug (struct loop &ref)
7552 print_loop (stderr, &ref, 0, /*verbosity*/0);
7556 debug (struct loop *ptr)
7561 fprintf (stderr, "<nil>\n");
7564 /* Dump a loop verbosely. */
7567 debug_verbose (struct loop &ref)
7569 print_loop (stderr, &ref, 0, /*verbosity*/3);
7573 debug_verbose (struct loop *ptr)
7578 fprintf (stderr, "<nil>\n");
7582 /* Debugging loops structure at tree level, at some VERBOSITY level. */
7585 debug_loops (int verbosity)
7587 print_loops (stderr, verbosity);
7590 /* Print on stderr the code of LOOP, at some VERBOSITY level. */
7593 debug_loop (struct loop *loop, int verbosity)
7595 print_loop (stderr, loop, 0, verbosity);
7598 /* Print on stderr the code of loop number NUM, at some VERBOSITY
7602 debug_loop_num (unsigned num, int verbosity)
7604 debug_loop (get_loop (cfun, num), verbosity);
7607 /* Return true if BB ends with a call, possibly followed by some
7608 instructions that must stay with the call. Return false,
7612 gimple_block_ends_with_call_p (basic_block bb)
7614 gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
7615 return !gsi_end_p (gsi) && is_gimple_call (gsi_stmt (gsi));
7619 /* Return true if BB ends with a conditional branch. Return false,
7623 gimple_block_ends_with_condjump_p (const_basic_block bb)
7625 gimple stmt = last_stmt (CONST_CAST_BB (bb));
7626 return (stmt && gimple_code (stmt) == GIMPLE_COND);
7630 /* Return true if we need to add fake edge to exit at statement T.
7631 Helper function for gimple_flow_call_edges_add. */
7634 need_fake_edge_p (gimple t)
7636 tree fndecl = NULL_TREE;
7639 /* NORETURN and LONGJMP calls already have an edge to exit.
7640 CONST and PURE calls do not need one.
7641 We don't currently check for CONST and PURE here, although
7642 it would be a good idea, because those attributes are
7643 figured out from the RTL in mark_constant_function, and
7644 the counter incrementation code from -fprofile-arcs
7645 leads to different results from -fbranch-probabilities. */
7646 if (is_gimple_call (t))
7648 fndecl = gimple_call_fndecl (t);
7649 call_flags = gimple_call_flags (t);
7652 if (is_gimple_call (t)
7654 && DECL_BUILT_IN (fndecl)
7655 && (call_flags & ECF_NOTHROW)
7656 && !(call_flags & ECF_RETURNS_TWICE)
7657 /* fork() doesn't really return twice, but the effect of
7658 wrapping it in __gcov_fork() which calls __gcov_flush()
7659 and clears the counters before forking has the same
7660 effect as returning twice. Force a fake edge. */
7661 && !(DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
7662 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FORK))
7665 if (is_gimple_call (t))
7671 if (!(call_flags & ECF_NORETURN))
7675 FOR_EACH_EDGE (e, ei, bb->succs)
7676 if ((e->flags & EDGE_FAKE) == 0)
7680 if (gasm *asm_stmt = dyn_cast <gasm *> (t))
7681 if (gimple_asm_volatile_p (asm_stmt) || gimple_asm_input_p (asm_stmt))
7688 /* Add fake edges to the function exit for any non constant and non
7689 noreturn calls (or noreturn calls with EH/abnormal edges),
7690 volatile inline assembly in the bitmap of blocks specified by BLOCKS
7691 or to the whole CFG if BLOCKS is zero. Return the number of blocks
7694 The goal is to expose cases in which entering a basic block does
7695 not imply that all subsequent instructions must be executed. */
7698 gimple_flow_call_edges_add (sbitmap blocks)
7701 int blocks_split = 0;
7702 int last_bb = last_basic_block_for_fn (cfun);
7703 bool check_last_block = false;
7705 if (n_basic_blocks_for_fn (cfun) == NUM_FIXED_BLOCKS)
7709 check_last_block = true;
7711 check_last_block = bitmap_bit_p (blocks,
7712 EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb->index);
7714 /* In the last basic block, before epilogue generation, there will be
7715 a fallthru edge to EXIT. Special care is required if the last insn
7716 of the last basic block is a call because make_edge folds duplicate
7717 edges, which would result in the fallthru edge also being marked
7718 fake, which would result in the fallthru edge being removed by
7719 remove_fake_edges, which would result in an invalid CFG.
7721 Moreover, we can't elide the outgoing fake edge, since the block
7722 profiler needs to take this into account in order to solve the minimal
7723 spanning tree in the case that the call doesn't return.
7725 Handle this by adding a dummy instruction in a new last basic block. */
7726 if (check_last_block)
7728 basic_block bb = EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb;
7729 gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
7732 if (!gsi_end_p (gsi))
7735 if (t && need_fake_edge_p (t))
7739 e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun));
7742 gsi_insert_on_edge (e, gimple_build_nop ());
7743 gsi_commit_edge_inserts ();
7748 /* Now add fake edges to the function exit for any non constant
7749 calls since there is no way that we can determine if they will
7751 for (i = 0; i < last_bb; i++)
7753 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
7754 gimple_stmt_iterator gsi;
7755 gimple stmt, last_stmt;
7760 if (blocks && !bitmap_bit_p (blocks, i))
7763 gsi = gsi_last_nondebug_bb (bb);
7764 if (!gsi_end_p (gsi))
7766 last_stmt = gsi_stmt (gsi);
7769 stmt = gsi_stmt (gsi);
7770 if (need_fake_edge_p (stmt))
7774 /* The handling above of the final block before the
7775 epilogue should be enough to verify that there is
7776 no edge to the exit block in CFG already.
7777 Calling make_edge in such case would cause us to
7778 mark that edge as fake and remove it later. */
7779 #ifdef ENABLE_CHECKING
7780 if (stmt == last_stmt)
7782 e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun));
7783 gcc_assert (e == NULL);
7787 /* Note that the following may create a new basic block
7788 and renumber the existing basic blocks. */
7789 if (stmt != last_stmt)
7791 e = split_block (bb, stmt);
7795 make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), EDGE_FAKE);
7799 while (!gsi_end_p (gsi));
7804 verify_flow_info ();
7806 return blocks_split;
7809 /* Removes edge E and all the blocks dominated by it, and updates dominance
7810 information. The IL in E->src needs to be updated separately.
7811 If dominance info is not available, only the edge E is removed.*/
7814 remove_edge_and_dominated_blocks (edge e)
7816 vec<basic_block> bbs_to_remove = vNULL;
7817 vec<basic_block> bbs_to_fix_dom = vNULL;
7821 bool none_removed = false;
7823 basic_block bb, dbb;
7826 if (!dom_info_available_p (CDI_DOMINATORS))
7832 /* No updating is needed for edges to exit. */
7833 if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
7835 if (cfgcleanup_altered_bbs)
7836 bitmap_set_bit (cfgcleanup_altered_bbs, e->src->index);
7841 /* First, we find the basic blocks to remove. If E->dest has a predecessor
7842 that is not dominated by E->dest, then this set is empty. Otherwise,
7843 all the basic blocks dominated by E->dest are removed.
7845 Also, to DF_IDOM we store the immediate dominators of the blocks in
7846 the dominance frontier of E (i.e., of the successors of the
7847 removed blocks, if there are any, and of E->dest otherwise). */
7848 FOR_EACH_EDGE (f, ei, e->dest->preds)
7853 if (!dominated_by_p (CDI_DOMINATORS, f->src, e->dest))
7855 none_removed = true;
7860 df = BITMAP_ALLOC (NULL);
7861 df_idom = BITMAP_ALLOC (NULL);
7864 bitmap_set_bit (df_idom,
7865 get_immediate_dominator (CDI_DOMINATORS, e->dest)->index);
7868 bbs_to_remove = get_all_dominated_blocks (CDI_DOMINATORS, e->dest);
7869 FOR_EACH_VEC_ELT (bbs_to_remove, i, bb)
7871 FOR_EACH_EDGE (f, ei, bb->succs)
7873 if (f->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
7874 bitmap_set_bit (df, f->dest->index);
7877 FOR_EACH_VEC_ELT (bbs_to_remove, i, bb)
7878 bitmap_clear_bit (df, bb->index);
7880 EXECUTE_IF_SET_IN_BITMAP (df, 0, i, bi)
7882 bb = BASIC_BLOCK_FOR_FN (cfun, i);
7883 bitmap_set_bit (df_idom,
7884 get_immediate_dominator (CDI_DOMINATORS, bb)->index);
7888 if (cfgcleanup_altered_bbs)
7890 /* Record the set of the altered basic blocks. */
7891 bitmap_set_bit (cfgcleanup_altered_bbs, e->src->index);
7892 bitmap_ior_into (cfgcleanup_altered_bbs, df);
7895 /* Remove E and the cancelled blocks. */
7900 /* Walk backwards so as to get a chance to substitute all
7901 released DEFs into debug stmts. See
7902 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
7904 for (i = bbs_to_remove.length (); i-- > 0; )
7905 delete_basic_block (bbs_to_remove[i]);
7908 /* Update the dominance information. The immediate dominator may change only
7909 for blocks whose immediate dominator belongs to DF_IDOM:
7911 Suppose that idom(X) = Y before removal of E and idom(X) != Y after the
7912 removal. Let Z the arbitrary block such that idom(Z) = Y and
7913 Z dominates X after the removal. Before removal, there exists a path P
7914 from Y to X that avoids Z. Let F be the last edge on P that is
7915 removed, and let W = F->dest. Before removal, idom(W) = Y (since Y
7916 dominates W, and because of P, Z does not dominate W), and W belongs to
7917 the dominance frontier of E. Therefore, Y belongs to DF_IDOM. */
7918 EXECUTE_IF_SET_IN_BITMAP (df_idom, 0, i, bi)
7920 bb = BASIC_BLOCK_FOR_FN (cfun, i);
7921 for (dbb = first_dom_son (CDI_DOMINATORS, bb);
7923 dbb = next_dom_son (CDI_DOMINATORS, dbb))
7924 bbs_to_fix_dom.safe_push (dbb);
7927 iterate_fix_dominators (CDI_DOMINATORS, bbs_to_fix_dom, true);
7930 BITMAP_FREE (df_idom);
7931 bbs_to_remove.release ();
7932 bbs_to_fix_dom.release ();
7935 /* Purge dead EH edges from basic block BB. */
7938 gimple_purge_dead_eh_edges (basic_block bb)
7940 bool changed = false;
7943 gimple stmt = last_stmt (bb);
7945 if (stmt && stmt_can_throw_internal (stmt))
7948 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
7950 if (e->flags & EDGE_EH)
7952 remove_edge_and_dominated_blocks (e);
7962 /* Purge dead EH edges from basic block listed in BLOCKS. */
7965 gimple_purge_all_dead_eh_edges (const_bitmap blocks)
7967 bool changed = false;
7971 EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
7973 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
7975 /* Earlier gimple_purge_dead_eh_edges could have removed
7976 this basic block already. */
7977 gcc_assert (bb || changed);
7979 changed |= gimple_purge_dead_eh_edges (bb);
7985 /* Purge dead abnormal call edges from basic block BB. */
7988 gimple_purge_dead_abnormal_call_edges (basic_block bb)
7990 bool changed = false;
7993 gimple stmt = last_stmt (bb);
7995 if (!cfun->has_nonlocal_label
7996 && !cfun->calls_setjmp)
7999 if (stmt && stmt_can_make_abnormal_goto (stmt))
8002 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
8004 if (e->flags & EDGE_ABNORMAL)
8006 if (e->flags & EDGE_FALLTHRU)
8007 e->flags &= ~EDGE_ABNORMAL;
8009 remove_edge_and_dominated_blocks (e);
8019 /* Purge dead abnormal call edges from basic block listed in BLOCKS. */
8022 gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks)
8024 bool changed = false;
8028 EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
8030 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
8032 /* Earlier gimple_purge_dead_abnormal_call_edges could have removed
8033 this basic block already. */
8034 gcc_assert (bb || changed);
8036 changed |= gimple_purge_dead_abnormal_call_edges (bb);
8042 /* This function is called whenever a new edge is created or
8046 gimple_execute_on_growing_pred (edge e)
8048 basic_block bb = e->dest;
8050 if (!gimple_seq_empty_p (phi_nodes (bb)))
8051 reserve_phi_args_for_new_edge (bb);
8054 /* This function is called immediately before edge E is removed from
8055 the edge vector E->dest->preds. */
8058 gimple_execute_on_shrinking_pred (edge e)
8060 if (!gimple_seq_empty_p (phi_nodes (e->dest)))
8061 remove_phi_args (e);
8064 /*---------------------------------------------------------------------------
8065 Helper functions for Loop versioning
8066 ---------------------------------------------------------------------------*/
8068 /* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy
8069 of 'first'. Both of them are dominated by 'new_head' basic block. When
8070 'new_head' was created by 'second's incoming edge it received phi arguments
8071 on the edge by split_edge(). Later, additional edge 'e' was created to
8072 connect 'new_head' and 'first'. Now this routine adds phi args on this
8073 additional edge 'e' that new_head to second edge received as part of edge
8077 gimple_lv_adjust_loop_header_phi (basic_block first, basic_block second,
8078 basic_block new_head, edge e)
8081 gphi_iterator psi1, psi2;
8083 edge e2 = find_edge (new_head, second);
8085 /* Because NEW_HEAD has been created by splitting SECOND's incoming
8086 edge, we should always have an edge from NEW_HEAD to SECOND. */
8087 gcc_assert (e2 != NULL);
8089 /* Browse all 'second' basic block phi nodes and add phi args to
8090 edge 'e' for 'first' head. PHI args are always in correct order. */
8092 for (psi2 = gsi_start_phis (second),
8093 psi1 = gsi_start_phis (first);
8094 !gsi_end_p (psi2) && !gsi_end_p (psi1);
8095 gsi_next (&psi2), gsi_next (&psi1))
8099 def = PHI_ARG_DEF (phi2, e2->dest_idx);
8100 add_phi_arg (phi1, def, e, gimple_phi_arg_location_from_edge (phi2, e2));
8105 /* Adds a if else statement to COND_BB with condition COND_EXPR.
8106 SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
8107 the destination of the ELSE part. */
8110 gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED,
8111 basic_block second_head ATTRIBUTE_UNUSED,
8112 basic_block cond_bb, void *cond_e)
8114 gimple_stmt_iterator gsi;
8115 gimple new_cond_expr;
8116 tree cond_expr = (tree) cond_e;
8119 /* Build new conditional expr */
8120 new_cond_expr = gimple_build_cond_from_tree (cond_expr,
8121 NULL_TREE, NULL_TREE);
8123 /* Add new cond in cond_bb. */
8124 gsi = gsi_last_bb (cond_bb);
8125 gsi_insert_after (&gsi, new_cond_expr, GSI_NEW_STMT);
8127 /* Adjust edges appropriately to connect new head with first head
8128 as well as second head. */
8129 e0 = single_succ_edge (cond_bb);
8130 e0->flags &= ~EDGE_FALLTHRU;
8131 e0->flags |= EDGE_FALSE_VALUE;
8135 /* Do book-keeping of basic block BB for the profile consistency checker.
8136 If AFTER_PASS is 0, do pre-pass accounting, or if AFTER_PASS is 1
8137 then do post-pass accounting. Store the counting in RECORD. */
8139 gimple_account_profile_record (basic_block bb, int after_pass,
8140 struct profile_record *record)
8142 gimple_stmt_iterator i;
8143 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
8145 record->size[after_pass]
8146 += estimate_num_insns (gsi_stmt (i), &eni_size_weights);
8147 if (profile_status_for_fn (cfun) == PROFILE_READ)
8148 record->time[after_pass]
8149 += estimate_num_insns (gsi_stmt (i),
8150 &eni_time_weights) * bb->count;
8151 else if (profile_status_for_fn (cfun) == PROFILE_GUESSED)
8152 record->time[after_pass]
8153 += estimate_num_insns (gsi_stmt (i),
8154 &eni_time_weights) * bb->frequency;
8158 struct cfg_hooks gimple_cfg_hooks = {
8160 gimple_verify_flow_info,
8161 gimple_dump_bb, /* dump_bb */
8162 gimple_dump_bb_for_graph, /* dump_bb_for_graph */
8163 create_bb, /* create_basic_block */
8164 gimple_redirect_edge_and_branch, /* redirect_edge_and_branch */
8165 gimple_redirect_edge_and_branch_force, /* redirect_edge_and_branch_force */
8166 gimple_can_remove_branch_p, /* can_remove_branch_p */
8167 remove_bb, /* delete_basic_block */
8168 gimple_split_block, /* split_block */
8169 gimple_move_block_after, /* move_block_after */
8170 gimple_can_merge_blocks_p, /* can_merge_blocks_p */
8171 gimple_merge_blocks, /* merge_blocks */
8172 gimple_predict_edge, /* predict_edge */
8173 gimple_predicted_by_p, /* predicted_by_p */
8174 gimple_can_duplicate_bb_p, /* can_duplicate_block_p */
8175 gimple_duplicate_bb, /* duplicate_block */
8176 gimple_split_edge, /* split_edge */
8177 gimple_make_forwarder_block, /* make_forward_block */
8178 NULL, /* tidy_fallthru_edge */
8179 NULL, /* force_nonfallthru */
8180 gimple_block_ends_with_call_p,/* block_ends_with_call_p */
8181 gimple_block_ends_with_condjump_p, /* block_ends_with_condjump_p */
8182 gimple_flow_call_edges_add, /* flow_call_edges_add */
8183 gimple_execute_on_growing_pred, /* execute_on_growing_pred */
8184 gimple_execute_on_shrinking_pred, /* execute_on_shrinking_pred */
8185 gimple_duplicate_loop_to_header_edge, /* duplicate loop for trees */
8186 gimple_lv_add_condition_to_bb, /* lv_add_condition_to_bb */
8187 gimple_lv_adjust_loop_header_phi, /* lv_adjust_loop_header_phi*/
8188 extract_true_false_edges_from_block, /* extract_cond_bb_edges */
8189 flush_pending_stmts, /* flush_pending_stmts */
8190 gimple_empty_block_p, /* block_empty_p */
8191 gimple_split_block_before_cond_jump, /* split_block_before_cond_jump */
8192 gimple_account_profile_record,
8196 /* Split all critical edges. */
8199 split_critical_edges (void)
8205 /* split_edge can redirect edges out of SWITCH_EXPRs, which can get
8206 expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
8207 mappings around the calls to split_edge. */
8208 start_recording_case_labels ();
8209 FOR_ALL_BB_FN (bb, cfun)
8211 FOR_EACH_EDGE (e, ei, bb->succs)
8213 if (EDGE_CRITICAL_P (e) && !(e->flags & EDGE_ABNORMAL))
8215 /* PRE inserts statements to edges and expects that
8216 since split_critical_edges was done beforehand, committing edge
8217 insertions will not split more edges. In addition to critical
8218 edges we must split edges that have multiple successors and
8219 end by control flow statements, such as RESX.
8220 Go ahead and split them too. This matches the logic in
8221 gimple_find_edge_insert_loc. */
8222 else if ((!single_pred_p (e->dest)
8223 || !gimple_seq_empty_p (phi_nodes (e->dest))
8224 || e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
8225 && e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)
8226 && !(e->flags & EDGE_ABNORMAL))
8228 gimple_stmt_iterator gsi;
8230 gsi = gsi_last_bb (e->src);
8231 if (!gsi_end_p (gsi)
8232 && stmt_ends_bb_p (gsi_stmt (gsi))
8233 && (gimple_code (gsi_stmt (gsi)) != GIMPLE_RETURN
8234 && !gimple_call_builtin_p (gsi_stmt (gsi),
8240 end_recording_case_labels ();
8246 const pass_data pass_data_split_crit_edges =
8248 GIMPLE_PASS, /* type */
8249 "crited", /* name */
8250 OPTGROUP_NONE, /* optinfo_flags */
8251 TV_TREE_SPLIT_EDGES, /* tv_id */
8252 PROP_cfg, /* properties_required */
8253 PROP_no_crit_edges, /* properties_provided */
8254 0, /* properties_destroyed */
8255 0, /* todo_flags_start */
8256 0, /* todo_flags_finish */
8259 class pass_split_crit_edges : public gimple_opt_pass
8262 pass_split_crit_edges (gcc::context *ctxt)
8263 : gimple_opt_pass (pass_data_split_crit_edges, ctxt)
8266 /* opt_pass methods: */
8267 virtual unsigned int execute (function *) { return split_critical_edges (); }
8269 opt_pass * clone () { return new pass_split_crit_edges (m_ctxt); }
8270 }; // class pass_split_crit_edges
8275 make_pass_split_crit_edges (gcc::context *ctxt)
8277 return new pass_split_crit_edges (ctxt);
8281 /* Insert COND expression which is GIMPLE_COND after STMT
8282 in basic block BB with appropriate basic block split
8283 and creation of a new conditionally executed basic block.
8284 Return created basic block. */
8286 insert_cond_bb (basic_block bb, gimple stmt, gimple cond)
8288 edge fall = split_block (bb, stmt);
8289 gimple_stmt_iterator iter = gsi_last_bb (bb);
8292 /* Insert cond statement. */
8293 gcc_assert (gimple_code (cond) == GIMPLE_COND);
8294 if (gsi_end_p (iter))
8295 gsi_insert_before (&iter, cond, GSI_CONTINUE_LINKING);
8297 gsi_insert_after (&iter, cond, GSI_CONTINUE_LINKING);
8299 /* Create conditionally executed block. */
8300 new_bb = create_empty_bb (bb);
8301 make_edge (bb, new_bb, EDGE_TRUE_VALUE);
8302 make_single_succ_edge (new_bb, fall->dest, EDGE_FALLTHRU);
8304 /* Fix edge for split bb. */
8305 fall->flags = EDGE_FALSE_VALUE;
8307 /* Update dominance info. */
8308 if (dom_info_available_p (CDI_DOMINATORS))
8310 set_immediate_dominator (CDI_DOMINATORS, new_bb, bb);
8311 set_immediate_dominator (CDI_DOMINATORS, fall->dest, bb);
8314 /* Update loop info. */
8316 add_bb_to_loop (new_bb, bb->loop_father);
8321 /* Build a ternary operation and gimplify it. Emit code before GSI.
8322 Return the gimple_val holding the result. */
8325 gimplify_build3 (gimple_stmt_iterator *gsi, enum tree_code code,
8326 tree type, tree a, tree b, tree c)
8329 location_t loc = gimple_location (gsi_stmt (*gsi));
8331 ret = fold_build3_loc (loc, code, type, a, b, c);
8334 return force_gimple_operand_gsi (gsi, ret, true, NULL, true,
8338 /* Build a binary operation and gimplify it. Emit code before GSI.
8339 Return the gimple_val holding the result. */
8342 gimplify_build2 (gimple_stmt_iterator *gsi, enum tree_code code,
8343 tree type, tree a, tree b)
8347 ret = fold_build2_loc (gimple_location (gsi_stmt (*gsi)), code, type, a, b);
8350 return force_gimple_operand_gsi (gsi, ret, true, NULL, true,
8354 /* Build a unary operation and gimplify it. Emit code before GSI.
8355 Return the gimple_val holding the result. */
8358 gimplify_build1 (gimple_stmt_iterator *gsi, enum tree_code code, tree type,
8363 ret = fold_build1_loc (gimple_location (gsi_stmt (*gsi)), code, type, a);
8366 return force_gimple_operand_gsi (gsi, ret, true, NULL, true,
8372 /* Given a basic block B which ends with a conditional and has
8373 precisely two successors, determine which of the edges is taken if
8374 the conditional is true and which is taken if the conditional is
8375 false. Set TRUE_EDGE and FALSE_EDGE appropriately. */
8378 extract_true_false_edges_from_block (basic_block b,
8382 edge e = EDGE_SUCC (b, 0);
8384 if (e->flags & EDGE_TRUE_VALUE)
8387 *false_edge = EDGE_SUCC (b, 1);
8392 *true_edge = EDGE_SUCC (b, 1);
8396 /* Emit return warnings. */
8400 const pass_data pass_data_warn_function_return =
8402 GIMPLE_PASS, /* type */
8403 "*warn_function_return", /* name */
8404 OPTGROUP_NONE, /* optinfo_flags */
8405 TV_NONE, /* tv_id */
8406 PROP_cfg, /* properties_required */
8407 0, /* properties_provided */
8408 0, /* properties_destroyed */
8409 0, /* todo_flags_start */
8410 0, /* todo_flags_finish */
8413 class pass_warn_function_return : public gimple_opt_pass
8416 pass_warn_function_return (gcc::context *ctxt)
8417 : gimple_opt_pass (pass_data_warn_function_return, ctxt)
8420 /* opt_pass methods: */
8421 virtual unsigned int execute (function *);
8423 }; // class pass_warn_function_return
8426 pass_warn_function_return::execute (function *fun)
8428 source_location location;
8433 if (!targetm.warn_func_return (fun->decl))
8436 /* If we have a path to EXIT, then we do return. */
8437 if (TREE_THIS_VOLATILE (fun->decl)
8438 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) > 0)
8440 location = UNKNOWN_LOCATION;
8441 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (fun)->preds)
8443 last = last_stmt (e->src);
8444 if ((gimple_code (last) == GIMPLE_RETURN
8445 || gimple_call_builtin_p (last, BUILT_IN_RETURN))
8446 && (location = gimple_location (last)) != UNKNOWN_LOCATION)
8449 if (location == UNKNOWN_LOCATION)
8450 location = cfun->function_end_locus;
8451 warning_at (location, 0, "%<noreturn%> function does return");
8454 /* If we see "return;" in some basic block, then we do reach the end
8455 without returning a value. */
8456 else if (warn_return_type
8457 && !TREE_NO_WARNING (fun->decl)
8458 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) > 0
8459 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fun->decl))))
8461 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (fun)->preds)
8463 gimple last = last_stmt (e->src);
8464 greturn *return_stmt = dyn_cast <greturn *> (last);
8466 && gimple_return_retval (return_stmt) == NULL
8467 && !gimple_no_warning_p (last))
8469 location = gimple_location (last);
8470 if (location == UNKNOWN_LOCATION)
8471 location = fun->function_end_locus;
8472 warning_at (location, OPT_Wreturn_type, "control reaches end of non-void function");
8473 TREE_NO_WARNING (fun->decl) = 1;
8484 make_pass_warn_function_return (gcc::context *ctxt)
8486 return new pass_warn_function_return (ctxt);
8489 /* Walk a gimplified function and warn for functions whose return value is
8490 ignored and attribute((warn_unused_result)) is set. This is done before
8491 inlining, so we don't have to worry about that. */
8494 do_warn_unused_result (gimple_seq seq)
8497 gimple_stmt_iterator i;
8499 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
8501 gimple g = gsi_stmt (i);
8503 switch (gimple_code (g))
8506 do_warn_unused_result (gimple_bind_body (as_a <gbind *>(g)));
8509 do_warn_unused_result (gimple_try_eval (g));
8510 do_warn_unused_result (gimple_try_cleanup (g));
8513 do_warn_unused_result (gimple_catch_handler (
8514 as_a <gcatch *> (g)));
8516 case GIMPLE_EH_FILTER:
8517 do_warn_unused_result (gimple_eh_filter_failure (g));
8521 if (gimple_call_lhs (g))
8523 if (gimple_call_internal_p (g))
8526 /* This is a naked call, as opposed to a GIMPLE_CALL with an
8527 LHS. All calls whose value is ignored should be
8528 represented like this. Look for the attribute. */
8529 fdecl = gimple_call_fndecl (g);
8530 ftype = gimple_call_fntype (g);
8532 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
8534 location_t loc = gimple_location (g);
8537 warning_at (loc, OPT_Wunused_result,
8538 "ignoring return value of %qD, "
8539 "declared with attribute warn_unused_result",
8542 warning_at (loc, OPT_Wunused_result,
8543 "ignoring return value of function "
8544 "declared with attribute warn_unused_result");
8549 /* Not a container, not a call, or a call whose value is used. */
8557 const pass_data pass_data_warn_unused_result =
8559 GIMPLE_PASS, /* type */
8560 "*warn_unused_result", /* name */
8561 OPTGROUP_NONE, /* optinfo_flags */
8562 TV_NONE, /* tv_id */
8563 PROP_gimple_any, /* properties_required */
8564 0, /* properties_provided */
8565 0, /* properties_destroyed */
8566 0, /* todo_flags_start */
8567 0, /* todo_flags_finish */
8570 class pass_warn_unused_result : public gimple_opt_pass
8573 pass_warn_unused_result (gcc::context *ctxt)
8574 : gimple_opt_pass (pass_data_warn_unused_result, ctxt)
8577 /* opt_pass methods: */
8578 virtual bool gate (function *) { return flag_warn_unused_result; }
8579 virtual unsigned int execute (function *)
8581 do_warn_unused_result (gimple_body (current_function_decl));
8585 }; // class pass_warn_unused_result
8590 make_pass_warn_unused_result (gcc::context *ctxt)
8592 return new pass_warn_unused_result (ctxt);
8595 /* IPA passes, compilation of earlier functions or inlining
8596 might have changed some properties, such as marked functions nothrow,
8597 pure, const or noreturn.
8598 Remove redundant edges and basic blocks, and create new ones if necessary.
8600 This pass can't be executed as stand alone pass from pass manager, because
8601 in between inlining and this fixup the verify_flow_info would fail. */
8604 execute_fixup_cfg (void)
8607 gimple_stmt_iterator gsi;
8609 gcov_type count_scale;
8614 = GCOV_COMPUTE_SCALE (cgraph_node::get (current_function_decl)->count,
8615 ENTRY_BLOCK_PTR_FOR_FN (cfun)->count);
8617 ENTRY_BLOCK_PTR_FOR_FN (cfun)->count =
8618 cgraph_node::get (current_function_decl)->count;
8619 EXIT_BLOCK_PTR_FOR_FN (cfun)->count =
8620 apply_scale (EXIT_BLOCK_PTR_FOR_FN (cfun)->count,
8623 FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs)
8624 e->count = apply_scale (e->count, count_scale);
8626 FOR_EACH_BB_FN (bb, cfun)
8628 bb->count = apply_scale (bb->count, count_scale);
8629 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
8631 gimple stmt = gsi_stmt (gsi);
8632 tree decl = is_gimple_call (stmt)
8633 ? gimple_call_fndecl (stmt)
8637 int flags = gimple_call_flags (stmt);
8638 if (flags & (ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE))
8640 if (gimple_purge_dead_abnormal_call_edges (bb))
8641 todo |= TODO_cleanup_cfg;
8643 if (gimple_in_ssa_p (cfun))
8645 todo |= TODO_update_ssa | TODO_cleanup_cfg;
8650 if (flags & ECF_NORETURN
8651 && fixup_noreturn_call (stmt))
8652 todo |= TODO_cleanup_cfg;
8655 /* Remove stores to variables we marked write-only.
8656 Keep access when store has side effect, i.e. in case when source
8658 if (gimple_store_p (stmt)
8659 && !gimple_has_side_effects (stmt))
8661 tree lhs = get_base_address (gimple_get_lhs (stmt));
8663 if (TREE_CODE (lhs) == VAR_DECL
8664 && (TREE_STATIC (lhs) || DECL_EXTERNAL (lhs))
8665 && varpool_node::get (lhs)->writeonly)
8667 unlink_stmt_vdef (stmt);
8668 gsi_remove (&gsi, true);
8669 release_defs (stmt);
8670 todo |= TODO_update_ssa | TODO_cleanup_cfg;
8674 /* For calls we can simply remove LHS when it is known
8675 to be write-only. */
8676 if (is_gimple_call (stmt)
8677 && gimple_get_lhs (stmt))
8679 tree lhs = get_base_address (gimple_get_lhs (stmt));
8681 if (TREE_CODE (lhs) == VAR_DECL
8682 && (TREE_STATIC (lhs) || DECL_EXTERNAL (lhs))
8683 && varpool_node::get (lhs)->writeonly)
8685 gimple_call_set_lhs (stmt, NULL);
8687 todo |= TODO_update_ssa | TODO_cleanup_cfg;
8691 if (maybe_clean_eh_stmt (stmt)
8692 && gimple_purge_dead_eh_edges (bb))
8693 todo |= TODO_cleanup_cfg;
8697 FOR_EACH_EDGE (e, ei, bb->succs)
8698 e->count = apply_scale (e->count, count_scale);
8700 /* If we have a basic block with no successors that does not
8701 end with a control statement or a noreturn call end it with
8702 a call to __builtin_unreachable. This situation can occur
8703 when inlining a noreturn call that does in fact return. */
8704 if (EDGE_COUNT (bb->succs) == 0)
8706 gimple stmt = last_stmt (bb);
8708 || (!is_ctrl_stmt (stmt)
8709 && (!is_gimple_call (stmt)
8710 || (gimple_call_flags (stmt) & ECF_NORETURN) == 0)))
8712 if (stmt && is_gimple_call (stmt))
8713 gimple_call_set_ctrl_altering (stmt, false);
8714 stmt = gimple_build_call
8715 (builtin_decl_implicit (BUILT_IN_UNREACHABLE), 0);
8716 gimple_stmt_iterator gsi = gsi_last_bb (bb);
8717 gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
8721 if (count_scale != REG_BR_PROB_BASE)
8722 compute_function_frequency ();
8725 && (todo & TODO_cleanup_cfg))
8726 loops_state_set (LOOPS_NEED_FIXUP);
8733 const pass_data pass_data_fixup_cfg =
8735 GIMPLE_PASS, /* type */
8736 "fixup_cfg", /* name */
8737 OPTGROUP_NONE, /* optinfo_flags */
8738 TV_NONE, /* tv_id */
8739 PROP_cfg, /* properties_required */
8740 0, /* properties_provided */
8741 0, /* properties_destroyed */
8742 0, /* todo_flags_start */
8743 0, /* todo_flags_finish */
8746 class pass_fixup_cfg : public gimple_opt_pass
8749 pass_fixup_cfg (gcc::context *ctxt)
8750 : gimple_opt_pass (pass_data_fixup_cfg, ctxt)
8753 /* opt_pass methods: */
8754 opt_pass * clone () { return new pass_fixup_cfg (m_ctxt); }
8755 virtual unsigned int execute (function *) { return execute_fixup_cfg (); }
8757 }; // class pass_fixup_cfg
8762 make_pass_fixup_cfg (gcc::context *ctxt)
8764 return new pass_fixup_cfg (ctxt);
8767 /* Garbage collection support for edge_def. */
8769 extern void gt_ggc_mx (tree&);
8770 extern void gt_ggc_mx (gimple&);
8771 extern void gt_ggc_mx (rtx&);
8772 extern void gt_ggc_mx (basic_block&);
8775 gt_ggc_mx (rtx_insn *& x)
8778 gt_ggc_mx_rtx_def ((void *) x);
8782 gt_ggc_mx (edge_def *e)
8784 tree block = LOCATION_BLOCK (e->goto_locus);
8786 gt_ggc_mx (e->dest);
8787 if (current_ir_type () == IR_GIMPLE)
8788 gt_ggc_mx (e->insns.g);
8790 gt_ggc_mx (e->insns.r);
8794 /* PCH support for edge_def. */
8796 extern void gt_pch_nx (tree&);
8797 extern void gt_pch_nx (gimple&);
8798 extern void gt_pch_nx (rtx&);
8799 extern void gt_pch_nx (basic_block&);
8802 gt_pch_nx (rtx_insn *& x)
8805 gt_pch_nx_rtx_def ((void *) x);
8809 gt_pch_nx (edge_def *e)
8811 tree block = LOCATION_BLOCK (e->goto_locus);
8813 gt_pch_nx (e->dest);
8814 if (current_ir_type () == IR_GIMPLE)
8815 gt_pch_nx (e->insns.g);
8817 gt_pch_nx (e->insns.r);
8822 gt_pch_nx (edge_def *e, gt_pointer_operator op, void *cookie)
8824 tree block = LOCATION_BLOCK (e->goto_locus);
8825 op (&(e->src), cookie);
8826 op (&(e->dest), cookie);
8827 if (current_ir_type () == IR_GIMPLE)
8828 op (&(e->insns.g), cookie);
8830 op (&(e->insns.r), cookie);
8831 op (&(block), cookie);