Add Cortex-A15 tuning to gcc.dg/uninit-pred-8_a.c
[official-gcc.git] / gcc / tree-cfg.c
blob315d0e16ed05817bc7d476393ae0376ad51ad7ed
1 /* Control flow functions for trees.
2 Copyright (C) 2001-2017 Free Software Foundation, Inc.
3 Contributed by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "backend.h"
25 #include "target.h"
26 #include "rtl.h"
27 #include "tree.h"
28 #include "gimple.h"
29 #include "cfghooks.h"
30 #include "tree-pass.h"
31 #include "ssa.h"
32 #include "cgraph.h"
33 #include "gimple-pretty-print.h"
34 #include "diagnostic-core.h"
35 #include "fold-const.h"
36 #include "trans-mem.h"
37 #include "stor-layout.h"
38 #include "print-tree.h"
39 #include "cfganal.h"
40 #include "gimple-fold.h"
41 #include "tree-eh.h"
42 #include "gimple-iterator.h"
43 #include "gimplify-me.h"
44 #include "gimple-walk.h"
45 #include "tree-cfg.h"
46 #include "tree-ssa-loop-manip.h"
47 #include "tree-ssa-loop-niter.h"
48 #include "tree-into-ssa.h"
49 #include "tree-dfa.h"
50 #include "tree-ssa.h"
51 #include "except.h"
52 #include "cfgloop.h"
53 #include "tree-ssa-propagate.h"
54 #include "value-prof.h"
55 #include "tree-inline.h"
56 #include "tree-ssa-live.h"
57 #include "omp-general.h"
58 #include "omp-expand.h"
59 #include "tree-cfgcleanup.h"
60 #include "gimplify.h"
61 #include "attribs.h"
62 #include "selftest.h"
64 /* This file contains functions for building the Control Flow Graph (CFG)
65 for a function tree. */
67 /* Local declarations. */
69 /* Initial capacity for the basic block array. */
70 static const int initial_cfg_capacity = 20;
72 /* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
73 which use a particular edge. The CASE_LABEL_EXPRs are chained together
74 via their CASE_CHAIN field, which we clear after we're done with the
75 hash table to prevent problems with duplication of GIMPLE_SWITCHes.
77 Access to this list of CASE_LABEL_EXPRs allows us to efficiently
78 update the case vector in response to edge redirections.
80 Right now this table is set up and torn down at key points in the
81 compilation process. It would be nice if we could make the table
82 more persistent. The key is getting notification of changes to
83 the CFG (particularly edge removal, creation and redirection). */
85 static hash_map<edge, tree> *edge_to_cases;
87 /* If we record edge_to_cases, this bitmap will hold indexes
88 of basic blocks that end in a GIMPLE_SWITCH which we touched
89 due to edge manipulations. */
91 static bitmap touched_switch_bbs;
93 /* CFG statistics. */
94 struct cfg_stats_d
96 long num_merged_labels;
99 static struct cfg_stats_d cfg_stats;
101 /* Data to pass to replace_block_vars_by_duplicates_1. */
102 struct replace_decls_d
104 hash_map<tree, tree> *vars_map;
105 tree to_context;
108 /* Hash table to store last discriminator assigned for each locus. */
109 struct locus_discrim_map
111 location_t locus;
112 int discriminator;
115 /* Hashtable helpers. */
117 struct locus_discrim_hasher : free_ptr_hash <locus_discrim_map>
119 static inline hashval_t hash (const locus_discrim_map *);
120 static inline bool equal (const locus_discrim_map *,
121 const locus_discrim_map *);
124 /* Trivial hash function for a location_t. ITEM is a pointer to
125 a hash table entry that maps a location_t to a discriminator. */
127 inline hashval_t
128 locus_discrim_hasher::hash (const locus_discrim_map *item)
130 return LOCATION_LINE (item->locus);
133 /* Equality function for the locus-to-discriminator map. A and B
134 point to the two hash table entries to compare. */
136 inline bool
137 locus_discrim_hasher::equal (const locus_discrim_map *a,
138 const locus_discrim_map *b)
140 return LOCATION_LINE (a->locus) == LOCATION_LINE (b->locus);
143 static hash_table<locus_discrim_hasher> *discriminator_per_locus;
145 /* Basic blocks and flowgraphs. */
146 static void make_blocks (gimple_seq);
148 /* Edges. */
149 static void make_edges (void);
150 static void assign_discriminators (void);
151 static void make_cond_expr_edges (basic_block);
152 static void make_gimple_switch_edges (gswitch *, basic_block);
153 static bool make_goto_expr_edges (basic_block);
154 static void make_gimple_asm_edges (basic_block);
155 static edge gimple_redirect_edge_and_branch (edge, basic_block);
156 static edge gimple_try_redirect_by_replacing_jump (edge, basic_block);
158 /* Various helpers. */
159 static inline bool stmt_starts_bb_p (gimple *, gimple *);
160 static int gimple_verify_flow_info (void);
161 static void gimple_make_forwarder_block (edge);
162 static gimple *first_non_label_stmt (basic_block);
163 static bool verify_gimple_transaction (gtransaction *);
164 static bool call_can_make_abnormal_goto (gimple *);
166 /* Flowgraph optimization and cleanup. */
167 static void gimple_merge_blocks (basic_block, basic_block);
168 static bool gimple_can_merge_blocks_p (basic_block, basic_block);
169 static void remove_bb (basic_block);
170 static edge find_taken_edge_computed_goto (basic_block, tree);
171 static edge find_taken_edge_cond_expr (basic_block, tree);
172 static edge find_taken_edge_switch_expr (gswitch *, basic_block, tree);
173 static tree find_case_label_for_value (gswitch *, tree);
174 static void lower_phi_internal_fn ();
176 void
177 init_empty_tree_cfg_for_function (struct function *fn)
179 /* Initialize the basic block array. */
180 init_flow (fn);
181 profile_status_for_fn (fn) = PROFILE_ABSENT;
182 n_basic_blocks_for_fn (fn) = NUM_FIXED_BLOCKS;
183 last_basic_block_for_fn (fn) = NUM_FIXED_BLOCKS;
184 vec_alloc (basic_block_info_for_fn (fn), initial_cfg_capacity);
185 vec_safe_grow_cleared (basic_block_info_for_fn (fn),
186 initial_cfg_capacity);
188 /* Build a mapping of labels to their associated blocks. */
189 vec_alloc (label_to_block_map_for_fn (fn), initial_cfg_capacity);
190 vec_safe_grow_cleared (label_to_block_map_for_fn (fn),
191 initial_cfg_capacity);
193 SET_BASIC_BLOCK_FOR_FN (fn, ENTRY_BLOCK, ENTRY_BLOCK_PTR_FOR_FN (fn));
194 SET_BASIC_BLOCK_FOR_FN (fn, EXIT_BLOCK, EXIT_BLOCK_PTR_FOR_FN (fn));
196 ENTRY_BLOCK_PTR_FOR_FN (fn)->next_bb
197 = EXIT_BLOCK_PTR_FOR_FN (fn);
198 EXIT_BLOCK_PTR_FOR_FN (fn)->prev_bb
199 = ENTRY_BLOCK_PTR_FOR_FN (fn);
202 void
203 init_empty_tree_cfg (void)
205 init_empty_tree_cfg_for_function (cfun);
208 /*---------------------------------------------------------------------------
209 Create basic blocks
210 ---------------------------------------------------------------------------*/
212 /* Entry point to the CFG builder for trees. SEQ is the sequence of
213 statements to be added to the flowgraph. */
215 static void
216 build_gimple_cfg (gimple_seq seq)
218 /* Register specific gimple functions. */
219 gimple_register_cfg_hooks ();
221 memset ((void *) &cfg_stats, 0, sizeof (cfg_stats));
223 init_empty_tree_cfg ();
225 make_blocks (seq);
227 /* Make sure there is always at least one block, even if it's empty. */
228 if (n_basic_blocks_for_fn (cfun) == NUM_FIXED_BLOCKS)
229 create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun));
231 /* Adjust the size of the array. */
232 if (basic_block_info_for_fn (cfun)->length ()
233 < (size_t) n_basic_blocks_for_fn (cfun))
234 vec_safe_grow_cleared (basic_block_info_for_fn (cfun),
235 n_basic_blocks_for_fn (cfun));
237 /* To speed up statement iterator walks, we first purge dead labels. */
238 cleanup_dead_labels ();
240 /* Group case nodes to reduce the number of edges.
241 We do this after cleaning up dead labels because otherwise we miss
242 a lot of obvious case merging opportunities. */
243 group_case_labels ();
245 /* Create the edges of the flowgraph. */
246 discriminator_per_locus = new hash_table<locus_discrim_hasher> (13);
247 make_edges ();
248 assign_discriminators ();
249 lower_phi_internal_fn ();
250 cleanup_dead_labels ();
251 delete discriminator_per_locus;
252 discriminator_per_locus = NULL;
255 /* Look for ANNOTATE calls with loop annotation kind in BB; if found, remove
256 them and propagate the information to LOOP. We assume that the annotations
257 come immediately before the condition in BB, if any. */
259 static void
260 replace_loop_annotate_in_block (basic_block bb, struct loop *loop)
262 gimple_stmt_iterator gsi = gsi_last_bb (bb);
263 gimple *stmt = gsi_stmt (gsi);
265 if (!(stmt && gimple_code (stmt) == GIMPLE_COND))
266 return;
268 for (gsi_prev_nondebug (&gsi); !gsi_end_p (gsi); gsi_prev (&gsi))
270 stmt = gsi_stmt (gsi);
271 if (gimple_code (stmt) != GIMPLE_CALL)
272 break;
273 if (!gimple_call_internal_p (stmt)
274 || gimple_call_internal_fn (stmt) != IFN_ANNOTATE)
275 break;
277 switch ((annot_expr_kind) tree_to_shwi (gimple_call_arg (stmt, 1)))
279 case annot_expr_ivdep_kind:
280 loop->safelen = INT_MAX;
281 break;
282 case annot_expr_no_vector_kind:
283 loop->dont_vectorize = true;
284 break;
285 case annot_expr_vector_kind:
286 loop->force_vectorize = true;
287 cfun->has_force_vectorize_loops = true;
288 break;
289 default:
290 gcc_unreachable ();
293 stmt = gimple_build_assign (gimple_call_lhs (stmt),
294 gimple_call_arg (stmt, 0));
295 gsi_replace (&gsi, stmt, true);
299 /* Look for ANNOTATE calls with loop annotation kind; if found, remove
300 them and propagate the information to the loop. We assume that the
301 annotations come immediately before the condition of the loop. */
303 static void
304 replace_loop_annotate (void)
306 struct loop *loop;
307 basic_block bb;
308 gimple_stmt_iterator gsi;
309 gimple *stmt;
311 FOR_EACH_LOOP (loop, 0)
313 /* First look into the header. */
314 replace_loop_annotate_in_block (loop->header, loop);
316 /* Then look into the latch, if any. */
317 if (loop->latch)
318 replace_loop_annotate_in_block (loop->latch, loop);
321 /* Remove IFN_ANNOTATE. Safeguard for the case loop->latch == NULL. */
322 FOR_EACH_BB_FN (bb, cfun)
324 for (gsi = gsi_last_bb (bb); !gsi_end_p (gsi); gsi_prev (&gsi))
326 stmt = gsi_stmt (gsi);
327 if (gimple_code (stmt) != GIMPLE_CALL)
328 continue;
329 if (!gimple_call_internal_p (stmt)
330 || gimple_call_internal_fn (stmt) != IFN_ANNOTATE)
331 continue;
333 switch ((annot_expr_kind) tree_to_shwi (gimple_call_arg (stmt, 1)))
335 case annot_expr_ivdep_kind:
336 case annot_expr_no_vector_kind:
337 case annot_expr_vector_kind:
338 break;
339 default:
340 gcc_unreachable ();
343 warning_at (gimple_location (stmt), 0, "ignoring loop annotation");
344 stmt = gimple_build_assign (gimple_call_lhs (stmt),
345 gimple_call_arg (stmt, 0));
346 gsi_replace (&gsi, stmt, true);
351 /* Lower internal PHI function from GIMPLE FE. */
353 static void
354 lower_phi_internal_fn ()
356 basic_block bb, pred = NULL;
357 gimple_stmt_iterator gsi;
358 tree lhs;
359 gphi *phi_node;
360 gimple *stmt;
362 /* After edge creation, handle __PHI function from GIMPLE FE. */
363 FOR_EACH_BB_FN (bb, cfun)
365 for (gsi = gsi_after_labels (bb); !gsi_end_p (gsi);)
367 stmt = gsi_stmt (gsi);
368 if (! gimple_call_internal_p (stmt, IFN_PHI))
369 break;
371 lhs = gimple_call_lhs (stmt);
372 phi_node = create_phi_node (lhs, bb);
374 /* Add arguments to the PHI node. */
375 for (unsigned i = 0; i < gimple_call_num_args (stmt); ++i)
377 tree arg = gimple_call_arg (stmt, i);
378 if (TREE_CODE (arg) == LABEL_DECL)
379 pred = label_to_block (arg);
380 else
382 edge e = find_edge (pred, bb);
383 add_phi_arg (phi_node, arg, e, UNKNOWN_LOCATION);
387 gsi_remove (&gsi, true);
392 static unsigned int
393 execute_build_cfg (void)
395 gimple_seq body = gimple_body (current_function_decl);
397 build_gimple_cfg (body);
398 gimple_set_body (current_function_decl, NULL);
399 if (dump_file && (dump_flags & TDF_DETAILS))
401 fprintf (dump_file, "Scope blocks:\n");
402 dump_scope_blocks (dump_file, dump_flags);
404 cleanup_tree_cfg ();
405 loop_optimizer_init (AVOID_CFG_MODIFICATIONS);
406 replace_loop_annotate ();
407 return 0;
410 namespace {
412 const pass_data pass_data_build_cfg =
414 GIMPLE_PASS, /* type */
415 "cfg", /* name */
416 OPTGROUP_NONE, /* optinfo_flags */
417 TV_TREE_CFG, /* tv_id */
418 PROP_gimple_leh, /* properties_required */
419 ( PROP_cfg | PROP_loops ), /* properties_provided */
420 0, /* properties_destroyed */
421 0, /* todo_flags_start */
422 0, /* todo_flags_finish */
425 class pass_build_cfg : public gimple_opt_pass
427 public:
428 pass_build_cfg (gcc::context *ctxt)
429 : gimple_opt_pass (pass_data_build_cfg, ctxt)
432 /* opt_pass methods: */
433 virtual unsigned int execute (function *) { return execute_build_cfg (); }
435 }; // class pass_build_cfg
437 } // anon namespace
439 gimple_opt_pass *
440 make_pass_build_cfg (gcc::context *ctxt)
442 return new pass_build_cfg (ctxt);
446 /* Return true if T is a computed goto. */
448 bool
449 computed_goto_p (gimple *t)
451 return (gimple_code (t) == GIMPLE_GOTO
452 && TREE_CODE (gimple_goto_dest (t)) != LABEL_DECL);
455 /* Returns true for edge E where e->src ends with a GIMPLE_COND and
456 the other edge points to a bb with just __builtin_unreachable ().
457 I.e. return true for C->M edge in:
458 <bb C>:
460 if (something)
461 goto <bb N>;
462 else
463 goto <bb M>;
464 <bb N>:
465 __builtin_unreachable ();
466 <bb M>: */
468 bool
469 assert_unreachable_fallthru_edge_p (edge e)
471 basic_block pred_bb = e->src;
472 gimple *last = last_stmt (pred_bb);
473 if (last && gimple_code (last) == GIMPLE_COND)
475 basic_block other_bb = EDGE_SUCC (pred_bb, 0)->dest;
476 if (other_bb == e->dest)
477 other_bb = EDGE_SUCC (pred_bb, 1)->dest;
478 if (EDGE_COUNT (other_bb->succs) == 0)
480 gimple_stmt_iterator gsi = gsi_after_labels (other_bb);
481 gimple *stmt;
483 if (gsi_end_p (gsi))
484 return false;
485 stmt = gsi_stmt (gsi);
486 while (is_gimple_debug (stmt) || gimple_clobber_p (stmt))
488 gsi_next (&gsi);
489 if (gsi_end_p (gsi))
490 return false;
491 stmt = gsi_stmt (gsi);
493 return gimple_call_builtin_p (stmt, BUILT_IN_UNREACHABLE);
496 return false;
500 /* Initialize GF_CALL_CTRL_ALTERING flag, which indicates the call
501 could alter control flow except via eh. We initialize the flag at
502 CFG build time and only ever clear it later. */
504 static void
505 gimple_call_initialize_ctrl_altering (gimple *stmt)
507 int flags = gimple_call_flags (stmt);
509 /* A call alters control flow if it can make an abnormal goto. */
510 if (call_can_make_abnormal_goto (stmt)
511 /* A call also alters control flow if it does not return. */
512 || flags & ECF_NORETURN
513 /* TM ending statements have backedges out of the transaction.
514 Return true so we split the basic block containing them.
515 Note that the TM_BUILTIN test is merely an optimization. */
516 || ((flags & ECF_TM_BUILTIN)
517 && is_tm_ending_fndecl (gimple_call_fndecl (stmt)))
518 /* BUILT_IN_RETURN call is same as return statement. */
519 || gimple_call_builtin_p (stmt, BUILT_IN_RETURN)
520 /* IFN_UNIQUE should be the last insn, to make checking for it
521 as cheap as possible. */
522 || (gimple_call_internal_p (stmt)
523 && gimple_call_internal_unique_p (stmt)))
524 gimple_call_set_ctrl_altering (stmt, true);
525 else
526 gimple_call_set_ctrl_altering (stmt, false);
530 /* Insert SEQ after BB and build a flowgraph. */
532 static basic_block
533 make_blocks_1 (gimple_seq seq, basic_block bb)
535 gimple_stmt_iterator i = gsi_start (seq);
536 gimple *stmt = NULL;
537 bool start_new_block = true;
538 bool first_stmt_of_seq = true;
540 while (!gsi_end_p (i))
542 gimple *prev_stmt;
544 prev_stmt = stmt;
545 stmt = gsi_stmt (i);
547 if (stmt && is_gimple_call (stmt))
548 gimple_call_initialize_ctrl_altering (stmt);
550 /* If the statement starts a new basic block or if we have determined
551 in a previous pass that we need to create a new block for STMT, do
552 so now. */
553 if (start_new_block || stmt_starts_bb_p (stmt, prev_stmt))
555 if (!first_stmt_of_seq)
556 gsi_split_seq_before (&i, &seq);
557 bb = create_basic_block (seq, bb);
558 start_new_block = false;
561 /* Now add STMT to BB and create the subgraphs for special statement
562 codes. */
563 gimple_set_bb (stmt, bb);
565 /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
566 next iteration. */
567 if (stmt_ends_bb_p (stmt))
569 /* If the stmt can make abnormal goto use a new temporary
570 for the assignment to the LHS. This makes sure the old value
571 of the LHS is available on the abnormal edge. Otherwise
572 we will end up with overlapping life-ranges for abnormal
573 SSA names. */
574 if (gimple_has_lhs (stmt)
575 && stmt_can_make_abnormal_goto (stmt)
576 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt))))
578 tree lhs = gimple_get_lhs (stmt);
579 tree tmp = create_tmp_var (TREE_TYPE (lhs));
580 gimple *s = gimple_build_assign (lhs, tmp);
581 gimple_set_location (s, gimple_location (stmt));
582 gimple_set_block (s, gimple_block (stmt));
583 gimple_set_lhs (stmt, tmp);
584 if (TREE_CODE (TREE_TYPE (tmp)) == COMPLEX_TYPE
585 || TREE_CODE (TREE_TYPE (tmp)) == VECTOR_TYPE)
586 DECL_GIMPLE_REG_P (tmp) = 1;
587 gsi_insert_after (&i, s, GSI_SAME_STMT);
589 start_new_block = true;
592 gsi_next (&i);
593 first_stmt_of_seq = false;
595 return bb;
598 /* Build a flowgraph for the sequence of stmts SEQ. */
600 static void
601 make_blocks (gimple_seq seq)
603 make_blocks_1 (seq, ENTRY_BLOCK_PTR_FOR_FN (cfun));
606 /* Create and return a new empty basic block after bb AFTER. */
608 static basic_block
609 create_bb (void *h, void *e, basic_block after)
611 basic_block bb;
613 gcc_assert (!e);
615 /* Create and initialize a new basic block. Since alloc_block uses
616 GC allocation that clears memory to allocate a basic block, we do
617 not have to clear the newly allocated basic block here. */
618 bb = alloc_block ();
620 bb->index = last_basic_block_for_fn (cfun);
621 bb->flags = BB_NEW;
622 set_bb_seq (bb, h ? (gimple_seq) h : NULL);
624 /* Add the new block to the linked list of blocks. */
625 link_block (bb, after);
627 /* Grow the basic block array if needed. */
628 if ((size_t) last_basic_block_for_fn (cfun)
629 == basic_block_info_for_fn (cfun)->length ())
631 size_t new_size =
632 (last_basic_block_for_fn (cfun)
633 + (last_basic_block_for_fn (cfun) + 3) / 4);
634 vec_safe_grow_cleared (basic_block_info_for_fn (cfun), new_size);
637 /* Add the newly created block to the array. */
638 SET_BASIC_BLOCK_FOR_FN (cfun, last_basic_block_for_fn (cfun), bb);
640 n_basic_blocks_for_fn (cfun)++;
641 last_basic_block_for_fn (cfun)++;
643 return bb;
647 /*---------------------------------------------------------------------------
648 Edge creation
649 ---------------------------------------------------------------------------*/
651 /* If basic block BB has an abnormal edge to a basic block
652 containing IFN_ABNORMAL_DISPATCHER internal call, return
653 that the dispatcher's basic block, otherwise return NULL. */
655 basic_block
656 get_abnormal_succ_dispatcher (basic_block bb)
658 edge e;
659 edge_iterator ei;
661 FOR_EACH_EDGE (e, ei, bb->succs)
662 if ((e->flags & (EDGE_ABNORMAL | EDGE_EH)) == EDGE_ABNORMAL)
664 gimple_stmt_iterator gsi
665 = gsi_start_nondebug_after_labels_bb (e->dest);
666 gimple *g = gsi_stmt (gsi);
667 if (g && gimple_call_internal_p (g, IFN_ABNORMAL_DISPATCHER))
668 return e->dest;
670 return NULL;
673 /* Helper function for make_edges. Create a basic block with
674 with ABNORMAL_DISPATCHER internal call in it if needed, and
675 create abnormal edges from BBS to it and from it to FOR_BB
676 if COMPUTED_GOTO is false, otherwise factor the computed gotos. */
678 static void
679 handle_abnormal_edges (basic_block *dispatcher_bbs,
680 basic_block for_bb, int *bb_to_omp_idx,
681 auto_vec<basic_block> *bbs, bool computed_goto)
683 basic_block *dispatcher = dispatcher_bbs + (computed_goto ? 1 : 0);
684 unsigned int idx = 0;
685 basic_block bb;
686 bool inner = false;
688 if (bb_to_omp_idx)
690 dispatcher = dispatcher_bbs + 2 * bb_to_omp_idx[for_bb->index];
691 if (bb_to_omp_idx[for_bb->index] != 0)
692 inner = true;
695 /* If the dispatcher has been created already, then there are basic
696 blocks with abnormal edges to it, so just make a new edge to
697 for_bb. */
698 if (*dispatcher == NULL)
700 /* Check if there are any basic blocks that need to have
701 abnormal edges to this dispatcher. If there are none, return
702 early. */
703 if (bb_to_omp_idx == NULL)
705 if (bbs->is_empty ())
706 return;
708 else
710 FOR_EACH_VEC_ELT (*bbs, idx, bb)
711 if (bb_to_omp_idx[bb->index] == bb_to_omp_idx[for_bb->index])
712 break;
713 if (bb == NULL)
714 return;
717 /* Create the dispatcher bb. */
718 *dispatcher = create_basic_block (NULL, for_bb);
719 if (computed_goto)
721 /* Factor computed gotos into a common computed goto site. Also
722 record the location of that site so that we can un-factor the
723 gotos after we have converted back to normal form. */
724 gimple_stmt_iterator gsi = gsi_start_bb (*dispatcher);
726 /* Create the destination of the factored goto. Each original
727 computed goto will put its desired destination into this
728 variable and jump to the label we create immediately below. */
729 tree var = create_tmp_var (ptr_type_node, "gotovar");
731 /* Build a label for the new block which will contain the
732 factored computed goto. */
733 tree factored_label_decl
734 = create_artificial_label (UNKNOWN_LOCATION);
735 gimple *factored_computed_goto_label
736 = gimple_build_label (factored_label_decl);
737 gsi_insert_after (&gsi, factored_computed_goto_label, GSI_NEW_STMT);
739 /* Build our new computed goto. */
740 gimple *factored_computed_goto = gimple_build_goto (var);
741 gsi_insert_after (&gsi, factored_computed_goto, GSI_NEW_STMT);
743 FOR_EACH_VEC_ELT (*bbs, idx, bb)
745 if (bb_to_omp_idx
746 && bb_to_omp_idx[bb->index] != bb_to_omp_idx[for_bb->index])
747 continue;
749 gsi = gsi_last_bb (bb);
750 gimple *last = gsi_stmt (gsi);
752 gcc_assert (computed_goto_p (last));
754 /* Copy the original computed goto's destination into VAR. */
755 gimple *assignment
756 = gimple_build_assign (var, gimple_goto_dest (last));
757 gsi_insert_before (&gsi, assignment, GSI_SAME_STMT);
759 edge e = make_edge (bb, *dispatcher, EDGE_FALLTHRU);
760 e->goto_locus = gimple_location (last);
761 gsi_remove (&gsi, true);
764 else
766 tree arg = inner ? boolean_true_node : boolean_false_node;
767 gimple *g = gimple_build_call_internal (IFN_ABNORMAL_DISPATCHER,
768 1, arg);
769 gimple_stmt_iterator gsi = gsi_after_labels (*dispatcher);
770 gsi_insert_after (&gsi, g, GSI_NEW_STMT);
772 /* Create predecessor edges of the dispatcher. */
773 FOR_EACH_VEC_ELT (*bbs, idx, bb)
775 if (bb_to_omp_idx
776 && bb_to_omp_idx[bb->index] != bb_to_omp_idx[for_bb->index])
777 continue;
778 make_edge (bb, *dispatcher, EDGE_ABNORMAL);
783 make_edge (*dispatcher, for_bb, EDGE_ABNORMAL);
786 /* Creates outgoing edges for BB. Returns 1 when it ends with an
787 computed goto, returns 2 when it ends with a statement that
788 might return to this function via an nonlocal goto, otherwise
789 return 0. Updates *PCUR_REGION with the OMP region this BB is in. */
791 static int
792 make_edges_bb (basic_block bb, struct omp_region **pcur_region, int *pomp_index)
794 gimple *last = last_stmt (bb);
795 bool fallthru = false;
796 int ret = 0;
798 if (!last)
799 return ret;
801 switch (gimple_code (last))
803 case GIMPLE_GOTO:
804 if (make_goto_expr_edges (bb))
805 ret = 1;
806 fallthru = false;
807 break;
808 case GIMPLE_RETURN:
810 edge e = make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
811 e->goto_locus = gimple_location (last);
812 fallthru = false;
814 break;
815 case GIMPLE_COND:
816 make_cond_expr_edges (bb);
817 fallthru = false;
818 break;
819 case GIMPLE_SWITCH:
820 make_gimple_switch_edges (as_a <gswitch *> (last), bb);
821 fallthru = false;
822 break;
823 case GIMPLE_RESX:
824 make_eh_edges (last);
825 fallthru = false;
826 break;
827 case GIMPLE_EH_DISPATCH:
828 fallthru = make_eh_dispatch_edges (as_a <geh_dispatch *> (last));
829 break;
831 case GIMPLE_CALL:
832 /* If this function receives a nonlocal goto, then we need to
833 make edges from this call site to all the nonlocal goto
834 handlers. */
835 if (stmt_can_make_abnormal_goto (last))
836 ret = 2;
838 /* If this statement has reachable exception handlers, then
839 create abnormal edges to them. */
840 make_eh_edges (last);
842 /* BUILTIN_RETURN is really a return statement. */
843 if (gimple_call_builtin_p (last, BUILT_IN_RETURN))
845 make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
846 fallthru = false;
848 /* Some calls are known not to return. */
849 else
850 fallthru = !gimple_call_noreturn_p (last);
851 break;
853 case GIMPLE_ASSIGN:
854 /* A GIMPLE_ASSIGN may throw internally and thus be considered
855 control-altering. */
856 if (is_ctrl_altering_stmt (last))
857 make_eh_edges (last);
858 fallthru = true;
859 break;
861 case GIMPLE_ASM:
862 make_gimple_asm_edges (bb);
863 fallthru = true;
864 break;
866 CASE_GIMPLE_OMP:
867 fallthru = omp_make_gimple_edges (bb, pcur_region, pomp_index);
868 break;
870 case GIMPLE_TRANSACTION:
872 gtransaction *txn = as_a <gtransaction *> (last);
873 tree label1 = gimple_transaction_label_norm (txn);
874 tree label2 = gimple_transaction_label_uninst (txn);
876 if (label1)
877 make_edge (bb, label_to_block (label1), EDGE_FALLTHRU);
878 if (label2)
879 make_edge (bb, label_to_block (label2),
880 EDGE_TM_UNINSTRUMENTED | (label1 ? 0 : EDGE_FALLTHRU));
882 tree label3 = gimple_transaction_label_over (txn);
883 if (gimple_transaction_subcode (txn)
884 & (GTMA_HAVE_ABORT | GTMA_IS_OUTER))
885 make_edge (bb, label_to_block (label3), EDGE_TM_ABORT);
887 fallthru = false;
889 break;
891 default:
892 gcc_assert (!stmt_ends_bb_p (last));
893 fallthru = true;
894 break;
897 if (fallthru)
898 make_edge (bb, bb->next_bb, EDGE_FALLTHRU);
900 return ret;
903 /* Join all the blocks in the flowgraph. */
905 static void
906 make_edges (void)
908 basic_block bb;
909 struct omp_region *cur_region = NULL;
910 auto_vec<basic_block> ab_edge_goto;
911 auto_vec<basic_block> ab_edge_call;
912 int *bb_to_omp_idx = NULL;
913 int cur_omp_region_idx = 0;
915 /* Create an edge from entry to the first block with executable
916 statements in it. */
917 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun),
918 BASIC_BLOCK_FOR_FN (cfun, NUM_FIXED_BLOCKS),
919 EDGE_FALLTHRU);
921 /* Traverse the basic block array placing edges. */
922 FOR_EACH_BB_FN (bb, cfun)
924 int mer;
926 if (bb_to_omp_idx)
927 bb_to_omp_idx[bb->index] = cur_omp_region_idx;
929 mer = make_edges_bb (bb, &cur_region, &cur_omp_region_idx);
930 if (mer == 1)
931 ab_edge_goto.safe_push (bb);
932 else if (mer == 2)
933 ab_edge_call.safe_push (bb);
935 if (cur_region && bb_to_omp_idx == NULL)
936 bb_to_omp_idx = XCNEWVEC (int, n_basic_blocks_for_fn (cfun));
939 /* Computed gotos are hell to deal with, especially if there are
940 lots of them with a large number of destinations. So we factor
941 them to a common computed goto location before we build the
942 edge list. After we convert back to normal form, we will un-factor
943 the computed gotos since factoring introduces an unwanted jump.
944 For non-local gotos and abnormal edges from calls to calls that return
945 twice or forced labels, factor the abnormal edges too, by having all
946 abnormal edges from the calls go to a common artificial basic block
947 with ABNORMAL_DISPATCHER internal call and abnormal edges from that
948 basic block to all forced labels and calls returning twice.
949 We do this per-OpenMP structured block, because those regions
950 are guaranteed to be single entry single exit by the standard,
951 so it is not allowed to enter or exit such regions abnormally this way,
952 thus all computed gotos, non-local gotos and setjmp/longjmp calls
953 must not transfer control across SESE region boundaries. */
954 if (!ab_edge_goto.is_empty () || !ab_edge_call.is_empty ())
956 gimple_stmt_iterator gsi;
957 basic_block dispatcher_bb_array[2] = { NULL, NULL };
958 basic_block *dispatcher_bbs = dispatcher_bb_array;
959 int count = n_basic_blocks_for_fn (cfun);
961 if (bb_to_omp_idx)
962 dispatcher_bbs = XCNEWVEC (basic_block, 2 * count);
964 FOR_EACH_BB_FN (bb, cfun)
966 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
968 glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
969 tree target;
971 if (!label_stmt)
972 break;
974 target = gimple_label_label (label_stmt);
976 /* Make an edge to every label block that has been marked as a
977 potential target for a computed goto or a non-local goto. */
978 if (FORCED_LABEL (target))
979 handle_abnormal_edges (dispatcher_bbs, bb, bb_to_omp_idx,
980 &ab_edge_goto, true);
981 if (DECL_NONLOCAL (target))
983 handle_abnormal_edges (dispatcher_bbs, bb, bb_to_omp_idx,
984 &ab_edge_call, false);
985 break;
989 if (!gsi_end_p (gsi) && is_gimple_debug (gsi_stmt (gsi)))
990 gsi_next_nondebug (&gsi);
991 if (!gsi_end_p (gsi))
993 /* Make an edge to every setjmp-like call. */
994 gimple *call_stmt = gsi_stmt (gsi);
995 if (is_gimple_call (call_stmt)
996 && ((gimple_call_flags (call_stmt) & ECF_RETURNS_TWICE)
997 || gimple_call_builtin_p (call_stmt,
998 BUILT_IN_SETJMP_RECEIVER)))
999 handle_abnormal_edges (dispatcher_bbs, bb, bb_to_omp_idx,
1000 &ab_edge_call, false);
1004 if (bb_to_omp_idx)
1005 XDELETE (dispatcher_bbs);
1008 XDELETE (bb_to_omp_idx);
1010 omp_free_regions ();
1013 /* Add SEQ after GSI. Start new bb after GSI, and created further bbs as
1014 needed. Returns true if new bbs were created.
1015 Note: This is transitional code, and should not be used for new code. We
1016 should be able to get rid of this by rewriting all target va-arg
1017 gimplification hooks to use an interface gimple_build_cond_value as described
1018 in https://gcc.gnu.org/ml/gcc-patches/2015-02/msg01194.html. */
1020 bool
1021 gimple_find_sub_bbs (gimple_seq seq, gimple_stmt_iterator *gsi)
1023 gimple *stmt = gsi_stmt (*gsi);
1024 basic_block bb = gimple_bb (stmt);
1025 basic_block lastbb, afterbb;
1026 int old_num_bbs = n_basic_blocks_for_fn (cfun);
1027 edge e;
1028 lastbb = make_blocks_1 (seq, bb);
1029 if (old_num_bbs == n_basic_blocks_for_fn (cfun))
1030 return false;
1031 e = split_block (bb, stmt);
1032 /* Move e->dest to come after the new basic blocks. */
1033 afterbb = e->dest;
1034 unlink_block (afterbb);
1035 link_block (afterbb, lastbb);
1036 redirect_edge_succ (e, bb->next_bb);
1037 bb = bb->next_bb;
1038 while (bb != afterbb)
1040 struct omp_region *cur_region = NULL;
1041 int cur_omp_region_idx = 0;
1042 int mer = make_edges_bb (bb, &cur_region, &cur_omp_region_idx);
1043 gcc_assert (!mer && !cur_region);
1044 add_bb_to_loop (bb, afterbb->loop_father);
1045 bb = bb->next_bb;
1047 return true;
1050 /* Find the next available discriminator value for LOCUS. The
1051 discriminator distinguishes among several basic blocks that
1052 share a common locus, allowing for more accurate sample-based
1053 profiling. */
1055 static int
1056 next_discriminator_for_locus (location_t locus)
1058 struct locus_discrim_map item;
1059 struct locus_discrim_map **slot;
1061 item.locus = locus;
1062 item.discriminator = 0;
1063 slot = discriminator_per_locus->find_slot_with_hash (
1064 &item, LOCATION_LINE (locus), INSERT);
1065 gcc_assert (slot);
1066 if (*slot == HTAB_EMPTY_ENTRY)
1068 *slot = XNEW (struct locus_discrim_map);
1069 gcc_assert (*slot);
1070 (*slot)->locus = locus;
1071 (*slot)->discriminator = 0;
1073 (*slot)->discriminator++;
1074 return (*slot)->discriminator;
1077 /* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line. */
1079 static bool
1080 same_line_p (location_t locus1, location_t locus2)
1082 expanded_location from, to;
1084 if (locus1 == locus2)
1085 return true;
1087 from = expand_location (locus1);
1088 to = expand_location (locus2);
1090 if (from.line != to.line)
1091 return false;
1092 if (from.file == to.file)
1093 return true;
1094 return (from.file != NULL
1095 && to.file != NULL
1096 && filename_cmp (from.file, to.file) == 0);
1099 /* Assign discriminators to each basic block. */
1101 static void
1102 assign_discriminators (void)
1104 basic_block bb;
1106 FOR_EACH_BB_FN (bb, cfun)
1108 edge e;
1109 edge_iterator ei;
1110 gimple *last = last_stmt (bb);
1111 location_t locus = last ? gimple_location (last) : UNKNOWN_LOCATION;
1113 if (locus == UNKNOWN_LOCATION)
1114 continue;
1116 FOR_EACH_EDGE (e, ei, bb->succs)
1118 gimple *first = first_non_label_stmt (e->dest);
1119 gimple *last = last_stmt (e->dest);
1120 if ((first && same_line_p (locus, gimple_location (first)))
1121 || (last && same_line_p (locus, gimple_location (last))))
1123 if (e->dest->discriminator != 0 && bb->discriminator == 0)
1124 bb->discriminator = next_discriminator_for_locus (locus);
1125 else
1126 e->dest->discriminator = next_discriminator_for_locus (locus);
1132 /* Create the edges for a GIMPLE_COND starting at block BB. */
1134 static void
1135 make_cond_expr_edges (basic_block bb)
1137 gcond *entry = as_a <gcond *> (last_stmt (bb));
1138 gimple *then_stmt, *else_stmt;
1139 basic_block then_bb, else_bb;
1140 tree then_label, else_label;
1141 edge e;
1143 gcc_assert (entry);
1144 gcc_assert (gimple_code (entry) == GIMPLE_COND);
1146 /* Entry basic blocks for each component. */
1147 then_label = gimple_cond_true_label (entry);
1148 else_label = gimple_cond_false_label (entry);
1149 then_bb = label_to_block (then_label);
1150 else_bb = label_to_block (else_label);
1151 then_stmt = first_stmt (then_bb);
1152 else_stmt = first_stmt (else_bb);
1154 e = make_edge (bb, then_bb, EDGE_TRUE_VALUE);
1155 e->goto_locus = gimple_location (then_stmt);
1156 e = make_edge (bb, else_bb, EDGE_FALSE_VALUE);
1157 if (e)
1158 e->goto_locus = gimple_location (else_stmt);
1160 /* We do not need the labels anymore. */
1161 gimple_cond_set_true_label (entry, NULL_TREE);
1162 gimple_cond_set_false_label (entry, NULL_TREE);
1166 /* Called for each element in the hash table (P) as we delete the
1167 edge to cases hash table.
1169 Clear all the CASE_CHAINs to prevent problems with copying of
1170 SWITCH_EXPRs and structure sharing rules, then free the hash table
1171 element. */
1173 bool
1174 edge_to_cases_cleanup (edge const &, tree const &value, void *)
1176 tree t, next;
1178 for (t = value; t; t = next)
1180 next = CASE_CHAIN (t);
1181 CASE_CHAIN (t) = NULL;
1184 return true;
1187 /* Start recording information mapping edges to case labels. */
1189 void
1190 start_recording_case_labels (void)
1192 gcc_assert (edge_to_cases == NULL);
1193 edge_to_cases = new hash_map<edge, tree>;
1194 touched_switch_bbs = BITMAP_ALLOC (NULL);
1197 /* Return nonzero if we are recording information for case labels. */
1199 static bool
1200 recording_case_labels_p (void)
1202 return (edge_to_cases != NULL);
1205 /* Stop recording information mapping edges to case labels and
1206 remove any information we have recorded. */
1207 void
1208 end_recording_case_labels (void)
1210 bitmap_iterator bi;
1211 unsigned i;
1212 edge_to_cases->traverse<void *, edge_to_cases_cleanup> (NULL);
1213 delete edge_to_cases;
1214 edge_to_cases = NULL;
1215 EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs, 0, i, bi)
1217 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
1218 if (bb)
1220 gimple *stmt = last_stmt (bb);
1221 if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
1222 group_case_labels_stmt (as_a <gswitch *> (stmt));
1225 BITMAP_FREE (touched_switch_bbs);
1228 /* If we are inside a {start,end}_recording_cases block, then return
1229 a chain of CASE_LABEL_EXPRs from T which reference E.
1231 Otherwise return NULL. */
1233 static tree
1234 get_cases_for_edge (edge e, gswitch *t)
1236 tree *slot;
1237 size_t i, n;
1239 /* If we are not recording cases, then we do not have CASE_LABEL_EXPR
1240 chains available. Return NULL so the caller can detect this case. */
1241 if (!recording_case_labels_p ())
1242 return NULL;
1244 slot = edge_to_cases->get (e);
1245 if (slot)
1246 return *slot;
1248 /* If we did not find E in the hash table, then this must be the first
1249 time we have been queried for information about E & T. Add all the
1250 elements from T to the hash table then perform the query again. */
1252 n = gimple_switch_num_labels (t);
1253 for (i = 0; i < n; i++)
1255 tree elt = gimple_switch_label (t, i);
1256 tree lab = CASE_LABEL (elt);
1257 basic_block label_bb = label_to_block (lab);
1258 edge this_edge = find_edge (e->src, label_bb);
1260 /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
1261 a new chain. */
1262 tree &s = edge_to_cases->get_or_insert (this_edge);
1263 CASE_CHAIN (elt) = s;
1264 s = elt;
1267 return *edge_to_cases->get (e);
1270 /* Create the edges for a GIMPLE_SWITCH starting at block BB. */
1272 static void
1273 make_gimple_switch_edges (gswitch *entry, basic_block bb)
1275 size_t i, n;
1277 n = gimple_switch_num_labels (entry);
1279 for (i = 0; i < n; ++i)
1281 tree lab = CASE_LABEL (gimple_switch_label (entry, i));
1282 basic_block label_bb = label_to_block (lab);
1283 make_edge (bb, label_bb, 0);
1288 /* Return the basic block holding label DEST. */
1290 basic_block
1291 label_to_block_fn (struct function *ifun, tree dest)
1293 int uid = LABEL_DECL_UID (dest);
1295 /* We would die hard when faced by an undefined label. Emit a label to
1296 the very first basic block. This will hopefully make even the dataflow
1297 and undefined variable warnings quite right. */
1298 if (seen_error () && uid < 0)
1300 gimple_stmt_iterator gsi =
1301 gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun, NUM_FIXED_BLOCKS));
1302 gimple *stmt;
1304 stmt = gimple_build_label (dest);
1305 gsi_insert_before (&gsi, stmt, GSI_NEW_STMT);
1306 uid = LABEL_DECL_UID (dest);
1308 if (vec_safe_length (ifun->cfg->x_label_to_block_map) <= (unsigned int) uid)
1309 return NULL;
1310 return (*ifun->cfg->x_label_to_block_map)[uid];
1313 /* Create edges for a goto statement at block BB. Returns true
1314 if abnormal edges should be created. */
1316 static bool
1317 make_goto_expr_edges (basic_block bb)
1319 gimple_stmt_iterator last = gsi_last_bb (bb);
1320 gimple *goto_t = gsi_stmt (last);
1322 /* A simple GOTO creates normal edges. */
1323 if (simple_goto_p (goto_t))
1325 tree dest = gimple_goto_dest (goto_t);
1326 basic_block label_bb = label_to_block (dest);
1327 edge e = make_edge (bb, label_bb, EDGE_FALLTHRU);
1328 e->goto_locus = gimple_location (goto_t);
1329 gsi_remove (&last, true);
1330 return false;
1333 /* A computed GOTO creates abnormal edges. */
1334 return true;
1337 /* Create edges for an asm statement with labels at block BB. */
1339 static void
1340 make_gimple_asm_edges (basic_block bb)
1342 gasm *stmt = as_a <gasm *> (last_stmt (bb));
1343 int i, n = gimple_asm_nlabels (stmt);
1345 for (i = 0; i < n; ++i)
1347 tree label = TREE_VALUE (gimple_asm_label_op (stmt, i));
1348 basic_block label_bb = label_to_block (label);
1349 make_edge (bb, label_bb, 0);
1353 /*---------------------------------------------------------------------------
1354 Flowgraph analysis
1355 ---------------------------------------------------------------------------*/
1357 /* Cleanup useless labels in basic blocks. This is something we wish
1358 to do early because it allows us to group case labels before creating
1359 the edges for the CFG, and it speeds up block statement iterators in
1360 all passes later on.
1361 We rerun this pass after CFG is created, to get rid of the labels that
1362 are no longer referenced. After then we do not run it any more, since
1363 (almost) no new labels should be created. */
1365 /* A map from basic block index to the leading label of that block. */
1366 static struct label_record
1368 /* The label. */
1369 tree label;
1371 /* True if the label is referenced from somewhere. */
1372 bool used;
1373 } *label_for_bb;
1375 /* Given LABEL return the first label in the same basic block. */
1377 static tree
1378 main_block_label (tree label)
1380 basic_block bb = label_to_block (label);
1381 tree main_label = label_for_bb[bb->index].label;
1383 /* label_to_block possibly inserted undefined label into the chain. */
1384 if (!main_label)
1386 label_for_bb[bb->index].label = label;
1387 main_label = label;
1390 label_for_bb[bb->index].used = true;
1391 return main_label;
1394 /* Clean up redundant labels within the exception tree. */
1396 static void
1397 cleanup_dead_labels_eh (void)
1399 eh_landing_pad lp;
1400 eh_region r;
1401 tree lab;
1402 int i;
1404 if (cfun->eh == NULL)
1405 return;
1407 for (i = 1; vec_safe_iterate (cfun->eh->lp_array, i, &lp); ++i)
1408 if (lp && lp->post_landing_pad)
1410 lab = main_block_label (lp->post_landing_pad);
1411 if (lab != lp->post_landing_pad)
1413 EH_LANDING_PAD_NR (lp->post_landing_pad) = 0;
1414 EH_LANDING_PAD_NR (lab) = lp->index;
1418 FOR_ALL_EH_REGION (r)
1419 switch (r->type)
1421 case ERT_CLEANUP:
1422 case ERT_MUST_NOT_THROW:
1423 break;
1425 case ERT_TRY:
1427 eh_catch c;
1428 for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
1430 lab = c->label;
1431 if (lab)
1432 c->label = main_block_label (lab);
1435 break;
1437 case ERT_ALLOWED_EXCEPTIONS:
1438 lab = r->u.allowed.label;
1439 if (lab)
1440 r->u.allowed.label = main_block_label (lab);
1441 break;
1446 /* Cleanup redundant labels. This is a three-step process:
1447 1) Find the leading label for each block.
1448 2) Redirect all references to labels to the leading labels.
1449 3) Cleanup all useless labels. */
1451 void
1452 cleanup_dead_labels (void)
1454 basic_block bb;
1455 label_for_bb = XCNEWVEC (struct label_record, last_basic_block_for_fn (cfun));
1457 /* Find a suitable label for each block. We use the first user-defined
1458 label if there is one, or otherwise just the first label we see. */
1459 FOR_EACH_BB_FN (bb, cfun)
1461 gimple_stmt_iterator i;
1463 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
1465 tree label;
1466 glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (i));
1468 if (!label_stmt)
1469 break;
1471 label = gimple_label_label (label_stmt);
1473 /* If we have not yet seen a label for the current block,
1474 remember this one and see if there are more labels. */
1475 if (!label_for_bb[bb->index].label)
1477 label_for_bb[bb->index].label = label;
1478 continue;
1481 /* If we did see a label for the current block already, but it
1482 is an artificially created label, replace it if the current
1483 label is a user defined label. */
1484 if (!DECL_ARTIFICIAL (label)
1485 && DECL_ARTIFICIAL (label_for_bb[bb->index].label))
1487 label_for_bb[bb->index].label = label;
1488 break;
1493 /* Now redirect all jumps/branches to the selected label.
1494 First do so for each block ending in a control statement. */
1495 FOR_EACH_BB_FN (bb, cfun)
1497 gimple *stmt = last_stmt (bb);
1498 tree label, new_label;
1500 if (!stmt)
1501 continue;
1503 switch (gimple_code (stmt))
1505 case GIMPLE_COND:
1507 gcond *cond_stmt = as_a <gcond *> (stmt);
1508 label = gimple_cond_true_label (cond_stmt);
1509 if (label)
1511 new_label = main_block_label (label);
1512 if (new_label != label)
1513 gimple_cond_set_true_label (cond_stmt, new_label);
1516 label = gimple_cond_false_label (cond_stmt);
1517 if (label)
1519 new_label = main_block_label (label);
1520 if (new_label != label)
1521 gimple_cond_set_false_label (cond_stmt, new_label);
1524 break;
1526 case GIMPLE_SWITCH:
1528 gswitch *switch_stmt = as_a <gswitch *> (stmt);
1529 size_t i, n = gimple_switch_num_labels (switch_stmt);
1531 /* Replace all destination labels. */
1532 for (i = 0; i < n; ++i)
1534 tree case_label = gimple_switch_label (switch_stmt, i);
1535 label = CASE_LABEL (case_label);
1536 new_label = main_block_label (label);
1537 if (new_label != label)
1538 CASE_LABEL (case_label) = new_label;
1540 break;
1543 case GIMPLE_ASM:
1545 gasm *asm_stmt = as_a <gasm *> (stmt);
1546 int i, n = gimple_asm_nlabels (asm_stmt);
1548 for (i = 0; i < n; ++i)
1550 tree cons = gimple_asm_label_op (asm_stmt, i);
1551 tree label = main_block_label (TREE_VALUE (cons));
1552 TREE_VALUE (cons) = label;
1554 break;
1557 /* We have to handle gotos until they're removed, and we don't
1558 remove them until after we've created the CFG edges. */
1559 case GIMPLE_GOTO:
1560 if (!computed_goto_p (stmt))
1562 ggoto *goto_stmt = as_a <ggoto *> (stmt);
1563 label = gimple_goto_dest (goto_stmt);
1564 new_label = main_block_label (label);
1565 if (new_label != label)
1566 gimple_goto_set_dest (goto_stmt, new_label);
1568 break;
1570 case GIMPLE_TRANSACTION:
1572 gtransaction *txn = as_a <gtransaction *> (stmt);
1574 label = gimple_transaction_label_norm (txn);
1575 if (label)
1577 new_label = main_block_label (label);
1578 if (new_label != label)
1579 gimple_transaction_set_label_norm (txn, new_label);
1582 label = gimple_transaction_label_uninst (txn);
1583 if (label)
1585 new_label = main_block_label (label);
1586 if (new_label != label)
1587 gimple_transaction_set_label_uninst (txn, new_label);
1590 label = gimple_transaction_label_over (txn);
1591 if (label)
1593 new_label = main_block_label (label);
1594 if (new_label != label)
1595 gimple_transaction_set_label_over (txn, new_label);
1598 break;
1600 default:
1601 break;
1605 /* Do the same for the exception region tree labels. */
1606 cleanup_dead_labels_eh ();
1608 /* Finally, purge dead labels. All user-defined labels and labels that
1609 can be the target of non-local gotos and labels which have their
1610 address taken are preserved. */
1611 FOR_EACH_BB_FN (bb, cfun)
1613 gimple_stmt_iterator i;
1614 tree label_for_this_bb = label_for_bb[bb->index].label;
1616 if (!label_for_this_bb)
1617 continue;
1619 /* If the main label of the block is unused, we may still remove it. */
1620 if (!label_for_bb[bb->index].used)
1621 label_for_this_bb = NULL;
1623 for (i = gsi_start_bb (bb); !gsi_end_p (i); )
1625 tree label;
1626 glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (i));
1628 if (!label_stmt)
1629 break;
1631 label = gimple_label_label (label_stmt);
1633 if (label == label_for_this_bb
1634 || !DECL_ARTIFICIAL (label)
1635 || DECL_NONLOCAL (label)
1636 || FORCED_LABEL (label))
1637 gsi_next (&i);
1638 else
1639 gsi_remove (&i, true);
1643 free (label_for_bb);
1646 /* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
1647 the ones jumping to the same label.
1648 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
1650 void
1651 group_case_labels_stmt (gswitch *stmt)
1653 int old_size = gimple_switch_num_labels (stmt);
1654 int i, j, new_size = old_size;
1655 basic_block default_bb = NULL;
1657 default_bb = label_to_block (CASE_LABEL (gimple_switch_default_label (stmt)));
1659 /* Look for possible opportunities to merge cases. */
1660 i = 1;
1661 while (i < old_size)
1663 tree base_case, base_high;
1664 basic_block base_bb;
1666 base_case = gimple_switch_label (stmt, i);
1668 gcc_assert (base_case);
1669 base_bb = label_to_block (CASE_LABEL (base_case));
1671 /* Discard cases that have the same destination as the
1672 default case. */
1673 if (base_bb == default_bb)
1675 gimple_switch_set_label (stmt, i, NULL_TREE);
1676 i++;
1677 new_size--;
1678 continue;
1681 base_high = CASE_HIGH (base_case)
1682 ? CASE_HIGH (base_case)
1683 : CASE_LOW (base_case);
1684 i++;
1686 /* Try to merge case labels. Break out when we reach the end
1687 of the label vector or when we cannot merge the next case
1688 label with the current one. */
1689 while (i < old_size)
1691 tree merge_case = gimple_switch_label (stmt, i);
1692 basic_block merge_bb = label_to_block (CASE_LABEL (merge_case));
1693 wide_int bhp1 = wi::add (base_high, 1);
1695 /* Merge the cases if they jump to the same place,
1696 and their ranges are consecutive. */
1697 if (merge_bb == base_bb
1698 && wi::eq_p (CASE_LOW (merge_case), bhp1))
1700 base_high = CASE_HIGH (merge_case) ?
1701 CASE_HIGH (merge_case) : CASE_LOW (merge_case);
1702 CASE_HIGH (base_case) = base_high;
1703 gimple_switch_set_label (stmt, i, NULL_TREE);
1704 new_size--;
1705 i++;
1707 else
1708 break;
1712 /* Compress the case labels in the label vector, and adjust the
1713 length of the vector. */
1714 for (i = 0, j = 0; i < new_size; i++)
1716 while (! gimple_switch_label (stmt, j))
1717 j++;
1718 gimple_switch_set_label (stmt, i,
1719 gimple_switch_label (stmt, j++));
1722 gcc_assert (new_size <= old_size);
1723 gimple_switch_set_num_labels (stmt, new_size);
1726 /* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
1727 and scan the sorted vector of cases. Combine the ones jumping to the
1728 same label. */
1730 void
1731 group_case_labels (void)
1733 basic_block bb;
1735 FOR_EACH_BB_FN (bb, cfun)
1737 gimple *stmt = last_stmt (bb);
1738 if (stmt && gimple_code (stmt) == GIMPLE_SWITCH)
1739 group_case_labels_stmt (as_a <gswitch *> (stmt));
1743 /* Checks whether we can merge block B into block A. */
1745 static bool
1746 gimple_can_merge_blocks_p (basic_block a, basic_block b)
1748 gimple *stmt;
1750 if (!single_succ_p (a))
1751 return false;
1753 if (single_succ_edge (a)->flags & EDGE_COMPLEX)
1754 return false;
1756 if (single_succ (a) != b)
1757 return false;
1759 if (!single_pred_p (b))
1760 return false;
1762 if (a == ENTRY_BLOCK_PTR_FOR_FN (cfun)
1763 || b == EXIT_BLOCK_PTR_FOR_FN (cfun))
1764 return false;
1766 /* If A ends by a statement causing exceptions or something similar, we
1767 cannot merge the blocks. */
1768 stmt = last_stmt (a);
1769 if (stmt && stmt_ends_bb_p (stmt))
1770 return false;
1772 /* Do not allow a block with only a non-local label to be merged. */
1773 if (stmt)
1774 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
1775 if (DECL_NONLOCAL (gimple_label_label (label_stmt)))
1776 return false;
1778 /* Examine the labels at the beginning of B. */
1779 for (gimple_stmt_iterator gsi = gsi_start_bb (b); !gsi_end_p (gsi);
1780 gsi_next (&gsi))
1782 tree lab;
1783 glabel *label_stmt = dyn_cast <glabel *> (gsi_stmt (gsi));
1784 if (!label_stmt)
1785 break;
1786 lab = gimple_label_label (label_stmt);
1788 /* Do not remove user forced labels or for -O0 any user labels. */
1789 if (!DECL_ARTIFICIAL (lab) && (!optimize || FORCED_LABEL (lab)))
1790 return false;
1793 /* Protect simple loop latches. We only want to avoid merging
1794 the latch with the loop header or with a block in another
1795 loop in this case. */
1796 if (current_loops
1797 && b->loop_father->latch == b
1798 && loops_state_satisfies_p (LOOPS_HAVE_SIMPLE_LATCHES)
1799 && (b->loop_father->header == a
1800 || b->loop_father != a->loop_father))
1801 return false;
1803 /* It must be possible to eliminate all phi nodes in B. If ssa form
1804 is not up-to-date and a name-mapping is registered, we cannot eliminate
1805 any phis. Symbols marked for renaming are never a problem though. */
1806 for (gphi_iterator gsi = gsi_start_phis (b); !gsi_end_p (gsi);
1807 gsi_next (&gsi))
1809 gphi *phi = gsi.phi ();
1810 /* Technically only new names matter. */
1811 if (name_registered_for_update_p (PHI_RESULT (phi)))
1812 return false;
1815 /* When not optimizing, don't merge if we'd lose goto_locus. */
1816 if (!optimize
1817 && single_succ_edge (a)->goto_locus != UNKNOWN_LOCATION)
1819 location_t goto_locus = single_succ_edge (a)->goto_locus;
1820 gimple_stmt_iterator prev, next;
1821 prev = gsi_last_nondebug_bb (a);
1822 next = gsi_after_labels (b);
1823 if (!gsi_end_p (next) && is_gimple_debug (gsi_stmt (next)))
1824 gsi_next_nondebug (&next);
1825 if ((gsi_end_p (prev)
1826 || gimple_location (gsi_stmt (prev)) != goto_locus)
1827 && (gsi_end_p (next)
1828 || gimple_location (gsi_stmt (next)) != goto_locus))
1829 return false;
1832 return true;
1835 /* Replaces all uses of NAME by VAL. */
1837 void
1838 replace_uses_by (tree name, tree val)
1840 imm_use_iterator imm_iter;
1841 use_operand_p use;
1842 gimple *stmt;
1843 edge e;
1845 FOR_EACH_IMM_USE_STMT (stmt, imm_iter, name)
1847 /* Mark the block if we change the last stmt in it. */
1848 if (cfgcleanup_altered_bbs
1849 && stmt_ends_bb_p (stmt))
1850 bitmap_set_bit (cfgcleanup_altered_bbs, gimple_bb (stmt)->index);
1852 FOR_EACH_IMM_USE_ON_STMT (use, imm_iter)
1854 replace_exp (use, val);
1856 if (gimple_code (stmt) == GIMPLE_PHI)
1858 e = gimple_phi_arg_edge (as_a <gphi *> (stmt),
1859 PHI_ARG_INDEX_FROM_USE (use));
1860 if (e->flags & EDGE_ABNORMAL
1861 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val))
1863 /* This can only occur for virtual operands, since
1864 for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
1865 would prevent replacement. */
1866 gcc_checking_assert (virtual_operand_p (name));
1867 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val) = 1;
1872 if (gimple_code (stmt) != GIMPLE_PHI)
1874 gimple_stmt_iterator gsi = gsi_for_stmt (stmt);
1875 gimple *orig_stmt = stmt;
1876 size_t i;
1878 /* FIXME. It shouldn't be required to keep TREE_CONSTANT
1879 on ADDR_EXPRs up-to-date on GIMPLE. Propagation will
1880 only change sth from non-invariant to invariant, and only
1881 when propagating constants. */
1882 if (is_gimple_min_invariant (val))
1883 for (i = 0; i < gimple_num_ops (stmt); i++)
1885 tree op = gimple_op (stmt, i);
1886 /* Operands may be empty here. For example, the labels
1887 of a GIMPLE_COND are nulled out following the creation
1888 of the corresponding CFG edges. */
1889 if (op && TREE_CODE (op) == ADDR_EXPR)
1890 recompute_tree_invariant_for_addr_expr (op);
1893 if (fold_stmt (&gsi))
1894 stmt = gsi_stmt (gsi);
1896 if (maybe_clean_or_replace_eh_stmt (orig_stmt, stmt))
1897 gimple_purge_dead_eh_edges (gimple_bb (stmt));
1899 update_stmt (stmt);
1903 gcc_checking_assert (has_zero_uses (name));
1905 /* Also update the trees stored in loop structures. */
1906 if (current_loops)
1908 struct loop *loop;
1910 FOR_EACH_LOOP (loop, 0)
1912 substitute_in_loop_info (loop, name, val);
1917 /* Merge block B into block A. */
1919 static void
1920 gimple_merge_blocks (basic_block a, basic_block b)
1922 gimple_stmt_iterator last, gsi;
1923 gphi_iterator psi;
1925 if (dump_file)
1926 fprintf (dump_file, "Merging blocks %d and %d\n", a->index, b->index);
1928 /* Remove all single-valued PHI nodes from block B of the form
1929 V_i = PHI <V_j> by propagating V_j to all the uses of V_i. */
1930 gsi = gsi_last_bb (a);
1931 for (psi = gsi_start_phis (b); !gsi_end_p (psi); )
1933 gimple *phi = gsi_stmt (psi);
1934 tree def = gimple_phi_result (phi), use = gimple_phi_arg_def (phi, 0);
1935 gimple *copy;
1936 bool may_replace_uses = (virtual_operand_p (def)
1937 || may_propagate_copy (def, use));
1939 /* In case we maintain loop closed ssa form, do not propagate arguments
1940 of loop exit phi nodes. */
1941 if (current_loops
1942 && loops_state_satisfies_p (LOOP_CLOSED_SSA)
1943 && !virtual_operand_p (def)
1944 && TREE_CODE (use) == SSA_NAME
1945 && a->loop_father != b->loop_father)
1946 may_replace_uses = false;
1948 if (!may_replace_uses)
1950 gcc_assert (!virtual_operand_p (def));
1952 /* Note that just emitting the copies is fine -- there is no problem
1953 with ordering of phi nodes. This is because A is the single
1954 predecessor of B, therefore results of the phi nodes cannot
1955 appear as arguments of the phi nodes. */
1956 copy = gimple_build_assign (def, use);
1957 gsi_insert_after (&gsi, copy, GSI_NEW_STMT);
1958 remove_phi_node (&psi, false);
1960 else
1962 /* If we deal with a PHI for virtual operands, we can simply
1963 propagate these without fussing with folding or updating
1964 the stmt. */
1965 if (virtual_operand_p (def))
1967 imm_use_iterator iter;
1968 use_operand_p use_p;
1969 gimple *stmt;
1971 FOR_EACH_IMM_USE_STMT (stmt, iter, def)
1972 FOR_EACH_IMM_USE_ON_STMT (use_p, iter)
1973 SET_USE (use_p, use);
1975 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def))
1976 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use) = 1;
1978 else
1979 replace_uses_by (def, use);
1981 remove_phi_node (&psi, true);
1985 /* Ensure that B follows A. */
1986 move_block_after (b, a);
1988 gcc_assert (single_succ_edge (a)->flags & EDGE_FALLTHRU);
1989 gcc_assert (!last_stmt (a) || !stmt_ends_bb_p (last_stmt (a)));
1991 /* Remove labels from B and set gimple_bb to A for other statements. */
1992 for (gsi = gsi_start_bb (b); !gsi_end_p (gsi);)
1994 gimple *stmt = gsi_stmt (gsi);
1995 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
1997 tree label = gimple_label_label (label_stmt);
1998 int lp_nr;
2000 gsi_remove (&gsi, false);
2002 /* Now that we can thread computed gotos, we might have
2003 a situation where we have a forced label in block B
2004 However, the label at the start of block B might still be
2005 used in other ways (think about the runtime checking for
2006 Fortran assigned gotos). So we can not just delete the
2007 label. Instead we move the label to the start of block A. */
2008 if (FORCED_LABEL (label))
2010 gimple_stmt_iterator dest_gsi = gsi_start_bb (a);
2011 gsi_insert_before (&dest_gsi, stmt, GSI_NEW_STMT);
2013 /* Other user labels keep around in a form of a debug stmt. */
2014 else if (!DECL_ARTIFICIAL (label) && MAY_HAVE_DEBUG_STMTS)
2016 gimple *dbg = gimple_build_debug_bind (label,
2017 integer_zero_node,
2018 stmt);
2019 gimple_debug_bind_reset_value (dbg);
2020 gsi_insert_before (&gsi, dbg, GSI_SAME_STMT);
2023 lp_nr = EH_LANDING_PAD_NR (label);
2024 if (lp_nr)
2026 eh_landing_pad lp = get_eh_landing_pad_from_number (lp_nr);
2027 lp->post_landing_pad = NULL;
2030 else
2032 gimple_set_bb (stmt, a);
2033 gsi_next (&gsi);
2037 /* When merging two BBs, if their counts are different, the larger count
2038 is selected as the new bb count. This is to handle inconsistent
2039 profiles. */
2040 if (a->loop_father == b->loop_father)
2042 a->count = MAX (a->count, b->count);
2043 a->frequency = MAX (a->frequency, b->frequency);
2046 /* Merge the sequences. */
2047 last = gsi_last_bb (a);
2048 gsi_insert_seq_after (&last, bb_seq (b), GSI_NEW_STMT);
2049 set_bb_seq (b, NULL);
2051 if (cfgcleanup_altered_bbs)
2052 bitmap_set_bit (cfgcleanup_altered_bbs, a->index);
2056 /* Return the one of two successors of BB that is not reachable by a
2057 complex edge, if there is one. Else, return BB. We use
2058 this in optimizations that use post-dominators for their heuristics,
2059 to catch the cases in C++ where function calls are involved. */
2061 basic_block
2062 single_noncomplex_succ (basic_block bb)
2064 edge e0, e1;
2065 if (EDGE_COUNT (bb->succs) != 2)
2066 return bb;
2068 e0 = EDGE_SUCC (bb, 0);
2069 e1 = EDGE_SUCC (bb, 1);
2070 if (e0->flags & EDGE_COMPLEX)
2071 return e1->dest;
2072 if (e1->flags & EDGE_COMPLEX)
2073 return e0->dest;
2075 return bb;
2078 /* T is CALL_EXPR. Set current_function_calls_* flags. */
2080 void
2081 notice_special_calls (gcall *call)
2083 int flags = gimple_call_flags (call);
2085 if (flags & ECF_MAY_BE_ALLOCA)
2086 cfun->calls_alloca = true;
2087 if (flags & ECF_RETURNS_TWICE)
2088 cfun->calls_setjmp = true;
2092 /* Clear flags set by notice_special_calls. Used by dead code removal
2093 to update the flags. */
2095 void
2096 clear_special_calls (void)
2098 cfun->calls_alloca = false;
2099 cfun->calls_setjmp = false;
2102 /* Remove PHI nodes associated with basic block BB and all edges out of BB. */
2104 static void
2105 remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb)
2107 /* Since this block is no longer reachable, we can just delete all
2108 of its PHI nodes. */
2109 remove_phi_nodes (bb);
2111 /* Remove edges to BB's successors. */
2112 while (EDGE_COUNT (bb->succs) > 0)
2113 remove_edge (EDGE_SUCC (bb, 0));
2117 /* Remove statements of basic block BB. */
2119 static void
2120 remove_bb (basic_block bb)
2122 gimple_stmt_iterator i;
2124 if (dump_file)
2126 fprintf (dump_file, "Removing basic block %d\n", bb->index);
2127 if (dump_flags & TDF_DETAILS)
2129 dump_bb (dump_file, bb, 0, TDF_BLOCKS);
2130 fprintf (dump_file, "\n");
2134 if (current_loops)
2136 struct loop *loop = bb->loop_father;
2138 /* If a loop gets removed, clean up the information associated
2139 with it. */
2140 if (loop->latch == bb
2141 || loop->header == bb)
2142 free_numbers_of_iterations_estimates_loop (loop);
2145 /* Remove all the instructions in the block. */
2146 if (bb_seq (bb) != NULL)
2148 /* Walk backwards so as to get a chance to substitute all
2149 released DEFs into debug stmts. See
2150 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
2151 details. */
2152 for (i = gsi_last_bb (bb); !gsi_end_p (i);)
2154 gimple *stmt = gsi_stmt (i);
2155 glabel *label_stmt = dyn_cast <glabel *> (stmt);
2156 if (label_stmt
2157 && (FORCED_LABEL (gimple_label_label (label_stmt))
2158 || DECL_NONLOCAL (gimple_label_label (label_stmt))))
2160 basic_block new_bb;
2161 gimple_stmt_iterator new_gsi;
2163 /* A non-reachable non-local label may still be referenced.
2164 But it no longer needs to carry the extra semantics of
2165 non-locality. */
2166 if (DECL_NONLOCAL (gimple_label_label (label_stmt)))
2168 DECL_NONLOCAL (gimple_label_label (label_stmt)) = 0;
2169 FORCED_LABEL (gimple_label_label (label_stmt)) = 1;
2172 new_bb = bb->prev_bb;
2173 new_gsi = gsi_start_bb (new_bb);
2174 gsi_remove (&i, false);
2175 gsi_insert_before (&new_gsi, stmt, GSI_NEW_STMT);
2177 else
2179 /* Release SSA definitions. */
2180 release_defs (stmt);
2181 gsi_remove (&i, true);
2184 if (gsi_end_p (i))
2185 i = gsi_last_bb (bb);
2186 else
2187 gsi_prev (&i);
2191 remove_phi_nodes_and_edges_for_unreachable_block (bb);
2192 bb->il.gimple.seq = NULL;
2193 bb->il.gimple.phi_nodes = NULL;
2197 /* Given a basic block BB ending with COND_EXPR or SWITCH_EXPR, and a
2198 predicate VAL, return the edge that will be taken out of the block.
2199 If VAL does not match a unique edge, NULL is returned. */
2201 edge
2202 find_taken_edge (basic_block bb, tree val)
2204 gimple *stmt;
2206 stmt = last_stmt (bb);
2208 gcc_assert (stmt);
2209 gcc_assert (is_ctrl_stmt (stmt));
2211 if (val == NULL)
2212 return NULL;
2214 if (!is_gimple_min_invariant (val))
2215 return NULL;
2217 if (gimple_code (stmt) == GIMPLE_COND)
2218 return find_taken_edge_cond_expr (bb, val);
2220 if (gimple_code (stmt) == GIMPLE_SWITCH)
2221 return find_taken_edge_switch_expr (as_a <gswitch *> (stmt), bb, val);
2223 if (computed_goto_p (stmt))
2225 /* Only optimize if the argument is a label, if the argument is
2226 not a label then we can not construct a proper CFG.
2228 It may be the case that we only need to allow the LABEL_REF to
2229 appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
2230 appear inside a LABEL_EXPR just to be safe. */
2231 if ((TREE_CODE (val) == ADDR_EXPR || TREE_CODE (val) == LABEL_EXPR)
2232 && TREE_CODE (TREE_OPERAND (val, 0)) == LABEL_DECL)
2233 return find_taken_edge_computed_goto (bb, TREE_OPERAND (val, 0));
2234 return NULL;
2237 gcc_unreachable ();
2240 /* Given a constant value VAL and the entry block BB to a GOTO_EXPR
2241 statement, determine which of the outgoing edges will be taken out of the
2242 block. Return NULL if either edge may be taken. */
2244 static edge
2245 find_taken_edge_computed_goto (basic_block bb, tree val)
2247 basic_block dest;
2248 edge e = NULL;
2250 dest = label_to_block (val);
2251 if (dest)
2253 e = find_edge (bb, dest);
2254 gcc_assert (e != NULL);
2257 return e;
2260 /* Given a constant value VAL and the entry block BB to a COND_EXPR
2261 statement, determine which of the two edges will be taken out of the
2262 block. Return NULL if either edge may be taken. */
2264 static edge
2265 find_taken_edge_cond_expr (basic_block bb, tree val)
2267 edge true_edge, false_edge;
2269 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
2271 gcc_assert (TREE_CODE (val) == INTEGER_CST);
2272 return (integer_zerop (val) ? false_edge : true_edge);
2275 /* Given an INTEGER_CST VAL and the entry block BB to a SWITCH_EXPR
2276 statement, determine which edge will be taken out of the block. Return
2277 NULL if any edge may be taken. */
2279 static edge
2280 find_taken_edge_switch_expr (gswitch *switch_stmt, basic_block bb,
2281 tree val)
2283 basic_block dest_bb;
2284 edge e;
2285 tree taken_case;
2287 taken_case = find_case_label_for_value (switch_stmt, val);
2288 dest_bb = label_to_block (CASE_LABEL (taken_case));
2290 e = find_edge (bb, dest_bb);
2291 gcc_assert (e);
2292 return e;
2296 /* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
2297 We can make optimal use here of the fact that the case labels are
2298 sorted: We can do a binary search for a case matching VAL. */
2300 static tree
2301 find_case_label_for_value (gswitch *switch_stmt, tree val)
2303 size_t low, high, n = gimple_switch_num_labels (switch_stmt);
2304 tree default_case = gimple_switch_default_label (switch_stmt);
2306 for (low = 0, high = n; high - low > 1; )
2308 size_t i = (high + low) / 2;
2309 tree t = gimple_switch_label (switch_stmt, i);
2310 int cmp;
2312 /* Cache the result of comparing CASE_LOW and val. */
2313 cmp = tree_int_cst_compare (CASE_LOW (t), val);
2315 if (cmp > 0)
2316 high = i;
2317 else
2318 low = i;
2320 if (CASE_HIGH (t) == NULL)
2322 /* A singe-valued case label. */
2323 if (cmp == 0)
2324 return t;
2326 else
2328 /* A case range. We can only handle integer ranges. */
2329 if (cmp <= 0 && tree_int_cst_compare (CASE_HIGH (t), val) >= 0)
2330 return t;
2334 return default_case;
2338 /* Dump a basic block on stderr. */
2340 void
2341 gimple_debug_bb (basic_block bb)
2343 dump_bb (stderr, bb, 0, TDF_VOPS|TDF_MEMSYMS|TDF_BLOCKS);
2347 /* Dump basic block with index N on stderr. */
2349 basic_block
2350 gimple_debug_bb_n (int n)
2352 gimple_debug_bb (BASIC_BLOCK_FOR_FN (cfun, n));
2353 return BASIC_BLOCK_FOR_FN (cfun, n);
2357 /* Dump the CFG on stderr.
2359 FLAGS are the same used by the tree dumping functions
2360 (see TDF_* in dumpfile.h). */
2362 void
2363 gimple_debug_cfg (int flags)
2365 gimple_dump_cfg (stderr, flags);
2369 /* Dump the program showing basic block boundaries on the given FILE.
2371 FLAGS are the same used by the tree dumping functions (see TDF_* in
2372 tree.h). */
2374 void
2375 gimple_dump_cfg (FILE *file, int flags)
2377 if (flags & TDF_DETAILS)
2379 dump_function_header (file, current_function_decl, flags);
2380 fprintf (file, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
2381 n_basic_blocks_for_fn (cfun), n_edges_for_fn (cfun),
2382 last_basic_block_for_fn (cfun));
2384 brief_dump_cfg (file, flags | TDF_COMMENT);
2385 fprintf (file, "\n");
2388 if (flags & TDF_STATS)
2389 dump_cfg_stats (file);
2391 dump_function_to_file (current_function_decl, file, flags | TDF_BLOCKS);
2395 /* Dump CFG statistics on FILE. */
2397 void
2398 dump_cfg_stats (FILE *file)
2400 static long max_num_merged_labels = 0;
2401 unsigned long size, total = 0;
2402 long num_edges;
2403 basic_block bb;
2404 const char * const fmt_str = "%-30s%-13s%12s\n";
2405 const char * const fmt_str_1 = "%-30s%13d%11lu%c\n";
2406 const char * const fmt_str_2 = "%-30s%13ld%11lu%c\n";
2407 const char * const fmt_str_3 = "%-43s%11lu%c\n";
2408 const char *funcname = current_function_name ();
2410 fprintf (file, "\nCFG Statistics for %s\n\n", funcname);
2412 fprintf (file, "---------------------------------------------------------\n");
2413 fprintf (file, fmt_str, "", " Number of ", "Memory");
2414 fprintf (file, fmt_str, "", " instances ", "used ");
2415 fprintf (file, "---------------------------------------------------------\n");
2417 size = n_basic_blocks_for_fn (cfun) * sizeof (struct basic_block_def);
2418 total += size;
2419 fprintf (file, fmt_str_1, "Basic blocks", n_basic_blocks_for_fn (cfun),
2420 SCALE (size), LABEL (size));
2422 num_edges = 0;
2423 FOR_EACH_BB_FN (bb, cfun)
2424 num_edges += EDGE_COUNT (bb->succs);
2425 size = num_edges * sizeof (struct edge_def);
2426 total += size;
2427 fprintf (file, fmt_str_2, "Edges", num_edges, SCALE (size), LABEL (size));
2429 fprintf (file, "---------------------------------------------------------\n");
2430 fprintf (file, fmt_str_3, "Total memory used by CFG data", SCALE (total),
2431 LABEL (total));
2432 fprintf (file, "---------------------------------------------------------\n");
2433 fprintf (file, "\n");
2435 if (cfg_stats.num_merged_labels > max_num_merged_labels)
2436 max_num_merged_labels = cfg_stats.num_merged_labels;
2438 fprintf (file, "Coalesced label blocks: %ld (Max so far: %ld)\n",
2439 cfg_stats.num_merged_labels, max_num_merged_labels);
2441 fprintf (file, "\n");
2445 /* Dump CFG statistics on stderr. Keep extern so that it's always
2446 linked in the final executable. */
2448 DEBUG_FUNCTION void
2449 debug_cfg_stats (void)
2451 dump_cfg_stats (stderr);
2454 /*---------------------------------------------------------------------------
2455 Miscellaneous helpers
2456 ---------------------------------------------------------------------------*/
2458 /* Return true if T, a GIMPLE_CALL, can make an abnormal transfer of control
2459 flow. Transfers of control flow associated with EH are excluded. */
2461 static bool
2462 call_can_make_abnormal_goto (gimple *t)
2464 /* If the function has no non-local labels, then a call cannot make an
2465 abnormal transfer of control. */
2466 if (!cfun->has_nonlocal_label
2467 && !cfun->calls_setjmp)
2468 return false;
2470 /* Likewise if the call has no side effects. */
2471 if (!gimple_has_side_effects (t))
2472 return false;
2474 /* Likewise if the called function is leaf. */
2475 if (gimple_call_flags (t) & ECF_LEAF)
2476 return false;
2478 return true;
2482 /* Return true if T can make an abnormal transfer of control flow.
2483 Transfers of control flow associated with EH are excluded. */
2485 bool
2486 stmt_can_make_abnormal_goto (gimple *t)
2488 if (computed_goto_p (t))
2489 return true;
2490 if (is_gimple_call (t))
2491 return call_can_make_abnormal_goto (t);
2492 return false;
2496 /* Return true if T represents a stmt that always transfers control. */
2498 bool
2499 is_ctrl_stmt (gimple *t)
2501 switch (gimple_code (t))
2503 case GIMPLE_COND:
2504 case GIMPLE_SWITCH:
2505 case GIMPLE_GOTO:
2506 case GIMPLE_RETURN:
2507 case GIMPLE_RESX:
2508 return true;
2509 default:
2510 return false;
2515 /* Return true if T is a statement that may alter the flow of control
2516 (e.g., a call to a non-returning function). */
2518 bool
2519 is_ctrl_altering_stmt (gimple *t)
2521 gcc_assert (t);
2523 switch (gimple_code (t))
2525 case GIMPLE_CALL:
2526 /* Per stmt call flag indicates whether the call could alter
2527 controlflow. */
2528 if (gimple_call_ctrl_altering_p (t))
2529 return true;
2530 break;
2532 case GIMPLE_EH_DISPATCH:
2533 /* EH_DISPATCH branches to the individual catch handlers at
2534 this level of a try or allowed-exceptions region. It can
2535 fallthru to the next statement as well. */
2536 return true;
2538 case GIMPLE_ASM:
2539 if (gimple_asm_nlabels (as_a <gasm *> (t)) > 0)
2540 return true;
2541 break;
2543 CASE_GIMPLE_OMP:
2544 /* OpenMP directives alter control flow. */
2545 return true;
2547 case GIMPLE_TRANSACTION:
2548 /* A transaction start alters control flow. */
2549 return true;
2551 default:
2552 break;
2555 /* If a statement can throw, it alters control flow. */
2556 return stmt_can_throw_internal (t);
2560 /* Return true if T is a simple local goto. */
2562 bool
2563 simple_goto_p (gimple *t)
2565 return (gimple_code (t) == GIMPLE_GOTO
2566 && TREE_CODE (gimple_goto_dest (t)) == LABEL_DECL);
2570 /* Return true if STMT should start a new basic block. PREV_STMT is
2571 the statement preceding STMT. It is used when STMT is a label or a
2572 case label. Labels should only start a new basic block if their
2573 previous statement wasn't a label. Otherwise, sequence of labels
2574 would generate unnecessary basic blocks that only contain a single
2575 label. */
2577 static inline bool
2578 stmt_starts_bb_p (gimple *stmt, gimple *prev_stmt)
2580 if (stmt == NULL)
2581 return false;
2583 /* Labels start a new basic block only if the preceding statement
2584 wasn't a label of the same type. This prevents the creation of
2585 consecutive blocks that have nothing but a single label. */
2586 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
2588 /* Nonlocal and computed GOTO targets always start a new block. */
2589 if (DECL_NONLOCAL (gimple_label_label (label_stmt))
2590 || FORCED_LABEL (gimple_label_label (label_stmt)))
2591 return true;
2593 if (prev_stmt && gimple_code (prev_stmt) == GIMPLE_LABEL)
2595 if (DECL_NONLOCAL (gimple_label_label (
2596 as_a <glabel *> (prev_stmt))))
2597 return true;
2599 cfg_stats.num_merged_labels++;
2600 return false;
2602 else
2603 return true;
2605 else if (gimple_code (stmt) == GIMPLE_CALL)
2607 if (gimple_call_flags (stmt) & ECF_RETURNS_TWICE)
2608 /* setjmp acts similar to a nonlocal GOTO target and thus should
2609 start a new block. */
2610 return true;
2611 if (gimple_call_internal_p (stmt, IFN_PHI)
2612 && prev_stmt
2613 && gimple_code (prev_stmt) != GIMPLE_LABEL
2614 && (gimple_code (prev_stmt) != GIMPLE_CALL
2615 || ! gimple_call_internal_p (prev_stmt, IFN_PHI)))
2616 /* PHI nodes start a new block unless preceeded by a label
2617 or another PHI. */
2618 return true;
2621 return false;
2625 /* Return true if T should end a basic block. */
2627 bool
2628 stmt_ends_bb_p (gimple *t)
2630 return is_ctrl_stmt (t) || is_ctrl_altering_stmt (t);
2633 /* Remove block annotations and other data structures. */
2635 void
2636 delete_tree_cfg_annotations (struct function *fn)
2638 vec_free (label_to_block_map_for_fn (fn));
2641 /* Return the virtual phi in BB. */
2643 gphi *
2644 get_virtual_phi (basic_block bb)
2646 for (gphi_iterator gsi = gsi_start_phis (bb);
2647 !gsi_end_p (gsi);
2648 gsi_next (&gsi))
2650 gphi *phi = gsi.phi ();
2652 if (virtual_operand_p (PHI_RESULT (phi)))
2653 return phi;
2656 return NULL;
2659 /* Return the first statement in basic block BB. */
2661 gimple *
2662 first_stmt (basic_block bb)
2664 gimple_stmt_iterator i = gsi_start_bb (bb);
2665 gimple *stmt = NULL;
2667 while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
2669 gsi_next (&i);
2670 stmt = NULL;
2672 return stmt;
2675 /* Return the first non-label statement in basic block BB. */
2677 static gimple *
2678 first_non_label_stmt (basic_block bb)
2680 gimple_stmt_iterator i = gsi_start_bb (bb);
2681 while (!gsi_end_p (i) && gimple_code (gsi_stmt (i)) == GIMPLE_LABEL)
2682 gsi_next (&i);
2683 return !gsi_end_p (i) ? gsi_stmt (i) : NULL;
2686 /* Return the last statement in basic block BB. */
2688 gimple *
2689 last_stmt (basic_block bb)
2691 gimple_stmt_iterator i = gsi_last_bb (bb);
2692 gimple *stmt = NULL;
2694 while (!gsi_end_p (i) && is_gimple_debug ((stmt = gsi_stmt (i))))
2696 gsi_prev (&i);
2697 stmt = NULL;
2699 return stmt;
2702 /* Return the last statement of an otherwise empty block. Return NULL
2703 if the block is totally empty, or if it contains more than one
2704 statement. */
2706 gimple *
2707 last_and_only_stmt (basic_block bb)
2709 gimple_stmt_iterator i = gsi_last_nondebug_bb (bb);
2710 gimple *last, *prev;
2712 if (gsi_end_p (i))
2713 return NULL;
2715 last = gsi_stmt (i);
2716 gsi_prev_nondebug (&i);
2717 if (gsi_end_p (i))
2718 return last;
2720 /* Empty statements should no longer appear in the instruction stream.
2721 Everything that might have appeared before should be deleted by
2722 remove_useless_stmts, and the optimizers should just gsi_remove
2723 instead of smashing with build_empty_stmt.
2725 Thus the only thing that should appear here in a block containing
2726 one executable statement is a label. */
2727 prev = gsi_stmt (i);
2728 if (gimple_code (prev) == GIMPLE_LABEL)
2729 return last;
2730 else
2731 return NULL;
2734 /* Reinstall those PHI arguments queued in OLD_EDGE to NEW_EDGE. */
2736 static void
2737 reinstall_phi_args (edge new_edge, edge old_edge)
2739 edge_var_map *vm;
2740 int i;
2741 gphi_iterator phis;
2743 vec<edge_var_map> *v = redirect_edge_var_map_vector (old_edge);
2744 if (!v)
2745 return;
2747 for (i = 0, phis = gsi_start_phis (new_edge->dest);
2748 v->iterate (i, &vm) && !gsi_end_p (phis);
2749 i++, gsi_next (&phis))
2751 gphi *phi = phis.phi ();
2752 tree result = redirect_edge_var_map_result (vm);
2753 tree arg = redirect_edge_var_map_def (vm);
2755 gcc_assert (result == gimple_phi_result (phi));
2757 add_phi_arg (phi, arg, new_edge, redirect_edge_var_map_location (vm));
2760 redirect_edge_var_map_clear (old_edge);
2763 /* Returns the basic block after which the new basic block created
2764 by splitting edge EDGE_IN should be placed. Tries to keep the new block
2765 near its "logical" location. This is of most help to humans looking
2766 at debugging dumps. */
2768 basic_block
2769 split_edge_bb_loc (edge edge_in)
2771 basic_block dest = edge_in->dest;
2772 basic_block dest_prev = dest->prev_bb;
2774 if (dest_prev)
2776 edge e = find_edge (dest_prev, dest);
2777 if (e && !(e->flags & EDGE_COMPLEX))
2778 return edge_in->src;
2780 return dest_prev;
2783 /* Split a (typically critical) edge EDGE_IN. Return the new block.
2784 Abort on abnormal edges. */
2786 static basic_block
2787 gimple_split_edge (edge edge_in)
2789 basic_block new_bb, after_bb, dest;
2790 edge new_edge, e;
2792 /* Abnormal edges cannot be split. */
2793 gcc_assert (!(edge_in->flags & EDGE_ABNORMAL));
2795 dest = edge_in->dest;
2797 after_bb = split_edge_bb_loc (edge_in);
2799 new_bb = create_empty_bb (after_bb);
2800 new_bb->frequency = EDGE_FREQUENCY (edge_in);
2801 new_bb->count = edge_in->count;
2802 new_edge = make_edge (new_bb, dest, EDGE_FALLTHRU);
2803 new_edge->probability = REG_BR_PROB_BASE;
2804 new_edge->count = edge_in->count;
2806 e = redirect_edge_and_branch (edge_in, new_bb);
2807 gcc_assert (e == edge_in);
2808 reinstall_phi_args (new_edge, e);
2810 return new_bb;
2814 /* Verify properties of the address expression T with base object BASE. */
2816 static tree
2817 verify_address (tree t, tree base)
2819 bool old_constant;
2820 bool old_side_effects;
2821 bool new_constant;
2822 bool new_side_effects;
2824 old_constant = TREE_CONSTANT (t);
2825 old_side_effects = TREE_SIDE_EFFECTS (t);
2827 recompute_tree_invariant_for_addr_expr (t);
2828 new_side_effects = TREE_SIDE_EFFECTS (t);
2829 new_constant = TREE_CONSTANT (t);
2831 if (old_constant != new_constant)
2833 error ("constant not recomputed when ADDR_EXPR changed");
2834 return t;
2836 if (old_side_effects != new_side_effects)
2838 error ("side effects not recomputed when ADDR_EXPR changed");
2839 return t;
2842 if (!(VAR_P (base)
2843 || TREE_CODE (base) == PARM_DECL
2844 || TREE_CODE (base) == RESULT_DECL))
2845 return NULL_TREE;
2847 if (DECL_GIMPLE_REG_P (base))
2849 error ("DECL_GIMPLE_REG_P set on a variable with address taken");
2850 return base;
2853 return NULL_TREE;
2856 /* Callback for walk_tree, check that all elements with address taken are
2857 properly noticed as such. The DATA is an int* that is 1 if TP was seen
2858 inside a PHI node. */
2860 static tree
2861 verify_expr (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
2863 tree t = *tp, x;
2865 if (TYPE_P (t))
2866 *walk_subtrees = 0;
2868 /* Check operand N for being valid GIMPLE and give error MSG if not. */
2869 #define CHECK_OP(N, MSG) \
2870 do { if (!is_gimple_val (TREE_OPERAND (t, N))) \
2871 { error (MSG); return TREE_OPERAND (t, N); }} while (0)
2873 switch (TREE_CODE (t))
2875 case SSA_NAME:
2876 if (SSA_NAME_IN_FREE_LIST (t))
2878 error ("SSA name in freelist but still referenced");
2879 return *tp;
2881 break;
2883 case PARM_DECL:
2884 case VAR_DECL:
2885 case RESULT_DECL:
2887 tree context = decl_function_context (t);
2888 if (context != cfun->decl
2889 && !SCOPE_FILE_SCOPE_P (context)
2890 && !TREE_STATIC (t)
2891 && !DECL_EXTERNAL (t))
2893 error ("Local declaration from a different function");
2894 return t;
2897 break;
2899 case INDIRECT_REF:
2900 error ("INDIRECT_REF in gimple IL");
2901 return t;
2903 case MEM_REF:
2904 x = TREE_OPERAND (t, 0);
2905 if (!POINTER_TYPE_P (TREE_TYPE (x))
2906 || !is_gimple_mem_ref_addr (x))
2908 error ("invalid first operand of MEM_REF");
2909 return x;
2911 if (TREE_CODE (TREE_OPERAND (t, 1)) != INTEGER_CST
2912 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 1))))
2914 error ("invalid offset operand of MEM_REF");
2915 return TREE_OPERAND (t, 1);
2917 if (TREE_CODE (x) == ADDR_EXPR)
2919 tree va = verify_address (x, TREE_OPERAND (x, 0));
2920 if (va)
2921 return va;
2922 x = TREE_OPERAND (x, 0);
2924 walk_tree (&x, verify_expr, data, NULL);
2925 *walk_subtrees = 0;
2926 break;
2928 case ASSERT_EXPR:
2929 x = fold (ASSERT_EXPR_COND (t));
2930 if (x == boolean_false_node)
2932 error ("ASSERT_EXPR with an always-false condition");
2933 return *tp;
2935 break;
2937 case MODIFY_EXPR:
2938 error ("MODIFY_EXPR not expected while having tuples");
2939 return *tp;
2941 case ADDR_EXPR:
2943 tree tem;
2945 gcc_assert (is_gimple_address (t));
2947 /* Skip any references (they will be checked when we recurse down the
2948 tree) and ensure that any variable used as a prefix is marked
2949 addressable. */
2950 for (x = TREE_OPERAND (t, 0);
2951 handled_component_p (x);
2952 x = TREE_OPERAND (x, 0))
2955 if ((tem = verify_address (t, x)))
2956 return tem;
2958 if (!(VAR_P (x)
2959 || TREE_CODE (x) == PARM_DECL
2960 || TREE_CODE (x) == RESULT_DECL))
2961 return NULL;
2963 if (!TREE_ADDRESSABLE (x))
2965 error ("address taken, but ADDRESSABLE bit not set");
2966 return x;
2969 break;
2972 case COND_EXPR:
2973 x = COND_EXPR_COND (t);
2974 if (!INTEGRAL_TYPE_P (TREE_TYPE (x)))
2976 error ("non-integral used in condition");
2977 return x;
2979 if (!is_gimple_condexpr (x))
2981 error ("invalid conditional operand");
2982 return x;
2984 break;
2986 case NON_LVALUE_EXPR:
2987 case TRUTH_NOT_EXPR:
2988 gcc_unreachable ();
2990 CASE_CONVERT:
2991 case FIX_TRUNC_EXPR:
2992 case FLOAT_EXPR:
2993 case NEGATE_EXPR:
2994 case ABS_EXPR:
2995 case BIT_NOT_EXPR:
2996 CHECK_OP (0, "invalid operand to unary operator");
2997 break;
2999 case REALPART_EXPR:
3000 case IMAGPART_EXPR:
3001 case BIT_FIELD_REF:
3002 if (!is_gimple_reg_type (TREE_TYPE (t)))
3004 error ("non-scalar BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR");
3005 return t;
3008 if (TREE_CODE (t) == BIT_FIELD_REF)
3010 tree t0 = TREE_OPERAND (t, 0);
3011 tree t1 = TREE_OPERAND (t, 1);
3012 tree t2 = TREE_OPERAND (t, 2);
3013 if (!tree_fits_uhwi_p (t1)
3014 || !tree_fits_uhwi_p (t2))
3016 error ("invalid position or size operand to BIT_FIELD_REF");
3017 return t;
3019 if (INTEGRAL_TYPE_P (TREE_TYPE (t))
3020 && (TYPE_PRECISION (TREE_TYPE (t))
3021 != tree_to_uhwi (t1)))
3023 error ("integral result type precision does not match "
3024 "field size of BIT_FIELD_REF");
3025 return t;
3027 else if (!INTEGRAL_TYPE_P (TREE_TYPE (t))
3028 && TYPE_MODE (TREE_TYPE (t)) != BLKmode
3029 && (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t)))
3030 != tree_to_uhwi (t1)))
3032 error ("mode size of non-integral result does not "
3033 "match field size of BIT_FIELD_REF");
3034 return t;
3036 if (!AGGREGATE_TYPE_P (TREE_TYPE (t0))
3037 && (tree_to_uhwi (t1) + tree_to_uhwi (t2)
3038 > tree_to_uhwi (TYPE_SIZE (TREE_TYPE (t0)))))
3040 error ("position plus size exceeds size of referenced object in "
3041 "BIT_FIELD_REF");
3042 return t;
3045 t = TREE_OPERAND (t, 0);
3047 /* Fall-through. */
3048 case COMPONENT_REF:
3049 case ARRAY_REF:
3050 case ARRAY_RANGE_REF:
3051 case VIEW_CONVERT_EXPR:
3052 /* We have a nest of references. Verify that each of the operands
3053 that determine where to reference is either a constant or a variable,
3054 verify that the base is valid, and then show we've already checked
3055 the subtrees. */
3056 while (handled_component_p (t))
3058 if (TREE_CODE (t) == COMPONENT_REF && TREE_OPERAND (t, 2))
3059 CHECK_OP (2, "invalid COMPONENT_REF offset operator");
3060 else if (TREE_CODE (t) == ARRAY_REF
3061 || TREE_CODE (t) == ARRAY_RANGE_REF)
3063 CHECK_OP (1, "invalid array index");
3064 if (TREE_OPERAND (t, 2))
3065 CHECK_OP (2, "invalid array lower bound");
3066 if (TREE_OPERAND (t, 3))
3067 CHECK_OP (3, "invalid array stride");
3069 else if (TREE_CODE (t) == BIT_FIELD_REF
3070 || TREE_CODE (t) == REALPART_EXPR
3071 || TREE_CODE (t) == IMAGPART_EXPR)
3073 error ("non-top-level BIT_FIELD_REF, IMAGPART_EXPR or "
3074 "REALPART_EXPR");
3075 return t;
3078 t = TREE_OPERAND (t, 0);
3081 if (!is_gimple_min_invariant (t) && !is_gimple_lvalue (t))
3083 error ("invalid reference prefix");
3084 return t;
3086 walk_tree (&t, verify_expr, data, NULL);
3087 *walk_subtrees = 0;
3088 break;
3089 case PLUS_EXPR:
3090 case MINUS_EXPR:
3091 /* PLUS_EXPR and MINUS_EXPR don't work on pointers, they should be done using
3092 POINTER_PLUS_EXPR. */
3093 if (POINTER_TYPE_P (TREE_TYPE (t)))
3095 error ("invalid operand to plus/minus, type is a pointer");
3096 return t;
3098 CHECK_OP (0, "invalid operand to binary operator");
3099 CHECK_OP (1, "invalid operand to binary operator");
3100 break;
3102 case POINTER_PLUS_EXPR:
3103 /* Check to make sure the first operand is a pointer or reference type. */
3104 if (!POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t, 0))))
3106 error ("invalid operand to pointer plus, first operand is not a pointer");
3107 return t;
3109 /* Check to make sure the second operand is a ptrofftype. */
3110 if (!ptrofftype_p (TREE_TYPE (TREE_OPERAND (t, 1))))
3112 error ("invalid operand to pointer plus, second operand is not an "
3113 "integer type of appropriate width");
3114 return t;
3116 /* FALLTHROUGH */
3117 case LT_EXPR:
3118 case LE_EXPR:
3119 case GT_EXPR:
3120 case GE_EXPR:
3121 case EQ_EXPR:
3122 case NE_EXPR:
3123 case UNORDERED_EXPR:
3124 case ORDERED_EXPR:
3125 case UNLT_EXPR:
3126 case UNLE_EXPR:
3127 case UNGT_EXPR:
3128 case UNGE_EXPR:
3129 case UNEQ_EXPR:
3130 case LTGT_EXPR:
3131 case MULT_EXPR:
3132 case TRUNC_DIV_EXPR:
3133 case CEIL_DIV_EXPR:
3134 case FLOOR_DIV_EXPR:
3135 case ROUND_DIV_EXPR:
3136 case TRUNC_MOD_EXPR:
3137 case CEIL_MOD_EXPR:
3138 case FLOOR_MOD_EXPR:
3139 case ROUND_MOD_EXPR:
3140 case RDIV_EXPR:
3141 case EXACT_DIV_EXPR:
3142 case MIN_EXPR:
3143 case MAX_EXPR:
3144 case LSHIFT_EXPR:
3145 case RSHIFT_EXPR:
3146 case LROTATE_EXPR:
3147 case RROTATE_EXPR:
3148 case BIT_IOR_EXPR:
3149 case BIT_XOR_EXPR:
3150 case BIT_AND_EXPR:
3151 CHECK_OP (0, "invalid operand to binary operator");
3152 CHECK_OP (1, "invalid operand to binary operator");
3153 break;
3155 case CONSTRUCTOR:
3156 if (TREE_CONSTANT (t) && TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
3157 *walk_subtrees = 0;
3158 break;
3160 case CASE_LABEL_EXPR:
3161 if (CASE_CHAIN (t))
3163 error ("invalid CASE_CHAIN");
3164 return t;
3166 break;
3168 default:
3169 break;
3171 return NULL;
3173 #undef CHECK_OP
3177 /* Verify if EXPR is either a GIMPLE ID or a GIMPLE indirect reference.
3178 Returns true if there is an error, otherwise false. */
3180 static bool
3181 verify_types_in_gimple_min_lval (tree expr)
3183 tree op;
3185 if (is_gimple_id (expr))
3186 return false;
3188 if (TREE_CODE (expr) != TARGET_MEM_REF
3189 && TREE_CODE (expr) != MEM_REF)
3191 error ("invalid expression for min lvalue");
3192 return true;
3195 /* TARGET_MEM_REFs are strange beasts. */
3196 if (TREE_CODE (expr) == TARGET_MEM_REF)
3197 return false;
3199 op = TREE_OPERAND (expr, 0);
3200 if (!is_gimple_val (op))
3202 error ("invalid operand in indirect reference");
3203 debug_generic_stmt (op);
3204 return true;
3206 /* Memory references now generally can involve a value conversion. */
3208 return false;
3211 /* Verify if EXPR is a valid GIMPLE reference expression. If
3212 REQUIRE_LVALUE is true verifies it is an lvalue. Returns true
3213 if there is an error, otherwise false. */
3215 static bool
3216 verify_types_in_gimple_reference (tree expr, bool require_lvalue)
3218 while (handled_component_p (expr))
3220 tree op = TREE_OPERAND (expr, 0);
3222 if (TREE_CODE (expr) == ARRAY_REF
3223 || TREE_CODE (expr) == ARRAY_RANGE_REF)
3225 if (!is_gimple_val (TREE_OPERAND (expr, 1))
3226 || (TREE_OPERAND (expr, 2)
3227 && !is_gimple_val (TREE_OPERAND (expr, 2)))
3228 || (TREE_OPERAND (expr, 3)
3229 && !is_gimple_val (TREE_OPERAND (expr, 3))))
3231 error ("invalid operands to array reference");
3232 debug_generic_stmt (expr);
3233 return true;
3237 /* Verify if the reference array element types are compatible. */
3238 if (TREE_CODE (expr) == ARRAY_REF
3239 && !useless_type_conversion_p (TREE_TYPE (expr),
3240 TREE_TYPE (TREE_TYPE (op))))
3242 error ("type mismatch in array reference");
3243 debug_generic_stmt (TREE_TYPE (expr));
3244 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
3245 return true;
3247 if (TREE_CODE (expr) == ARRAY_RANGE_REF
3248 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr)),
3249 TREE_TYPE (TREE_TYPE (op))))
3251 error ("type mismatch in array range reference");
3252 debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr)));
3253 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
3254 return true;
3257 if ((TREE_CODE (expr) == REALPART_EXPR
3258 || TREE_CODE (expr) == IMAGPART_EXPR)
3259 && !useless_type_conversion_p (TREE_TYPE (expr),
3260 TREE_TYPE (TREE_TYPE (op))))
3262 error ("type mismatch in real/imagpart reference");
3263 debug_generic_stmt (TREE_TYPE (expr));
3264 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op)));
3265 return true;
3268 if (TREE_CODE (expr) == COMPONENT_REF
3269 && !useless_type_conversion_p (TREE_TYPE (expr),
3270 TREE_TYPE (TREE_OPERAND (expr, 1))))
3272 error ("type mismatch in component reference");
3273 debug_generic_stmt (TREE_TYPE (expr));
3274 debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr, 1)));
3275 return true;
3278 if (TREE_CODE (expr) == VIEW_CONVERT_EXPR)
3280 /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
3281 that their operand is not an SSA name or an invariant when
3282 requiring an lvalue (this usually means there is a SRA or IPA-SRA
3283 bug). Otherwise there is nothing to verify, gross mismatches at
3284 most invoke undefined behavior. */
3285 if (require_lvalue
3286 && (TREE_CODE (op) == SSA_NAME
3287 || is_gimple_min_invariant (op)))
3289 error ("conversion of an SSA_NAME on the left hand side");
3290 debug_generic_stmt (expr);
3291 return true;
3293 else if (TREE_CODE (op) == SSA_NAME
3294 && TYPE_SIZE (TREE_TYPE (expr)) != TYPE_SIZE (TREE_TYPE (op)))
3296 error ("conversion of register to a different size");
3297 debug_generic_stmt (expr);
3298 return true;
3300 else if (!handled_component_p (op))
3301 return false;
3304 expr = op;
3307 if (TREE_CODE (expr) == MEM_REF)
3309 if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr, 0)))
3311 error ("invalid address operand in MEM_REF");
3312 debug_generic_stmt (expr);
3313 return true;
3315 if (TREE_CODE (TREE_OPERAND (expr, 1)) != INTEGER_CST
3316 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr, 1))))
3318 error ("invalid offset operand in MEM_REF");
3319 debug_generic_stmt (expr);
3320 return true;
3323 else if (TREE_CODE (expr) == TARGET_MEM_REF)
3325 if (!TMR_BASE (expr)
3326 || !is_gimple_mem_ref_addr (TMR_BASE (expr)))
3328 error ("invalid address operand in TARGET_MEM_REF");
3329 return true;
3331 if (!TMR_OFFSET (expr)
3332 || TREE_CODE (TMR_OFFSET (expr)) != INTEGER_CST
3333 || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr))))
3335 error ("invalid offset operand in TARGET_MEM_REF");
3336 debug_generic_stmt (expr);
3337 return true;
3341 return ((require_lvalue || !is_gimple_min_invariant (expr))
3342 && verify_types_in_gimple_min_lval (expr));
3345 /* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
3346 list of pointer-to types that is trivially convertible to DEST. */
3348 static bool
3349 one_pointer_to_useless_type_conversion_p (tree dest, tree src_obj)
3351 tree src;
3353 if (!TYPE_POINTER_TO (src_obj))
3354 return true;
3356 for (src = TYPE_POINTER_TO (src_obj); src; src = TYPE_NEXT_PTR_TO (src))
3357 if (useless_type_conversion_p (dest, src))
3358 return true;
3360 return false;
3363 /* Return true if TYPE1 is a fixed-point type and if conversions to and
3364 from TYPE2 can be handled by FIXED_CONVERT_EXPR. */
3366 static bool
3367 valid_fixed_convert_types_p (tree type1, tree type2)
3369 return (FIXED_POINT_TYPE_P (type1)
3370 && (INTEGRAL_TYPE_P (type2)
3371 || SCALAR_FLOAT_TYPE_P (type2)
3372 || FIXED_POINT_TYPE_P (type2)));
3375 /* Verify the contents of a GIMPLE_CALL STMT. Returns true when there
3376 is a problem, otherwise false. */
3378 static bool
3379 verify_gimple_call (gcall *stmt)
3381 tree fn = gimple_call_fn (stmt);
3382 tree fntype, fndecl;
3383 unsigned i;
3385 if (gimple_call_internal_p (stmt))
3387 if (fn)
3389 error ("gimple call has two targets");
3390 debug_generic_stmt (fn);
3391 return true;
3393 /* FIXME : for passing label as arg in internal fn PHI from GIMPLE FE*/
3394 else if (gimple_call_internal_fn (stmt) == IFN_PHI)
3396 return false;
3399 else
3401 if (!fn)
3403 error ("gimple call has no target");
3404 return true;
3408 if (fn && !is_gimple_call_addr (fn))
3410 error ("invalid function in gimple call");
3411 debug_generic_stmt (fn);
3412 return true;
3415 if (fn
3416 && (!POINTER_TYPE_P (TREE_TYPE (fn))
3417 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn))) != FUNCTION_TYPE
3418 && TREE_CODE (TREE_TYPE (TREE_TYPE (fn))) != METHOD_TYPE)))
3420 error ("non-function in gimple call");
3421 return true;
3424 fndecl = gimple_call_fndecl (stmt);
3425 if (fndecl
3426 && TREE_CODE (fndecl) == FUNCTION_DECL
3427 && DECL_LOOPING_CONST_OR_PURE_P (fndecl)
3428 && !DECL_PURE_P (fndecl)
3429 && !TREE_READONLY (fndecl))
3431 error ("invalid pure const state for function");
3432 return true;
3435 tree lhs = gimple_call_lhs (stmt);
3436 if (lhs
3437 && (!is_gimple_lvalue (lhs)
3438 || verify_types_in_gimple_reference (lhs, true)))
3440 error ("invalid LHS in gimple call");
3441 return true;
3444 if (gimple_call_ctrl_altering_p (stmt)
3445 && gimple_call_noreturn_p (stmt)
3446 && should_remove_lhs_p (lhs))
3448 error ("LHS in noreturn call");
3449 return true;
3452 fntype = gimple_call_fntype (stmt);
3453 if (fntype
3454 && lhs
3455 && !useless_type_conversion_p (TREE_TYPE (lhs), TREE_TYPE (fntype))
3456 /* ??? At least C++ misses conversions at assignments from
3457 void * call results.
3458 ??? Java is completely off. Especially with functions
3459 returning java.lang.Object.
3460 For now simply allow arbitrary pointer type conversions. */
3461 && !(POINTER_TYPE_P (TREE_TYPE (lhs))
3462 && POINTER_TYPE_P (TREE_TYPE (fntype))))
3464 error ("invalid conversion in gimple call");
3465 debug_generic_stmt (TREE_TYPE (lhs));
3466 debug_generic_stmt (TREE_TYPE (fntype));
3467 return true;
3470 if (gimple_call_chain (stmt)
3471 && !is_gimple_val (gimple_call_chain (stmt)))
3473 error ("invalid static chain in gimple call");
3474 debug_generic_stmt (gimple_call_chain (stmt));
3475 return true;
3478 /* If there is a static chain argument, the call should either be
3479 indirect, or the decl should have DECL_STATIC_CHAIN set. */
3480 if (gimple_call_chain (stmt)
3481 && fndecl
3482 && !DECL_STATIC_CHAIN (fndecl))
3484 error ("static chain with function that doesn%'t use one");
3485 return true;
3488 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
3490 switch (DECL_FUNCTION_CODE (fndecl))
3492 case BUILT_IN_UNREACHABLE:
3493 case BUILT_IN_TRAP:
3494 if (gimple_call_num_args (stmt) > 0)
3496 /* Built-in unreachable with parameters might not be caught by
3497 undefined behavior sanitizer. Front-ends do check users do not
3498 call them that way but we also produce calls to
3499 __builtin_unreachable internally, for example when IPA figures
3500 out a call cannot happen in a legal program. In such cases,
3501 we must make sure arguments are stripped off. */
3502 error ("__builtin_unreachable or __builtin_trap call with "
3503 "arguments");
3504 return true;
3506 break;
3507 default:
3508 break;
3512 /* ??? The C frontend passes unpromoted arguments in case it
3513 didn't see a function declaration before the call. So for now
3514 leave the call arguments mostly unverified. Once we gimplify
3515 unit-at-a-time we have a chance to fix this. */
3517 for (i = 0; i < gimple_call_num_args (stmt); ++i)
3519 tree arg = gimple_call_arg (stmt, i);
3520 if ((is_gimple_reg_type (TREE_TYPE (arg))
3521 && !is_gimple_val (arg))
3522 || (!is_gimple_reg_type (TREE_TYPE (arg))
3523 && !is_gimple_lvalue (arg)))
3525 error ("invalid argument to gimple call");
3526 debug_generic_expr (arg);
3527 return true;
3531 return false;
3534 /* Verifies the gimple comparison with the result type TYPE and
3535 the operands OP0 and OP1, comparison code is CODE. */
3537 static bool
3538 verify_gimple_comparison (tree type, tree op0, tree op1, enum tree_code code)
3540 tree op0_type = TREE_TYPE (op0);
3541 tree op1_type = TREE_TYPE (op1);
3543 if (!is_gimple_val (op0) || !is_gimple_val (op1))
3545 error ("invalid operands in gimple comparison");
3546 return true;
3549 /* For comparisons we do not have the operations type as the
3550 effective type the comparison is carried out in. Instead
3551 we require that either the first operand is trivially
3552 convertible into the second, or the other way around.
3553 Because we special-case pointers to void we allow
3554 comparisons of pointers with the same mode as well. */
3555 if (!useless_type_conversion_p (op0_type, op1_type)
3556 && !useless_type_conversion_p (op1_type, op0_type)
3557 && (!POINTER_TYPE_P (op0_type)
3558 || !POINTER_TYPE_P (op1_type)
3559 || TYPE_MODE (op0_type) != TYPE_MODE (op1_type)))
3561 error ("mismatching comparison operand types");
3562 debug_generic_expr (op0_type);
3563 debug_generic_expr (op1_type);
3564 return true;
3567 /* The resulting type of a comparison may be an effective boolean type. */
3568 if (INTEGRAL_TYPE_P (type)
3569 && (TREE_CODE (type) == BOOLEAN_TYPE
3570 || TYPE_PRECISION (type) == 1))
3572 if ((TREE_CODE (op0_type) == VECTOR_TYPE
3573 || TREE_CODE (op1_type) == VECTOR_TYPE)
3574 && code != EQ_EXPR && code != NE_EXPR
3575 && !VECTOR_BOOLEAN_TYPE_P (op0_type)
3576 && !VECTOR_INTEGER_TYPE_P (op0_type))
3578 error ("unsupported operation or type for vector comparison"
3579 " returning a boolean");
3580 debug_generic_expr (op0_type);
3581 debug_generic_expr (op1_type);
3582 return true;
3585 /* Or a boolean vector type with the same element count
3586 as the comparison operand types. */
3587 else if (TREE_CODE (type) == VECTOR_TYPE
3588 && TREE_CODE (TREE_TYPE (type)) == BOOLEAN_TYPE)
3590 if (TREE_CODE (op0_type) != VECTOR_TYPE
3591 || TREE_CODE (op1_type) != VECTOR_TYPE)
3593 error ("non-vector operands in vector comparison");
3594 debug_generic_expr (op0_type);
3595 debug_generic_expr (op1_type);
3596 return true;
3599 if (TYPE_VECTOR_SUBPARTS (type) != TYPE_VECTOR_SUBPARTS (op0_type))
3601 error ("invalid vector comparison resulting type");
3602 debug_generic_expr (type);
3603 return true;
3606 else
3608 error ("bogus comparison result type");
3609 debug_generic_expr (type);
3610 return true;
3613 return false;
3616 /* Verify a gimple assignment statement STMT with an unary rhs.
3617 Returns true if anything is wrong. */
3619 static bool
3620 verify_gimple_assign_unary (gassign *stmt)
3622 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
3623 tree lhs = gimple_assign_lhs (stmt);
3624 tree lhs_type = TREE_TYPE (lhs);
3625 tree rhs1 = gimple_assign_rhs1 (stmt);
3626 tree rhs1_type = TREE_TYPE (rhs1);
3628 if (!is_gimple_reg (lhs))
3630 error ("non-register as LHS of unary operation");
3631 return true;
3634 if (!is_gimple_val (rhs1))
3636 error ("invalid operand in unary operation");
3637 return true;
3640 /* First handle conversions. */
3641 switch (rhs_code)
3643 CASE_CONVERT:
3645 /* Allow conversions from pointer type to integral type only if
3646 there is no sign or zero extension involved.
3647 For targets were the precision of ptrofftype doesn't match that
3648 of pointers we need to allow arbitrary conversions to ptrofftype. */
3649 if ((POINTER_TYPE_P (lhs_type)
3650 && INTEGRAL_TYPE_P (rhs1_type))
3651 || (POINTER_TYPE_P (rhs1_type)
3652 && INTEGRAL_TYPE_P (lhs_type)
3653 && (TYPE_PRECISION (rhs1_type) >= TYPE_PRECISION (lhs_type)
3654 || ptrofftype_p (sizetype))))
3655 return false;
3657 /* Allow conversion from integral to offset type and vice versa. */
3658 if ((TREE_CODE (lhs_type) == OFFSET_TYPE
3659 && INTEGRAL_TYPE_P (rhs1_type))
3660 || (INTEGRAL_TYPE_P (lhs_type)
3661 && TREE_CODE (rhs1_type) == OFFSET_TYPE))
3662 return false;
3664 /* Otherwise assert we are converting between types of the
3665 same kind. */
3666 if (INTEGRAL_TYPE_P (lhs_type) != INTEGRAL_TYPE_P (rhs1_type))
3668 error ("invalid types in nop conversion");
3669 debug_generic_expr (lhs_type);
3670 debug_generic_expr (rhs1_type);
3671 return true;
3674 return false;
3677 case ADDR_SPACE_CONVERT_EXPR:
3679 if (!POINTER_TYPE_P (rhs1_type) || !POINTER_TYPE_P (lhs_type)
3680 || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type))
3681 == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type))))
3683 error ("invalid types in address space conversion");
3684 debug_generic_expr (lhs_type);
3685 debug_generic_expr (rhs1_type);
3686 return true;
3689 return false;
3692 case FIXED_CONVERT_EXPR:
3694 if (!valid_fixed_convert_types_p (lhs_type, rhs1_type)
3695 && !valid_fixed_convert_types_p (rhs1_type, lhs_type))
3697 error ("invalid types in fixed-point conversion");
3698 debug_generic_expr (lhs_type);
3699 debug_generic_expr (rhs1_type);
3700 return true;
3703 return false;
3706 case FLOAT_EXPR:
3708 if ((!INTEGRAL_TYPE_P (rhs1_type) || !SCALAR_FLOAT_TYPE_P (lhs_type))
3709 && (!VECTOR_INTEGER_TYPE_P (rhs1_type)
3710 || !VECTOR_FLOAT_TYPE_P (lhs_type)))
3712 error ("invalid types in conversion to floating point");
3713 debug_generic_expr (lhs_type);
3714 debug_generic_expr (rhs1_type);
3715 return true;
3718 return false;
3721 case FIX_TRUNC_EXPR:
3723 if ((!INTEGRAL_TYPE_P (lhs_type) || !SCALAR_FLOAT_TYPE_P (rhs1_type))
3724 && (!VECTOR_INTEGER_TYPE_P (lhs_type)
3725 || !VECTOR_FLOAT_TYPE_P (rhs1_type)))
3727 error ("invalid types in conversion to integer");
3728 debug_generic_expr (lhs_type);
3729 debug_generic_expr (rhs1_type);
3730 return true;
3733 return false;
3735 case REDUC_MAX_EXPR:
3736 case REDUC_MIN_EXPR:
3737 case REDUC_PLUS_EXPR:
3738 if (!VECTOR_TYPE_P (rhs1_type)
3739 || !useless_type_conversion_p (lhs_type, TREE_TYPE (rhs1_type)))
3741 error ("reduction should convert from vector to element type");
3742 debug_generic_expr (lhs_type);
3743 debug_generic_expr (rhs1_type);
3744 return true;
3746 return false;
3748 case VEC_UNPACK_HI_EXPR:
3749 case VEC_UNPACK_LO_EXPR:
3750 case VEC_UNPACK_FLOAT_HI_EXPR:
3751 case VEC_UNPACK_FLOAT_LO_EXPR:
3752 /* FIXME. */
3753 return false;
3755 case NEGATE_EXPR:
3756 case ABS_EXPR:
3757 case BIT_NOT_EXPR:
3758 case PAREN_EXPR:
3759 case CONJ_EXPR:
3760 break;
3762 default:
3763 gcc_unreachable ();
3766 /* For the remaining codes assert there is no conversion involved. */
3767 if (!useless_type_conversion_p (lhs_type, rhs1_type))
3769 error ("non-trivial conversion in unary operation");
3770 debug_generic_expr (lhs_type);
3771 debug_generic_expr (rhs1_type);
3772 return true;
3775 return false;
3778 /* Verify a gimple assignment statement STMT with a binary rhs.
3779 Returns true if anything is wrong. */
3781 static bool
3782 verify_gimple_assign_binary (gassign *stmt)
3784 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
3785 tree lhs = gimple_assign_lhs (stmt);
3786 tree lhs_type = TREE_TYPE (lhs);
3787 tree rhs1 = gimple_assign_rhs1 (stmt);
3788 tree rhs1_type = TREE_TYPE (rhs1);
3789 tree rhs2 = gimple_assign_rhs2 (stmt);
3790 tree rhs2_type = TREE_TYPE (rhs2);
3792 if (!is_gimple_reg (lhs))
3794 error ("non-register as LHS of binary operation");
3795 return true;
3798 if (!is_gimple_val (rhs1)
3799 || !is_gimple_val (rhs2))
3801 error ("invalid operands in binary operation");
3802 return true;
3805 /* First handle operations that involve different types. */
3806 switch (rhs_code)
3808 case COMPLEX_EXPR:
3810 if (TREE_CODE (lhs_type) != COMPLEX_TYPE
3811 || !(INTEGRAL_TYPE_P (rhs1_type)
3812 || SCALAR_FLOAT_TYPE_P (rhs1_type))
3813 || !(INTEGRAL_TYPE_P (rhs2_type)
3814 || SCALAR_FLOAT_TYPE_P (rhs2_type)))
3816 error ("type mismatch in complex expression");
3817 debug_generic_expr (lhs_type);
3818 debug_generic_expr (rhs1_type);
3819 debug_generic_expr (rhs2_type);
3820 return true;
3823 return false;
3826 case LSHIFT_EXPR:
3827 case RSHIFT_EXPR:
3828 case LROTATE_EXPR:
3829 case RROTATE_EXPR:
3831 /* Shifts and rotates are ok on integral types, fixed point
3832 types and integer vector types. */
3833 if ((!INTEGRAL_TYPE_P (rhs1_type)
3834 && !FIXED_POINT_TYPE_P (rhs1_type)
3835 && !(TREE_CODE (rhs1_type) == VECTOR_TYPE
3836 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))))
3837 || (!INTEGRAL_TYPE_P (rhs2_type)
3838 /* Vector shifts of vectors are also ok. */
3839 && !(TREE_CODE (rhs1_type) == VECTOR_TYPE
3840 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
3841 && TREE_CODE (rhs2_type) == VECTOR_TYPE
3842 && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type))))
3843 || !useless_type_conversion_p (lhs_type, rhs1_type))
3845 error ("type mismatch in shift expression");
3846 debug_generic_expr (lhs_type);
3847 debug_generic_expr (rhs1_type);
3848 debug_generic_expr (rhs2_type);
3849 return true;
3852 return false;
3855 case WIDEN_LSHIFT_EXPR:
3857 if (!INTEGRAL_TYPE_P (lhs_type)
3858 || !INTEGRAL_TYPE_P (rhs1_type)
3859 || TREE_CODE (rhs2) != INTEGER_CST
3860 || (2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type)))
3862 error ("type mismatch in widening vector shift expression");
3863 debug_generic_expr (lhs_type);
3864 debug_generic_expr (rhs1_type);
3865 debug_generic_expr (rhs2_type);
3866 return true;
3869 return false;
3872 case VEC_WIDEN_LSHIFT_HI_EXPR:
3873 case VEC_WIDEN_LSHIFT_LO_EXPR:
3875 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
3876 || TREE_CODE (lhs_type) != VECTOR_TYPE
3877 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type))
3878 || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type))
3879 || TREE_CODE (rhs2) != INTEGER_CST
3880 || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type))
3881 > TYPE_PRECISION (TREE_TYPE (lhs_type))))
3883 error ("type mismatch in widening vector shift expression");
3884 debug_generic_expr (lhs_type);
3885 debug_generic_expr (rhs1_type);
3886 debug_generic_expr (rhs2_type);
3887 return true;
3890 return false;
3893 case PLUS_EXPR:
3894 case MINUS_EXPR:
3896 tree lhs_etype = lhs_type;
3897 tree rhs1_etype = rhs1_type;
3898 tree rhs2_etype = rhs2_type;
3899 if (TREE_CODE (lhs_type) == VECTOR_TYPE)
3901 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
3902 || TREE_CODE (rhs2_type) != VECTOR_TYPE)
3904 error ("invalid non-vector operands to vector valued plus");
3905 return true;
3907 lhs_etype = TREE_TYPE (lhs_type);
3908 rhs1_etype = TREE_TYPE (rhs1_type);
3909 rhs2_etype = TREE_TYPE (rhs2_type);
3911 if (POINTER_TYPE_P (lhs_etype)
3912 || POINTER_TYPE_P (rhs1_etype)
3913 || POINTER_TYPE_P (rhs2_etype))
3915 error ("invalid (pointer) operands to plus/minus");
3916 return true;
3919 /* Continue with generic binary expression handling. */
3920 break;
3923 case POINTER_PLUS_EXPR:
3925 if (!POINTER_TYPE_P (rhs1_type)
3926 || !useless_type_conversion_p (lhs_type, rhs1_type)
3927 || !ptrofftype_p (rhs2_type))
3929 error ("type mismatch in pointer plus expression");
3930 debug_generic_stmt (lhs_type);
3931 debug_generic_stmt (rhs1_type);
3932 debug_generic_stmt (rhs2_type);
3933 return true;
3936 return false;
3939 case TRUTH_ANDIF_EXPR:
3940 case TRUTH_ORIF_EXPR:
3941 case TRUTH_AND_EXPR:
3942 case TRUTH_OR_EXPR:
3943 case TRUTH_XOR_EXPR:
3945 gcc_unreachable ();
3947 case LT_EXPR:
3948 case LE_EXPR:
3949 case GT_EXPR:
3950 case GE_EXPR:
3951 case EQ_EXPR:
3952 case NE_EXPR:
3953 case UNORDERED_EXPR:
3954 case ORDERED_EXPR:
3955 case UNLT_EXPR:
3956 case UNLE_EXPR:
3957 case UNGT_EXPR:
3958 case UNGE_EXPR:
3959 case UNEQ_EXPR:
3960 case LTGT_EXPR:
3961 /* Comparisons are also binary, but the result type is not
3962 connected to the operand types. */
3963 return verify_gimple_comparison (lhs_type, rhs1, rhs2, rhs_code);
3965 case WIDEN_MULT_EXPR:
3966 if (TREE_CODE (lhs_type) != INTEGER_TYPE)
3967 return true;
3968 return ((2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type))
3969 || (TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (rhs2_type)));
3971 case WIDEN_SUM_EXPR:
3972 case VEC_WIDEN_MULT_HI_EXPR:
3973 case VEC_WIDEN_MULT_LO_EXPR:
3974 case VEC_WIDEN_MULT_EVEN_EXPR:
3975 case VEC_WIDEN_MULT_ODD_EXPR:
3976 case VEC_PACK_TRUNC_EXPR:
3977 case VEC_PACK_SAT_EXPR:
3978 case VEC_PACK_FIX_TRUNC_EXPR:
3979 /* FIXME. */
3980 return false;
3982 case MULT_EXPR:
3983 case MULT_HIGHPART_EXPR:
3984 case TRUNC_DIV_EXPR:
3985 case CEIL_DIV_EXPR:
3986 case FLOOR_DIV_EXPR:
3987 case ROUND_DIV_EXPR:
3988 case TRUNC_MOD_EXPR:
3989 case CEIL_MOD_EXPR:
3990 case FLOOR_MOD_EXPR:
3991 case ROUND_MOD_EXPR:
3992 case RDIV_EXPR:
3993 case EXACT_DIV_EXPR:
3994 case MIN_EXPR:
3995 case MAX_EXPR:
3996 case BIT_IOR_EXPR:
3997 case BIT_XOR_EXPR:
3998 case BIT_AND_EXPR:
3999 /* Continue with generic binary expression handling. */
4000 break;
4002 default:
4003 gcc_unreachable ();
4006 if (!useless_type_conversion_p (lhs_type, rhs1_type)
4007 || !useless_type_conversion_p (lhs_type, rhs2_type))
4009 error ("type mismatch in binary expression");
4010 debug_generic_stmt (lhs_type);
4011 debug_generic_stmt (rhs1_type);
4012 debug_generic_stmt (rhs2_type);
4013 return true;
4016 return false;
4019 /* Verify a gimple assignment statement STMT with a ternary rhs.
4020 Returns true if anything is wrong. */
4022 static bool
4023 verify_gimple_assign_ternary (gassign *stmt)
4025 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
4026 tree lhs = gimple_assign_lhs (stmt);
4027 tree lhs_type = TREE_TYPE (lhs);
4028 tree rhs1 = gimple_assign_rhs1 (stmt);
4029 tree rhs1_type = TREE_TYPE (rhs1);
4030 tree rhs2 = gimple_assign_rhs2 (stmt);
4031 tree rhs2_type = TREE_TYPE (rhs2);
4032 tree rhs3 = gimple_assign_rhs3 (stmt);
4033 tree rhs3_type = TREE_TYPE (rhs3);
4035 if (!is_gimple_reg (lhs))
4037 error ("non-register as LHS of ternary operation");
4038 return true;
4041 if (((rhs_code == VEC_COND_EXPR || rhs_code == COND_EXPR)
4042 ? !is_gimple_condexpr (rhs1) : !is_gimple_val (rhs1))
4043 || !is_gimple_val (rhs2)
4044 || !is_gimple_val (rhs3))
4046 error ("invalid operands in ternary operation");
4047 return true;
4050 /* First handle operations that involve different types. */
4051 switch (rhs_code)
4053 case WIDEN_MULT_PLUS_EXPR:
4054 case WIDEN_MULT_MINUS_EXPR:
4055 if ((!INTEGRAL_TYPE_P (rhs1_type)
4056 && !FIXED_POINT_TYPE_P (rhs1_type))
4057 || !useless_type_conversion_p (rhs1_type, rhs2_type)
4058 || !useless_type_conversion_p (lhs_type, rhs3_type)
4059 || 2 * TYPE_PRECISION (rhs1_type) > TYPE_PRECISION (lhs_type)
4060 || TYPE_PRECISION (rhs1_type) != TYPE_PRECISION (rhs2_type))
4062 error ("type mismatch in widening multiply-accumulate expression");
4063 debug_generic_expr (lhs_type);
4064 debug_generic_expr (rhs1_type);
4065 debug_generic_expr (rhs2_type);
4066 debug_generic_expr (rhs3_type);
4067 return true;
4069 break;
4071 case FMA_EXPR:
4072 if (!useless_type_conversion_p (lhs_type, rhs1_type)
4073 || !useless_type_conversion_p (lhs_type, rhs2_type)
4074 || !useless_type_conversion_p (lhs_type, rhs3_type))
4076 error ("type mismatch in fused multiply-add expression");
4077 debug_generic_expr (lhs_type);
4078 debug_generic_expr (rhs1_type);
4079 debug_generic_expr (rhs2_type);
4080 debug_generic_expr (rhs3_type);
4081 return true;
4083 break;
4085 case VEC_COND_EXPR:
4086 if (!VECTOR_BOOLEAN_TYPE_P (rhs1_type)
4087 || TYPE_VECTOR_SUBPARTS (rhs1_type)
4088 != TYPE_VECTOR_SUBPARTS (lhs_type))
4090 error ("the first argument of a VEC_COND_EXPR must be of a "
4091 "boolean vector type of the same number of elements "
4092 "as the result");
4093 debug_generic_expr (lhs_type);
4094 debug_generic_expr (rhs1_type);
4095 return true;
4097 /* Fallthrough. */
4098 case COND_EXPR:
4099 if (!useless_type_conversion_p (lhs_type, rhs2_type)
4100 || !useless_type_conversion_p (lhs_type, rhs3_type))
4102 error ("type mismatch in conditional expression");
4103 debug_generic_expr (lhs_type);
4104 debug_generic_expr (rhs2_type);
4105 debug_generic_expr (rhs3_type);
4106 return true;
4108 break;
4110 case VEC_PERM_EXPR:
4111 if (!useless_type_conversion_p (lhs_type, rhs1_type)
4112 || !useless_type_conversion_p (lhs_type, rhs2_type))
4114 error ("type mismatch in vector permute expression");
4115 debug_generic_expr (lhs_type);
4116 debug_generic_expr (rhs1_type);
4117 debug_generic_expr (rhs2_type);
4118 debug_generic_expr (rhs3_type);
4119 return true;
4122 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
4123 || TREE_CODE (rhs2_type) != VECTOR_TYPE
4124 || TREE_CODE (rhs3_type) != VECTOR_TYPE)
4126 error ("vector types expected in vector permute expression");
4127 debug_generic_expr (lhs_type);
4128 debug_generic_expr (rhs1_type);
4129 debug_generic_expr (rhs2_type);
4130 debug_generic_expr (rhs3_type);
4131 return true;
4134 if (TYPE_VECTOR_SUBPARTS (rhs1_type) != TYPE_VECTOR_SUBPARTS (rhs2_type)
4135 || TYPE_VECTOR_SUBPARTS (rhs2_type)
4136 != TYPE_VECTOR_SUBPARTS (rhs3_type)
4137 || TYPE_VECTOR_SUBPARTS (rhs3_type)
4138 != TYPE_VECTOR_SUBPARTS (lhs_type))
4140 error ("vectors with different element number found "
4141 "in vector permute expression");
4142 debug_generic_expr (lhs_type);
4143 debug_generic_expr (rhs1_type);
4144 debug_generic_expr (rhs2_type);
4145 debug_generic_expr (rhs3_type);
4146 return true;
4149 if (TREE_CODE (TREE_TYPE (rhs3_type)) != INTEGER_TYPE
4150 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs3_type)))
4151 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type))))
4153 error ("invalid mask type in vector permute expression");
4154 debug_generic_expr (lhs_type);
4155 debug_generic_expr (rhs1_type);
4156 debug_generic_expr (rhs2_type);
4157 debug_generic_expr (rhs3_type);
4158 return true;
4161 return false;
4163 case SAD_EXPR:
4164 if (!useless_type_conversion_p (rhs1_type, rhs2_type)
4165 || !useless_type_conversion_p (lhs_type, rhs3_type)
4166 || 2 * GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type)))
4167 > GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (lhs_type))))
4169 error ("type mismatch in sad expression");
4170 debug_generic_expr (lhs_type);
4171 debug_generic_expr (rhs1_type);
4172 debug_generic_expr (rhs2_type);
4173 debug_generic_expr (rhs3_type);
4174 return true;
4177 if (TREE_CODE (rhs1_type) != VECTOR_TYPE
4178 || TREE_CODE (rhs2_type) != VECTOR_TYPE
4179 || TREE_CODE (rhs3_type) != VECTOR_TYPE)
4181 error ("vector types expected in sad expression");
4182 debug_generic_expr (lhs_type);
4183 debug_generic_expr (rhs1_type);
4184 debug_generic_expr (rhs2_type);
4185 debug_generic_expr (rhs3_type);
4186 return true;
4189 return false;
4191 case BIT_INSERT_EXPR:
4192 if (! useless_type_conversion_p (lhs_type, rhs1_type))
4194 error ("type mismatch in BIT_INSERT_EXPR");
4195 debug_generic_expr (lhs_type);
4196 debug_generic_expr (rhs1_type);
4197 return true;
4199 if (! ((INTEGRAL_TYPE_P (rhs1_type)
4200 && INTEGRAL_TYPE_P (rhs2_type))
4201 || (VECTOR_TYPE_P (rhs1_type)
4202 && types_compatible_p (TREE_TYPE (rhs1_type), rhs2_type))))
4204 error ("not allowed type combination in BIT_INSERT_EXPR");
4205 debug_generic_expr (rhs1_type);
4206 debug_generic_expr (rhs2_type);
4207 return true;
4209 if (! tree_fits_uhwi_p (rhs3)
4210 || ! tree_fits_uhwi_p (TYPE_SIZE (rhs2_type)))
4212 error ("invalid position or size in BIT_INSERT_EXPR");
4213 return true;
4215 if (INTEGRAL_TYPE_P (rhs1_type))
4217 unsigned HOST_WIDE_INT bitpos = tree_to_uhwi (rhs3);
4218 if (bitpos >= TYPE_PRECISION (rhs1_type)
4219 || (bitpos + TYPE_PRECISION (rhs2_type)
4220 > TYPE_PRECISION (rhs1_type)))
4222 error ("insertion out of range in BIT_INSERT_EXPR");
4223 return true;
4226 else if (VECTOR_TYPE_P (rhs1_type))
4228 unsigned HOST_WIDE_INT bitpos = tree_to_uhwi (rhs3);
4229 unsigned HOST_WIDE_INT bitsize = tree_to_uhwi (TYPE_SIZE (rhs2_type));
4230 if (bitpos % bitsize != 0)
4232 error ("vector insertion not at element boundary");
4233 return true;
4236 return false;
4238 case DOT_PROD_EXPR:
4239 case REALIGN_LOAD_EXPR:
4240 /* FIXME. */
4241 return false;
4243 default:
4244 gcc_unreachable ();
4246 return false;
4249 /* Verify a gimple assignment statement STMT with a single rhs.
4250 Returns true if anything is wrong. */
4252 static bool
4253 verify_gimple_assign_single (gassign *stmt)
4255 enum tree_code rhs_code = gimple_assign_rhs_code (stmt);
4256 tree lhs = gimple_assign_lhs (stmt);
4257 tree lhs_type = TREE_TYPE (lhs);
4258 tree rhs1 = gimple_assign_rhs1 (stmt);
4259 tree rhs1_type = TREE_TYPE (rhs1);
4260 bool res = false;
4262 if (!useless_type_conversion_p (lhs_type, rhs1_type))
4264 error ("non-trivial conversion at assignment");
4265 debug_generic_expr (lhs_type);
4266 debug_generic_expr (rhs1_type);
4267 return true;
4270 if (gimple_clobber_p (stmt)
4271 && !(DECL_P (lhs) || TREE_CODE (lhs) == MEM_REF))
4273 error ("non-decl/MEM_REF LHS in clobber statement");
4274 debug_generic_expr (lhs);
4275 return true;
4278 if (handled_component_p (lhs)
4279 || TREE_CODE (lhs) == MEM_REF
4280 || TREE_CODE (lhs) == TARGET_MEM_REF)
4281 res |= verify_types_in_gimple_reference (lhs, true);
4283 /* Special codes we cannot handle via their class. */
4284 switch (rhs_code)
4286 case ADDR_EXPR:
4288 tree op = TREE_OPERAND (rhs1, 0);
4289 if (!is_gimple_addressable (op))
4291 error ("invalid operand in unary expression");
4292 return true;
4295 /* Technically there is no longer a need for matching types, but
4296 gimple hygiene asks for this check. In LTO we can end up
4297 combining incompatible units and thus end up with addresses
4298 of globals that change their type to a common one. */
4299 if (!in_lto_p
4300 && !types_compatible_p (TREE_TYPE (op),
4301 TREE_TYPE (TREE_TYPE (rhs1)))
4302 && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1),
4303 TREE_TYPE (op)))
4305 error ("type mismatch in address expression");
4306 debug_generic_stmt (TREE_TYPE (rhs1));
4307 debug_generic_stmt (TREE_TYPE (op));
4308 return true;
4311 return verify_types_in_gimple_reference (op, true);
4314 /* tcc_reference */
4315 case INDIRECT_REF:
4316 error ("INDIRECT_REF in gimple IL");
4317 return true;
4319 case COMPONENT_REF:
4320 case BIT_FIELD_REF:
4321 case ARRAY_REF:
4322 case ARRAY_RANGE_REF:
4323 case VIEW_CONVERT_EXPR:
4324 case REALPART_EXPR:
4325 case IMAGPART_EXPR:
4326 case TARGET_MEM_REF:
4327 case MEM_REF:
4328 if (!is_gimple_reg (lhs)
4329 && is_gimple_reg_type (TREE_TYPE (lhs)))
4331 error ("invalid rhs for gimple memory store");
4332 debug_generic_stmt (lhs);
4333 debug_generic_stmt (rhs1);
4334 return true;
4336 return res || verify_types_in_gimple_reference (rhs1, false);
4338 /* tcc_constant */
4339 case SSA_NAME:
4340 case INTEGER_CST:
4341 case REAL_CST:
4342 case FIXED_CST:
4343 case COMPLEX_CST:
4344 case VECTOR_CST:
4345 case STRING_CST:
4346 return res;
4348 /* tcc_declaration */
4349 case CONST_DECL:
4350 return res;
4351 case VAR_DECL:
4352 case PARM_DECL:
4353 if (!is_gimple_reg (lhs)
4354 && !is_gimple_reg (rhs1)
4355 && is_gimple_reg_type (TREE_TYPE (lhs)))
4357 error ("invalid rhs for gimple memory store");
4358 debug_generic_stmt (lhs);
4359 debug_generic_stmt (rhs1);
4360 return true;
4362 return res;
4364 case CONSTRUCTOR:
4365 if (TREE_CODE (rhs1_type) == VECTOR_TYPE)
4367 unsigned int i;
4368 tree elt_i, elt_v, elt_t = NULL_TREE;
4370 if (CONSTRUCTOR_NELTS (rhs1) == 0)
4371 return res;
4372 /* For vector CONSTRUCTORs we require that either it is empty
4373 CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
4374 (then the element count must be correct to cover the whole
4375 outer vector and index must be NULL on all elements, or it is
4376 a CONSTRUCTOR of scalar elements, where we as an exception allow
4377 smaller number of elements (assuming zero filling) and
4378 consecutive indexes as compared to NULL indexes (such
4379 CONSTRUCTORs can appear in the IL from FEs). */
4380 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1), i, elt_i, elt_v)
4382 if (elt_t == NULL_TREE)
4384 elt_t = TREE_TYPE (elt_v);
4385 if (TREE_CODE (elt_t) == VECTOR_TYPE)
4387 tree elt_t = TREE_TYPE (elt_v);
4388 if (!useless_type_conversion_p (TREE_TYPE (rhs1_type),
4389 TREE_TYPE (elt_t)))
4391 error ("incorrect type of vector CONSTRUCTOR"
4392 " elements");
4393 debug_generic_stmt (rhs1);
4394 return true;
4396 else if (CONSTRUCTOR_NELTS (rhs1)
4397 * TYPE_VECTOR_SUBPARTS (elt_t)
4398 != TYPE_VECTOR_SUBPARTS (rhs1_type))
4400 error ("incorrect number of vector CONSTRUCTOR"
4401 " elements");
4402 debug_generic_stmt (rhs1);
4403 return true;
4406 else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type),
4407 elt_t))
4409 error ("incorrect type of vector CONSTRUCTOR elements");
4410 debug_generic_stmt (rhs1);
4411 return true;
4413 else if (CONSTRUCTOR_NELTS (rhs1)
4414 > TYPE_VECTOR_SUBPARTS (rhs1_type))
4416 error ("incorrect number of vector CONSTRUCTOR elements");
4417 debug_generic_stmt (rhs1);
4418 return true;
4421 else if (!useless_type_conversion_p (elt_t, TREE_TYPE (elt_v)))
4423 error ("incorrect type of vector CONSTRUCTOR elements");
4424 debug_generic_stmt (rhs1);
4425 return true;
4427 if (elt_i != NULL_TREE
4428 && (TREE_CODE (elt_t) == VECTOR_TYPE
4429 || TREE_CODE (elt_i) != INTEGER_CST
4430 || compare_tree_int (elt_i, i) != 0))
4432 error ("vector CONSTRUCTOR with non-NULL element index");
4433 debug_generic_stmt (rhs1);
4434 return true;
4436 if (!is_gimple_val (elt_v))
4438 error ("vector CONSTRUCTOR element is not a GIMPLE value");
4439 debug_generic_stmt (rhs1);
4440 return true;
4444 else if (CONSTRUCTOR_NELTS (rhs1) != 0)
4446 error ("non-vector CONSTRUCTOR with elements");
4447 debug_generic_stmt (rhs1);
4448 return true;
4450 return res;
4451 case OBJ_TYPE_REF:
4452 case ASSERT_EXPR:
4453 case WITH_SIZE_EXPR:
4454 /* FIXME. */
4455 return res;
4457 default:;
4460 return res;
4463 /* Verify the contents of a GIMPLE_ASSIGN STMT. Returns true when there
4464 is a problem, otherwise false. */
4466 static bool
4467 verify_gimple_assign (gassign *stmt)
4469 switch (gimple_assign_rhs_class (stmt))
4471 case GIMPLE_SINGLE_RHS:
4472 return verify_gimple_assign_single (stmt);
4474 case GIMPLE_UNARY_RHS:
4475 return verify_gimple_assign_unary (stmt);
4477 case GIMPLE_BINARY_RHS:
4478 return verify_gimple_assign_binary (stmt);
4480 case GIMPLE_TERNARY_RHS:
4481 return verify_gimple_assign_ternary (stmt);
4483 default:
4484 gcc_unreachable ();
4488 /* Verify the contents of a GIMPLE_RETURN STMT. Returns true when there
4489 is a problem, otherwise false. */
4491 static bool
4492 verify_gimple_return (greturn *stmt)
4494 tree op = gimple_return_retval (stmt);
4495 tree restype = TREE_TYPE (TREE_TYPE (cfun->decl));
4497 /* We cannot test for present return values as we do not fix up missing
4498 return values from the original source. */
4499 if (op == NULL)
4500 return false;
4502 if (!is_gimple_val (op)
4503 && TREE_CODE (op) != RESULT_DECL)
4505 error ("invalid operand in return statement");
4506 debug_generic_stmt (op);
4507 return true;
4510 if ((TREE_CODE (op) == RESULT_DECL
4511 && DECL_BY_REFERENCE (op))
4512 || (TREE_CODE (op) == SSA_NAME
4513 && SSA_NAME_VAR (op)
4514 && TREE_CODE (SSA_NAME_VAR (op)) == RESULT_DECL
4515 && DECL_BY_REFERENCE (SSA_NAME_VAR (op))))
4516 op = TREE_TYPE (op);
4518 if (!useless_type_conversion_p (restype, TREE_TYPE (op)))
4520 error ("invalid conversion in return statement");
4521 debug_generic_stmt (restype);
4522 debug_generic_stmt (TREE_TYPE (op));
4523 return true;
4526 return false;
4530 /* Verify the contents of a GIMPLE_GOTO STMT. Returns true when there
4531 is a problem, otherwise false. */
4533 static bool
4534 verify_gimple_goto (ggoto *stmt)
4536 tree dest = gimple_goto_dest (stmt);
4538 /* ??? We have two canonical forms of direct goto destinations, a
4539 bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
4540 if (TREE_CODE (dest) != LABEL_DECL
4541 && (!is_gimple_val (dest)
4542 || !POINTER_TYPE_P (TREE_TYPE (dest))))
4544 error ("goto destination is neither a label nor a pointer");
4545 return true;
4548 return false;
4551 /* Verify the contents of a GIMPLE_SWITCH STMT. Returns true when there
4552 is a problem, otherwise false. */
4554 static bool
4555 verify_gimple_switch (gswitch *stmt)
4557 unsigned int i, n;
4558 tree elt, prev_upper_bound = NULL_TREE;
4559 tree index_type, elt_type = NULL_TREE;
4561 if (!is_gimple_val (gimple_switch_index (stmt)))
4563 error ("invalid operand to switch statement");
4564 debug_generic_stmt (gimple_switch_index (stmt));
4565 return true;
4568 index_type = TREE_TYPE (gimple_switch_index (stmt));
4569 if (! INTEGRAL_TYPE_P (index_type))
4571 error ("non-integral type switch statement");
4572 debug_generic_expr (index_type);
4573 return true;
4576 elt = gimple_switch_label (stmt, 0);
4577 if (CASE_LOW (elt) != NULL_TREE || CASE_HIGH (elt) != NULL_TREE)
4579 error ("invalid default case label in switch statement");
4580 debug_generic_expr (elt);
4581 return true;
4584 n = gimple_switch_num_labels (stmt);
4585 for (i = 1; i < n; i++)
4587 elt = gimple_switch_label (stmt, i);
4589 if (! CASE_LOW (elt))
4591 error ("invalid case label in switch statement");
4592 debug_generic_expr (elt);
4593 return true;
4595 if (CASE_HIGH (elt)
4596 && ! tree_int_cst_lt (CASE_LOW (elt), CASE_HIGH (elt)))
4598 error ("invalid case range in switch statement");
4599 debug_generic_expr (elt);
4600 return true;
4603 if (elt_type)
4605 if (TREE_TYPE (CASE_LOW (elt)) != elt_type
4606 || (CASE_HIGH (elt) && TREE_TYPE (CASE_HIGH (elt)) != elt_type))
4608 error ("type mismatch for case label in switch statement");
4609 debug_generic_expr (elt);
4610 return true;
4613 else
4615 elt_type = TREE_TYPE (CASE_LOW (elt));
4616 if (TYPE_PRECISION (index_type) < TYPE_PRECISION (elt_type))
4618 error ("type precision mismatch in switch statement");
4619 return true;
4623 if (prev_upper_bound)
4625 if (! tree_int_cst_lt (prev_upper_bound, CASE_LOW (elt)))
4627 error ("case labels not sorted in switch statement");
4628 return true;
4632 prev_upper_bound = CASE_HIGH (elt);
4633 if (! prev_upper_bound)
4634 prev_upper_bound = CASE_LOW (elt);
4637 return false;
4640 /* Verify a gimple debug statement STMT.
4641 Returns true if anything is wrong. */
4643 static bool
4644 verify_gimple_debug (gimple *stmt ATTRIBUTE_UNUSED)
4646 /* There isn't much that could be wrong in a gimple debug stmt. A
4647 gimple debug bind stmt, for example, maps a tree, that's usually
4648 a VAR_DECL or a PARM_DECL, but that could also be some scalarized
4649 component or member of an aggregate type, to another tree, that
4650 can be an arbitrary expression. These stmts expand into debug
4651 insns, and are converted to debug notes by var-tracking.c. */
4652 return false;
4655 /* Verify a gimple label statement STMT.
4656 Returns true if anything is wrong. */
4658 static bool
4659 verify_gimple_label (glabel *stmt)
4661 tree decl = gimple_label_label (stmt);
4662 int uid;
4663 bool err = false;
4665 if (TREE_CODE (decl) != LABEL_DECL)
4666 return true;
4667 if (!DECL_NONLOCAL (decl) && !FORCED_LABEL (decl)
4668 && DECL_CONTEXT (decl) != current_function_decl)
4670 error ("label's context is not the current function decl");
4671 err |= true;
4674 uid = LABEL_DECL_UID (decl);
4675 if (cfun->cfg
4676 && (uid == -1
4677 || (*label_to_block_map_for_fn (cfun))[uid] != gimple_bb (stmt)))
4679 error ("incorrect entry in label_to_block_map");
4680 err |= true;
4683 uid = EH_LANDING_PAD_NR (decl);
4684 if (uid)
4686 eh_landing_pad lp = get_eh_landing_pad_from_number (uid);
4687 if (decl != lp->post_landing_pad)
4689 error ("incorrect setting of landing pad number");
4690 err |= true;
4694 return err;
4697 /* Verify a gimple cond statement STMT.
4698 Returns true if anything is wrong. */
4700 static bool
4701 verify_gimple_cond (gcond *stmt)
4703 if (TREE_CODE_CLASS (gimple_cond_code (stmt)) != tcc_comparison)
4705 error ("invalid comparison code in gimple cond");
4706 return true;
4708 if (!(!gimple_cond_true_label (stmt)
4709 || TREE_CODE (gimple_cond_true_label (stmt)) == LABEL_DECL)
4710 || !(!gimple_cond_false_label (stmt)
4711 || TREE_CODE (gimple_cond_false_label (stmt)) == LABEL_DECL))
4713 error ("invalid labels in gimple cond");
4714 return true;
4717 return verify_gimple_comparison (boolean_type_node,
4718 gimple_cond_lhs (stmt),
4719 gimple_cond_rhs (stmt),
4720 gimple_cond_code (stmt));
4723 /* Verify the GIMPLE statement STMT. Returns true if there is an
4724 error, otherwise false. */
4726 static bool
4727 verify_gimple_stmt (gimple *stmt)
4729 switch (gimple_code (stmt))
4731 case GIMPLE_ASSIGN:
4732 return verify_gimple_assign (as_a <gassign *> (stmt));
4734 case GIMPLE_LABEL:
4735 return verify_gimple_label (as_a <glabel *> (stmt));
4737 case GIMPLE_CALL:
4738 return verify_gimple_call (as_a <gcall *> (stmt));
4740 case GIMPLE_COND:
4741 return verify_gimple_cond (as_a <gcond *> (stmt));
4743 case GIMPLE_GOTO:
4744 return verify_gimple_goto (as_a <ggoto *> (stmt));
4746 case GIMPLE_SWITCH:
4747 return verify_gimple_switch (as_a <gswitch *> (stmt));
4749 case GIMPLE_RETURN:
4750 return verify_gimple_return (as_a <greturn *> (stmt));
4752 case GIMPLE_ASM:
4753 return false;
4755 case GIMPLE_TRANSACTION:
4756 return verify_gimple_transaction (as_a <gtransaction *> (stmt));
4758 /* Tuples that do not have tree operands. */
4759 case GIMPLE_NOP:
4760 case GIMPLE_PREDICT:
4761 case GIMPLE_RESX:
4762 case GIMPLE_EH_DISPATCH:
4763 case GIMPLE_EH_MUST_NOT_THROW:
4764 return false;
4766 CASE_GIMPLE_OMP:
4767 /* OpenMP directives are validated by the FE and never operated
4768 on by the optimizers. Furthermore, GIMPLE_OMP_FOR may contain
4769 non-gimple expressions when the main index variable has had
4770 its address taken. This does not affect the loop itself
4771 because the header of an GIMPLE_OMP_FOR is merely used to determine
4772 how to setup the parallel iteration. */
4773 return false;
4775 case GIMPLE_DEBUG:
4776 return verify_gimple_debug (stmt);
4778 default:
4779 gcc_unreachable ();
4783 /* Verify the contents of a GIMPLE_PHI. Returns true if there is a problem,
4784 and false otherwise. */
4786 static bool
4787 verify_gimple_phi (gimple *phi)
4789 bool err = false;
4790 unsigned i;
4791 tree phi_result = gimple_phi_result (phi);
4792 bool virtual_p;
4794 if (!phi_result)
4796 error ("invalid PHI result");
4797 return true;
4800 virtual_p = virtual_operand_p (phi_result);
4801 if (TREE_CODE (phi_result) != SSA_NAME
4802 || (virtual_p
4803 && SSA_NAME_VAR (phi_result) != gimple_vop (cfun)))
4805 error ("invalid PHI result");
4806 err = true;
4809 for (i = 0; i < gimple_phi_num_args (phi); i++)
4811 tree t = gimple_phi_arg_def (phi, i);
4813 if (!t)
4815 error ("missing PHI def");
4816 err |= true;
4817 continue;
4819 /* Addressable variables do have SSA_NAMEs but they
4820 are not considered gimple values. */
4821 else if ((TREE_CODE (t) == SSA_NAME
4822 && virtual_p != virtual_operand_p (t))
4823 || (virtual_p
4824 && (TREE_CODE (t) != SSA_NAME
4825 || SSA_NAME_VAR (t) != gimple_vop (cfun)))
4826 || (!virtual_p
4827 && !is_gimple_val (t)))
4829 error ("invalid PHI argument");
4830 debug_generic_expr (t);
4831 err |= true;
4833 #ifdef ENABLE_TYPES_CHECKING
4834 if (!useless_type_conversion_p (TREE_TYPE (phi_result), TREE_TYPE (t)))
4836 error ("incompatible types in PHI argument %u", i);
4837 debug_generic_stmt (TREE_TYPE (phi_result));
4838 debug_generic_stmt (TREE_TYPE (t));
4839 err |= true;
4841 #endif
4844 return err;
4847 /* Verify the GIMPLE statements inside the sequence STMTS. */
4849 static bool
4850 verify_gimple_in_seq_2 (gimple_seq stmts)
4852 gimple_stmt_iterator ittr;
4853 bool err = false;
4855 for (ittr = gsi_start (stmts); !gsi_end_p (ittr); gsi_next (&ittr))
4857 gimple *stmt = gsi_stmt (ittr);
4859 switch (gimple_code (stmt))
4861 case GIMPLE_BIND:
4862 err |= verify_gimple_in_seq_2 (
4863 gimple_bind_body (as_a <gbind *> (stmt)));
4864 break;
4866 case GIMPLE_TRY:
4867 err |= verify_gimple_in_seq_2 (gimple_try_eval (stmt));
4868 err |= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt));
4869 break;
4871 case GIMPLE_EH_FILTER:
4872 err |= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt));
4873 break;
4875 case GIMPLE_EH_ELSE:
4877 geh_else *eh_else = as_a <geh_else *> (stmt);
4878 err |= verify_gimple_in_seq_2 (gimple_eh_else_n_body (eh_else));
4879 err |= verify_gimple_in_seq_2 (gimple_eh_else_e_body (eh_else));
4881 break;
4883 case GIMPLE_CATCH:
4884 err |= verify_gimple_in_seq_2 (gimple_catch_handler (
4885 as_a <gcatch *> (stmt)));
4886 break;
4888 case GIMPLE_TRANSACTION:
4889 err |= verify_gimple_transaction (as_a <gtransaction *> (stmt));
4890 break;
4892 default:
4894 bool err2 = verify_gimple_stmt (stmt);
4895 if (err2)
4896 debug_gimple_stmt (stmt);
4897 err |= err2;
4902 return err;
4905 /* Verify the contents of a GIMPLE_TRANSACTION. Returns true if there
4906 is a problem, otherwise false. */
4908 static bool
4909 verify_gimple_transaction (gtransaction *stmt)
4911 tree lab;
4913 lab = gimple_transaction_label_norm (stmt);
4914 if (lab != NULL && TREE_CODE (lab) != LABEL_DECL)
4915 return true;
4916 lab = gimple_transaction_label_uninst (stmt);
4917 if (lab != NULL && TREE_CODE (lab) != LABEL_DECL)
4918 return true;
4919 lab = gimple_transaction_label_over (stmt);
4920 if (lab != NULL && TREE_CODE (lab) != LABEL_DECL)
4921 return true;
4923 return verify_gimple_in_seq_2 (gimple_transaction_body (stmt));
4927 /* Verify the GIMPLE statements inside the statement list STMTS. */
4929 DEBUG_FUNCTION void
4930 verify_gimple_in_seq (gimple_seq stmts)
4932 timevar_push (TV_TREE_STMT_VERIFY);
4933 if (verify_gimple_in_seq_2 (stmts))
4934 internal_error ("verify_gimple failed");
4935 timevar_pop (TV_TREE_STMT_VERIFY);
4938 /* Return true when the T can be shared. */
4940 static bool
4941 tree_node_can_be_shared (tree t)
4943 if (IS_TYPE_OR_DECL_P (t)
4944 || is_gimple_min_invariant (t)
4945 || TREE_CODE (t) == SSA_NAME
4946 || t == error_mark_node
4947 || TREE_CODE (t) == IDENTIFIER_NODE)
4948 return true;
4950 if (TREE_CODE (t) == CASE_LABEL_EXPR)
4951 return true;
4953 if (DECL_P (t))
4954 return true;
4956 return false;
4959 /* Called via walk_tree. Verify tree sharing. */
4961 static tree
4962 verify_node_sharing_1 (tree *tp, int *walk_subtrees, void *data)
4964 hash_set<void *> *visited = (hash_set<void *> *) data;
4966 if (tree_node_can_be_shared (*tp))
4968 *walk_subtrees = false;
4969 return NULL;
4972 if (visited->add (*tp))
4973 return *tp;
4975 return NULL;
4978 /* Called via walk_gimple_stmt. Verify tree sharing. */
4980 static tree
4981 verify_node_sharing (tree *tp, int *walk_subtrees, void *data)
4983 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
4984 return verify_node_sharing_1 (tp, walk_subtrees, wi->info);
4987 static bool eh_error_found;
4988 bool
4989 verify_eh_throw_stmt_node (gimple *const &stmt, const int &,
4990 hash_set<gimple *> *visited)
4992 if (!visited->contains (stmt))
4994 error ("dead STMT in EH table");
4995 debug_gimple_stmt (stmt);
4996 eh_error_found = true;
4998 return true;
5001 /* Verify if the location LOCs block is in BLOCKS. */
5003 static bool
5004 verify_location (hash_set<tree> *blocks, location_t loc)
5006 tree block = LOCATION_BLOCK (loc);
5007 if (block != NULL_TREE
5008 && !blocks->contains (block))
5010 error ("location references block not in block tree");
5011 return true;
5013 if (block != NULL_TREE)
5014 return verify_location (blocks, BLOCK_SOURCE_LOCATION (block));
5015 return false;
5018 /* Called via walk_tree. Verify that expressions have no blocks. */
5020 static tree
5021 verify_expr_no_block (tree *tp, int *walk_subtrees, void *)
5023 if (!EXPR_P (*tp))
5025 *walk_subtrees = false;
5026 return NULL;
5029 location_t loc = EXPR_LOCATION (*tp);
5030 if (LOCATION_BLOCK (loc) != NULL)
5031 return *tp;
5033 return NULL;
5036 /* Called via walk_tree. Verify locations of expressions. */
5038 static tree
5039 verify_expr_location_1 (tree *tp, int *walk_subtrees, void *data)
5041 hash_set<tree> *blocks = (hash_set<tree> *) data;
5043 if (VAR_P (*tp) && DECL_HAS_DEBUG_EXPR_P (*tp))
5045 tree t = DECL_DEBUG_EXPR (*tp);
5046 tree addr = walk_tree (&t, verify_expr_no_block, NULL, NULL);
5047 if (addr)
5048 return addr;
5050 if ((VAR_P (*tp)
5051 || TREE_CODE (*tp) == PARM_DECL
5052 || TREE_CODE (*tp) == RESULT_DECL)
5053 && DECL_HAS_VALUE_EXPR_P (*tp))
5055 tree t = DECL_VALUE_EXPR (*tp);
5056 tree addr = walk_tree (&t, verify_expr_no_block, NULL, NULL);
5057 if (addr)
5058 return addr;
5061 if (!EXPR_P (*tp))
5063 *walk_subtrees = false;
5064 return NULL;
5067 location_t loc = EXPR_LOCATION (*tp);
5068 if (verify_location (blocks, loc))
5069 return *tp;
5071 return NULL;
5074 /* Called via walk_gimple_op. Verify locations of expressions. */
5076 static tree
5077 verify_expr_location (tree *tp, int *walk_subtrees, void *data)
5079 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
5080 return verify_expr_location_1 (tp, walk_subtrees, wi->info);
5083 /* Insert all subblocks of BLOCK into BLOCKS and recurse. */
5085 static void
5086 collect_subblocks (hash_set<tree> *blocks, tree block)
5088 tree t;
5089 for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
5091 blocks->add (t);
5092 collect_subblocks (blocks, t);
5096 /* Verify the GIMPLE statements in the CFG of FN. */
5098 DEBUG_FUNCTION void
5099 verify_gimple_in_cfg (struct function *fn, bool verify_nothrow)
5101 basic_block bb;
5102 bool err = false;
5104 timevar_push (TV_TREE_STMT_VERIFY);
5105 hash_set<void *> visited;
5106 hash_set<gimple *> visited_stmts;
5108 /* Collect all BLOCKs referenced by the BLOCK tree of FN. */
5109 hash_set<tree> blocks;
5110 if (DECL_INITIAL (fn->decl))
5112 blocks.add (DECL_INITIAL (fn->decl));
5113 collect_subblocks (&blocks, DECL_INITIAL (fn->decl));
5116 FOR_EACH_BB_FN (bb, fn)
5118 gimple_stmt_iterator gsi;
5120 for (gphi_iterator gpi = gsi_start_phis (bb);
5121 !gsi_end_p (gpi);
5122 gsi_next (&gpi))
5124 gphi *phi = gpi.phi ();
5125 bool err2 = false;
5126 unsigned i;
5128 visited_stmts.add (phi);
5130 if (gimple_bb (phi) != bb)
5132 error ("gimple_bb (phi) is set to a wrong basic block");
5133 err2 = true;
5136 err2 |= verify_gimple_phi (phi);
5138 /* Only PHI arguments have locations. */
5139 if (gimple_location (phi) != UNKNOWN_LOCATION)
5141 error ("PHI node with location");
5142 err2 = true;
5145 for (i = 0; i < gimple_phi_num_args (phi); i++)
5147 tree arg = gimple_phi_arg_def (phi, i);
5148 tree addr = walk_tree (&arg, verify_node_sharing_1,
5149 &visited, NULL);
5150 if (addr)
5152 error ("incorrect sharing of tree nodes");
5153 debug_generic_expr (addr);
5154 err2 |= true;
5156 location_t loc = gimple_phi_arg_location (phi, i);
5157 if (virtual_operand_p (gimple_phi_result (phi))
5158 && loc != UNKNOWN_LOCATION)
5160 error ("virtual PHI with argument locations");
5161 err2 = true;
5163 addr = walk_tree (&arg, verify_expr_location_1, &blocks, NULL);
5164 if (addr)
5166 debug_generic_expr (addr);
5167 err2 = true;
5169 err2 |= verify_location (&blocks, loc);
5172 if (err2)
5173 debug_gimple_stmt (phi);
5174 err |= err2;
5177 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
5179 gimple *stmt = gsi_stmt (gsi);
5180 bool err2 = false;
5181 struct walk_stmt_info wi;
5182 tree addr;
5183 int lp_nr;
5185 visited_stmts.add (stmt);
5187 if (gimple_bb (stmt) != bb)
5189 error ("gimple_bb (stmt) is set to a wrong basic block");
5190 err2 = true;
5193 err2 |= verify_gimple_stmt (stmt);
5194 err2 |= verify_location (&blocks, gimple_location (stmt));
5196 memset (&wi, 0, sizeof (wi));
5197 wi.info = (void *) &visited;
5198 addr = walk_gimple_op (stmt, verify_node_sharing, &wi);
5199 if (addr)
5201 error ("incorrect sharing of tree nodes");
5202 debug_generic_expr (addr);
5203 err2 |= true;
5206 memset (&wi, 0, sizeof (wi));
5207 wi.info = (void *) &blocks;
5208 addr = walk_gimple_op (stmt, verify_expr_location, &wi);
5209 if (addr)
5211 debug_generic_expr (addr);
5212 err2 |= true;
5215 /* ??? Instead of not checking these stmts at all the walker
5216 should know its context via wi. */
5217 if (!is_gimple_debug (stmt)
5218 && !is_gimple_omp (stmt))
5220 memset (&wi, 0, sizeof (wi));
5221 addr = walk_gimple_op (stmt, verify_expr, &wi);
5222 if (addr)
5224 debug_generic_expr (addr);
5225 inform (gimple_location (stmt), "in statement");
5226 err2 |= true;
5230 /* If the statement is marked as part of an EH region, then it is
5231 expected that the statement could throw. Verify that when we
5232 have optimizations that simplify statements such that we prove
5233 that they cannot throw, that we update other data structures
5234 to match. */
5235 lp_nr = lookup_stmt_eh_lp (stmt);
5236 if (lp_nr > 0)
5238 if (!stmt_could_throw_p (stmt))
5240 if (verify_nothrow)
5242 error ("statement marked for throw, but doesn%'t");
5243 err2 |= true;
5246 else if (!gsi_one_before_end_p (gsi))
5248 error ("statement marked for throw in middle of block");
5249 err2 |= true;
5253 if (err2)
5254 debug_gimple_stmt (stmt);
5255 err |= err2;
5259 eh_error_found = false;
5260 hash_map<gimple *, int> *eh_table = get_eh_throw_stmt_table (cfun);
5261 if (eh_table)
5262 eh_table->traverse<hash_set<gimple *> *, verify_eh_throw_stmt_node>
5263 (&visited_stmts);
5265 if (err || eh_error_found)
5266 internal_error ("verify_gimple failed");
5268 verify_histograms ();
5269 timevar_pop (TV_TREE_STMT_VERIFY);
5273 /* Verifies that the flow information is OK. */
5275 static int
5276 gimple_verify_flow_info (void)
5278 int err = 0;
5279 basic_block bb;
5280 gimple_stmt_iterator gsi;
5281 gimple *stmt;
5282 edge e;
5283 edge_iterator ei;
5285 if (ENTRY_BLOCK_PTR_FOR_FN (cfun)->il.gimple.seq
5286 || ENTRY_BLOCK_PTR_FOR_FN (cfun)->il.gimple.phi_nodes)
5288 error ("ENTRY_BLOCK has IL associated with it");
5289 err = 1;
5292 if (EXIT_BLOCK_PTR_FOR_FN (cfun)->il.gimple.seq
5293 || EXIT_BLOCK_PTR_FOR_FN (cfun)->il.gimple.phi_nodes)
5295 error ("EXIT_BLOCK has IL associated with it");
5296 err = 1;
5299 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
5300 if (e->flags & EDGE_FALLTHRU)
5302 error ("fallthru to exit from bb %d", e->src->index);
5303 err = 1;
5306 FOR_EACH_BB_FN (bb, cfun)
5308 bool found_ctrl_stmt = false;
5310 stmt = NULL;
5312 /* Skip labels on the start of basic block. */
5313 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
5315 tree label;
5316 gimple *prev_stmt = stmt;
5318 stmt = gsi_stmt (gsi);
5320 if (gimple_code (stmt) != GIMPLE_LABEL)
5321 break;
5323 label = gimple_label_label (as_a <glabel *> (stmt));
5324 if (prev_stmt && DECL_NONLOCAL (label))
5326 error ("nonlocal label ");
5327 print_generic_expr (stderr, label, 0);
5328 fprintf (stderr, " is not first in a sequence of labels in bb %d",
5329 bb->index);
5330 err = 1;
5333 if (prev_stmt && EH_LANDING_PAD_NR (label) != 0)
5335 error ("EH landing pad label ");
5336 print_generic_expr (stderr, label, 0);
5337 fprintf (stderr, " is not first in a sequence of labels in bb %d",
5338 bb->index);
5339 err = 1;
5342 if (label_to_block (label) != bb)
5344 error ("label ");
5345 print_generic_expr (stderr, label, 0);
5346 fprintf (stderr, " to block does not match in bb %d",
5347 bb->index);
5348 err = 1;
5351 if (decl_function_context (label) != current_function_decl)
5353 error ("label ");
5354 print_generic_expr (stderr, label, 0);
5355 fprintf (stderr, " has incorrect context in bb %d",
5356 bb->index);
5357 err = 1;
5361 /* Verify that body of basic block BB is free of control flow. */
5362 for (; !gsi_end_p (gsi); gsi_next (&gsi))
5364 gimple *stmt = gsi_stmt (gsi);
5366 if (found_ctrl_stmt)
5368 error ("control flow in the middle of basic block %d",
5369 bb->index);
5370 err = 1;
5373 if (stmt_ends_bb_p (stmt))
5374 found_ctrl_stmt = true;
5376 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
5378 error ("label ");
5379 print_generic_expr (stderr, gimple_label_label (label_stmt), 0);
5380 fprintf (stderr, " in the middle of basic block %d", bb->index);
5381 err = 1;
5385 gsi = gsi_last_bb (bb);
5386 if (gsi_end_p (gsi))
5387 continue;
5389 stmt = gsi_stmt (gsi);
5391 if (gimple_code (stmt) == GIMPLE_LABEL)
5392 continue;
5394 err |= verify_eh_edges (stmt);
5396 if (is_ctrl_stmt (stmt))
5398 FOR_EACH_EDGE (e, ei, bb->succs)
5399 if (e->flags & EDGE_FALLTHRU)
5401 error ("fallthru edge after a control statement in bb %d",
5402 bb->index);
5403 err = 1;
5407 if (gimple_code (stmt) != GIMPLE_COND)
5409 /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
5410 after anything else but if statement. */
5411 FOR_EACH_EDGE (e, ei, bb->succs)
5412 if (e->flags & (EDGE_TRUE_VALUE | EDGE_FALSE_VALUE))
5414 error ("true/false edge after a non-GIMPLE_COND in bb %d",
5415 bb->index);
5416 err = 1;
5420 switch (gimple_code (stmt))
5422 case GIMPLE_COND:
5424 edge true_edge;
5425 edge false_edge;
5427 extract_true_false_edges_from_block (bb, &true_edge, &false_edge);
5429 if (!true_edge
5430 || !false_edge
5431 || !(true_edge->flags & EDGE_TRUE_VALUE)
5432 || !(false_edge->flags & EDGE_FALSE_VALUE)
5433 || (true_edge->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL))
5434 || (false_edge->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL))
5435 || EDGE_COUNT (bb->succs) >= 3)
5437 error ("wrong outgoing edge flags at end of bb %d",
5438 bb->index);
5439 err = 1;
5442 break;
5444 case GIMPLE_GOTO:
5445 if (simple_goto_p (stmt))
5447 error ("explicit goto at end of bb %d", bb->index);
5448 err = 1;
5450 else
5452 /* FIXME. We should double check that the labels in the
5453 destination blocks have their address taken. */
5454 FOR_EACH_EDGE (e, ei, bb->succs)
5455 if ((e->flags & (EDGE_FALLTHRU | EDGE_TRUE_VALUE
5456 | EDGE_FALSE_VALUE))
5457 || !(e->flags & EDGE_ABNORMAL))
5459 error ("wrong outgoing edge flags at end of bb %d",
5460 bb->index);
5461 err = 1;
5464 break;
5466 case GIMPLE_CALL:
5467 if (!gimple_call_builtin_p (stmt, BUILT_IN_RETURN))
5468 break;
5469 /* fallthru */
5470 case GIMPLE_RETURN:
5471 if (!single_succ_p (bb)
5472 || (single_succ_edge (bb)->flags
5473 & (EDGE_FALLTHRU | EDGE_ABNORMAL
5474 | EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
5476 error ("wrong outgoing edge flags at end of bb %d", bb->index);
5477 err = 1;
5479 if (single_succ (bb) != EXIT_BLOCK_PTR_FOR_FN (cfun))
5481 error ("return edge does not point to exit in bb %d",
5482 bb->index);
5483 err = 1;
5485 break;
5487 case GIMPLE_SWITCH:
5489 gswitch *switch_stmt = as_a <gswitch *> (stmt);
5490 tree prev;
5491 edge e;
5492 size_t i, n;
5494 n = gimple_switch_num_labels (switch_stmt);
5496 /* Mark all the destination basic blocks. */
5497 for (i = 0; i < n; ++i)
5499 tree lab = CASE_LABEL (gimple_switch_label (switch_stmt, i));
5500 basic_block label_bb = label_to_block (lab);
5501 gcc_assert (!label_bb->aux || label_bb->aux == (void *)1);
5502 label_bb->aux = (void *)1;
5505 /* Verify that the case labels are sorted. */
5506 prev = gimple_switch_label (switch_stmt, 0);
5507 for (i = 1; i < n; ++i)
5509 tree c = gimple_switch_label (switch_stmt, i);
5510 if (!CASE_LOW (c))
5512 error ("found default case not at the start of "
5513 "case vector");
5514 err = 1;
5515 continue;
5517 if (CASE_LOW (prev)
5518 && !tree_int_cst_lt (CASE_LOW (prev), CASE_LOW (c)))
5520 error ("case labels not sorted: ");
5521 print_generic_expr (stderr, prev, 0);
5522 fprintf (stderr," is greater than ");
5523 print_generic_expr (stderr, c, 0);
5524 fprintf (stderr," but comes before it.\n");
5525 err = 1;
5527 prev = c;
5529 /* VRP will remove the default case if it can prove it will
5530 never be executed. So do not verify there always exists
5531 a default case here. */
5533 FOR_EACH_EDGE (e, ei, bb->succs)
5535 if (!e->dest->aux)
5537 error ("extra outgoing edge %d->%d",
5538 bb->index, e->dest->index);
5539 err = 1;
5542 e->dest->aux = (void *)2;
5543 if ((e->flags & (EDGE_FALLTHRU | EDGE_ABNORMAL
5544 | EDGE_TRUE_VALUE | EDGE_FALSE_VALUE)))
5546 error ("wrong outgoing edge flags at end of bb %d",
5547 bb->index);
5548 err = 1;
5552 /* Check that we have all of them. */
5553 for (i = 0; i < n; ++i)
5555 tree lab = CASE_LABEL (gimple_switch_label (switch_stmt, i));
5556 basic_block label_bb = label_to_block (lab);
5558 if (label_bb->aux != (void *)2)
5560 error ("missing edge %i->%i", bb->index, label_bb->index);
5561 err = 1;
5565 FOR_EACH_EDGE (e, ei, bb->succs)
5566 e->dest->aux = (void *)0;
5568 break;
5570 case GIMPLE_EH_DISPATCH:
5571 err |= verify_eh_dispatch_edge (as_a <geh_dispatch *> (stmt));
5572 break;
5574 default:
5575 break;
5579 if (dom_info_state (CDI_DOMINATORS) >= DOM_NO_FAST_QUERY)
5580 verify_dominators (CDI_DOMINATORS);
5582 return err;
5586 /* Updates phi nodes after creating a forwarder block joined
5587 by edge FALLTHRU. */
5589 static void
5590 gimple_make_forwarder_block (edge fallthru)
5592 edge e;
5593 edge_iterator ei;
5594 basic_block dummy, bb;
5595 tree var;
5596 gphi_iterator gsi;
5598 dummy = fallthru->src;
5599 bb = fallthru->dest;
5601 if (single_pred_p (bb))
5602 return;
5604 /* If we redirected a branch we must create new PHI nodes at the
5605 start of BB. */
5606 for (gsi = gsi_start_phis (dummy); !gsi_end_p (gsi); gsi_next (&gsi))
5608 gphi *phi, *new_phi;
5610 phi = gsi.phi ();
5611 var = gimple_phi_result (phi);
5612 new_phi = create_phi_node (var, bb);
5613 gimple_phi_set_result (phi, copy_ssa_name (var, phi));
5614 add_phi_arg (new_phi, gimple_phi_result (phi), fallthru,
5615 UNKNOWN_LOCATION);
5618 /* Add the arguments we have stored on edges. */
5619 FOR_EACH_EDGE (e, ei, bb->preds)
5621 if (e == fallthru)
5622 continue;
5624 flush_pending_stmts (e);
5629 /* Return a non-special label in the head of basic block BLOCK.
5630 Create one if it doesn't exist. */
5632 tree
5633 gimple_block_label (basic_block bb)
5635 gimple_stmt_iterator i, s = gsi_start_bb (bb);
5636 bool first = true;
5637 tree label;
5638 glabel *stmt;
5640 for (i = s; !gsi_end_p (i); first = false, gsi_next (&i))
5642 stmt = dyn_cast <glabel *> (gsi_stmt (i));
5643 if (!stmt)
5644 break;
5645 label = gimple_label_label (stmt);
5646 if (!DECL_NONLOCAL (label))
5648 if (!first)
5649 gsi_move_before (&i, &s);
5650 return label;
5654 label = create_artificial_label (UNKNOWN_LOCATION);
5655 stmt = gimple_build_label (label);
5656 gsi_insert_before (&s, stmt, GSI_NEW_STMT);
5657 return label;
5661 /* Attempt to perform edge redirection by replacing a possibly complex
5662 jump instruction by a goto or by removing the jump completely.
5663 This can apply only if all edges now point to the same block. The
5664 parameters and return values are equivalent to
5665 redirect_edge_and_branch. */
5667 static edge
5668 gimple_try_redirect_by_replacing_jump (edge e, basic_block target)
5670 basic_block src = e->src;
5671 gimple_stmt_iterator i;
5672 gimple *stmt;
5674 /* We can replace or remove a complex jump only when we have exactly
5675 two edges. */
5676 if (EDGE_COUNT (src->succs) != 2
5677 /* Verify that all targets will be TARGET. Specifically, the
5678 edge that is not E must also go to TARGET. */
5679 || EDGE_SUCC (src, EDGE_SUCC (src, 0) == e)->dest != target)
5680 return NULL;
5682 i = gsi_last_bb (src);
5683 if (gsi_end_p (i))
5684 return NULL;
5686 stmt = gsi_stmt (i);
5688 if (gimple_code (stmt) == GIMPLE_COND || gimple_code (stmt) == GIMPLE_SWITCH)
5690 gsi_remove (&i, true);
5691 e = ssa_redirect_edge (e, target);
5692 e->flags = EDGE_FALLTHRU;
5693 return e;
5696 return NULL;
5700 /* Redirect E to DEST. Return NULL on failure. Otherwise, return the
5701 edge representing the redirected branch. */
5703 static edge
5704 gimple_redirect_edge_and_branch (edge e, basic_block dest)
5706 basic_block bb = e->src;
5707 gimple_stmt_iterator gsi;
5708 edge ret;
5709 gimple *stmt;
5711 if (e->flags & EDGE_ABNORMAL)
5712 return NULL;
5714 if (e->dest == dest)
5715 return NULL;
5717 if (e->flags & EDGE_EH)
5718 return redirect_eh_edge (e, dest);
5720 if (e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun))
5722 ret = gimple_try_redirect_by_replacing_jump (e, dest);
5723 if (ret)
5724 return ret;
5727 gsi = gsi_last_bb (bb);
5728 stmt = gsi_end_p (gsi) ? NULL : gsi_stmt (gsi);
5730 switch (stmt ? gimple_code (stmt) : GIMPLE_ERROR_MARK)
5732 case GIMPLE_COND:
5733 /* For COND_EXPR, we only need to redirect the edge. */
5734 break;
5736 case GIMPLE_GOTO:
5737 /* No non-abnormal edges should lead from a non-simple goto, and
5738 simple ones should be represented implicitly. */
5739 gcc_unreachable ();
5741 case GIMPLE_SWITCH:
5743 gswitch *switch_stmt = as_a <gswitch *> (stmt);
5744 tree label = gimple_block_label (dest);
5745 tree cases = get_cases_for_edge (e, switch_stmt);
5747 /* If we have a list of cases associated with E, then use it
5748 as it's a lot faster than walking the entire case vector. */
5749 if (cases)
5751 edge e2 = find_edge (e->src, dest);
5752 tree last, first;
5754 first = cases;
5755 while (cases)
5757 last = cases;
5758 CASE_LABEL (cases) = label;
5759 cases = CASE_CHAIN (cases);
5762 /* If there was already an edge in the CFG, then we need
5763 to move all the cases associated with E to E2. */
5764 if (e2)
5766 tree cases2 = get_cases_for_edge (e2, switch_stmt);
5768 CASE_CHAIN (last) = CASE_CHAIN (cases2);
5769 CASE_CHAIN (cases2) = first;
5771 bitmap_set_bit (touched_switch_bbs, gimple_bb (stmt)->index);
5773 else
5775 size_t i, n = gimple_switch_num_labels (switch_stmt);
5777 for (i = 0; i < n; i++)
5779 tree elt = gimple_switch_label (switch_stmt, i);
5780 if (label_to_block (CASE_LABEL (elt)) == e->dest)
5781 CASE_LABEL (elt) = label;
5785 break;
5787 case GIMPLE_ASM:
5789 gasm *asm_stmt = as_a <gasm *> (stmt);
5790 int i, n = gimple_asm_nlabels (asm_stmt);
5791 tree label = NULL;
5793 for (i = 0; i < n; ++i)
5795 tree cons = gimple_asm_label_op (asm_stmt, i);
5796 if (label_to_block (TREE_VALUE (cons)) == e->dest)
5798 if (!label)
5799 label = gimple_block_label (dest);
5800 TREE_VALUE (cons) = label;
5804 /* If we didn't find any label matching the former edge in the
5805 asm labels, we must be redirecting the fallthrough
5806 edge. */
5807 gcc_assert (label || (e->flags & EDGE_FALLTHRU));
5809 break;
5811 case GIMPLE_RETURN:
5812 gsi_remove (&gsi, true);
5813 e->flags |= EDGE_FALLTHRU;
5814 break;
5816 case GIMPLE_OMP_RETURN:
5817 case GIMPLE_OMP_CONTINUE:
5818 case GIMPLE_OMP_SECTIONS_SWITCH:
5819 case GIMPLE_OMP_FOR:
5820 /* The edges from OMP constructs can be simply redirected. */
5821 break;
5823 case GIMPLE_EH_DISPATCH:
5824 if (!(e->flags & EDGE_FALLTHRU))
5825 redirect_eh_dispatch_edge (as_a <geh_dispatch *> (stmt), e, dest);
5826 break;
5828 case GIMPLE_TRANSACTION:
5829 if (e->flags & EDGE_TM_ABORT)
5830 gimple_transaction_set_label_over (as_a <gtransaction *> (stmt),
5831 gimple_block_label (dest));
5832 else if (e->flags & EDGE_TM_UNINSTRUMENTED)
5833 gimple_transaction_set_label_uninst (as_a <gtransaction *> (stmt),
5834 gimple_block_label (dest));
5835 else
5836 gimple_transaction_set_label_norm (as_a <gtransaction *> (stmt),
5837 gimple_block_label (dest));
5838 break;
5840 default:
5841 /* Otherwise it must be a fallthru edge, and we don't need to
5842 do anything besides redirecting it. */
5843 gcc_assert (e->flags & EDGE_FALLTHRU);
5844 break;
5847 /* Update/insert PHI nodes as necessary. */
5849 /* Now update the edges in the CFG. */
5850 e = ssa_redirect_edge (e, dest);
5852 return e;
5855 /* Returns true if it is possible to remove edge E by redirecting
5856 it to the destination of the other edge from E->src. */
5858 static bool
5859 gimple_can_remove_branch_p (const_edge e)
5861 if (e->flags & (EDGE_ABNORMAL | EDGE_EH))
5862 return false;
5864 return true;
5867 /* Simple wrapper, as we can always redirect fallthru edges. */
5869 static basic_block
5870 gimple_redirect_edge_and_branch_force (edge e, basic_block dest)
5872 e = gimple_redirect_edge_and_branch (e, dest);
5873 gcc_assert (e);
5875 return NULL;
5879 /* Splits basic block BB after statement STMT (but at least after the
5880 labels). If STMT is NULL, BB is split just after the labels. */
5882 static basic_block
5883 gimple_split_block (basic_block bb, void *stmt)
5885 gimple_stmt_iterator gsi;
5886 gimple_stmt_iterator gsi_tgt;
5887 gimple_seq list;
5888 basic_block new_bb;
5889 edge e;
5890 edge_iterator ei;
5892 new_bb = create_empty_bb (bb);
5894 /* Redirect the outgoing edges. */
5895 new_bb->succs = bb->succs;
5896 bb->succs = NULL;
5897 FOR_EACH_EDGE (e, ei, new_bb->succs)
5898 e->src = new_bb;
5900 /* Get a stmt iterator pointing to the first stmt to move. */
5901 if (!stmt || gimple_code ((gimple *) stmt) == GIMPLE_LABEL)
5902 gsi = gsi_after_labels (bb);
5903 else
5905 gsi = gsi_for_stmt ((gimple *) stmt);
5906 gsi_next (&gsi);
5909 /* Move everything from GSI to the new basic block. */
5910 if (gsi_end_p (gsi))
5911 return new_bb;
5913 /* Split the statement list - avoid re-creating new containers as this
5914 brings ugly quadratic memory consumption in the inliner.
5915 (We are still quadratic since we need to update stmt BB pointers,
5916 sadly.) */
5917 gsi_split_seq_before (&gsi, &list);
5918 set_bb_seq (new_bb, list);
5919 for (gsi_tgt = gsi_start (list);
5920 !gsi_end_p (gsi_tgt); gsi_next (&gsi_tgt))
5921 gimple_set_bb (gsi_stmt (gsi_tgt), new_bb);
5923 return new_bb;
5927 /* Moves basic block BB after block AFTER. */
5929 static bool
5930 gimple_move_block_after (basic_block bb, basic_block after)
5932 if (bb->prev_bb == after)
5933 return true;
5935 unlink_block (bb);
5936 link_block (bb, after);
5938 return true;
5942 /* Return TRUE if block BB has no executable statements, otherwise return
5943 FALSE. */
5945 static bool
5946 gimple_empty_block_p (basic_block bb)
5948 /* BB must have no executable statements. */
5949 gimple_stmt_iterator gsi = gsi_after_labels (bb);
5950 if (phi_nodes (bb))
5951 return false;
5952 if (gsi_end_p (gsi))
5953 return true;
5954 if (is_gimple_debug (gsi_stmt (gsi)))
5955 gsi_next_nondebug (&gsi);
5956 return gsi_end_p (gsi);
5960 /* Split a basic block if it ends with a conditional branch and if the
5961 other part of the block is not empty. */
5963 static basic_block
5964 gimple_split_block_before_cond_jump (basic_block bb)
5966 gimple *last, *split_point;
5967 gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
5968 if (gsi_end_p (gsi))
5969 return NULL;
5970 last = gsi_stmt (gsi);
5971 if (gimple_code (last) != GIMPLE_COND
5972 && gimple_code (last) != GIMPLE_SWITCH)
5973 return NULL;
5974 gsi_prev (&gsi);
5975 split_point = gsi_stmt (gsi);
5976 return split_block (bb, split_point)->dest;
5980 /* Return true if basic_block can be duplicated. */
5982 static bool
5983 gimple_can_duplicate_bb_p (const_basic_block bb ATTRIBUTE_UNUSED)
5985 return true;
5988 /* Create a duplicate of the basic block BB. NOTE: This does not
5989 preserve SSA form. */
5991 static basic_block
5992 gimple_duplicate_bb (basic_block bb)
5994 basic_block new_bb;
5995 gimple_stmt_iterator gsi_tgt;
5997 new_bb = create_empty_bb (EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb);
5999 /* Copy the PHI nodes. We ignore PHI node arguments here because
6000 the incoming edges have not been setup yet. */
6001 for (gphi_iterator gpi = gsi_start_phis (bb);
6002 !gsi_end_p (gpi);
6003 gsi_next (&gpi))
6005 gphi *phi, *copy;
6006 phi = gpi.phi ();
6007 copy = create_phi_node (NULL_TREE, new_bb);
6008 create_new_def_for (gimple_phi_result (phi), copy,
6009 gimple_phi_result_ptr (copy));
6010 gimple_set_uid (copy, gimple_uid (phi));
6013 gsi_tgt = gsi_start_bb (new_bb);
6014 for (gimple_stmt_iterator gsi = gsi_start_bb (bb);
6015 !gsi_end_p (gsi);
6016 gsi_next (&gsi))
6018 def_operand_p def_p;
6019 ssa_op_iter op_iter;
6020 tree lhs;
6021 gimple *stmt, *copy;
6023 stmt = gsi_stmt (gsi);
6024 if (gimple_code (stmt) == GIMPLE_LABEL)
6025 continue;
6027 /* Don't duplicate label debug stmts. */
6028 if (gimple_debug_bind_p (stmt)
6029 && TREE_CODE (gimple_debug_bind_get_var (stmt))
6030 == LABEL_DECL)
6031 continue;
6033 /* Create a new copy of STMT and duplicate STMT's virtual
6034 operands. */
6035 copy = gimple_copy (stmt);
6036 gsi_insert_after (&gsi_tgt, copy, GSI_NEW_STMT);
6038 maybe_duplicate_eh_stmt (copy, stmt);
6039 gimple_duplicate_stmt_histograms (cfun, copy, cfun, stmt);
6041 /* When copying around a stmt writing into a local non-user
6042 aggregate, make sure it won't share stack slot with other
6043 vars. */
6044 lhs = gimple_get_lhs (stmt);
6045 if (lhs && TREE_CODE (lhs) != SSA_NAME)
6047 tree base = get_base_address (lhs);
6048 if (base
6049 && (VAR_P (base) || TREE_CODE (base) == RESULT_DECL)
6050 && DECL_IGNORED_P (base)
6051 && !TREE_STATIC (base)
6052 && !DECL_EXTERNAL (base)
6053 && (!VAR_P (base) || !DECL_HAS_VALUE_EXPR_P (base)))
6054 DECL_NONSHAREABLE (base) = 1;
6057 /* Create new names for all the definitions created by COPY and
6058 add replacement mappings for each new name. */
6059 FOR_EACH_SSA_DEF_OPERAND (def_p, copy, op_iter, SSA_OP_ALL_DEFS)
6060 create_new_def_for (DEF_FROM_PTR (def_p), copy, def_p);
6063 return new_bb;
6066 /* Adds phi node arguments for edge E_COPY after basic block duplication. */
6068 static void
6069 add_phi_args_after_copy_edge (edge e_copy)
6071 basic_block bb, bb_copy = e_copy->src, dest;
6072 edge e;
6073 edge_iterator ei;
6074 gphi *phi, *phi_copy;
6075 tree def;
6076 gphi_iterator psi, psi_copy;
6078 if (gimple_seq_empty_p (phi_nodes (e_copy->dest)))
6079 return;
6081 bb = bb_copy->flags & BB_DUPLICATED ? get_bb_original (bb_copy) : bb_copy;
6083 if (e_copy->dest->flags & BB_DUPLICATED)
6084 dest = get_bb_original (e_copy->dest);
6085 else
6086 dest = e_copy->dest;
6088 e = find_edge (bb, dest);
6089 if (!e)
6091 /* During loop unrolling the target of the latch edge is copied.
6092 In this case we are not looking for edge to dest, but to
6093 duplicated block whose original was dest. */
6094 FOR_EACH_EDGE (e, ei, bb->succs)
6096 if ((e->dest->flags & BB_DUPLICATED)
6097 && get_bb_original (e->dest) == dest)
6098 break;
6101 gcc_assert (e != NULL);
6104 for (psi = gsi_start_phis (e->dest),
6105 psi_copy = gsi_start_phis (e_copy->dest);
6106 !gsi_end_p (psi);
6107 gsi_next (&psi), gsi_next (&psi_copy))
6109 phi = psi.phi ();
6110 phi_copy = psi_copy.phi ();
6111 def = PHI_ARG_DEF_FROM_EDGE (phi, e);
6112 add_phi_arg (phi_copy, def, e_copy,
6113 gimple_phi_arg_location_from_edge (phi, e));
6118 /* Basic block BB_COPY was created by code duplication. Add phi node
6119 arguments for edges going out of BB_COPY. The blocks that were
6120 duplicated have BB_DUPLICATED set. */
6122 void
6123 add_phi_args_after_copy_bb (basic_block bb_copy)
6125 edge e_copy;
6126 edge_iterator ei;
6128 FOR_EACH_EDGE (e_copy, ei, bb_copy->succs)
6130 add_phi_args_after_copy_edge (e_copy);
6134 /* Blocks in REGION_COPY array of length N_REGION were created by
6135 duplication of basic blocks. Add phi node arguments for edges
6136 going from these blocks. If E_COPY is not NULL, also add
6137 phi node arguments for its destination.*/
6139 void
6140 add_phi_args_after_copy (basic_block *region_copy, unsigned n_region,
6141 edge e_copy)
6143 unsigned i;
6145 for (i = 0; i < n_region; i++)
6146 region_copy[i]->flags |= BB_DUPLICATED;
6148 for (i = 0; i < n_region; i++)
6149 add_phi_args_after_copy_bb (region_copy[i]);
6150 if (e_copy)
6151 add_phi_args_after_copy_edge (e_copy);
6153 for (i = 0; i < n_region; i++)
6154 region_copy[i]->flags &= ~BB_DUPLICATED;
6157 /* Duplicates a REGION (set of N_REGION basic blocks) with just a single
6158 important exit edge EXIT. By important we mean that no SSA name defined
6159 inside region is live over the other exit edges of the region. All entry
6160 edges to the region must go to ENTRY->dest. The edge ENTRY is redirected
6161 to the duplicate of the region. Dominance and loop information is
6162 updated if UPDATE_DOMINANCE is true, but not the SSA web. If
6163 UPDATE_DOMINANCE is false then we assume that the caller will update the
6164 dominance information after calling this function. The new basic
6165 blocks are stored to REGION_COPY in the same order as they had in REGION,
6166 provided that REGION_COPY is not NULL.
6167 The function returns false if it is unable to copy the region,
6168 true otherwise. */
6170 bool
6171 gimple_duplicate_sese_region (edge entry, edge exit,
6172 basic_block *region, unsigned n_region,
6173 basic_block *region_copy,
6174 bool update_dominance)
6176 unsigned i;
6177 bool free_region_copy = false, copying_header = false;
6178 struct loop *loop = entry->dest->loop_father;
6179 edge exit_copy;
6180 vec<basic_block> doms;
6181 edge redirected;
6182 int total_freq = 0, entry_freq = 0;
6183 gcov_type total_count = 0, entry_count = 0;
6185 if (!can_copy_bbs_p (region, n_region))
6186 return false;
6188 /* Some sanity checking. Note that we do not check for all possible
6189 missuses of the functions. I.e. if you ask to copy something weird,
6190 it will work, but the state of structures probably will not be
6191 correct. */
6192 for (i = 0; i < n_region; i++)
6194 /* We do not handle subloops, i.e. all the blocks must belong to the
6195 same loop. */
6196 if (region[i]->loop_father != loop)
6197 return false;
6199 if (region[i] != entry->dest
6200 && region[i] == loop->header)
6201 return false;
6204 /* In case the function is used for loop header copying (which is the primary
6205 use), ensure that EXIT and its copy will be new latch and entry edges. */
6206 if (loop->header == entry->dest)
6208 copying_header = true;
6210 if (!dominated_by_p (CDI_DOMINATORS, loop->latch, exit->src))
6211 return false;
6213 for (i = 0; i < n_region; i++)
6214 if (region[i] != exit->src
6215 && dominated_by_p (CDI_DOMINATORS, region[i], exit->src))
6216 return false;
6219 initialize_original_copy_tables ();
6221 if (copying_header)
6222 set_loop_copy (loop, loop_outer (loop));
6223 else
6224 set_loop_copy (loop, loop);
6226 if (!region_copy)
6228 region_copy = XNEWVEC (basic_block, n_region);
6229 free_region_copy = true;
6232 /* Record blocks outside the region that are dominated by something
6233 inside. */
6234 if (update_dominance)
6236 doms.create (0);
6237 doms = get_dominated_by_region (CDI_DOMINATORS, region, n_region);
6240 if (entry->dest->count)
6242 total_count = entry->dest->count;
6243 entry_count = entry->count;
6244 /* Fix up corner cases, to avoid division by zero or creation of negative
6245 frequencies. */
6246 if (entry_count > total_count)
6247 entry_count = total_count;
6249 else
6251 total_freq = entry->dest->frequency;
6252 entry_freq = EDGE_FREQUENCY (entry);
6253 /* Fix up corner cases, to avoid division by zero or creation of negative
6254 frequencies. */
6255 if (total_freq == 0)
6256 total_freq = 1;
6257 else if (entry_freq > total_freq)
6258 entry_freq = total_freq;
6261 copy_bbs (region, n_region, region_copy, &exit, 1, &exit_copy, loop,
6262 split_edge_bb_loc (entry), update_dominance);
6263 if (total_count)
6265 scale_bbs_frequencies_gcov_type (region, n_region,
6266 total_count - entry_count,
6267 total_count);
6268 scale_bbs_frequencies_gcov_type (region_copy, n_region, entry_count,
6269 total_count);
6271 else
6273 scale_bbs_frequencies_int (region, n_region, total_freq - entry_freq,
6274 total_freq);
6275 scale_bbs_frequencies_int (region_copy, n_region, entry_freq, total_freq);
6278 if (copying_header)
6280 loop->header = exit->dest;
6281 loop->latch = exit->src;
6284 /* Redirect the entry and add the phi node arguments. */
6285 redirected = redirect_edge_and_branch (entry, get_bb_copy (entry->dest));
6286 gcc_assert (redirected != NULL);
6287 flush_pending_stmts (entry);
6289 /* Concerning updating of dominators: We must recount dominators
6290 for entry block and its copy. Anything that is outside of the
6291 region, but was dominated by something inside needs recounting as
6292 well. */
6293 if (update_dominance)
6295 set_immediate_dominator (CDI_DOMINATORS, entry->dest, entry->src);
6296 doms.safe_push (get_bb_original (entry->dest));
6297 iterate_fix_dominators (CDI_DOMINATORS, doms, false);
6298 doms.release ();
6301 /* Add the other PHI node arguments. */
6302 add_phi_args_after_copy (region_copy, n_region, NULL);
6304 if (free_region_copy)
6305 free (region_copy);
6307 free_original_copy_tables ();
6308 return true;
6311 /* Checks if BB is part of the region defined by N_REGION BBS. */
6312 static bool
6313 bb_part_of_region_p (basic_block bb, basic_block* bbs, unsigned n_region)
6315 unsigned int n;
6317 for (n = 0; n < n_region; n++)
6319 if (bb == bbs[n])
6320 return true;
6322 return false;
6325 /* Duplicates REGION consisting of N_REGION blocks. The new blocks
6326 are stored to REGION_COPY in the same order in that they appear
6327 in REGION, if REGION_COPY is not NULL. ENTRY is the entry to
6328 the region, EXIT an exit from it. The condition guarding EXIT
6329 is moved to ENTRY. Returns true if duplication succeeds, false
6330 otherwise.
6332 For example,
6334 some_code;
6335 if (cond)
6337 else
6340 is transformed to
6342 if (cond)
6344 some_code;
6347 else
6349 some_code;
6354 bool
6355 gimple_duplicate_sese_tail (edge entry ATTRIBUTE_UNUSED, edge exit ATTRIBUTE_UNUSED,
6356 basic_block *region ATTRIBUTE_UNUSED, unsigned n_region ATTRIBUTE_UNUSED,
6357 basic_block *region_copy ATTRIBUTE_UNUSED)
6359 unsigned i;
6360 bool free_region_copy = false;
6361 struct loop *loop = exit->dest->loop_father;
6362 struct loop *orig_loop = entry->dest->loop_father;
6363 basic_block switch_bb, entry_bb, nentry_bb;
6364 vec<basic_block> doms;
6365 int total_freq = 0, exit_freq = 0;
6366 gcov_type total_count = 0, exit_count = 0;
6367 edge exits[2], nexits[2], e;
6368 gimple_stmt_iterator gsi;
6369 gimple *cond_stmt;
6370 edge sorig, snew;
6371 basic_block exit_bb;
6372 gphi_iterator psi;
6373 gphi *phi;
6374 tree def;
6375 struct loop *target, *aloop, *cloop;
6377 gcc_assert (EDGE_COUNT (exit->src->succs) == 2);
6378 exits[0] = exit;
6379 exits[1] = EDGE_SUCC (exit->src, EDGE_SUCC (exit->src, 0) == exit);
6381 if (!can_copy_bbs_p (region, n_region))
6382 return false;
6384 initialize_original_copy_tables ();
6385 set_loop_copy (orig_loop, loop);
6387 target= loop;
6388 for (aloop = orig_loop->inner; aloop; aloop = aloop->next)
6390 if (bb_part_of_region_p (aloop->header, region, n_region))
6392 cloop = duplicate_loop (aloop, target);
6393 duplicate_subloops (aloop, cloop);
6397 if (!region_copy)
6399 region_copy = XNEWVEC (basic_block, n_region);
6400 free_region_copy = true;
6403 gcc_assert (!need_ssa_update_p (cfun));
6405 /* Record blocks outside the region that are dominated by something
6406 inside. */
6407 doms = get_dominated_by_region (CDI_DOMINATORS, region, n_region);
6409 if (exit->src->count)
6411 total_count = exit->src->count;
6412 exit_count = exit->count;
6413 /* Fix up corner cases, to avoid division by zero or creation of negative
6414 frequencies. */
6415 if (exit_count > total_count)
6416 exit_count = total_count;
6418 else
6420 total_freq = exit->src->frequency;
6421 exit_freq = EDGE_FREQUENCY (exit);
6422 /* Fix up corner cases, to avoid division by zero or creation of negative
6423 frequencies. */
6424 if (total_freq == 0)
6425 total_freq = 1;
6426 if (exit_freq > total_freq)
6427 exit_freq = total_freq;
6430 copy_bbs (region, n_region, region_copy, exits, 2, nexits, orig_loop,
6431 split_edge_bb_loc (exit), true);
6432 if (total_count)
6434 scale_bbs_frequencies_gcov_type (region, n_region,
6435 total_count - exit_count,
6436 total_count);
6437 scale_bbs_frequencies_gcov_type (region_copy, n_region, exit_count,
6438 total_count);
6440 else
6442 scale_bbs_frequencies_int (region, n_region, total_freq - exit_freq,
6443 total_freq);
6444 scale_bbs_frequencies_int (region_copy, n_region, exit_freq, total_freq);
6447 /* Create the switch block, and put the exit condition to it. */
6448 entry_bb = entry->dest;
6449 nentry_bb = get_bb_copy (entry_bb);
6450 if (!last_stmt (entry->src)
6451 || !stmt_ends_bb_p (last_stmt (entry->src)))
6452 switch_bb = entry->src;
6453 else
6454 switch_bb = split_edge (entry);
6455 set_immediate_dominator (CDI_DOMINATORS, nentry_bb, switch_bb);
6457 gsi = gsi_last_bb (switch_bb);
6458 cond_stmt = last_stmt (exit->src);
6459 gcc_assert (gimple_code (cond_stmt) == GIMPLE_COND);
6460 cond_stmt = gimple_copy (cond_stmt);
6462 gsi_insert_after (&gsi, cond_stmt, GSI_NEW_STMT);
6464 sorig = single_succ_edge (switch_bb);
6465 sorig->flags = exits[1]->flags;
6466 snew = make_edge (switch_bb, nentry_bb, exits[0]->flags);
6468 /* Register the new edge from SWITCH_BB in loop exit lists. */
6469 rescan_loop_exit (snew, true, false);
6471 /* Add the PHI node arguments. */
6472 add_phi_args_after_copy (region_copy, n_region, snew);
6474 /* Get rid of now superfluous conditions and associated edges (and phi node
6475 arguments). */
6476 exit_bb = exit->dest;
6478 e = redirect_edge_and_branch (exits[0], exits[1]->dest);
6479 PENDING_STMT (e) = NULL;
6481 /* The latch of ORIG_LOOP was copied, and so was the backedge
6482 to the original header. We redirect this backedge to EXIT_BB. */
6483 for (i = 0; i < n_region; i++)
6484 if (get_bb_original (region_copy[i]) == orig_loop->latch)
6486 gcc_assert (single_succ_edge (region_copy[i]));
6487 e = redirect_edge_and_branch (single_succ_edge (region_copy[i]), exit_bb);
6488 PENDING_STMT (e) = NULL;
6489 for (psi = gsi_start_phis (exit_bb);
6490 !gsi_end_p (psi);
6491 gsi_next (&psi))
6493 phi = psi.phi ();
6494 def = PHI_ARG_DEF (phi, nexits[0]->dest_idx);
6495 add_phi_arg (phi, def, e, gimple_phi_arg_location_from_edge (phi, e));
6498 e = redirect_edge_and_branch (nexits[1], nexits[0]->dest);
6499 PENDING_STMT (e) = NULL;
6501 /* Anything that is outside of the region, but was dominated by something
6502 inside needs to update dominance info. */
6503 iterate_fix_dominators (CDI_DOMINATORS, doms, false);
6504 doms.release ();
6505 /* Update the SSA web. */
6506 update_ssa (TODO_update_ssa);
6508 if (free_region_copy)
6509 free (region_copy);
6511 free_original_copy_tables ();
6512 return true;
6515 /* Add all the blocks dominated by ENTRY to the array BBS_P. Stop
6516 adding blocks when the dominator traversal reaches EXIT. This
6517 function silently assumes that ENTRY strictly dominates EXIT. */
6519 void
6520 gather_blocks_in_sese_region (basic_block entry, basic_block exit,
6521 vec<basic_block> *bbs_p)
6523 basic_block son;
6525 for (son = first_dom_son (CDI_DOMINATORS, entry);
6526 son;
6527 son = next_dom_son (CDI_DOMINATORS, son))
6529 bbs_p->safe_push (son);
6530 if (son != exit)
6531 gather_blocks_in_sese_region (son, exit, bbs_p);
6535 /* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
6536 The duplicates are recorded in VARS_MAP. */
6538 static void
6539 replace_by_duplicate_decl (tree *tp, hash_map<tree, tree> *vars_map,
6540 tree to_context)
6542 tree t = *tp, new_t;
6543 struct function *f = DECL_STRUCT_FUNCTION (to_context);
6545 if (DECL_CONTEXT (t) == to_context)
6546 return;
6548 bool existed;
6549 tree &loc = vars_map->get_or_insert (t, &existed);
6551 if (!existed)
6553 if (SSA_VAR_P (t))
6555 new_t = copy_var_decl (t, DECL_NAME (t), TREE_TYPE (t));
6556 add_local_decl (f, new_t);
6558 else
6560 gcc_assert (TREE_CODE (t) == CONST_DECL);
6561 new_t = copy_node (t);
6563 DECL_CONTEXT (new_t) = to_context;
6565 loc = new_t;
6567 else
6568 new_t = loc;
6570 *tp = new_t;
6574 /* Creates an ssa name in TO_CONTEXT equivalent to NAME.
6575 VARS_MAP maps old ssa names and var_decls to the new ones. */
6577 static tree
6578 replace_ssa_name (tree name, hash_map<tree, tree> *vars_map,
6579 tree to_context)
6581 tree new_name;
6583 gcc_assert (!virtual_operand_p (name));
6585 tree *loc = vars_map->get (name);
6587 if (!loc)
6589 tree decl = SSA_NAME_VAR (name);
6590 if (decl)
6592 gcc_assert (!SSA_NAME_IS_DEFAULT_DEF (name));
6593 replace_by_duplicate_decl (&decl, vars_map, to_context);
6594 new_name = make_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context),
6595 decl, SSA_NAME_DEF_STMT (name));
6597 else
6598 new_name = copy_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context),
6599 name, SSA_NAME_DEF_STMT (name));
6601 /* Now that we've used the def stmt to define new_name, make sure it
6602 doesn't define name anymore. */
6603 SSA_NAME_DEF_STMT (name) = NULL;
6605 vars_map->put (name, new_name);
6607 else
6608 new_name = *loc;
6610 return new_name;
6613 struct move_stmt_d
6615 tree orig_block;
6616 tree new_block;
6617 tree from_context;
6618 tree to_context;
6619 hash_map<tree, tree> *vars_map;
6620 htab_t new_label_map;
6621 hash_map<void *, void *> *eh_map;
6622 bool remap_decls_p;
6625 /* Helper for move_block_to_fn. Set TREE_BLOCK in every expression
6626 contained in *TP if it has been ORIG_BLOCK previously and change the
6627 DECL_CONTEXT of every local variable referenced in *TP. */
6629 static tree
6630 move_stmt_op (tree *tp, int *walk_subtrees, void *data)
6632 struct walk_stmt_info *wi = (struct walk_stmt_info *) data;
6633 struct move_stmt_d *p = (struct move_stmt_d *) wi->info;
6634 tree t = *tp;
6636 if (EXPR_P (t))
6638 tree block = TREE_BLOCK (t);
6639 if (block == p->orig_block
6640 || (p->orig_block == NULL_TREE
6641 && block != NULL_TREE))
6642 TREE_SET_BLOCK (t, p->new_block);
6643 else if (flag_checking && block != NULL_TREE)
6645 while (block && TREE_CODE (block) == BLOCK && block != p->orig_block)
6646 block = BLOCK_SUPERCONTEXT (block);
6647 gcc_assert (block == p->orig_block);
6650 else if (DECL_P (t) || TREE_CODE (t) == SSA_NAME)
6652 if (TREE_CODE (t) == SSA_NAME)
6653 *tp = replace_ssa_name (t, p->vars_map, p->to_context);
6654 else if (TREE_CODE (t) == PARM_DECL
6655 && gimple_in_ssa_p (cfun))
6656 *tp = *(p->vars_map->get (t));
6657 else if (TREE_CODE (t) == LABEL_DECL)
6659 if (p->new_label_map)
6661 struct tree_map in, *out;
6662 in.base.from = t;
6663 out = (struct tree_map *)
6664 htab_find_with_hash (p->new_label_map, &in, DECL_UID (t));
6665 if (out)
6666 *tp = t = out->to;
6669 DECL_CONTEXT (t) = p->to_context;
6671 else if (p->remap_decls_p)
6673 /* Replace T with its duplicate. T should no longer appear in the
6674 parent function, so this looks wasteful; however, it may appear
6675 in referenced_vars, and more importantly, as virtual operands of
6676 statements, and in alias lists of other variables. It would be
6677 quite difficult to expunge it from all those places. ??? It might
6678 suffice to do this for addressable variables. */
6679 if ((VAR_P (t) && !is_global_var (t))
6680 || TREE_CODE (t) == CONST_DECL)
6681 replace_by_duplicate_decl (tp, p->vars_map, p->to_context);
6683 *walk_subtrees = 0;
6685 else if (TYPE_P (t))
6686 *walk_subtrees = 0;
6688 return NULL_TREE;
6691 /* Helper for move_stmt_r. Given an EH region number for the source
6692 function, map that to the duplicate EH regio number in the dest. */
6694 static int
6695 move_stmt_eh_region_nr (int old_nr, struct move_stmt_d *p)
6697 eh_region old_r, new_r;
6699 old_r = get_eh_region_from_number (old_nr);
6700 new_r = static_cast<eh_region> (*p->eh_map->get (old_r));
6702 return new_r->index;
6705 /* Similar, but operate on INTEGER_CSTs. */
6707 static tree
6708 move_stmt_eh_region_tree_nr (tree old_t_nr, struct move_stmt_d *p)
6710 int old_nr, new_nr;
6712 old_nr = tree_to_shwi (old_t_nr);
6713 new_nr = move_stmt_eh_region_nr (old_nr, p);
6715 return build_int_cst (integer_type_node, new_nr);
6718 /* Like move_stmt_op, but for gimple statements.
6720 Helper for move_block_to_fn. Set GIMPLE_BLOCK in every expression
6721 contained in the current statement in *GSI_P and change the
6722 DECL_CONTEXT of every local variable referenced in the current
6723 statement. */
6725 static tree
6726 move_stmt_r (gimple_stmt_iterator *gsi_p, bool *handled_ops_p,
6727 struct walk_stmt_info *wi)
6729 struct move_stmt_d *p = (struct move_stmt_d *) wi->info;
6730 gimple *stmt = gsi_stmt (*gsi_p);
6731 tree block = gimple_block (stmt);
6733 if (block == p->orig_block
6734 || (p->orig_block == NULL_TREE
6735 && block != NULL_TREE))
6736 gimple_set_block (stmt, p->new_block);
6738 switch (gimple_code (stmt))
6740 case GIMPLE_CALL:
6741 /* Remap the region numbers for __builtin_eh_{pointer,filter}. */
6743 tree r, fndecl = gimple_call_fndecl (stmt);
6744 if (fndecl && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
6745 switch (DECL_FUNCTION_CODE (fndecl))
6747 case BUILT_IN_EH_COPY_VALUES:
6748 r = gimple_call_arg (stmt, 1);
6749 r = move_stmt_eh_region_tree_nr (r, p);
6750 gimple_call_set_arg (stmt, 1, r);
6751 /* FALLTHRU */
6753 case BUILT_IN_EH_POINTER:
6754 case BUILT_IN_EH_FILTER:
6755 r = gimple_call_arg (stmt, 0);
6756 r = move_stmt_eh_region_tree_nr (r, p);
6757 gimple_call_set_arg (stmt, 0, r);
6758 break;
6760 default:
6761 break;
6764 break;
6766 case GIMPLE_RESX:
6768 gresx *resx_stmt = as_a <gresx *> (stmt);
6769 int r = gimple_resx_region (resx_stmt);
6770 r = move_stmt_eh_region_nr (r, p);
6771 gimple_resx_set_region (resx_stmt, r);
6773 break;
6775 case GIMPLE_EH_DISPATCH:
6777 geh_dispatch *eh_dispatch_stmt = as_a <geh_dispatch *> (stmt);
6778 int r = gimple_eh_dispatch_region (eh_dispatch_stmt);
6779 r = move_stmt_eh_region_nr (r, p);
6780 gimple_eh_dispatch_set_region (eh_dispatch_stmt, r);
6782 break;
6784 case GIMPLE_OMP_RETURN:
6785 case GIMPLE_OMP_CONTINUE:
6786 break;
6787 default:
6788 if (is_gimple_omp (stmt))
6790 /* Do not remap variables inside OMP directives. Variables
6791 referenced in clauses and directive header belong to the
6792 parent function and should not be moved into the child
6793 function. */
6794 bool save_remap_decls_p = p->remap_decls_p;
6795 p->remap_decls_p = false;
6796 *handled_ops_p = true;
6798 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt), move_stmt_r,
6799 move_stmt_op, wi);
6801 p->remap_decls_p = save_remap_decls_p;
6803 break;
6806 return NULL_TREE;
6809 /* Move basic block BB from function CFUN to function DEST_FN. The
6810 block is moved out of the original linked list and placed after
6811 block AFTER in the new list. Also, the block is removed from the
6812 original array of blocks and placed in DEST_FN's array of blocks.
6813 If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
6814 updated to reflect the moved edges.
6816 The local variables are remapped to new instances, VARS_MAP is used
6817 to record the mapping. */
6819 static void
6820 move_block_to_fn (struct function *dest_cfun, basic_block bb,
6821 basic_block after, bool update_edge_count_p,
6822 struct move_stmt_d *d)
6824 struct control_flow_graph *cfg;
6825 edge_iterator ei;
6826 edge e;
6827 gimple_stmt_iterator si;
6828 unsigned old_len, new_len;
6830 /* Remove BB from dominance structures. */
6831 delete_from_dominance_info (CDI_DOMINATORS, bb);
6833 /* Move BB from its current loop to the copy in the new function. */
6834 if (current_loops)
6836 struct loop *new_loop = (struct loop *)bb->loop_father->aux;
6837 if (new_loop)
6838 bb->loop_father = new_loop;
6841 /* Link BB to the new linked list. */
6842 move_block_after (bb, after);
6844 /* Update the edge count in the corresponding flowgraphs. */
6845 if (update_edge_count_p)
6846 FOR_EACH_EDGE (e, ei, bb->succs)
6848 cfun->cfg->x_n_edges--;
6849 dest_cfun->cfg->x_n_edges++;
6852 /* Remove BB from the original basic block array. */
6853 (*cfun->cfg->x_basic_block_info)[bb->index] = NULL;
6854 cfun->cfg->x_n_basic_blocks--;
6856 /* Grow DEST_CFUN's basic block array if needed. */
6857 cfg = dest_cfun->cfg;
6858 cfg->x_n_basic_blocks++;
6859 if (bb->index >= cfg->x_last_basic_block)
6860 cfg->x_last_basic_block = bb->index + 1;
6862 old_len = vec_safe_length (cfg->x_basic_block_info);
6863 if ((unsigned) cfg->x_last_basic_block >= old_len)
6865 new_len = cfg->x_last_basic_block + (cfg->x_last_basic_block + 3) / 4;
6866 vec_safe_grow_cleared (cfg->x_basic_block_info, new_len);
6869 (*cfg->x_basic_block_info)[bb->index] = bb;
6871 /* Remap the variables in phi nodes. */
6872 for (gphi_iterator psi = gsi_start_phis (bb);
6873 !gsi_end_p (psi); )
6875 gphi *phi = psi.phi ();
6876 use_operand_p use;
6877 tree op = PHI_RESULT (phi);
6878 ssa_op_iter oi;
6879 unsigned i;
6881 if (virtual_operand_p (op))
6883 /* Remove the phi nodes for virtual operands (alias analysis will be
6884 run for the new function, anyway). */
6885 remove_phi_node (&psi, true);
6886 continue;
6889 SET_PHI_RESULT (phi,
6890 replace_ssa_name (op, d->vars_map, dest_cfun->decl));
6891 FOR_EACH_PHI_ARG (use, phi, oi, SSA_OP_USE)
6893 op = USE_FROM_PTR (use);
6894 if (TREE_CODE (op) == SSA_NAME)
6895 SET_USE (use, replace_ssa_name (op, d->vars_map, dest_cfun->decl));
6898 for (i = 0; i < EDGE_COUNT (bb->preds); i++)
6900 location_t locus = gimple_phi_arg_location (phi, i);
6901 tree block = LOCATION_BLOCK (locus);
6903 if (locus == UNKNOWN_LOCATION)
6904 continue;
6905 if (d->orig_block == NULL_TREE || block == d->orig_block)
6907 locus = set_block (locus, d->new_block);
6908 gimple_phi_arg_set_location (phi, i, locus);
6912 gsi_next (&psi);
6915 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
6917 gimple *stmt = gsi_stmt (si);
6918 struct walk_stmt_info wi;
6920 memset (&wi, 0, sizeof (wi));
6921 wi.info = d;
6922 walk_gimple_stmt (&si, move_stmt_r, move_stmt_op, &wi);
6924 if (glabel *label_stmt = dyn_cast <glabel *> (stmt))
6926 tree label = gimple_label_label (label_stmt);
6927 int uid = LABEL_DECL_UID (label);
6929 gcc_assert (uid > -1);
6931 old_len = vec_safe_length (cfg->x_label_to_block_map);
6932 if (old_len <= (unsigned) uid)
6934 new_len = 3 * uid / 2 + 1;
6935 vec_safe_grow_cleared (cfg->x_label_to_block_map, new_len);
6938 (*cfg->x_label_to_block_map)[uid] = bb;
6939 (*cfun->cfg->x_label_to_block_map)[uid] = NULL;
6941 gcc_assert (DECL_CONTEXT (label) == dest_cfun->decl);
6943 if (uid >= dest_cfun->cfg->last_label_uid)
6944 dest_cfun->cfg->last_label_uid = uid + 1;
6947 maybe_duplicate_eh_stmt_fn (dest_cfun, stmt, cfun, stmt, d->eh_map, 0);
6948 remove_stmt_from_eh_lp_fn (cfun, stmt);
6950 gimple_duplicate_stmt_histograms (dest_cfun, stmt, cfun, stmt);
6951 gimple_remove_stmt_histograms (cfun, stmt);
6953 /* We cannot leave any operands allocated from the operand caches of
6954 the current function. */
6955 free_stmt_operands (cfun, stmt);
6956 push_cfun (dest_cfun);
6957 update_stmt (stmt);
6958 pop_cfun ();
6961 FOR_EACH_EDGE (e, ei, bb->succs)
6962 if (e->goto_locus != UNKNOWN_LOCATION)
6964 tree block = LOCATION_BLOCK (e->goto_locus);
6965 if (d->orig_block == NULL_TREE
6966 || block == d->orig_block)
6967 e->goto_locus = set_block (e->goto_locus, d->new_block);
6971 /* Examine the statements in BB (which is in SRC_CFUN); find and return
6972 the outermost EH region. Use REGION as the incoming base EH region. */
6974 static eh_region
6975 find_outermost_region_in_block (struct function *src_cfun,
6976 basic_block bb, eh_region region)
6978 gimple_stmt_iterator si;
6980 for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
6982 gimple *stmt = gsi_stmt (si);
6983 eh_region stmt_region;
6984 int lp_nr;
6986 lp_nr = lookup_stmt_eh_lp_fn (src_cfun, stmt);
6987 stmt_region = get_eh_region_from_lp_number_fn (src_cfun, lp_nr);
6988 if (stmt_region)
6990 if (region == NULL)
6991 region = stmt_region;
6992 else if (stmt_region != region)
6994 region = eh_region_outermost (src_cfun, stmt_region, region);
6995 gcc_assert (region != NULL);
7000 return region;
7003 static tree
7004 new_label_mapper (tree decl, void *data)
7006 htab_t hash = (htab_t) data;
7007 struct tree_map *m;
7008 void **slot;
7010 gcc_assert (TREE_CODE (decl) == LABEL_DECL);
7012 m = XNEW (struct tree_map);
7013 m->hash = DECL_UID (decl);
7014 m->base.from = decl;
7015 m->to = create_artificial_label (UNKNOWN_LOCATION);
7016 LABEL_DECL_UID (m->to) = LABEL_DECL_UID (decl);
7017 if (LABEL_DECL_UID (m->to) >= cfun->cfg->last_label_uid)
7018 cfun->cfg->last_label_uid = LABEL_DECL_UID (m->to) + 1;
7020 slot = htab_find_slot_with_hash (hash, m, m->hash, INSERT);
7021 gcc_assert (*slot == NULL);
7023 *slot = m;
7025 return m->to;
7028 /* Tree walker to replace the decls used inside value expressions by
7029 duplicates. */
7031 static tree
7032 replace_block_vars_by_duplicates_1 (tree *tp, int *walk_subtrees, void *data)
7034 struct replace_decls_d *rd = (struct replace_decls_d *)data;
7036 switch (TREE_CODE (*tp))
7038 case VAR_DECL:
7039 case PARM_DECL:
7040 case RESULT_DECL:
7041 replace_by_duplicate_decl (tp, rd->vars_map, rd->to_context);
7042 break;
7043 default:
7044 break;
7047 if (IS_TYPE_OR_DECL_P (*tp))
7048 *walk_subtrees = false;
7050 return NULL;
7053 /* Change DECL_CONTEXT of all BLOCK_VARS in block, including
7054 subblocks. */
7056 static void
7057 replace_block_vars_by_duplicates (tree block, hash_map<tree, tree> *vars_map,
7058 tree to_context)
7060 tree *tp, t;
7062 for (tp = &BLOCK_VARS (block); *tp; tp = &DECL_CHAIN (*tp))
7064 t = *tp;
7065 if (!VAR_P (t) && TREE_CODE (t) != CONST_DECL)
7066 continue;
7067 replace_by_duplicate_decl (&t, vars_map, to_context);
7068 if (t != *tp)
7070 if (VAR_P (*tp) && DECL_HAS_VALUE_EXPR_P (*tp))
7072 tree x = DECL_VALUE_EXPR (*tp);
7073 struct replace_decls_d rd = { vars_map, to_context };
7074 unshare_expr (x);
7075 walk_tree (&x, replace_block_vars_by_duplicates_1, &rd, NULL);
7076 SET_DECL_VALUE_EXPR (t, x);
7077 DECL_HAS_VALUE_EXPR_P (t) = 1;
7079 DECL_CHAIN (t) = DECL_CHAIN (*tp);
7080 *tp = t;
7084 for (block = BLOCK_SUBBLOCKS (block); block; block = BLOCK_CHAIN (block))
7085 replace_block_vars_by_duplicates (block, vars_map, to_context);
7088 /* Fixup the loop arrays and numbers after moving LOOP and its subloops
7089 from FN1 to FN2. */
7091 static void
7092 fixup_loop_arrays_after_move (struct function *fn1, struct function *fn2,
7093 struct loop *loop)
7095 /* Discard it from the old loop array. */
7096 (*get_loops (fn1))[loop->num] = NULL;
7098 /* Place it in the new loop array, assigning it a new number. */
7099 loop->num = number_of_loops (fn2);
7100 vec_safe_push (loops_for_fn (fn2)->larray, loop);
7102 /* Recurse to children. */
7103 for (loop = loop->inner; loop; loop = loop->next)
7104 fixup_loop_arrays_after_move (fn1, fn2, loop);
7107 /* Verify that the blocks in BBS_P are a single-entry, single-exit region
7108 delimited by ENTRY_BB and EXIT_BB, possibly containing noreturn blocks. */
7110 DEBUG_FUNCTION void
7111 verify_sese (basic_block entry, basic_block exit, vec<basic_block> *bbs_p)
7113 basic_block bb;
7114 edge_iterator ei;
7115 edge e;
7116 bitmap bbs = BITMAP_ALLOC (NULL);
7117 int i;
7119 gcc_assert (entry != NULL);
7120 gcc_assert (entry != exit);
7121 gcc_assert (bbs_p != NULL);
7123 gcc_assert (bbs_p->length () > 0);
7125 FOR_EACH_VEC_ELT (*bbs_p, i, bb)
7126 bitmap_set_bit (bbs, bb->index);
7128 gcc_assert (bitmap_bit_p (bbs, entry->index));
7129 gcc_assert (exit == NULL || bitmap_bit_p (bbs, exit->index));
7131 FOR_EACH_VEC_ELT (*bbs_p, i, bb)
7133 if (bb == entry)
7135 gcc_assert (single_pred_p (entry));
7136 gcc_assert (!bitmap_bit_p (bbs, single_pred (entry)->index));
7138 else
7139 for (ei = ei_start (bb->preds); !ei_end_p (ei); ei_next (&ei))
7141 e = ei_edge (ei);
7142 gcc_assert (bitmap_bit_p (bbs, e->src->index));
7145 if (bb == exit)
7147 gcc_assert (single_succ_p (exit));
7148 gcc_assert (!bitmap_bit_p (bbs, single_succ (exit)->index));
7150 else
7151 for (ei = ei_start (bb->succs); !ei_end_p (ei); ei_next (&ei))
7153 e = ei_edge (ei);
7154 gcc_assert (bitmap_bit_p (bbs, e->dest->index));
7158 BITMAP_FREE (bbs);
7161 /* If FROM is an SSA_NAME, mark the version in bitmap DATA. */
7163 bool
7164 gather_ssa_name_hash_map_from (tree const &from, tree const &, void *data)
7166 bitmap release_names = (bitmap)data;
7168 if (TREE_CODE (from) != SSA_NAME)
7169 return true;
7171 bitmap_set_bit (release_names, SSA_NAME_VERSION (from));
7172 return true;
7175 /* Move a single-entry, single-exit region delimited by ENTRY_BB and
7176 EXIT_BB to function DEST_CFUN. The whole region is replaced by a
7177 single basic block in the original CFG and the new basic block is
7178 returned. DEST_CFUN must not have a CFG yet.
7180 Note that the region need not be a pure SESE region. Blocks inside
7181 the region may contain calls to abort/exit. The only restriction
7182 is that ENTRY_BB should be the only entry point and it must
7183 dominate EXIT_BB.
7185 Change TREE_BLOCK of all statements in ORIG_BLOCK to the new
7186 functions outermost BLOCK, move all subblocks of ORIG_BLOCK
7187 to the new function.
7189 All local variables referenced in the region are assumed to be in
7190 the corresponding BLOCK_VARS and unexpanded variable lists
7191 associated with DEST_CFUN.
7193 TODO: investigate whether we can reuse gimple_duplicate_sese_region to
7194 reimplement move_sese_region_to_fn by duplicating the region rather than
7195 moving it. */
7197 basic_block
7198 move_sese_region_to_fn (struct function *dest_cfun, basic_block entry_bb,
7199 basic_block exit_bb, tree orig_block)
7201 vec<basic_block> bbs, dom_bbs;
7202 basic_block dom_entry = get_immediate_dominator (CDI_DOMINATORS, entry_bb);
7203 basic_block after, bb, *entry_pred, *exit_succ, abb;
7204 struct function *saved_cfun = cfun;
7205 int *entry_flag, *exit_flag;
7206 unsigned *entry_prob, *exit_prob;
7207 unsigned i, num_entry_edges, num_exit_edges, num_nodes;
7208 edge e;
7209 edge_iterator ei;
7210 htab_t new_label_map;
7211 hash_map<void *, void *> *eh_map;
7212 struct loop *loop = entry_bb->loop_father;
7213 struct loop *loop0 = get_loop (saved_cfun, 0);
7214 struct move_stmt_d d;
7216 /* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
7217 region. */
7218 gcc_assert (entry_bb != exit_bb
7219 && (!exit_bb
7220 || dominated_by_p (CDI_DOMINATORS, exit_bb, entry_bb)));
7222 /* Collect all the blocks in the region. Manually add ENTRY_BB
7223 because it won't be added by dfs_enumerate_from. */
7224 bbs.create (0);
7225 bbs.safe_push (entry_bb);
7226 gather_blocks_in_sese_region (entry_bb, exit_bb, &bbs);
7228 if (flag_checking)
7229 verify_sese (entry_bb, exit_bb, &bbs);
7231 /* The blocks that used to be dominated by something in BBS will now be
7232 dominated by the new block. */
7233 dom_bbs = get_dominated_by_region (CDI_DOMINATORS,
7234 bbs.address (),
7235 bbs.length ());
7237 /* Detach ENTRY_BB and EXIT_BB from CFUN->CFG. We need to remember
7238 the predecessor edges to ENTRY_BB and the successor edges to
7239 EXIT_BB so that we can re-attach them to the new basic block that
7240 will replace the region. */
7241 num_entry_edges = EDGE_COUNT (entry_bb->preds);
7242 entry_pred = XNEWVEC (basic_block, num_entry_edges);
7243 entry_flag = XNEWVEC (int, num_entry_edges);
7244 entry_prob = XNEWVEC (unsigned, num_entry_edges);
7245 i = 0;
7246 for (ei = ei_start (entry_bb->preds); (e = ei_safe_edge (ei)) != NULL;)
7248 entry_prob[i] = e->probability;
7249 entry_flag[i] = e->flags;
7250 entry_pred[i++] = e->src;
7251 remove_edge (e);
7254 if (exit_bb)
7256 num_exit_edges = EDGE_COUNT (exit_bb->succs);
7257 exit_succ = XNEWVEC (basic_block, num_exit_edges);
7258 exit_flag = XNEWVEC (int, num_exit_edges);
7259 exit_prob = XNEWVEC (unsigned, num_exit_edges);
7260 i = 0;
7261 for (ei = ei_start (exit_bb->succs); (e = ei_safe_edge (ei)) != NULL;)
7263 exit_prob[i] = e->probability;
7264 exit_flag[i] = e->flags;
7265 exit_succ[i++] = e->dest;
7266 remove_edge (e);
7269 else
7271 num_exit_edges = 0;
7272 exit_succ = NULL;
7273 exit_flag = NULL;
7274 exit_prob = NULL;
7277 /* Switch context to the child function to initialize DEST_FN's CFG. */
7278 gcc_assert (dest_cfun->cfg == NULL);
7279 push_cfun (dest_cfun);
7281 init_empty_tree_cfg ();
7283 /* Initialize EH information for the new function. */
7284 eh_map = NULL;
7285 new_label_map = NULL;
7286 if (saved_cfun->eh)
7288 eh_region region = NULL;
7290 FOR_EACH_VEC_ELT (bbs, i, bb)
7291 region = find_outermost_region_in_block (saved_cfun, bb, region);
7293 init_eh_for_function ();
7294 if (region != NULL)
7296 new_label_map = htab_create (17, tree_map_hash, tree_map_eq, free);
7297 eh_map = duplicate_eh_regions (saved_cfun, region, 0,
7298 new_label_mapper, new_label_map);
7302 /* Initialize an empty loop tree. */
7303 struct loops *loops = ggc_cleared_alloc<struct loops> ();
7304 init_loops_structure (dest_cfun, loops, 1);
7305 loops->state = LOOPS_MAY_HAVE_MULTIPLE_LATCHES;
7306 set_loops_for_fn (dest_cfun, loops);
7308 /* Move the outlined loop tree part. */
7309 num_nodes = bbs.length ();
7310 FOR_EACH_VEC_ELT (bbs, i, bb)
7312 if (bb->loop_father->header == bb)
7314 struct loop *this_loop = bb->loop_father;
7315 struct loop *outer = loop_outer (this_loop);
7316 if (outer == loop
7317 /* If the SESE region contains some bbs ending with
7318 a noreturn call, those are considered to belong
7319 to the outermost loop in saved_cfun, rather than
7320 the entry_bb's loop_father. */
7321 || outer == loop0)
7323 if (outer != loop)
7324 num_nodes -= this_loop->num_nodes;
7325 flow_loop_tree_node_remove (bb->loop_father);
7326 flow_loop_tree_node_add (get_loop (dest_cfun, 0), this_loop);
7327 fixup_loop_arrays_after_move (saved_cfun, cfun, this_loop);
7330 else if (bb->loop_father == loop0 && loop0 != loop)
7331 num_nodes--;
7333 /* Remove loop exits from the outlined region. */
7334 if (loops_for_fn (saved_cfun)->exits)
7335 FOR_EACH_EDGE (e, ei, bb->succs)
7337 struct loops *l = loops_for_fn (saved_cfun);
7338 loop_exit **slot
7339 = l->exits->find_slot_with_hash (e, htab_hash_pointer (e),
7340 NO_INSERT);
7341 if (slot)
7342 l->exits->clear_slot (slot);
7347 /* Adjust the number of blocks in the tree root of the outlined part. */
7348 get_loop (dest_cfun, 0)->num_nodes = bbs.length () + 2;
7350 /* Setup a mapping to be used by move_block_to_fn. */
7351 loop->aux = current_loops->tree_root;
7352 loop0->aux = current_loops->tree_root;
7354 pop_cfun ();
7356 /* Move blocks from BBS into DEST_CFUN. */
7357 gcc_assert (bbs.length () >= 2);
7358 after = dest_cfun->cfg->x_entry_block_ptr;
7359 hash_map<tree, tree> vars_map;
7361 memset (&d, 0, sizeof (d));
7362 d.orig_block = orig_block;
7363 d.new_block = DECL_INITIAL (dest_cfun->decl);
7364 d.from_context = cfun->decl;
7365 d.to_context = dest_cfun->decl;
7366 d.vars_map = &vars_map;
7367 d.new_label_map = new_label_map;
7368 d.eh_map = eh_map;
7369 d.remap_decls_p = true;
7371 if (gimple_in_ssa_p (cfun))
7372 for (tree arg = DECL_ARGUMENTS (d.to_context); arg; arg = DECL_CHAIN (arg))
7374 tree narg = make_ssa_name_fn (dest_cfun, arg, gimple_build_nop ());
7375 set_ssa_default_def (dest_cfun, arg, narg);
7376 vars_map.put (arg, narg);
7379 FOR_EACH_VEC_ELT (bbs, i, bb)
7381 /* No need to update edge counts on the last block. It has
7382 already been updated earlier when we detached the region from
7383 the original CFG. */
7384 move_block_to_fn (dest_cfun, bb, after, bb != exit_bb, &d);
7385 after = bb;
7388 loop->aux = NULL;
7389 loop0->aux = NULL;
7390 /* Loop sizes are no longer correct, fix them up. */
7391 loop->num_nodes -= num_nodes;
7392 for (struct loop *outer = loop_outer (loop);
7393 outer; outer = loop_outer (outer))
7394 outer->num_nodes -= num_nodes;
7395 loop0->num_nodes -= bbs.length () - num_nodes;
7397 if (saved_cfun->has_simduid_loops || saved_cfun->has_force_vectorize_loops)
7399 struct loop *aloop;
7400 for (i = 0; vec_safe_iterate (loops->larray, i, &aloop); i++)
7401 if (aloop != NULL)
7403 if (aloop->simduid)
7405 replace_by_duplicate_decl (&aloop->simduid, d.vars_map,
7406 d.to_context);
7407 dest_cfun->has_simduid_loops = true;
7409 if (aloop->force_vectorize)
7410 dest_cfun->has_force_vectorize_loops = true;
7414 /* Rewire BLOCK_SUBBLOCKS of orig_block. */
7415 if (orig_block)
7417 tree block;
7418 gcc_assert (BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun->decl))
7419 == NULL_TREE);
7420 BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun->decl))
7421 = BLOCK_SUBBLOCKS (orig_block);
7422 for (block = BLOCK_SUBBLOCKS (orig_block);
7423 block; block = BLOCK_CHAIN (block))
7424 BLOCK_SUPERCONTEXT (block) = DECL_INITIAL (dest_cfun->decl);
7425 BLOCK_SUBBLOCKS (orig_block) = NULL_TREE;
7428 replace_block_vars_by_duplicates (DECL_INITIAL (dest_cfun->decl),
7429 &vars_map, dest_cfun->decl);
7431 if (new_label_map)
7432 htab_delete (new_label_map);
7433 if (eh_map)
7434 delete eh_map;
7436 if (gimple_in_ssa_p (cfun))
7438 /* We need to release ssa-names in a defined order, so first find them,
7439 and then iterate in ascending version order. */
7440 bitmap release_names = BITMAP_ALLOC (NULL);
7441 vars_map.traverse<void *, gather_ssa_name_hash_map_from> (release_names);
7442 bitmap_iterator bi;
7443 unsigned i;
7444 EXECUTE_IF_SET_IN_BITMAP (release_names, 0, i, bi)
7445 release_ssa_name (ssa_name (i));
7446 BITMAP_FREE (release_names);
7449 /* Rewire the entry and exit blocks. The successor to the entry
7450 block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
7451 the child function. Similarly, the predecessor of DEST_FN's
7452 EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR. We
7453 need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
7454 various CFG manipulation function get to the right CFG.
7456 FIXME, this is silly. The CFG ought to become a parameter to
7457 these helpers. */
7458 push_cfun (dest_cfun);
7459 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun), entry_bb, EDGE_FALLTHRU);
7460 if (exit_bb)
7461 make_edge (exit_bb, EXIT_BLOCK_PTR_FOR_FN (cfun), 0);
7462 pop_cfun ();
7464 /* Back in the original function, the SESE region has disappeared,
7465 create a new basic block in its place. */
7466 bb = create_empty_bb (entry_pred[0]);
7467 if (current_loops)
7468 add_bb_to_loop (bb, loop);
7469 for (i = 0; i < num_entry_edges; i++)
7471 e = make_edge (entry_pred[i], bb, entry_flag[i]);
7472 e->probability = entry_prob[i];
7475 for (i = 0; i < num_exit_edges; i++)
7477 e = make_edge (bb, exit_succ[i], exit_flag[i]);
7478 e->probability = exit_prob[i];
7481 set_immediate_dominator (CDI_DOMINATORS, bb, dom_entry);
7482 FOR_EACH_VEC_ELT (dom_bbs, i, abb)
7483 set_immediate_dominator (CDI_DOMINATORS, abb, bb);
7484 dom_bbs.release ();
7486 if (exit_bb)
7488 free (exit_prob);
7489 free (exit_flag);
7490 free (exit_succ);
7492 free (entry_prob);
7493 free (entry_flag);
7494 free (entry_pred);
7495 bbs.release ();
7497 return bb;
7500 /* Dump default def DEF to file FILE using FLAGS and indentation
7501 SPC. */
7503 static void
7504 dump_default_def (FILE *file, tree def, int spc, int flags)
7506 for (int i = 0; i < spc; ++i)
7507 fprintf (file, " ");
7508 dump_ssaname_info_to_file (file, def, spc);
7510 print_generic_expr (file, TREE_TYPE (def), flags);
7511 fprintf (file, " ");
7512 print_generic_expr (file, def, flags);
7513 fprintf (file, " = ");
7514 print_generic_expr (file, SSA_NAME_VAR (def), flags);
7515 fprintf (file, ";\n");
7518 /* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in dumpfile.h)
7521 void
7522 dump_function_to_file (tree fndecl, FILE *file, int flags)
7524 tree arg, var, old_current_fndecl = current_function_decl;
7525 struct function *dsf;
7526 bool ignore_topmost_bind = false, any_var = false;
7527 basic_block bb;
7528 tree chain;
7529 bool tmclone = (TREE_CODE (fndecl) == FUNCTION_DECL
7530 && decl_is_tm_clone (fndecl));
7531 struct function *fun = DECL_STRUCT_FUNCTION (fndecl);
7533 if (DECL_ATTRIBUTES (fndecl) != NULL_TREE)
7535 fprintf (file, "__attribute__((");
7537 bool first = true;
7538 tree chain;
7539 for (chain = DECL_ATTRIBUTES (fndecl); chain;
7540 first = false, chain = TREE_CHAIN (chain))
7542 if (!first)
7543 fprintf (file, ", ");
7545 print_generic_expr (file, get_attribute_name (chain), dump_flags);
7546 if (TREE_VALUE (chain) != NULL_TREE)
7548 fprintf (file, " (");
7549 print_generic_expr (file, TREE_VALUE (chain), dump_flags);
7550 fprintf (file, ")");
7554 fprintf (file, "))\n");
7557 current_function_decl = fndecl;
7558 if (flags & TDF_GIMPLE)
7560 print_generic_expr (file, TREE_TYPE (TREE_TYPE (fndecl)),
7561 dump_flags | TDF_SLIM);
7562 fprintf (file, " __GIMPLE ()\n%s (", function_name (fun));
7564 else
7565 fprintf (file, "%s %s(", function_name (fun), tmclone ? "[tm-clone] " : "");
7567 arg = DECL_ARGUMENTS (fndecl);
7568 while (arg)
7570 print_generic_expr (file, TREE_TYPE (arg), dump_flags);
7571 fprintf (file, " ");
7572 print_generic_expr (file, arg, dump_flags);
7573 if (flags & TDF_VERBOSE)
7574 print_node (file, "", arg, 4);
7575 if (DECL_CHAIN (arg))
7576 fprintf (file, ", ");
7577 arg = DECL_CHAIN (arg);
7579 fprintf (file, ")\n");
7581 if (flags & TDF_VERBOSE)
7582 print_node (file, "", fndecl, 2);
7584 dsf = DECL_STRUCT_FUNCTION (fndecl);
7585 if (dsf && (flags & TDF_EH))
7586 dump_eh_tree (file, dsf);
7588 if (flags & TDF_RAW && !gimple_has_body_p (fndecl))
7590 dump_node (fndecl, TDF_SLIM | flags, file);
7591 current_function_decl = old_current_fndecl;
7592 return;
7595 /* When GIMPLE is lowered, the variables are no longer available in
7596 BIND_EXPRs, so display them separately. */
7597 if (fun && fun->decl == fndecl && (fun->curr_properties & PROP_gimple_lcf))
7599 unsigned ix;
7600 ignore_topmost_bind = true;
7602 fprintf (file, "{\n");
7603 if (gimple_in_ssa_p (fun)
7604 && (flags & TDF_ALIAS))
7606 for (arg = DECL_ARGUMENTS (fndecl); arg != NULL;
7607 arg = DECL_CHAIN (arg))
7609 tree def = ssa_default_def (fun, arg);
7610 if (def)
7611 dump_default_def (file, def, 2, flags);
7614 tree res = DECL_RESULT (fun->decl);
7615 if (res != NULL_TREE
7616 && DECL_BY_REFERENCE (res))
7618 tree def = ssa_default_def (fun, res);
7619 if (def)
7620 dump_default_def (file, def, 2, flags);
7623 tree static_chain = fun->static_chain_decl;
7624 if (static_chain != NULL_TREE)
7626 tree def = ssa_default_def (fun, static_chain);
7627 if (def)
7628 dump_default_def (file, def, 2, flags);
7632 if (!vec_safe_is_empty (fun->local_decls))
7633 FOR_EACH_LOCAL_DECL (fun, ix, var)
7635 print_generic_decl (file, var, flags);
7636 if (flags & TDF_VERBOSE)
7637 print_node (file, "", var, 4);
7638 fprintf (file, "\n");
7640 any_var = true;
7643 tree name;
7645 if (gimple_in_ssa_p (cfun))
7646 FOR_EACH_SSA_NAME (ix, name, cfun)
7648 if (!SSA_NAME_VAR (name))
7650 fprintf (file, " ");
7651 print_generic_expr (file, TREE_TYPE (name), flags);
7652 fprintf (file, " ");
7653 print_generic_expr (file, name, flags);
7654 fprintf (file, ";\n");
7656 any_var = true;
7661 if (fun && fun->decl == fndecl
7662 && fun->cfg
7663 && basic_block_info_for_fn (fun))
7665 /* If the CFG has been built, emit a CFG-based dump. */
7666 if (!ignore_topmost_bind)
7667 fprintf (file, "{\n");
7669 if (any_var && n_basic_blocks_for_fn (fun))
7670 fprintf (file, "\n");
7672 FOR_EACH_BB_FN (bb, fun)
7673 dump_bb (file, bb, 2, flags | TDF_COMMENT);
7675 fprintf (file, "}\n");
7677 else if (fun->curr_properties & PROP_gimple_any)
7679 /* The function is now in GIMPLE form but the CFG has not been
7680 built yet. Emit the single sequence of GIMPLE statements
7681 that make up its body. */
7682 gimple_seq body = gimple_body (fndecl);
7684 if (gimple_seq_first_stmt (body)
7685 && gimple_seq_first_stmt (body) == gimple_seq_last_stmt (body)
7686 && gimple_code (gimple_seq_first_stmt (body)) == GIMPLE_BIND)
7687 print_gimple_seq (file, body, 0, flags);
7688 else
7690 if (!ignore_topmost_bind)
7691 fprintf (file, "{\n");
7693 if (any_var)
7694 fprintf (file, "\n");
7696 print_gimple_seq (file, body, 2, flags);
7697 fprintf (file, "}\n");
7700 else
7702 int indent;
7704 /* Make a tree based dump. */
7705 chain = DECL_SAVED_TREE (fndecl);
7706 if (chain && TREE_CODE (chain) == BIND_EXPR)
7708 if (ignore_topmost_bind)
7710 chain = BIND_EXPR_BODY (chain);
7711 indent = 2;
7713 else
7714 indent = 0;
7716 else
7718 if (!ignore_topmost_bind)
7720 fprintf (file, "{\n");
7721 /* No topmost bind, pretend it's ignored for later. */
7722 ignore_topmost_bind = true;
7724 indent = 2;
7727 if (any_var)
7728 fprintf (file, "\n");
7730 print_generic_stmt_indented (file, chain, flags, indent);
7731 if (ignore_topmost_bind)
7732 fprintf (file, "}\n");
7735 if (flags & TDF_ENUMERATE_LOCALS)
7736 dump_enumerated_decls (file, flags);
7737 fprintf (file, "\n\n");
7739 current_function_decl = old_current_fndecl;
7742 /* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h) */
7744 DEBUG_FUNCTION void
7745 debug_function (tree fn, int flags)
7747 dump_function_to_file (fn, stderr, flags);
7751 /* Print on FILE the indexes for the predecessors of basic_block BB. */
7753 static void
7754 print_pred_bbs (FILE *file, basic_block bb)
7756 edge e;
7757 edge_iterator ei;
7759 FOR_EACH_EDGE (e, ei, bb->preds)
7760 fprintf (file, "bb_%d ", e->src->index);
7764 /* Print on FILE the indexes for the successors of basic_block BB. */
7766 static void
7767 print_succ_bbs (FILE *file, basic_block bb)
7769 edge e;
7770 edge_iterator ei;
7772 FOR_EACH_EDGE (e, ei, bb->succs)
7773 fprintf (file, "bb_%d ", e->dest->index);
7776 /* Print to FILE the basic block BB following the VERBOSITY level. */
7778 void
7779 print_loops_bb (FILE *file, basic_block bb, int indent, int verbosity)
7781 char *s_indent = (char *) alloca ((size_t) indent + 1);
7782 memset ((void *) s_indent, ' ', (size_t) indent);
7783 s_indent[indent] = '\0';
7785 /* Print basic_block's header. */
7786 if (verbosity >= 2)
7788 fprintf (file, "%s bb_%d (preds = {", s_indent, bb->index);
7789 print_pred_bbs (file, bb);
7790 fprintf (file, "}, succs = {");
7791 print_succ_bbs (file, bb);
7792 fprintf (file, "})\n");
7795 /* Print basic_block's body. */
7796 if (verbosity >= 3)
7798 fprintf (file, "%s {\n", s_indent);
7799 dump_bb (file, bb, indent + 4, TDF_VOPS|TDF_MEMSYMS);
7800 fprintf (file, "%s }\n", s_indent);
7804 static void print_loop_and_siblings (FILE *, struct loop *, int, int);
7806 /* Pretty print LOOP on FILE, indented INDENT spaces. Following
7807 VERBOSITY level this outputs the contents of the loop, or just its
7808 structure. */
7810 static void
7811 print_loop (FILE *file, struct loop *loop, int indent, int verbosity)
7813 char *s_indent;
7814 basic_block bb;
7816 if (loop == NULL)
7817 return;
7819 s_indent = (char *) alloca ((size_t) indent + 1);
7820 memset ((void *) s_indent, ' ', (size_t) indent);
7821 s_indent[indent] = '\0';
7823 /* Print loop's header. */
7824 fprintf (file, "%sloop_%d (", s_indent, loop->num);
7825 if (loop->header)
7826 fprintf (file, "header = %d", loop->header->index);
7827 else
7829 fprintf (file, "deleted)\n");
7830 return;
7832 if (loop->latch)
7833 fprintf (file, ", latch = %d", loop->latch->index);
7834 else
7835 fprintf (file, ", multiple latches");
7836 fprintf (file, ", niter = ");
7837 print_generic_expr (file, loop->nb_iterations, 0);
7839 if (loop->any_upper_bound)
7841 fprintf (file, ", upper_bound = ");
7842 print_decu (loop->nb_iterations_upper_bound, file);
7844 if (loop->any_likely_upper_bound)
7846 fprintf (file, ", likely_upper_bound = ");
7847 print_decu (loop->nb_iterations_likely_upper_bound, file);
7850 if (loop->any_estimate)
7852 fprintf (file, ", estimate = ");
7853 print_decu (loop->nb_iterations_estimate, file);
7855 fprintf (file, ")\n");
7857 /* Print loop's body. */
7858 if (verbosity >= 1)
7860 fprintf (file, "%s{\n", s_indent);
7861 FOR_EACH_BB_FN (bb, cfun)
7862 if (bb->loop_father == loop)
7863 print_loops_bb (file, bb, indent, verbosity);
7865 print_loop_and_siblings (file, loop->inner, indent + 2, verbosity);
7866 fprintf (file, "%s}\n", s_indent);
7870 /* Print the LOOP and its sibling loops on FILE, indented INDENT
7871 spaces. Following VERBOSITY level this outputs the contents of the
7872 loop, or just its structure. */
7874 static void
7875 print_loop_and_siblings (FILE *file, struct loop *loop, int indent,
7876 int verbosity)
7878 if (loop == NULL)
7879 return;
7881 print_loop (file, loop, indent, verbosity);
7882 print_loop_and_siblings (file, loop->next, indent, verbosity);
7885 /* Follow a CFG edge from the entry point of the program, and on entry
7886 of a loop, pretty print the loop structure on FILE. */
7888 void
7889 print_loops (FILE *file, int verbosity)
7891 basic_block bb;
7893 bb = ENTRY_BLOCK_PTR_FOR_FN (cfun);
7894 fprintf (file, "\nLoops in function: %s\n", current_function_name ());
7895 if (bb && bb->loop_father)
7896 print_loop_and_siblings (file, bb->loop_father, 0, verbosity);
7899 /* Dump a loop. */
7901 DEBUG_FUNCTION void
7902 debug (struct loop &ref)
7904 print_loop (stderr, &ref, 0, /*verbosity*/0);
7907 DEBUG_FUNCTION void
7908 debug (struct loop *ptr)
7910 if (ptr)
7911 debug (*ptr);
7912 else
7913 fprintf (stderr, "<nil>\n");
7916 /* Dump a loop verbosely. */
7918 DEBUG_FUNCTION void
7919 debug_verbose (struct loop &ref)
7921 print_loop (stderr, &ref, 0, /*verbosity*/3);
7924 DEBUG_FUNCTION void
7925 debug_verbose (struct loop *ptr)
7927 if (ptr)
7928 debug (*ptr);
7929 else
7930 fprintf (stderr, "<nil>\n");
7934 /* Debugging loops structure at tree level, at some VERBOSITY level. */
7936 DEBUG_FUNCTION void
7937 debug_loops (int verbosity)
7939 print_loops (stderr, verbosity);
7942 /* Print on stderr the code of LOOP, at some VERBOSITY level. */
7944 DEBUG_FUNCTION void
7945 debug_loop (struct loop *loop, int verbosity)
7947 print_loop (stderr, loop, 0, verbosity);
7950 /* Print on stderr the code of loop number NUM, at some VERBOSITY
7951 level. */
7953 DEBUG_FUNCTION void
7954 debug_loop_num (unsigned num, int verbosity)
7956 debug_loop (get_loop (cfun, num), verbosity);
7959 /* Return true if BB ends with a call, possibly followed by some
7960 instructions that must stay with the call. Return false,
7961 otherwise. */
7963 static bool
7964 gimple_block_ends_with_call_p (basic_block bb)
7966 gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
7967 return !gsi_end_p (gsi) && is_gimple_call (gsi_stmt (gsi));
7971 /* Return true if BB ends with a conditional branch. Return false,
7972 otherwise. */
7974 static bool
7975 gimple_block_ends_with_condjump_p (const_basic_block bb)
7977 gimple *stmt = last_stmt (CONST_CAST_BB (bb));
7978 return (stmt && gimple_code (stmt) == GIMPLE_COND);
7982 /* Return true if statement T may terminate execution of BB in ways not
7983 explicitly represtented in the CFG. */
7985 bool
7986 stmt_can_terminate_bb_p (gimple *t)
7988 tree fndecl = NULL_TREE;
7989 int call_flags = 0;
7991 /* Eh exception not handled internally terminates execution of the whole
7992 function. */
7993 if (stmt_can_throw_external (t))
7994 return true;
7996 /* NORETURN and LONGJMP calls already have an edge to exit.
7997 CONST and PURE calls do not need one.
7998 We don't currently check for CONST and PURE here, although
7999 it would be a good idea, because those attributes are
8000 figured out from the RTL in mark_constant_function, and
8001 the counter incrementation code from -fprofile-arcs
8002 leads to different results from -fbranch-probabilities. */
8003 if (is_gimple_call (t))
8005 fndecl = gimple_call_fndecl (t);
8006 call_flags = gimple_call_flags (t);
8009 if (is_gimple_call (t)
8010 && fndecl
8011 && DECL_BUILT_IN (fndecl)
8012 && (call_flags & ECF_NOTHROW)
8013 && !(call_flags & ECF_RETURNS_TWICE)
8014 /* fork() doesn't really return twice, but the effect of
8015 wrapping it in __gcov_fork() which calls __gcov_flush()
8016 and clears the counters before forking has the same
8017 effect as returning twice. Force a fake edge. */
8018 && !(DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
8019 && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_FORK))
8020 return false;
8022 if (is_gimple_call (t))
8024 edge_iterator ei;
8025 edge e;
8026 basic_block bb;
8028 if (call_flags & (ECF_PURE | ECF_CONST)
8029 && !(call_flags & ECF_LOOPING_CONST_OR_PURE))
8030 return false;
8032 /* Function call may do longjmp, terminate program or do other things.
8033 Special case noreturn that have non-abnormal edges out as in this case
8034 the fact is sufficiently represented by lack of edges out of T. */
8035 if (!(call_flags & ECF_NORETURN))
8036 return true;
8038 bb = gimple_bb (t);
8039 FOR_EACH_EDGE (e, ei, bb->succs)
8040 if ((e->flags & EDGE_FAKE) == 0)
8041 return true;
8044 if (gasm *asm_stmt = dyn_cast <gasm *> (t))
8045 if (gimple_asm_volatile_p (asm_stmt) || gimple_asm_input_p (asm_stmt))
8046 return true;
8048 return false;
8052 /* Add fake edges to the function exit for any non constant and non
8053 noreturn calls (or noreturn calls with EH/abnormal edges),
8054 volatile inline assembly in the bitmap of blocks specified by BLOCKS
8055 or to the whole CFG if BLOCKS is zero. Return the number of blocks
8056 that were split.
8058 The goal is to expose cases in which entering a basic block does
8059 not imply that all subsequent instructions must be executed. */
8061 static int
8062 gimple_flow_call_edges_add (sbitmap blocks)
8064 int i;
8065 int blocks_split = 0;
8066 int last_bb = last_basic_block_for_fn (cfun);
8067 bool check_last_block = false;
8069 if (n_basic_blocks_for_fn (cfun) == NUM_FIXED_BLOCKS)
8070 return 0;
8072 if (! blocks)
8073 check_last_block = true;
8074 else
8075 check_last_block = bitmap_bit_p (blocks,
8076 EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb->index);
8078 /* In the last basic block, before epilogue generation, there will be
8079 a fallthru edge to EXIT. Special care is required if the last insn
8080 of the last basic block is a call because make_edge folds duplicate
8081 edges, which would result in the fallthru edge also being marked
8082 fake, which would result in the fallthru edge being removed by
8083 remove_fake_edges, which would result in an invalid CFG.
8085 Moreover, we can't elide the outgoing fake edge, since the block
8086 profiler needs to take this into account in order to solve the minimal
8087 spanning tree in the case that the call doesn't return.
8089 Handle this by adding a dummy instruction in a new last basic block. */
8090 if (check_last_block)
8092 basic_block bb = EXIT_BLOCK_PTR_FOR_FN (cfun)->prev_bb;
8093 gimple_stmt_iterator gsi = gsi_last_nondebug_bb (bb);
8094 gimple *t = NULL;
8096 if (!gsi_end_p (gsi))
8097 t = gsi_stmt (gsi);
8099 if (t && stmt_can_terminate_bb_p (t))
8101 edge e;
8103 e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun));
8104 if (e)
8106 gsi_insert_on_edge (e, gimple_build_nop ());
8107 gsi_commit_edge_inserts ();
8112 /* Now add fake edges to the function exit for any non constant
8113 calls since there is no way that we can determine if they will
8114 return or not... */
8115 for (i = 0; i < last_bb; i++)
8117 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
8118 gimple_stmt_iterator gsi;
8119 gimple *stmt, *last_stmt;
8121 if (!bb)
8122 continue;
8124 if (blocks && !bitmap_bit_p (blocks, i))
8125 continue;
8127 gsi = gsi_last_nondebug_bb (bb);
8128 if (!gsi_end_p (gsi))
8130 last_stmt = gsi_stmt (gsi);
8133 stmt = gsi_stmt (gsi);
8134 if (stmt_can_terminate_bb_p (stmt))
8136 edge e;
8138 /* The handling above of the final block before the
8139 epilogue should be enough to verify that there is
8140 no edge to the exit block in CFG already.
8141 Calling make_edge in such case would cause us to
8142 mark that edge as fake and remove it later. */
8143 if (flag_checking && stmt == last_stmt)
8145 e = find_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun));
8146 gcc_assert (e == NULL);
8149 /* Note that the following may create a new basic block
8150 and renumber the existing basic blocks. */
8151 if (stmt != last_stmt)
8153 e = split_block (bb, stmt);
8154 if (e)
8155 blocks_split++;
8157 make_edge (bb, EXIT_BLOCK_PTR_FOR_FN (cfun), EDGE_FAKE);
8159 gsi_prev (&gsi);
8161 while (!gsi_end_p (gsi));
8165 if (blocks_split)
8166 verify_flow_info ();
8168 return blocks_split;
8171 /* Removes edge E and all the blocks dominated by it, and updates dominance
8172 information. The IL in E->src needs to be updated separately.
8173 If dominance info is not available, only the edge E is removed.*/
8175 void
8176 remove_edge_and_dominated_blocks (edge e)
8178 vec<basic_block> bbs_to_remove = vNULL;
8179 vec<basic_block> bbs_to_fix_dom = vNULL;
8180 bitmap df, df_idom;
8181 edge f;
8182 edge_iterator ei;
8183 bool none_removed = false;
8184 unsigned i;
8185 basic_block bb, dbb;
8186 bitmap_iterator bi;
8188 /* If we are removing a path inside a non-root loop that may change
8189 loop ownership of blocks or remove loops. Mark loops for fixup. */
8190 if (current_loops
8191 && loop_outer (e->src->loop_father) != NULL
8192 && e->src->loop_father == e->dest->loop_father)
8193 loops_state_set (LOOPS_NEED_FIXUP);
8195 if (!dom_info_available_p (CDI_DOMINATORS))
8197 remove_edge (e);
8198 return;
8201 /* No updating is needed for edges to exit. */
8202 if (e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
8204 if (cfgcleanup_altered_bbs)
8205 bitmap_set_bit (cfgcleanup_altered_bbs, e->src->index);
8206 remove_edge (e);
8207 return;
8210 /* First, we find the basic blocks to remove. If E->dest has a predecessor
8211 that is not dominated by E->dest, then this set is empty. Otherwise,
8212 all the basic blocks dominated by E->dest are removed.
8214 Also, to DF_IDOM we store the immediate dominators of the blocks in
8215 the dominance frontier of E (i.e., of the successors of the
8216 removed blocks, if there are any, and of E->dest otherwise). */
8217 FOR_EACH_EDGE (f, ei, e->dest->preds)
8219 if (f == e)
8220 continue;
8222 if (!dominated_by_p (CDI_DOMINATORS, f->src, e->dest))
8224 none_removed = true;
8225 break;
8229 df = BITMAP_ALLOC (NULL);
8230 df_idom = BITMAP_ALLOC (NULL);
8232 if (none_removed)
8233 bitmap_set_bit (df_idom,
8234 get_immediate_dominator (CDI_DOMINATORS, e->dest)->index);
8235 else
8237 bbs_to_remove = get_all_dominated_blocks (CDI_DOMINATORS, e->dest);
8238 FOR_EACH_VEC_ELT (bbs_to_remove, i, bb)
8240 FOR_EACH_EDGE (f, ei, bb->succs)
8242 if (f->dest != EXIT_BLOCK_PTR_FOR_FN (cfun))
8243 bitmap_set_bit (df, f->dest->index);
8246 FOR_EACH_VEC_ELT (bbs_to_remove, i, bb)
8247 bitmap_clear_bit (df, bb->index);
8249 EXECUTE_IF_SET_IN_BITMAP (df, 0, i, bi)
8251 bb = BASIC_BLOCK_FOR_FN (cfun, i);
8252 bitmap_set_bit (df_idom,
8253 get_immediate_dominator (CDI_DOMINATORS, bb)->index);
8257 if (cfgcleanup_altered_bbs)
8259 /* Record the set of the altered basic blocks. */
8260 bitmap_set_bit (cfgcleanup_altered_bbs, e->src->index);
8261 bitmap_ior_into (cfgcleanup_altered_bbs, df);
8264 /* Remove E and the cancelled blocks. */
8265 if (none_removed)
8266 remove_edge (e);
8267 else
8269 /* Walk backwards so as to get a chance to substitute all
8270 released DEFs into debug stmts. See
8271 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
8272 details. */
8273 for (i = bbs_to_remove.length (); i-- > 0; )
8274 delete_basic_block (bbs_to_remove[i]);
8277 /* Update the dominance information. The immediate dominator may change only
8278 for blocks whose immediate dominator belongs to DF_IDOM:
8280 Suppose that idom(X) = Y before removal of E and idom(X) != Y after the
8281 removal. Let Z the arbitrary block such that idom(Z) = Y and
8282 Z dominates X after the removal. Before removal, there exists a path P
8283 from Y to X that avoids Z. Let F be the last edge on P that is
8284 removed, and let W = F->dest. Before removal, idom(W) = Y (since Y
8285 dominates W, and because of P, Z does not dominate W), and W belongs to
8286 the dominance frontier of E. Therefore, Y belongs to DF_IDOM. */
8287 EXECUTE_IF_SET_IN_BITMAP (df_idom, 0, i, bi)
8289 bb = BASIC_BLOCK_FOR_FN (cfun, i);
8290 for (dbb = first_dom_son (CDI_DOMINATORS, bb);
8291 dbb;
8292 dbb = next_dom_son (CDI_DOMINATORS, dbb))
8293 bbs_to_fix_dom.safe_push (dbb);
8296 iterate_fix_dominators (CDI_DOMINATORS, bbs_to_fix_dom, true);
8298 BITMAP_FREE (df);
8299 BITMAP_FREE (df_idom);
8300 bbs_to_remove.release ();
8301 bbs_to_fix_dom.release ();
8304 /* Purge dead EH edges from basic block BB. */
8306 bool
8307 gimple_purge_dead_eh_edges (basic_block bb)
8309 bool changed = false;
8310 edge e;
8311 edge_iterator ei;
8312 gimple *stmt = last_stmt (bb);
8314 if (stmt && stmt_can_throw_internal (stmt))
8315 return false;
8317 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
8319 if (e->flags & EDGE_EH)
8321 remove_edge_and_dominated_blocks (e);
8322 changed = true;
8324 else
8325 ei_next (&ei);
8328 return changed;
8331 /* Purge dead EH edges from basic block listed in BLOCKS. */
8333 bool
8334 gimple_purge_all_dead_eh_edges (const_bitmap blocks)
8336 bool changed = false;
8337 unsigned i;
8338 bitmap_iterator bi;
8340 EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
8342 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
8344 /* Earlier gimple_purge_dead_eh_edges could have removed
8345 this basic block already. */
8346 gcc_assert (bb || changed);
8347 if (bb != NULL)
8348 changed |= gimple_purge_dead_eh_edges (bb);
8351 return changed;
8354 /* Purge dead abnormal call edges from basic block BB. */
8356 bool
8357 gimple_purge_dead_abnormal_call_edges (basic_block bb)
8359 bool changed = false;
8360 edge e;
8361 edge_iterator ei;
8362 gimple *stmt = last_stmt (bb);
8364 if (!cfun->has_nonlocal_label
8365 && !cfun->calls_setjmp)
8366 return false;
8368 if (stmt && stmt_can_make_abnormal_goto (stmt))
8369 return false;
8371 for (ei = ei_start (bb->succs); (e = ei_safe_edge (ei)); )
8373 if (e->flags & EDGE_ABNORMAL)
8375 if (e->flags & EDGE_FALLTHRU)
8376 e->flags &= ~EDGE_ABNORMAL;
8377 else
8378 remove_edge_and_dominated_blocks (e);
8379 changed = true;
8381 else
8382 ei_next (&ei);
8385 return changed;
8388 /* Purge dead abnormal call edges from basic block listed in BLOCKS. */
8390 bool
8391 gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks)
8393 bool changed = false;
8394 unsigned i;
8395 bitmap_iterator bi;
8397 EXECUTE_IF_SET_IN_BITMAP (blocks, 0, i, bi)
8399 basic_block bb = BASIC_BLOCK_FOR_FN (cfun, i);
8401 /* Earlier gimple_purge_dead_abnormal_call_edges could have removed
8402 this basic block already. */
8403 gcc_assert (bb || changed);
8404 if (bb != NULL)
8405 changed |= gimple_purge_dead_abnormal_call_edges (bb);
8408 return changed;
8411 /* This function is called whenever a new edge is created or
8412 redirected. */
8414 static void
8415 gimple_execute_on_growing_pred (edge e)
8417 basic_block bb = e->dest;
8419 if (!gimple_seq_empty_p (phi_nodes (bb)))
8420 reserve_phi_args_for_new_edge (bb);
8423 /* This function is called immediately before edge E is removed from
8424 the edge vector E->dest->preds. */
8426 static void
8427 gimple_execute_on_shrinking_pred (edge e)
8429 if (!gimple_seq_empty_p (phi_nodes (e->dest)))
8430 remove_phi_args (e);
8433 /*---------------------------------------------------------------------------
8434 Helper functions for Loop versioning
8435 ---------------------------------------------------------------------------*/
8437 /* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy
8438 of 'first'. Both of them are dominated by 'new_head' basic block. When
8439 'new_head' was created by 'second's incoming edge it received phi arguments
8440 on the edge by split_edge(). Later, additional edge 'e' was created to
8441 connect 'new_head' and 'first'. Now this routine adds phi args on this
8442 additional edge 'e' that new_head to second edge received as part of edge
8443 splitting. */
8445 static void
8446 gimple_lv_adjust_loop_header_phi (basic_block first, basic_block second,
8447 basic_block new_head, edge e)
8449 gphi *phi1, *phi2;
8450 gphi_iterator psi1, psi2;
8451 tree def;
8452 edge e2 = find_edge (new_head, second);
8454 /* Because NEW_HEAD has been created by splitting SECOND's incoming
8455 edge, we should always have an edge from NEW_HEAD to SECOND. */
8456 gcc_assert (e2 != NULL);
8458 /* Browse all 'second' basic block phi nodes and add phi args to
8459 edge 'e' for 'first' head. PHI args are always in correct order. */
8461 for (psi2 = gsi_start_phis (second),
8462 psi1 = gsi_start_phis (first);
8463 !gsi_end_p (psi2) && !gsi_end_p (psi1);
8464 gsi_next (&psi2), gsi_next (&psi1))
8466 phi1 = psi1.phi ();
8467 phi2 = psi2.phi ();
8468 def = PHI_ARG_DEF (phi2, e2->dest_idx);
8469 add_phi_arg (phi1, def, e, gimple_phi_arg_location_from_edge (phi2, e2));
8474 /* Adds a if else statement to COND_BB with condition COND_EXPR.
8475 SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
8476 the destination of the ELSE part. */
8478 static void
8479 gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED,
8480 basic_block second_head ATTRIBUTE_UNUSED,
8481 basic_block cond_bb, void *cond_e)
8483 gimple_stmt_iterator gsi;
8484 gimple *new_cond_expr;
8485 tree cond_expr = (tree) cond_e;
8486 edge e0;
8488 /* Build new conditional expr */
8489 new_cond_expr = gimple_build_cond_from_tree (cond_expr,
8490 NULL_TREE, NULL_TREE);
8492 /* Add new cond in cond_bb. */
8493 gsi = gsi_last_bb (cond_bb);
8494 gsi_insert_after (&gsi, new_cond_expr, GSI_NEW_STMT);
8496 /* Adjust edges appropriately to connect new head with first head
8497 as well as second head. */
8498 e0 = single_succ_edge (cond_bb);
8499 e0->flags &= ~EDGE_FALLTHRU;
8500 e0->flags |= EDGE_FALSE_VALUE;
8504 /* Do book-keeping of basic block BB for the profile consistency checker.
8505 If AFTER_PASS is 0, do pre-pass accounting, or if AFTER_PASS is 1
8506 then do post-pass accounting. Store the counting in RECORD. */
8507 static void
8508 gimple_account_profile_record (basic_block bb, int after_pass,
8509 struct profile_record *record)
8511 gimple_stmt_iterator i;
8512 for (i = gsi_start_bb (bb); !gsi_end_p (i); gsi_next (&i))
8514 record->size[after_pass]
8515 += estimate_num_insns (gsi_stmt (i), &eni_size_weights);
8516 if (profile_status_for_fn (cfun) == PROFILE_READ)
8517 record->time[after_pass]
8518 += estimate_num_insns (gsi_stmt (i),
8519 &eni_time_weights) * bb->count;
8520 else if (profile_status_for_fn (cfun) == PROFILE_GUESSED)
8521 record->time[after_pass]
8522 += estimate_num_insns (gsi_stmt (i),
8523 &eni_time_weights) * bb->frequency;
8527 struct cfg_hooks gimple_cfg_hooks = {
8528 "gimple",
8529 gimple_verify_flow_info,
8530 gimple_dump_bb, /* dump_bb */
8531 gimple_dump_bb_for_graph, /* dump_bb_for_graph */
8532 create_bb, /* create_basic_block */
8533 gimple_redirect_edge_and_branch, /* redirect_edge_and_branch */
8534 gimple_redirect_edge_and_branch_force, /* redirect_edge_and_branch_force */
8535 gimple_can_remove_branch_p, /* can_remove_branch_p */
8536 remove_bb, /* delete_basic_block */
8537 gimple_split_block, /* split_block */
8538 gimple_move_block_after, /* move_block_after */
8539 gimple_can_merge_blocks_p, /* can_merge_blocks_p */
8540 gimple_merge_blocks, /* merge_blocks */
8541 gimple_predict_edge, /* predict_edge */
8542 gimple_predicted_by_p, /* predicted_by_p */
8543 gimple_can_duplicate_bb_p, /* can_duplicate_block_p */
8544 gimple_duplicate_bb, /* duplicate_block */
8545 gimple_split_edge, /* split_edge */
8546 gimple_make_forwarder_block, /* make_forward_block */
8547 NULL, /* tidy_fallthru_edge */
8548 NULL, /* force_nonfallthru */
8549 gimple_block_ends_with_call_p,/* block_ends_with_call_p */
8550 gimple_block_ends_with_condjump_p, /* block_ends_with_condjump_p */
8551 gimple_flow_call_edges_add, /* flow_call_edges_add */
8552 gimple_execute_on_growing_pred, /* execute_on_growing_pred */
8553 gimple_execute_on_shrinking_pred, /* execute_on_shrinking_pred */
8554 gimple_duplicate_loop_to_header_edge, /* duplicate loop for trees */
8555 gimple_lv_add_condition_to_bb, /* lv_add_condition_to_bb */
8556 gimple_lv_adjust_loop_header_phi, /* lv_adjust_loop_header_phi*/
8557 extract_true_false_edges_from_block, /* extract_cond_bb_edges */
8558 flush_pending_stmts, /* flush_pending_stmts */
8559 gimple_empty_block_p, /* block_empty_p */
8560 gimple_split_block_before_cond_jump, /* split_block_before_cond_jump */
8561 gimple_account_profile_record,
8565 /* Split all critical edges. */
8567 unsigned int
8568 split_critical_edges (void)
8570 basic_block bb;
8571 edge e;
8572 edge_iterator ei;
8574 /* split_edge can redirect edges out of SWITCH_EXPRs, which can get
8575 expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
8576 mappings around the calls to split_edge. */
8577 start_recording_case_labels ();
8578 FOR_ALL_BB_FN (bb, cfun)
8580 FOR_EACH_EDGE (e, ei, bb->succs)
8582 if (EDGE_CRITICAL_P (e) && !(e->flags & EDGE_ABNORMAL))
8583 split_edge (e);
8584 /* PRE inserts statements to edges and expects that
8585 since split_critical_edges was done beforehand, committing edge
8586 insertions will not split more edges. In addition to critical
8587 edges we must split edges that have multiple successors and
8588 end by control flow statements, such as RESX.
8589 Go ahead and split them too. This matches the logic in
8590 gimple_find_edge_insert_loc. */
8591 else if ((!single_pred_p (e->dest)
8592 || !gimple_seq_empty_p (phi_nodes (e->dest))
8593 || e->dest == EXIT_BLOCK_PTR_FOR_FN (cfun))
8594 && e->src != ENTRY_BLOCK_PTR_FOR_FN (cfun)
8595 && !(e->flags & EDGE_ABNORMAL))
8597 gimple_stmt_iterator gsi;
8599 gsi = gsi_last_bb (e->src);
8600 if (!gsi_end_p (gsi)
8601 && stmt_ends_bb_p (gsi_stmt (gsi))
8602 && (gimple_code (gsi_stmt (gsi)) != GIMPLE_RETURN
8603 && !gimple_call_builtin_p (gsi_stmt (gsi),
8604 BUILT_IN_RETURN)))
8605 split_edge (e);
8609 end_recording_case_labels ();
8610 return 0;
8613 namespace {
8615 const pass_data pass_data_split_crit_edges =
8617 GIMPLE_PASS, /* type */
8618 "crited", /* name */
8619 OPTGROUP_NONE, /* optinfo_flags */
8620 TV_TREE_SPLIT_EDGES, /* tv_id */
8621 PROP_cfg, /* properties_required */
8622 PROP_no_crit_edges, /* properties_provided */
8623 0, /* properties_destroyed */
8624 0, /* todo_flags_start */
8625 0, /* todo_flags_finish */
8628 class pass_split_crit_edges : public gimple_opt_pass
8630 public:
8631 pass_split_crit_edges (gcc::context *ctxt)
8632 : gimple_opt_pass (pass_data_split_crit_edges, ctxt)
8635 /* opt_pass methods: */
8636 virtual unsigned int execute (function *) { return split_critical_edges (); }
8638 opt_pass * clone () { return new pass_split_crit_edges (m_ctxt); }
8639 }; // class pass_split_crit_edges
8641 } // anon namespace
8643 gimple_opt_pass *
8644 make_pass_split_crit_edges (gcc::context *ctxt)
8646 return new pass_split_crit_edges (ctxt);
8650 /* Insert COND expression which is GIMPLE_COND after STMT
8651 in basic block BB with appropriate basic block split
8652 and creation of a new conditionally executed basic block.
8653 Return created basic block. */
8654 basic_block
8655 insert_cond_bb (basic_block bb, gimple *stmt, gimple *cond)
8657 edge fall = split_block (bb, stmt);
8658 gimple_stmt_iterator iter = gsi_last_bb (bb);
8659 basic_block new_bb;
8661 /* Insert cond statement. */
8662 gcc_assert (gimple_code (cond) == GIMPLE_COND);
8663 if (gsi_end_p (iter))
8664 gsi_insert_before (&iter, cond, GSI_CONTINUE_LINKING);
8665 else
8666 gsi_insert_after (&iter, cond, GSI_CONTINUE_LINKING);
8668 /* Create conditionally executed block. */
8669 new_bb = create_empty_bb (bb);
8670 make_edge (bb, new_bb, EDGE_TRUE_VALUE);
8671 make_single_succ_edge (new_bb, fall->dest, EDGE_FALLTHRU);
8673 /* Fix edge for split bb. */
8674 fall->flags = EDGE_FALSE_VALUE;
8676 /* Update dominance info. */
8677 if (dom_info_available_p (CDI_DOMINATORS))
8679 set_immediate_dominator (CDI_DOMINATORS, new_bb, bb);
8680 set_immediate_dominator (CDI_DOMINATORS, fall->dest, bb);
8683 /* Update loop info. */
8684 if (current_loops)
8685 add_bb_to_loop (new_bb, bb->loop_father);
8687 return new_bb;
8690 /* Build a ternary operation and gimplify it. Emit code before GSI.
8691 Return the gimple_val holding the result. */
8693 tree
8694 gimplify_build3 (gimple_stmt_iterator *gsi, enum tree_code code,
8695 tree type, tree a, tree b, tree c)
8697 tree ret;
8698 location_t loc = gimple_location (gsi_stmt (*gsi));
8700 ret = fold_build3_loc (loc, code, type, a, b, c);
8701 STRIP_NOPS (ret);
8703 return force_gimple_operand_gsi (gsi, ret, true, NULL, true,
8704 GSI_SAME_STMT);
8707 /* Build a binary operation and gimplify it. Emit code before GSI.
8708 Return the gimple_val holding the result. */
8710 tree
8711 gimplify_build2 (gimple_stmt_iterator *gsi, enum tree_code code,
8712 tree type, tree a, tree b)
8714 tree ret;
8716 ret = fold_build2_loc (gimple_location (gsi_stmt (*gsi)), code, type, a, b);
8717 STRIP_NOPS (ret);
8719 return force_gimple_operand_gsi (gsi, ret, true, NULL, true,
8720 GSI_SAME_STMT);
8723 /* Build a unary operation and gimplify it. Emit code before GSI.
8724 Return the gimple_val holding the result. */
8726 tree
8727 gimplify_build1 (gimple_stmt_iterator *gsi, enum tree_code code, tree type,
8728 tree a)
8730 tree ret;
8732 ret = fold_build1_loc (gimple_location (gsi_stmt (*gsi)), code, type, a);
8733 STRIP_NOPS (ret);
8735 return force_gimple_operand_gsi (gsi, ret, true, NULL, true,
8736 GSI_SAME_STMT);
8741 /* Given a basic block B which ends with a conditional and has
8742 precisely two successors, determine which of the edges is taken if
8743 the conditional is true and which is taken if the conditional is
8744 false. Set TRUE_EDGE and FALSE_EDGE appropriately. */
8746 void
8747 extract_true_false_edges_from_block (basic_block b,
8748 edge *true_edge,
8749 edge *false_edge)
8751 edge e = EDGE_SUCC (b, 0);
8753 if (e->flags & EDGE_TRUE_VALUE)
8755 *true_edge = e;
8756 *false_edge = EDGE_SUCC (b, 1);
8758 else
8760 *false_edge = e;
8761 *true_edge = EDGE_SUCC (b, 1);
8766 /* From a controlling predicate in the immediate dominator DOM of
8767 PHIBLOCK determine the edges into PHIBLOCK that are chosen if the
8768 predicate evaluates to true and false and store them to
8769 *TRUE_CONTROLLED_EDGE and *FALSE_CONTROLLED_EDGE if
8770 they are non-NULL. Returns true if the edges can be determined,
8771 else return false. */
8773 bool
8774 extract_true_false_controlled_edges (basic_block dom, basic_block phiblock,
8775 edge *true_controlled_edge,
8776 edge *false_controlled_edge)
8778 basic_block bb = phiblock;
8779 edge true_edge, false_edge, tem;
8780 edge e0 = NULL, e1 = NULL;
8782 /* We have to verify that one edge into the PHI node is dominated
8783 by the true edge of the predicate block and the other edge
8784 dominated by the false edge. This ensures that the PHI argument
8785 we are going to take is completely determined by the path we
8786 take from the predicate block.
8787 We can only use BB dominance checks below if the destination of
8788 the true/false edges are dominated by their edge, thus only
8789 have a single predecessor. */
8790 extract_true_false_edges_from_block (dom, &true_edge, &false_edge);
8791 tem = EDGE_PRED (bb, 0);
8792 if (tem == true_edge
8793 || (single_pred_p (true_edge->dest)
8794 && (tem->src == true_edge->dest
8795 || dominated_by_p (CDI_DOMINATORS,
8796 tem->src, true_edge->dest))))
8797 e0 = tem;
8798 else if (tem == false_edge
8799 || (single_pred_p (false_edge->dest)
8800 && (tem->src == false_edge->dest
8801 || dominated_by_p (CDI_DOMINATORS,
8802 tem->src, false_edge->dest))))
8803 e1 = tem;
8804 else
8805 return false;
8806 tem = EDGE_PRED (bb, 1);
8807 if (tem == true_edge
8808 || (single_pred_p (true_edge->dest)
8809 && (tem->src == true_edge->dest
8810 || dominated_by_p (CDI_DOMINATORS,
8811 tem->src, true_edge->dest))))
8812 e0 = tem;
8813 else if (tem == false_edge
8814 || (single_pred_p (false_edge->dest)
8815 && (tem->src == false_edge->dest
8816 || dominated_by_p (CDI_DOMINATORS,
8817 tem->src, false_edge->dest))))
8818 e1 = tem;
8819 else
8820 return false;
8821 if (!e0 || !e1)
8822 return false;
8824 if (true_controlled_edge)
8825 *true_controlled_edge = e0;
8826 if (false_controlled_edge)
8827 *false_controlled_edge = e1;
8829 return true;
8834 /* Emit return warnings. */
8836 namespace {
8838 const pass_data pass_data_warn_function_return =
8840 GIMPLE_PASS, /* type */
8841 "*warn_function_return", /* name */
8842 OPTGROUP_NONE, /* optinfo_flags */
8843 TV_NONE, /* tv_id */
8844 PROP_cfg, /* properties_required */
8845 0, /* properties_provided */
8846 0, /* properties_destroyed */
8847 0, /* todo_flags_start */
8848 0, /* todo_flags_finish */
8851 class pass_warn_function_return : public gimple_opt_pass
8853 public:
8854 pass_warn_function_return (gcc::context *ctxt)
8855 : gimple_opt_pass (pass_data_warn_function_return, ctxt)
8858 /* opt_pass methods: */
8859 virtual unsigned int execute (function *);
8861 }; // class pass_warn_function_return
8863 unsigned int
8864 pass_warn_function_return::execute (function *fun)
8866 source_location location;
8867 gimple *last;
8868 edge e;
8869 edge_iterator ei;
8871 if (!targetm.warn_func_return (fun->decl))
8872 return 0;
8874 /* If we have a path to EXIT, then we do return. */
8875 if (TREE_THIS_VOLATILE (fun->decl)
8876 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) > 0)
8878 location = UNKNOWN_LOCATION;
8879 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (fun)->preds)
8881 last = last_stmt (e->src);
8882 if ((gimple_code (last) == GIMPLE_RETURN
8883 || gimple_call_builtin_p (last, BUILT_IN_RETURN))
8884 && (location = gimple_location (last)) != UNKNOWN_LOCATION)
8885 break;
8887 if (location == UNKNOWN_LOCATION)
8888 location = cfun->function_end_locus;
8889 warning_at (location, 0, "%<noreturn%> function does return");
8892 /* If we see "return;" in some basic block, then we do reach the end
8893 without returning a value. */
8894 else if (warn_return_type
8895 && !TREE_NO_WARNING (fun->decl)
8896 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun)->preds) > 0
8897 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fun->decl))))
8899 FOR_EACH_EDGE (e, ei, EXIT_BLOCK_PTR_FOR_FN (fun)->preds)
8901 gimple *last = last_stmt (e->src);
8902 greturn *return_stmt = dyn_cast <greturn *> (last);
8903 if (return_stmt
8904 && gimple_return_retval (return_stmt) == NULL
8905 && !gimple_no_warning_p (last))
8907 location = gimple_location (last);
8908 if (location == UNKNOWN_LOCATION)
8909 location = fun->function_end_locus;
8910 warning_at (location, OPT_Wreturn_type, "control reaches end of non-void function");
8911 TREE_NO_WARNING (fun->decl) = 1;
8912 break;
8916 return 0;
8919 } // anon namespace
8921 gimple_opt_pass *
8922 make_pass_warn_function_return (gcc::context *ctxt)
8924 return new pass_warn_function_return (ctxt);
8927 /* Walk a gimplified function and warn for functions whose return value is
8928 ignored and attribute((warn_unused_result)) is set. This is done before
8929 inlining, so we don't have to worry about that. */
8931 static void
8932 do_warn_unused_result (gimple_seq seq)
8934 tree fdecl, ftype;
8935 gimple_stmt_iterator i;
8937 for (i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
8939 gimple *g = gsi_stmt (i);
8941 switch (gimple_code (g))
8943 case GIMPLE_BIND:
8944 do_warn_unused_result (gimple_bind_body (as_a <gbind *>(g)));
8945 break;
8946 case GIMPLE_TRY:
8947 do_warn_unused_result (gimple_try_eval (g));
8948 do_warn_unused_result (gimple_try_cleanup (g));
8949 break;
8950 case GIMPLE_CATCH:
8951 do_warn_unused_result (gimple_catch_handler (
8952 as_a <gcatch *> (g)));
8953 break;
8954 case GIMPLE_EH_FILTER:
8955 do_warn_unused_result (gimple_eh_filter_failure (g));
8956 break;
8958 case GIMPLE_CALL:
8959 if (gimple_call_lhs (g))
8960 break;
8961 if (gimple_call_internal_p (g))
8962 break;
8964 /* This is a naked call, as opposed to a GIMPLE_CALL with an
8965 LHS. All calls whose value is ignored should be
8966 represented like this. Look for the attribute. */
8967 fdecl = gimple_call_fndecl (g);
8968 ftype = gimple_call_fntype (g);
8970 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
8972 location_t loc = gimple_location (g);
8974 if (fdecl)
8975 warning_at (loc, OPT_Wunused_result,
8976 "ignoring return value of %qD, "
8977 "declared with attribute warn_unused_result",
8978 fdecl);
8979 else
8980 warning_at (loc, OPT_Wunused_result,
8981 "ignoring return value of function "
8982 "declared with attribute warn_unused_result");
8984 break;
8986 default:
8987 /* Not a container, not a call, or a call whose value is used. */
8988 break;
8993 namespace {
8995 const pass_data pass_data_warn_unused_result =
8997 GIMPLE_PASS, /* type */
8998 "*warn_unused_result", /* name */
8999 OPTGROUP_NONE, /* optinfo_flags */
9000 TV_NONE, /* tv_id */
9001 PROP_gimple_any, /* properties_required */
9002 0, /* properties_provided */
9003 0, /* properties_destroyed */
9004 0, /* todo_flags_start */
9005 0, /* todo_flags_finish */
9008 class pass_warn_unused_result : public gimple_opt_pass
9010 public:
9011 pass_warn_unused_result (gcc::context *ctxt)
9012 : gimple_opt_pass (pass_data_warn_unused_result, ctxt)
9015 /* opt_pass methods: */
9016 virtual bool gate (function *) { return flag_warn_unused_result; }
9017 virtual unsigned int execute (function *)
9019 do_warn_unused_result (gimple_body (current_function_decl));
9020 return 0;
9023 }; // class pass_warn_unused_result
9025 } // anon namespace
9027 gimple_opt_pass *
9028 make_pass_warn_unused_result (gcc::context *ctxt)
9030 return new pass_warn_unused_result (ctxt);
9033 /* IPA passes, compilation of earlier functions or inlining
9034 might have changed some properties, such as marked functions nothrow,
9035 pure, const or noreturn.
9036 Remove redundant edges and basic blocks, and create new ones if necessary.
9038 This pass can't be executed as stand alone pass from pass manager, because
9039 in between inlining and this fixup the verify_flow_info would fail. */
9041 unsigned int
9042 execute_fixup_cfg (void)
9044 basic_block bb;
9045 gimple_stmt_iterator gsi;
9046 int todo = 0;
9047 gcov_type count_scale;
9048 edge e;
9049 edge_iterator ei;
9050 cgraph_node *node = cgraph_node::get (current_function_decl);
9052 count_scale
9053 = GCOV_COMPUTE_SCALE (node->count, ENTRY_BLOCK_PTR_FOR_FN (cfun)->count);
9055 ENTRY_BLOCK_PTR_FOR_FN (cfun)->count = node->count;
9056 EXIT_BLOCK_PTR_FOR_FN (cfun)->count
9057 = apply_scale (EXIT_BLOCK_PTR_FOR_FN (cfun)->count, count_scale);
9059 FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR_FOR_FN (cfun)->succs)
9060 e->count = apply_scale (e->count, count_scale);
9062 FOR_EACH_BB_FN (bb, cfun)
9064 bb->count = apply_scale (bb->count, count_scale);
9065 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi);)
9067 gimple *stmt = gsi_stmt (gsi);
9068 tree decl = is_gimple_call (stmt)
9069 ? gimple_call_fndecl (stmt)
9070 : NULL;
9071 if (decl)
9073 int flags = gimple_call_flags (stmt);
9074 if (flags & (ECF_CONST | ECF_PURE | ECF_LOOPING_CONST_OR_PURE))
9076 if (gimple_purge_dead_abnormal_call_edges (bb))
9077 todo |= TODO_cleanup_cfg;
9079 if (gimple_in_ssa_p (cfun))
9081 todo |= TODO_update_ssa | TODO_cleanup_cfg;
9082 update_stmt (stmt);
9086 if (flags & ECF_NORETURN
9087 && fixup_noreturn_call (stmt))
9088 todo |= TODO_cleanup_cfg;
9091 /* Remove stores to variables we marked write-only.
9092 Keep access when store has side effect, i.e. in case when source
9093 is volatile. */
9094 if (gimple_store_p (stmt)
9095 && !gimple_has_side_effects (stmt))
9097 tree lhs = get_base_address (gimple_get_lhs (stmt));
9099 if (VAR_P (lhs)
9100 && (TREE_STATIC (lhs) || DECL_EXTERNAL (lhs))
9101 && varpool_node::get (lhs)->writeonly)
9103 unlink_stmt_vdef (stmt);
9104 gsi_remove (&gsi, true);
9105 release_defs (stmt);
9106 todo |= TODO_update_ssa | TODO_cleanup_cfg;
9107 continue;
9110 /* For calls we can simply remove LHS when it is known
9111 to be write-only. */
9112 if (is_gimple_call (stmt)
9113 && gimple_get_lhs (stmt))
9115 tree lhs = get_base_address (gimple_get_lhs (stmt));
9117 if (VAR_P (lhs)
9118 && (TREE_STATIC (lhs) || DECL_EXTERNAL (lhs))
9119 && varpool_node::get (lhs)->writeonly)
9121 gimple_call_set_lhs (stmt, NULL);
9122 update_stmt (stmt);
9123 todo |= TODO_update_ssa | TODO_cleanup_cfg;
9127 if (maybe_clean_eh_stmt (stmt)
9128 && gimple_purge_dead_eh_edges (bb))
9129 todo |= TODO_cleanup_cfg;
9130 gsi_next (&gsi);
9133 FOR_EACH_EDGE (e, ei, bb->succs)
9134 e->count = apply_scale (e->count, count_scale);
9136 /* If we have a basic block with no successors that does not
9137 end with a control statement or a noreturn call end it with
9138 a call to __builtin_unreachable. This situation can occur
9139 when inlining a noreturn call that does in fact return. */
9140 if (EDGE_COUNT (bb->succs) == 0)
9142 gimple *stmt = last_stmt (bb);
9143 if (!stmt
9144 || (!is_ctrl_stmt (stmt)
9145 && (!is_gimple_call (stmt)
9146 || !gimple_call_noreturn_p (stmt))))
9148 if (stmt && is_gimple_call (stmt))
9149 gimple_call_set_ctrl_altering (stmt, false);
9150 tree fndecl = builtin_decl_implicit (BUILT_IN_UNREACHABLE);
9151 stmt = gimple_build_call (fndecl, 0);
9152 gimple_stmt_iterator gsi = gsi_last_bb (bb);
9153 gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
9154 if (!cfun->after_inlining)
9156 gcall *call_stmt = dyn_cast <gcall *> (stmt);
9157 int freq
9158 = compute_call_stmt_bb_frequency (current_function_decl,
9159 bb);
9160 node->create_edge (cgraph_node::get_create (fndecl),
9161 call_stmt, bb->count, freq);
9166 if (count_scale != REG_BR_PROB_BASE)
9167 compute_function_frequency ();
9169 if (current_loops
9170 && (todo & TODO_cleanup_cfg))
9171 loops_state_set (LOOPS_NEED_FIXUP);
9173 return todo;
9176 namespace {
9178 const pass_data pass_data_fixup_cfg =
9180 GIMPLE_PASS, /* type */
9181 "fixup_cfg", /* name */
9182 OPTGROUP_NONE, /* optinfo_flags */
9183 TV_NONE, /* tv_id */
9184 PROP_cfg, /* properties_required */
9185 0, /* properties_provided */
9186 0, /* properties_destroyed */
9187 0, /* todo_flags_start */
9188 0, /* todo_flags_finish */
9191 class pass_fixup_cfg : public gimple_opt_pass
9193 public:
9194 pass_fixup_cfg (gcc::context *ctxt)
9195 : gimple_opt_pass (pass_data_fixup_cfg, ctxt)
9198 /* opt_pass methods: */
9199 opt_pass * clone () { return new pass_fixup_cfg (m_ctxt); }
9200 virtual unsigned int execute (function *) { return execute_fixup_cfg (); }
9202 }; // class pass_fixup_cfg
9204 } // anon namespace
9206 gimple_opt_pass *
9207 make_pass_fixup_cfg (gcc::context *ctxt)
9209 return new pass_fixup_cfg (ctxt);
9212 /* Garbage collection support for edge_def. */
9214 extern void gt_ggc_mx (tree&);
9215 extern void gt_ggc_mx (gimple *&);
9216 extern void gt_ggc_mx (rtx&);
9217 extern void gt_ggc_mx (basic_block&);
9219 static void
9220 gt_ggc_mx (rtx_insn *& x)
9222 if (x)
9223 gt_ggc_mx_rtx_def ((void *) x);
9226 void
9227 gt_ggc_mx (edge_def *e)
9229 tree block = LOCATION_BLOCK (e->goto_locus);
9230 gt_ggc_mx (e->src);
9231 gt_ggc_mx (e->dest);
9232 if (current_ir_type () == IR_GIMPLE)
9233 gt_ggc_mx (e->insns.g);
9234 else
9235 gt_ggc_mx (e->insns.r);
9236 gt_ggc_mx (block);
9239 /* PCH support for edge_def. */
9241 extern void gt_pch_nx (tree&);
9242 extern void gt_pch_nx (gimple *&);
9243 extern void gt_pch_nx (rtx&);
9244 extern void gt_pch_nx (basic_block&);
9246 static void
9247 gt_pch_nx (rtx_insn *& x)
9249 if (x)
9250 gt_pch_nx_rtx_def ((void *) x);
9253 void
9254 gt_pch_nx (edge_def *e)
9256 tree block = LOCATION_BLOCK (e->goto_locus);
9257 gt_pch_nx (e->src);
9258 gt_pch_nx (e->dest);
9259 if (current_ir_type () == IR_GIMPLE)
9260 gt_pch_nx (e->insns.g);
9261 else
9262 gt_pch_nx (e->insns.r);
9263 gt_pch_nx (block);
9266 void
9267 gt_pch_nx (edge_def *e, gt_pointer_operator op, void *cookie)
9269 tree block = LOCATION_BLOCK (e->goto_locus);
9270 op (&(e->src), cookie);
9271 op (&(e->dest), cookie);
9272 if (current_ir_type () == IR_GIMPLE)
9273 op (&(e->insns.g), cookie);
9274 else
9275 op (&(e->insns.r), cookie);
9276 op (&(block), cookie);
9279 #if CHECKING_P
9281 namespace selftest {
9283 /* Helper function for CFG selftests: create a dummy function decl
9284 and push it as cfun. */
9286 static tree
9287 push_fndecl (const char *name)
9289 tree fn_type = build_function_type_array (integer_type_node, 0, NULL);
9290 /* FIXME: this uses input_location: */
9291 tree fndecl = build_fn_decl (name, fn_type);
9292 tree retval = build_decl (UNKNOWN_LOCATION, RESULT_DECL,
9293 NULL_TREE, integer_type_node);
9294 DECL_RESULT (fndecl) = retval;
9295 push_struct_function (fndecl);
9296 function *fun = DECL_STRUCT_FUNCTION (fndecl);
9297 ASSERT_TRUE (fun != NULL);
9298 init_empty_tree_cfg_for_function (fun);
9299 ASSERT_EQ (2, n_basic_blocks_for_fn (fun));
9300 ASSERT_EQ (0, n_edges_for_fn (fun));
9301 return fndecl;
9304 /* These tests directly create CFGs.
9305 Compare with the static fns within tree-cfg.c:
9306 - build_gimple_cfg
9307 - make_blocks: calls create_basic_block (seq, bb);
9308 - make_edges. */
9310 /* Verify a simple cfg of the form:
9311 ENTRY -> A -> B -> C -> EXIT. */
9313 static void
9314 test_linear_chain ()
9316 gimple_register_cfg_hooks ();
9318 tree fndecl = push_fndecl ("cfg_test_linear_chain");
9319 function *fun = DECL_STRUCT_FUNCTION (fndecl);
9321 /* Create some empty blocks. */
9322 basic_block bb_a = create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun));
9323 basic_block bb_b = create_empty_bb (bb_a);
9324 basic_block bb_c = create_empty_bb (bb_b);
9326 ASSERT_EQ (5, n_basic_blocks_for_fn (fun));
9327 ASSERT_EQ (0, n_edges_for_fn (fun));
9329 /* Create some edges: a simple linear chain of BBs. */
9330 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun), bb_a, EDGE_FALLTHRU);
9331 make_edge (bb_a, bb_b, 0);
9332 make_edge (bb_b, bb_c, 0);
9333 make_edge (bb_c, EXIT_BLOCK_PTR_FOR_FN (fun), 0);
9335 /* Verify the edges. */
9336 ASSERT_EQ (4, n_edges_for_fn (fun));
9337 ASSERT_EQ (NULL, ENTRY_BLOCK_PTR_FOR_FN (fun)->preds);
9338 ASSERT_EQ (1, ENTRY_BLOCK_PTR_FOR_FN (fun)->succs->length ());
9339 ASSERT_EQ (1, bb_a->preds->length ());
9340 ASSERT_EQ (1, bb_a->succs->length ());
9341 ASSERT_EQ (1, bb_b->preds->length ());
9342 ASSERT_EQ (1, bb_b->succs->length ());
9343 ASSERT_EQ (1, bb_c->preds->length ());
9344 ASSERT_EQ (1, bb_c->succs->length ());
9345 ASSERT_EQ (1, EXIT_BLOCK_PTR_FOR_FN (fun)->preds->length ());
9346 ASSERT_EQ (NULL, EXIT_BLOCK_PTR_FOR_FN (fun)->succs);
9348 /* Verify the dominance information
9349 Each BB in our simple chain should be dominated by the one before
9350 it. */
9351 calculate_dominance_info (CDI_DOMINATORS);
9352 ASSERT_EQ (bb_a, get_immediate_dominator (CDI_DOMINATORS, bb_b));
9353 ASSERT_EQ (bb_b, get_immediate_dominator (CDI_DOMINATORS, bb_c));
9354 vec<basic_block> dom_by_b = get_dominated_by (CDI_DOMINATORS, bb_b);
9355 ASSERT_EQ (1, dom_by_b.length ());
9356 ASSERT_EQ (bb_c, dom_by_b[0]);
9357 free_dominance_info (CDI_DOMINATORS);
9358 dom_by_b.release ();
9360 /* Similarly for post-dominance: each BB in our chain is post-dominated
9361 by the one after it. */
9362 calculate_dominance_info (CDI_POST_DOMINATORS);
9363 ASSERT_EQ (bb_b, get_immediate_dominator (CDI_POST_DOMINATORS, bb_a));
9364 ASSERT_EQ (bb_c, get_immediate_dominator (CDI_POST_DOMINATORS, bb_b));
9365 vec<basic_block> postdom_by_b = get_dominated_by (CDI_POST_DOMINATORS, bb_b);
9366 ASSERT_EQ (1, postdom_by_b.length ());
9367 ASSERT_EQ (bb_a, postdom_by_b[0]);
9368 free_dominance_info (CDI_POST_DOMINATORS);
9369 postdom_by_b.release ();
9371 pop_cfun ();
9374 /* Verify a simple CFG of the form:
9375 ENTRY
9379 /t \f
9385 EXIT. */
9387 static void
9388 test_diamond ()
9390 gimple_register_cfg_hooks ();
9392 tree fndecl = push_fndecl ("cfg_test_diamond");
9393 function *fun = DECL_STRUCT_FUNCTION (fndecl);
9395 /* Create some empty blocks. */
9396 basic_block bb_a = create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun));
9397 basic_block bb_b = create_empty_bb (bb_a);
9398 basic_block bb_c = create_empty_bb (bb_a);
9399 basic_block bb_d = create_empty_bb (bb_b);
9401 ASSERT_EQ (6, n_basic_blocks_for_fn (fun));
9402 ASSERT_EQ (0, n_edges_for_fn (fun));
9404 /* Create the edges. */
9405 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun), bb_a, EDGE_FALLTHRU);
9406 make_edge (bb_a, bb_b, EDGE_TRUE_VALUE);
9407 make_edge (bb_a, bb_c, EDGE_FALSE_VALUE);
9408 make_edge (bb_b, bb_d, 0);
9409 make_edge (bb_c, bb_d, 0);
9410 make_edge (bb_d, EXIT_BLOCK_PTR_FOR_FN (fun), 0);
9412 /* Verify the edges. */
9413 ASSERT_EQ (6, n_edges_for_fn (fun));
9414 ASSERT_EQ (1, bb_a->preds->length ());
9415 ASSERT_EQ (2, bb_a->succs->length ());
9416 ASSERT_EQ (1, bb_b->preds->length ());
9417 ASSERT_EQ (1, bb_b->succs->length ());
9418 ASSERT_EQ (1, bb_c->preds->length ());
9419 ASSERT_EQ (1, bb_c->succs->length ());
9420 ASSERT_EQ (2, bb_d->preds->length ());
9421 ASSERT_EQ (1, bb_d->succs->length ());
9423 /* Verify the dominance information. */
9424 calculate_dominance_info (CDI_DOMINATORS);
9425 ASSERT_EQ (bb_a, get_immediate_dominator (CDI_DOMINATORS, bb_b));
9426 ASSERT_EQ (bb_a, get_immediate_dominator (CDI_DOMINATORS, bb_c));
9427 ASSERT_EQ (bb_a, get_immediate_dominator (CDI_DOMINATORS, bb_d));
9428 vec<basic_block> dom_by_a = get_dominated_by (CDI_DOMINATORS, bb_a);
9429 ASSERT_EQ (3, dom_by_a.length ()); /* B, C, D, in some order. */
9430 dom_by_a.release ();
9431 vec<basic_block> dom_by_b = get_dominated_by (CDI_DOMINATORS, bb_b);
9432 ASSERT_EQ (0, dom_by_b.length ());
9433 dom_by_b.release ();
9434 free_dominance_info (CDI_DOMINATORS);
9436 /* Similarly for post-dominance. */
9437 calculate_dominance_info (CDI_POST_DOMINATORS);
9438 ASSERT_EQ (bb_d, get_immediate_dominator (CDI_POST_DOMINATORS, bb_a));
9439 ASSERT_EQ (bb_d, get_immediate_dominator (CDI_POST_DOMINATORS, bb_b));
9440 ASSERT_EQ (bb_d, get_immediate_dominator (CDI_POST_DOMINATORS, bb_c));
9441 vec<basic_block> postdom_by_d = get_dominated_by (CDI_POST_DOMINATORS, bb_d);
9442 ASSERT_EQ (3, postdom_by_d.length ()); /* A, B, C in some order. */
9443 postdom_by_d.release ();
9444 vec<basic_block> postdom_by_b = get_dominated_by (CDI_POST_DOMINATORS, bb_b);
9445 ASSERT_EQ (0, postdom_by_b.length ());
9446 postdom_by_b.release ();
9447 free_dominance_info (CDI_POST_DOMINATORS);
9449 pop_cfun ();
9452 /* Verify that we can handle a CFG containing a "complete" aka
9453 fully-connected subgraph (where A B C D below all have edges
9454 pointing to each other node, also to themselves).
9455 e.g.:
9456 ENTRY EXIT
9462 A<--->B
9463 ^^ ^^
9464 | \ / |
9465 | X |
9466 | / \ |
9467 VV VV
9468 C<--->D
9471 static void
9472 test_fully_connected ()
9474 gimple_register_cfg_hooks ();
9476 tree fndecl = push_fndecl ("cfg_fully_connected");
9477 function *fun = DECL_STRUCT_FUNCTION (fndecl);
9479 const int n = 4;
9481 /* Create some empty blocks. */
9482 auto_vec <basic_block> subgraph_nodes;
9483 for (int i = 0; i < n; i++)
9484 subgraph_nodes.safe_push (create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun)));
9486 ASSERT_EQ (n + 2, n_basic_blocks_for_fn (fun));
9487 ASSERT_EQ (0, n_edges_for_fn (fun));
9489 /* Create the edges. */
9490 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun), subgraph_nodes[0], EDGE_FALLTHRU);
9491 make_edge (subgraph_nodes[0], EXIT_BLOCK_PTR_FOR_FN (fun), 0);
9492 for (int i = 0; i < n; i++)
9493 for (int j = 0; j < n; j++)
9494 make_edge (subgraph_nodes[i], subgraph_nodes[j], 0);
9496 /* Verify the edges. */
9497 ASSERT_EQ (2 + (n * n), n_edges_for_fn (fun));
9498 /* The first one is linked to ENTRY/EXIT as well as itself and
9499 everything else. */
9500 ASSERT_EQ (n + 1, subgraph_nodes[0]->preds->length ());
9501 ASSERT_EQ (n + 1, subgraph_nodes[0]->succs->length ());
9502 /* The other ones in the subgraph are linked to everything in
9503 the subgraph (including themselves). */
9504 for (int i = 1; i < n; i++)
9506 ASSERT_EQ (n, subgraph_nodes[i]->preds->length ());
9507 ASSERT_EQ (n, subgraph_nodes[i]->succs->length ());
9510 /* Verify the dominance information. */
9511 calculate_dominance_info (CDI_DOMINATORS);
9512 /* The initial block in the subgraph should be dominated by ENTRY. */
9513 ASSERT_EQ (ENTRY_BLOCK_PTR_FOR_FN (fun),
9514 get_immediate_dominator (CDI_DOMINATORS,
9515 subgraph_nodes[0]));
9516 /* Every other block in the subgraph should be dominated by the
9517 initial block. */
9518 for (int i = 1; i < n; i++)
9519 ASSERT_EQ (subgraph_nodes[0],
9520 get_immediate_dominator (CDI_DOMINATORS,
9521 subgraph_nodes[i]));
9522 free_dominance_info (CDI_DOMINATORS);
9524 /* Similarly for post-dominance. */
9525 calculate_dominance_info (CDI_POST_DOMINATORS);
9526 /* The initial block in the subgraph should be postdominated by EXIT. */
9527 ASSERT_EQ (EXIT_BLOCK_PTR_FOR_FN (fun),
9528 get_immediate_dominator (CDI_POST_DOMINATORS,
9529 subgraph_nodes[0]));
9530 /* Every other block in the subgraph should be postdominated by the
9531 initial block, since that leads to EXIT. */
9532 for (int i = 1; i < n; i++)
9533 ASSERT_EQ (subgraph_nodes[0],
9534 get_immediate_dominator (CDI_POST_DOMINATORS,
9535 subgraph_nodes[i]));
9536 free_dominance_info (CDI_POST_DOMINATORS);
9538 pop_cfun ();
9541 /* Run all of the selftests within this file. */
9543 void
9544 tree_cfg_c_tests ()
9546 test_linear_chain ();
9547 test_diamond ();
9548 test_fully_connected ();
9551 } // namespace selftest
9553 /* TODO: test the dominator/postdominator logic with various graphs/nodes:
9554 - loop
9555 - nested loops
9556 - switch statement (a block with many out-edges)
9557 - something that jumps to itself
9558 - etc */
9560 #endif /* CHECKING_P */