1 /* Control flow functions for trees.
2 Copyright (C) 2001-2020 Free Software Foundation, Inc.
3 Contributed by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
30 #include "tree-pass.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"
40 #include "gimple-fold.h"
42 #include "gimple-iterator.h"
43 #include "gimplify-me.h"
44 #include "gimple-walk.h"
46 #include "tree-ssa-loop-manip.h"
47 #include "tree-ssa-loop-niter.h"
48 #include "tree-into-ssa.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"
67 /* This file contains functions for building the Control Flow Graph (CFG)
68 for a function tree. */
70 /* Local declarations. */
72 /* Initial capacity for the basic block array. */
73 static const int initial_cfg_capacity
= 20;
75 /* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
76 which use a particular edge. The CASE_LABEL_EXPRs are chained together
77 via their CASE_CHAIN field, which we clear after we're done with the
78 hash table to prevent problems with duplication of GIMPLE_SWITCHes.
80 Access to this list of CASE_LABEL_EXPRs allows us to efficiently
81 update the case vector in response to edge redirections.
83 Right now this table is set up and torn down at key points in the
84 compilation process. It would be nice if we could make the table
85 more persistent. The key is getting notification of changes to
86 the CFG (particularly edge removal, creation and redirection). */
88 static hash_map
<edge
, tree
> *edge_to_cases
;
90 /* If we record edge_to_cases, this bitmap will hold indexes
91 of basic blocks that end in a GIMPLE_SWITCH which we touched
92 due to edge manipulations. */
94 static bitmap touched_switch_bbs
;
99 long num_merged_labels
;
102 static struct cfg_stats_d cfg_stats
;
104 /* Data to pass to replace_block_vars_by_duplicates_1. */
105 struct replace_decls_d
107 hash_map
<tree
, tree
> *vars_map
;
111 /* Hash table to store last discriminator assigned for each locus. */
112 struct locus_discrim_map
118 /* Hashtable helpers. */
120 struct locus_discrim_hasher
: free_ptr_hash
<locus_discrim_map
>
122 static inline hashval_t
hash (const locus_discrim_map
*);
123 static inline bool equal (const locus_discrim_map
*,
124 const locus_discrim_map
*);
127 /* Trivial hash function for a location_t. ITEM is a pointer to
128 a hash table entry that maps a location_t to a discriminator. */
131 locus_discrim_hasher::hash (const locus_discrim_map
*item
)
133 return item
->location_line
;
136 /* Equality function for the locus-to-discriminator map. A and B
137 point to the two hash table entries to compare. */
140 locus_discrim_hasher::equal (const locus_discrim_map
*a
,
141 const locus_discrim_map
*b
)
143 return a
->location_line
== b
->location_line
;
146 static hash_table
<locus_discrim_hasher
> *discriminator_per_locus
;
148 /* Basic blocks and flowgraphs. */
149 static void make_blocks (gimple_seq
);
152 static void make_edges (void);
153 static void assign_discriminators (void);
154 static void make_cond_expr_edges (basic_block
);
155 static void make_gimple_switch_edges (gswitch
*, basic_block
);
156 static bool make_goto_expr_edges (basic_block
);
157 static void make_gimple_asm_edges (basic_block
);
158 static edge
gimple_redirect_edge_and_branch (edge
, basic_block
);
159 static edge
gimple_try_redirect_by_replacing_jump (edge
, basic_block
);
161 /* Various helpers. */
162 static inline bool stmt_starts_bb_p (gimple
*, gimple
*);
163 static int gimple_verify_flow_info (void);
164 static void gimple_make_forwarder_block (edge
);
165 static gimple
*first_non_label_stmt (basic_block
);
166 static bool verify_gimple_transaction (gtransaction
*);
167 static bool call_can_make_abnormal_goto (gimple
*);
169 /* Flowgraph optimization and cleanup. */
170 static void gimple_merge_blocks (basic_block
, basic_block
);
171 static bool gimple_can_merge_blocks_p (basic_block
, basic_block
);
172 static void remove_bb (basic_block
);
173 static edge
find_taken_edge_computed_goto (basic_block
, tree
);
174 static edge
find_taken_edge_cond_expr (const gcond
*, tree
);
177 init_empty_tree_cfg_for_function (struct function
*fn
)
179 /* Initialize the basic block array. */
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_safe_grow_cleared (basic_block_info_for_fn (fn
),
185 initial_cfg_capacity
, true);
187 /* Build a mapping of labels to their associated blocks. */
188 vec_safe_grow_cleared (label_to_block_map_for_fn (fn
),
189 initial_cfg_capacity
, true);
191 SET_BASIC_BLOCK_FOR_FN (fn
, ENTRY_BLOCK
, ENTRY_BLOCK_PTR_FOR_FN (fn
));
192 SET_BASIC_BLOCK_FOR_FN (fn
, EXIT_BLOCK
, EXIT_BLOCK_PTR_FOR_FN (fn
));
194 ENTRY_BLOCK_PTR_FOR_FN (fn
)->next_bb
195 = EXIT_BLOCK_PTR_FOR_FN (fn
);
196 EXIT_BLOCK_PTR_FOR_FN (fn
)->prev_bb
197 = ENTRY_BLOCK_PTR_FOR_FN (fn
);
201 init_empty_tree_cfg (void)
203 init_empty_tree_cfg_for_function (cfun
);
206 /*---------------------------------------------------------------------------
208 ---------------------------------------------------------------------------*/
210 /* Entry point to the CFG builder for trees. SEQ is the sequence of
211 statements to be added to the flowgraph. */
214 build_gimple_cfg (gimple_seq seq
)
216 /* Register specific gimple functions. */
217 gimple_register_cfg_hooks ();
219 memset ((void *) &cfg_stats
, 0, sizeof (cfg_stats
));
221 init_empty_tree_cfg ();
225 /* Make sure there is always at least one block, even if it's empty. */
226 if (n_basic_blocks_for_fn (cfun
) == NUM_FIXED_BLOCKS
)
227 create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
229 /* Adjust the size of the array. */
230 if (basic_block_info_for_fn (cfun
)->length ()
231 < (size_t) n_basic_blocks_for_fn (cfun
))
232 vec_safe_grow_cleared (basic_block_info_for_fn (cfun
),
233 n_basic_blocks_for_fn (cfun
));
235 /* To speed up statement iterator walks, we first purge dead labels. */
236 cleanup_dead_labels ();
238 /* Group case nodes to reduce the number of edges.
239 We do this after cleaning up dead labels because otherwise we miss
240 a lot of obvious case merging opportunities. */
241 group_case_labels ();
243 /* Create the edges of the flowgraph. */
244 discriminator_per_locus
= new hash_table
<locus_discrim_hasher
> (13);
246 assign_discriminators ();
247 cleanup_dead_labels ();
248 delete discriminator_per_locus
;
249 discriminator_per_locus
= NULL
;
252 /* Look for ANNOTATE calls with loop annotation kind in BB; if found, remove
253 them and propagate the information to LOOP. We assume that the annotations
254 come immediately before the condition in BB, if any. */
257 replace_loop_annotate_in_block (basic_block bb
, class loop
*loop
)
259 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
260 gimple
*stmt
= gsi_stmt (gsi
);
262 if (!(stmt
&& gimple_code (stmt
) == GIMPLE_COND
))
265 for (gsi_prev_nondebug (&gsi
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
267 stmt
= gsi_stmt (gsi
);
268 if (gimple_code (stmt
) != GIMPLE_CALL
)
270 if (!gimple_call_internal_p (stmt
)
271 || gimple_call_internal_fn (stmt
) != IFN_ANNOTATE
)
274 switch ((annot_expr_kind
) tree_to_shwi (gimple_call_arg (stmt
, 1)))
276 case annot_expr_ivdep_kind
:
277 loop
->safelen
= INT_MAX
;
279 case annot_expr_unroll_kind
:
281 = (unsigned short) tree_to_shwi (gimple_call_arg (stmt
, 2));
282 cfun
->has_unroll
= true;
284 case annot_expr_no_vector_kind
:
285 loop
->dont_vectorize
= true;
287 case annot_expr_vector_kind
:
288 loop
->force_vectorize
= true;
289 cfun
->has_force_vectorize_loops
= true;
291 case annot_expr_parallel_kind
:
292 loop
->can_be_parallel
= true;
293 loop
->safelen
= INT_MAX
;
299 stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
300 gimple_call_arg (stmt
, 0));
301 gsi_replace (&gsi
, stmt
, true);
305 /* Look for ANNOTATE calls with loop annotation kind; if found, remove
306 them and propagate the information to the loop. We assume that the
307 annotations come immediately before the condition of the loop. */
310 replace_loop_annotate (void)
314 gimple_stmt_iterator gsi
;
317 FOR_EACH_LOOP (loop
, 0)
319 /* First look into the header. */
320 replace_loop_annotate_in_block (loop
->header
, loop
);
322 /* Then look into the latch, if any. */
324 replace_loop_annotate_in_block (loop
->latch
, loop
);
326 /* Push the global flag_finite_loops state down to individual loops. */
327 loop
->finite_p
= flag_finite_loops
;
330 /* Remove IFN_ANNOTATE. Safeguard for the case loop->latch == NULL. */
331 FOR_EACH_BB_FN (bb
, cfun
)
333 for (gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
335 stmt
= gsi_stmt (gsi
);
336 if (gimple_code (stmt
) != GIMPLE_CALL
)
338 if (!gimple_call_internal_p (stmt
)
339 || gimple_call_internal_fn (stmt
) != IFN_ANNOTATE
)
342 switch ((annot_expr_kind
) tree_to_shwi (gimple_call_arg (stmt
, 1)))
344 case annot_expr_ivdep_kind
:
345 case annot_expr_unroll_kind
:
346 case annot_expr_no_vector_kind
:
347 case annot_expr_vector_kind
:
348 case annot_expr_parallel_kind
:
354 warning_at (gimple_location (stmt
), 0, "ignoring loop annotation");
355 stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
356 gimple_call_arg (stmt
, 0));
357 gsi_replace (&gsi
, stmt
, true);
363 execute_build_cfg (void)
365 gimple_seq body
= gimple_body (current_function_decl
);
367 build_gimple_cfg (body
);
368 gimple_set_body (current_function_decl
, NULL
);
369 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
371 fprintf (dump_file
, "Scope blocks:\n");
372 dump_scope_blocks (dump_file
, dump_flags
);
375 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
376 replace_loop_annotate ();
382 const pass_data pass_data_build_cfg
=
384 GIMPLE_PASS
, /* type */
386 OPTGROUP_NONE
, /* optinfo_flags */
387 TV_TREE_CFG
, /* tv_id */
388 PROP_gimple_leh
, /* properties_required */
389 ( PROP_cfg
| PROP_loops
), /* properties_provided */
390 0, /* properties_destroyed */
391 0, /* todo_flags_start */
392 0, /* todo_flags_finish */
395 class pass_build_cfg
: public gimple_opt_pass
398 pass_build_cfg (gcc::context
*ctxt
)
399 : gimple_opt_pass (pass_data_build_cfg
, ctxt
)
402 /* opt_pass methods: */
403 virtual unsigned int execute (function
*) { return execute_build_cfg (); }
405 }; // class pass_build_cfg
410 make_pass_build_cfg (gcc::context
*ctxt
)
412 return new pass_build_cfg (ctxt
);
416 /* Return true if T is a computed goto. */
419 computed_goto_p (gimple
*t
)
421 return (gimple_code (t
) == GIMPLE_GOTO
422 && TREE_CODE (gimple_goto_dest (t
)) != LABEL_DECL
);
425 /* Returns true if the sequence of statements STMTS only contains
426 a call to __builtin_unreachable (). */
429 gimple_seq_unreachable_p (gimple_seq stmts
)
432 /* Return false if -fsanitize=unreachable, we don't want to
433 optimize away those calls, but rather turn them into
434 __ubsan_handle_builtin_unreachable () or __builtin_trap ()
436 || sanitize_flags_p (SANITIZE_UNREACHABLE
))
439 gimple_stmt_iterator gsi
= gsi_last (stmts
);
441 if (!gimple_call_builtin_p (gsi_stmt (gsi
), BUILT_IN_UNREACHABLE
))
444 for (gsi_prev (&gsi
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
446 gimple
*stmt
= gsi_stmt (gsi
);
447 if (gimple_code (stmt
) != GIMPLE_LABEL
448 && !is_gimple_debug (stmt
)
449 && !gimple_clobber_p (stmt
))
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:
465 __builtin_unreachable ();
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)
479 return gimple_seq_unreachable_p (bb_seq (other_bb
));
485 /* Initialize GF_CALL_CTRL_ALTERING flag, which indicates the call
486 could alter control flow except via eh. We initialize the flag at
487 CFG build time and only ever clear it later. */
490 gimple_call_initialize_ctrl_altering (gimple
*stmt
)
492 int flags
= gimple_call_flags (stmt
);
494 /* A call alters control flow if it can make an abnormal goto. */
495 if (call_can_make_abnormal_goto (stmt
)
496 /* A call also alters control flow if it does not return. */
497 || flags
& ECF_NORETURN
498 /* TM ending statements have backedges out of the transaction.
499 Return true so we split the basic block containing them.
500 Note that the TM_BUILTIN test is merely an optimization. */
501 || ((flags
& ECF_TM_BUILTIN
)
502 && is_tm_ending_fndecl (gimple_call_fndecl (stmt
)))
503 /* BUILT_IN_RETURN call is same as return statement. */
504 || gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
)
505 /* IFN_UNIQUE should be the last insn, to make checking for it
506 as cheap as possible. */
507 || (gimple_call_internal_p (stmt
)
508 && gimple_call_internal_unique_p (stmt
)))
509 gimple_call_set_ctrl_altering (stmt
, true);
511 gimple_call_set_ctrl_altering (stmt
, false);
515 /* Insert SEQ after BB and build a flowgraph. */
518 make_blocks_1 (gimple_seq seq
, basic_block bb
)
520 gimple_stmt_iterator i
= gsi_start (seq
);
522 gimple
*prev_stmt
= NULL
;
523 bool start_new_block
= true;
524 bool first_stmt_of_seq
= true;
526 while (!gsi_end_p (i
))
528 /* PREV_STMT should only be set to a debug stmt if the debug
529 stmt is before nondebug stmts. Once stmt reaches a nondebug
530 nonlabel, prev_stmt will be set to it, so that
531 stmt_starts_bb_p will know to start a new block if a label is
532 found. However, if stmt was a label after debug stmts only,
533 keep the label in prev_stmt even if we find further debug
534 stmts, for there may be other labels after them, and they
535 should land in the same block. */
536 if (!prev_stmt
|| !stmt
|| !is_gimple_debug (stmt
))
540 if (stmt
&& is_gimple_call (stmt
))
541 gimple_call_initialize_ctrl_altering (stmt
);
543 /* If the statement starts a new basic block or if we have determined
544 in a previous pass that we need to create a new block for STMT, do
546 if (start_new_block
|| stmt_starts_bb_p (stmt
, prev_stmt
))
548 if (!first_stmt_of_seq
)
549 gsi_split_seq_before (&i
, &seq
);
550 bb
= create_basic_block (seq
, bb
);
551 start_new_block
= false;
555 /* Now add STMT to BB and create the subgraphs for special statement
557 gimple_set_bb (stmt
, bb
);
559 /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
561 if (stmt_ends_bb_p (stmt
))
563 /* If the stmt can make abnormal goto use a new temporary
564 for the assignment to the LHS. This makes sure the old value
565 of the LHS is available on the abnormal edge. Otherwise
566 we will end up with overlapping life-ranges for abnormal
568 if (gimple_has_lhs (stmt
)
569 && stmt_can_make_abnormal_goto (stmt
)
570 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt
))))
572 tree lhs
= gimple_get_lhs (stmt
);
573 tree tmp
= create_tmp_var (TREE_TYPE (lhs
));
574 gimple
*s
= gimple_build_assign (lhs
, tmp
);
575 gimple_set_location (s
, gimple_location (stmt
));
576 gimple_set_block (s
, gimple_block (stmt
));
577 gimple_set_lhs (stmt
, tmp
);
578 gsi_insert_after (&i
, s
, GSI_SAME_STMT
);
580 start_new_block
= true;
584 first_stmt_of_seq
= false;
589 /* Build a flowgraph for the sequence of stmts SEQ. */
592 make_blocks (gimple_seq seq
)
594 /* Look for debug markers right before labels, and move the debug
595 stmts after the labels. Accepting labels among debug markers
596 adds no value, just complexity; if we wanted to annotate labels
597 with view numbers (so sequencing among markers would matter) or
598 somesuch, we're probably better off still moving the labels, but
599 adding other debug annotations in their original positions or
600 emitting nonbind or bind markers associated with the labels in
601 the original position of the labels.
603 Moving labels would probably be simpler, but we can't do that:
604 moving labels assigns label ids to them, and doing so because of
605 debug markers makes for -fcompare-debug and possibly even codegen
606 differences. So, we have to move the debug stmts instead. To
607 that end, we scan SEQ backwards, marking the position of the
608 latest (earliest we find) label, and moving debug stmts that are
609 not separated from it by nondebug nonlabel stmts after the
611 if (MAY_HAVE_DEBUG_MARKER_STMTS
)
613 gimple_stmt_iterator label
= gsi_none ();
615 for (gimple_stmt_iterator i
= gsi_last (seq
); !gsi_end_p (i
); gsi_prev (&i
))
617 gimple
*stmt
= gsi_stmt (i
);
619 /* If this is the first label we encounter (latest in SEQ)
620 before nondebug stmts, record its position. */
621 if (is_a
<glabel
*> (stmt
))
623 if (gsi_end_p (label
))
628 /* Without a recorded label position to move debug stmts to,
629 there's nothing to do. */
630 if (gsi_end_p (label
))
633 /* Move the debug stmt at I after LABEL. */
634 if (is_gimple_debug (stmt
))
636 gcc_assert (gimple_debug_nonbind_marker_p (stmt
));
637 /* As STMT is removed, I advances to the stmt after
638 STMT, so the gsi_prev in the for "increment"
639 expression gets us to the stmt we're to visit after
640 STMT. LABEL, however, would advance to the moved
641 stmt if we passed it to gsi_move_after, so pass it a
642 copy instead, so as to keep LABEL pointing to the
644 gimple_stmt_iterator copy
= label
;
645 gsi_move_after (&i
, ©
);
649 /* There aren't any (more?) debug stmts before label, so
650 there isn't anything else to move after it. */
655 make_blocks_1 (seq
, ENTRY_BLOCK_PTR_FOR_FN (cfun
));
658 /* Create and return a new empty basic block after bb AFTER. */
661 create_bb (void *h
, void *e
, basic_block after
)
667 /* Create and initialize a new basic block. Since alloc_block uses
668 GC allocation that clears memory to allocate a basic block, we do
669 not have to clear the newly allocated basic block here. */
672 bb
->index
= last_basic_block_for_fn (cfun
);
674 set_bb_seq (bb
, h
? (gimple_seq
) h
: NULL
);
676 /* Add the new block to the linked list of blocks. */
677 link_block (bb
, after
);
679 /* Grow the basic block array if needed. */
680 if ((size_t) last_basic_block_for_fn (cfun
)
681 == basic_block_info_for_fn (cfun
)->length ())
682 vec_safe_grow_cleared (basic_block_info_for_fn (cfun
),
683 last_basic_block_for_fn (cfun
) + 1);
685 /* Add the newly created block to the array. */
686 SET_BASIC_BLOCK_FOR_FN (cfun
, last_basic_block_for_fn (cfun
), bb
);
688 n_basic_blocks_for_fn (cfun
)++;
689 last_basic_block_for_fn (cfun
)++;
695 /*---------------------------------------------------------------------------
697 ---------------------------------------------------------------------------*/
699 /* If basic block BB has an abnormal edge to a basic block
700 containing IFN_ABNORMAL_DISPATCHER internal call, return
701 that the dispatcher's basic block, otherwise return NULL. */
704 get_abnormal_succ_dispatcher (basic_block bb
)
709 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
710 if ((e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)) == EDGE_ABNORMAL
)
712 gimple_stmt_iterator gsi
713 = gsi_start_nondebug_after_labels_bb (e
->dest
);
714 gimple
*g
= gsi_stmt (gsi
);
715 if (g
&& gimple_call_internal_p (g
, IFN_ABNORMAL_DISPATCHER
))
721 /* Helper function for make_edges. Create a basic block with
722 with ABNORMAL_DISPATCHER internal call in it if needed, and
723 create abnormal edges from BBS to it and from it to FOR_BB
724 if COMPUTED_GOTO is false, otherwise factor the computed gotos. */
727 handle_abnormal_edges (basic_block
*dispatcher_bbs
,
728 basic_block for_bb
, int *bb_to_omp_idx
,
729 auto_vec
<basic_block
> *bbs
, bool computed_goto
)
731 basic_block
*dispatcher
= dispatcher_bbs
+ (computed_goto
? 1 : 0);
732 unsigned int idx
= 0;
738 dispatcher
= dispatcher_bbs
+ 2 * bb_to_omp_idx
[for_bb
->index
];
739 if (bb_to_omp_idx
[for_bb
->index
] != 0)
743 /* If the dispatcher has been created already, then there are basic
744 blocks with abnormal edges to it, so just make a new edge to
746 if (*dispatcher
== NULL
)
748 /* Check if there are any basic blocks that need to have
749 abnormal edges to this dispatcher. If there are none, return
751 if (bb_to_omp_idx
== NULL
)
753 if (bbs
->is_empty ())
758 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
759 if (bb_to_omp_idx
[bb
->index
] == bb_to_omp_idx
[for_bb
->index
])
765 /* Create the dispatcher bb. */
766 *dispatcher
= create_basic_block (NULL
, for_bb
);
769 /* Factor computed gotos into a common computed goto site. Also
770 record the location of that site so that we can un-factor the
771 gotos after we have converted back to normal form. */
772 gimple_stmt_iterator gsi
= gsi_start_bb (*dispatcher
);
774 /* Create the destination of the factored goto. Each original
775 computed goto will put its desired destination into this
776 variable and jump to the label we create immediately below. */
777 tree var
= create_tmp_var (ptr_type_node
, "gotovar");
779 /* Build a label for the new block which will contain the
780 factored computed goto. */
781 tree factored_label_decl
782 = create_artificial_label (UNKNOWN_LOCATION
);
783 gimple
*factored_computed_goto_label
784 = gimple_build_label (factored_label_decl
);
785 gsi_insert_after (&gsi
, factored_computed_goto_label
, GSI_NEW_STMT
);
787 /* Build our new computed goto. */
788 gimple
*factored_computed_goto
= gimple_build_goto (var
);
789 gsi_insert_after (&gsi
, factored_computed_goto
, GSI_NEW_STMT
);
791 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
794 && bb_to_omp_idx
[bb
->index
] != bb_to_omp_idx
[for_bb
->index
])
797 gsi
= gsi_last_bb (bb
);
798 gimple
*last
= gsi_stmt (gsi
);
800 gcc_assert (computed_goto_p (last
));
802 /* Copy the original computed goto's destination into VAR. */
804 = gimple_build_assign (var
, gimple_goto_dest (last
));
805 gsi_insert_before (&gsi
, assignment
, GSI_SAME_STMT
);
807 edge e
= make_edge (bb
, *dispatcher
, EDGE_FALLTHRU
);
808 e
->goto_locus
= gimple_location (last
);
809 gsi_remove (&gsi
, true);
814 tree arg
= inner
? boolean_true_node
: boolean_false_node
;
815 gimple
*g
= gimple_build_call_internal (IFN_ABNORMAL_DISPATCHER
,
817 gimple_stmt_iterator gsi
= gsi_after_labels (*dispatcher
);
818 gsi_insert_after (&gsi
, g
, GSI_NEW_STMT
);
820 /* Create predecessor edges of the dispatcher. */
821 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
824 && bb_to_omp_idx
[bb
->index
] != bb_to_omp_idx
[for_bb
->index
])
826 make_edge (bb
, *dispatcher
, EDGE_ABNORMAL
);
831 make_edge (*dispatcher
, for_bb
, EDGE_ABNORMAL
);
834 /* Creates outgoing edges for BB. Returns 1 when it ends with an
835 computed goto, returns 2 when it ends with a statement that
836 might return to this function via an nonlocal goto, otherwise
837 return 0. Updates *PCUR_REGION with the OMP region this BB is in. */
840 make_edges_bb (basic_block bb
, struct omp_region
**pcur_region
, int *pomp_index
)
842 gimple
*last
= last_stmt (bb
);
843 bool fallthru
= false;
849 switch (gimple_code (last
))
852 if (make_goto_expr_edges (bb
))
858 edge e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
859 e
->goto_locus
= gimple_location (last
);
864 make_cond_expr_edges (bb
);
868 make_gimple_switch_edges (as_a
<gswitch
*> (last
), bb
);
872 make_eh_edges (last
);
875 case GIMPLE_EH_DISPATCH
:
876 fallthru
= make_eh_dispatch_edges (as_a
<geh_dispatch
*> (last
));
880 /* If this function receives a nonlocal goto, then we need to
881 make edges from this call site to all the nonlocal goto
883 if (stmt_can_make_abnormal_goto (last
))
886 /* If this statement has reachable exception handlers, then
887 create abnormal edges to them. */
888 make_eh_edges (last
);
890 /* BUILTIN_RETURN is really a return statement. */
891 if (gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
893 make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
896 /* Some calls are known not to return. */
898 fallthru
= !gimple_call_noreturn_p (last
);
902 /* A GIMPLE_ASSIGN may throw internally and thus be considered
904 if (is_ctrl_altering_stmt (last
))
905 make_eh_edges (last
);
910 make_gimple_asm_edges (bb
);
915 fallthru
= omp_make_gimple_edges (bb
, pcur_region
, pomp_index
);
918 case GIMPLE_TRANSACTION
:
920 gtransaction
*txn
= as_a
<gtransaction
*> (last
);
921 tree label1
= gimple_transaction_label_norm (txn
);
922 tree label2
= gimple_transaction_label_uninst (txn
);
925 make_edge (bb
, label_to_block (cfun
, label1
), EDGE_FALLTHRU
);
927 make_edge (bb
, label_to_block (cfun
, label2
),
928 EDGE_TM_UNINSTRUMENTED
| (label1
? 0 : EDGE_FALLTHRU
));
930 tree label3
= gimple_transaction_label_over (txn
);
931 if (gimple_transaction_subcode (txn
)
932 & (GTMA_HAVE_ABORT
| GTMA_IS_OUTER
))
933 make_edge (bb
, label_to_block (cfun
, label3
), EDGE_TM_ABORT
);
940 gcc_assert (!stmt_ends_bb_p (last
));
946 make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
951 /* Join all the blocks in the flowgraph. */
957 struct omp_region
*cur_region
= NULL
;
958 auto_vec
<basic_block
> ab_edge_goto
;
959 auto_vec
<basic_block
> ab_edge_call
;
960 int *bb_to_omp_idx
= NULL
;
961 int cur_omp_region_idx
= 0;
963 /* Create an edge from entry to the first block with executable
965 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
966 BASIC_BLOCK_FOR_FN (cfun
, NUM_FIXED_BLOCKS
),
969 /* Traverse the basic block array placing edges. */
970 FOR_EACH_BB_FN (bb
, cfun
)
975 bb_to_omp_idx
[bb
->index
] = cur_omp_region_idx
;
977 mer
= make_edges_bb (bb
, &cur_region
, &cur_omp_region_idx
);
979 ab_edge_goto
.safe_push (bb
);
981 ab_edge_call
.safe_push (bb
);
983 if (cur_region
&& bb_to_omp_idx
== NULL
)
984 bb_to_omp_idx
= XCNEWVEC (int, n_basic_blocks_for_fn (cfun
));
987 /* Computed gotos are hell to deal with, especially if there are
988 lots of them with a large number of destinations. So we factor
989 them to a common computed goto location before we build the
990 edge list. After we convert back to normal form, we will un-factor
991 the computed gotos since factoring introduces an unwanted jump.
992 For non-local gotos and abnormal edges from calls to calls that return
993 twice or forced labels, factor the abnormal edges too, by having all
994 abnormal edges from the calls go to a common artificial basic block
995 with ABNORMAL_DISPATCHER internal call and abnormal edges from that
996 basic block to all forced labels and calls returning twice.
997 We do this per-OpenMP structured block, because those regions
998 are guaranteed to be single entry single exit by the standard,
999 so it is not allowed to enter or exit such regions abnormally this way,
1000 thus all computed gotos, non-local gotos and setjmp/longjmp calls
1001 must not transfer control across SESE region boundaries. */
1002 if (!ab_edge_goto
.is_empty () || !ab_edge_call
.is_empty ())
1004 gimple_stmt_iterator gsi
;
1005 basic_block dispatcher_bb_array
[2] = { NULL
, NULL
};
1006 basic_block
*dispatcher_bbs
= dispatcher_bb_array
;
1007 int count
= n_basic_blocks_for_fn (cfun
);
1010 dispatcher_bbs
= XCNEWVEC (basic_block
, 2 * count
);
1012 FOR_EACH_BB_FN (bb
, cfun
)
1014 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1016 glabel
*label_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
1022 target
= gimple_label_label (label_stmt
);
1024 /* Make an edge to every label block that has been marked as a
1025 potential target for a computed goto or a non-local goto. */
1026 if (FORCED_LABEL (target
))
1027 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
1028 &ab_edge_goto
, true);
1029 if (DECL_NONLOCAL (target
))
1031 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
1032 &ab_edge_call
, false);
1037 if (!gsi_end_p (gsi
) && is_gimple_debug (gsi_stmt (gsi
)))
1038 gsi_next_nondebug (&gsi
);
1039 if (!gsi_end_p (gsi
))
1041 /* Make an edge to every setjmp-like call. */
1042 gimple
*call_stmt
= gsi_stmt (gsi
);
1043 if (is_gimple_call (call_stmt
)
1044 && ((gimple_call_flags (call_stmt
) & ECF_RETURNS_TWICE
)
1045 || gimple_call_builtin_p (call_stmt
,
1046 BUILT_IN_SETJMP_RECEIVER
)))
1047 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
1048 &ab_edge_call
, false);
1053 XDELETE (dispatcher_bbs
);
1056 XDELETE (bb_to_omp_idx
);
1058 omp_free_regions ();
1061 /* Add SEQ after GSI. Start new bb after GSI, and created further bbs as
1062 needed. Returns true if new bbs were created.
1063 Note: This is transitional code, and should not be used for new code. We
1064 should be able to get rid of this by rewriting all target va-arg
1065 gimplification hooks to use an interface gimple_build_cond_value as described
1066 in https://gcc.gnu.org/ml/gcc-patches/2015-02/msg01194.html. */
1069 gimple_find_sub_bbs (gimple_seq seq
, gimple_stmt_iterator
*gsi
)
1071 gimple
*stmt
= gsi_stmt (*gsi
);
1072 basic_block bb
= gimple_bb (stmt
);
1073 basic_block lastbb
, afterbb
;
1074 int old_num_bbs
= n_basic_blocks_for_fn (cfun
);
1076 lastbb
= make_blocks_1 (seq
, bb
);
1077 if (old_num_bbs
== n_basic_blocks_for_fn (cfun
))
1079 e
= split_block (bb
, stmt
);
1080 /* Move e->dest to come after the new basic blocks. */
1082 unlink_block (afterbb
);
1083 link_block (afterbb
, lastbb
);
1084 redirect_edge_succ (e
, bb
->next_bb
);
1086 while (bb
!= afterbb
)
1088 struct omp_region
*cur_region
= NULL
;
1089 profile_count cnt
= profile_count::zero ();
1092 int cur_omp_region_idx
= 0;
1093 int mer
= make_edges_bb (bb
, &cur_region
, &cur_omp_region_idx
);
1094 gcc_assert (!mer
&& !cur_region
);
1095 add_bb_to_loop (bb
, afterbb
->loop_father
);
1099 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1101 if (e
->count ().initialized_p ())
1106 tree_guess_outgoing_edge_probabilities (bb
);
1107 if (all
|| profile_status_for_fn (cfun
) == PROFILE_READ
)
1115 /* Find the next available discriminator value for LOCUS. The
1116 discriminator distinguishes among several basic blocks that
1117 share a common locus, allowing for more accurate sample-based
1121 next_discriminator_for_locus (int line
)
1123 struct locus_discrim_map item
;
1124 struct locus_discrim_map
**slot
;
1126 item
.location_line
= line
;
1127 item
.discriminator
= 0;
1128 slot
= discriminator_per_locus
->find_slot_with_hash (&item
, line
, INSERT
);
1130 if (*slot
== HTAB_EMPTY_ENTRY
)
1132 *slot
= XNEW (struct locus_discrim_map
);
1134 (*slot
)->location_line
= line
;
1135 (*slot
)->discriminator
= 0;
1137 (*slot
)->discriminator
++;
1138 return (*slot
)->discriminator
;
1141 /* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line. */
1144 same_line_p (location_t locus1
, expanded_location
*from
, location_t locus2
)
1146 expanded_location to
;
1148 if (locus1
== locus2
)
1151 to
= expand_location (locus2
);
1153 if (from
->line
!= to
.line
)
1155 if (from
->file
== to
.file
)
1157 return (from
->file
!= NULL
1159 && filename_cmp (from
->file
, to
.file
) == 0);
1162 /* Assign discriminators to each basic block. */
1165 assign_discriminators (void)
1169 FOR_EACH_BB_FN (bb
, cfun
)
1173 gimple
*last
= last_stmt (bb
);
1174 location_t locus
= last
? gimple_location (last
) : UNKNOWN_LOCATION
;
1176 if (locus
== UNKNOWN_LOCATION
)
1179 expanded_location locus_e
= expand_location (locus
);
1181 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1183 gimple
*first
= first_non_label_stmt (e
->dest
);
1184 gimple
*last
= last_stmt (e
->dest
);
1185 if ((first
&& same_line_p (locus
, &locus_e
,
1186 gimple_location (first
)))
1187 || (last
&& same_line_p (locus
, &locus_e
,
1188 gimple_location (last
))))
1190 if (e
->dest
->discriminator
!= 0 && bb
->discriminator
== 0)
1192 = next_discriminator_for_locus (locus_e
.line
);
1194 e
->dest
->discriminator
1195 = next_discriminator_for_locus (locus_e
.line
);
1201 /* Create the edges for a GIMPLE_COND starting at block BB. */
1204 make_cond_expr_edges (basic_block bb
)
1206 gcond
*entry
= as_a
<gcond
*> (last_stmt (bb
));
1207 gimple
*then_stmt
, *else_stmt
;
1208 basic_block then_bb
, else_bb
;
1209 tree then_label
, else_label
;
1213 gcc_assert (gimple_code (entry
) == GIMPLE_COND
);
1215 /* Entry basic blocks for each component. */
1216 then_label
= gimple_cond_true_label (entry
);
1217 else_label
= gimple_cond_false_label (entry
);
1218 then_bb
= label_to_block (cfun
, then_label
);
1219 else_bb
= label_to_block (cfun
, else_label
);
1220 then_stmt
= first_stmt (then_bb
);
1221 else_stmt
= first_stmt (else_bb
);
1223 e
= make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1224 e
->goto_locus
= gimple_location (then_stmt
);
1225 e
= make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1227 e
->goto_locus
= gimple_location (else_stmt
);
1229 /* We do not need the labels anymore. */
1230 gimple_cond_set_true_label (entry
, NULL_TREE
);
1231 gimple_cond_set_false_label (entry
, NULL_TREE
);
1235 /* Called for each element in the hash table (P) as we delete the
1236 edge to cases hash table.
1238 Clear all the CASE_CHAINs to prevent problems with copying of
1239 SWITCH_EXPRs and structure sharing rules, then free the hash table
1243 edge_to_cases_cleanup (edge
const &, tree
const &value
, void *)
1247 for (t
= value
; t
; t
= next
)
1249 next
= CASE_CHAIN (t
);
1250 CASE_CHAIN (t
) = NULL
;
1256 /* Start recording information mapping edges to case labels. */
1259 start_recording_case_labels (void)
1261 gcc_assert (edge_to_cases
== NULL
);
1262 edge_to_cases
= new hash_map
<edge
, tree
>;
1263 touched_switch_bbs
= BITMAP_ALLOC (NULL
);
1266 /* Return nonzero if we are recording information for case labels. */
1269 recording_case_labels_p (void)
1271 return (edge_to_cases
!= NULL
);
1274 /* Stop recording information mapping edges to case labels and
1275 remove any information we have recorded. */
1277 end_recording_case_labels (void)
1281 edge_to_cases
->traverse
<void *, edge_to_cases_cleanup
> (NULL
);
1282 delete edge_to_cases
;
1283 edge_to_cases
= NULL
;
1284 EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs
, 0, i
, bi
)
1286 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
1289 gimple
*stmt
= last_stmt (bb
);
1290 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1291 group_case_labels_stmt (as_a
<gswitch
*> (stmt
));
1294 BITMAP_FREE (touched_switch_bbs
);
1297 /* If we are inside a {start,end}_recording_cases block, then return
1298 a chain of CASE_LABEL_EXPRs from T which reference E.
1300 Otherwise return NULL. */
1303 get_cases_for_edge (edge e
, gswitch
*t
)
1308 /* If we are not recording cases, then we do not have CASE_LABEL_EXPR
1309 chains available. Return NULL so the caller can detect this case. */
1310 if (!recording_case_labels_p ())
1313 slot
= edge_to_cases
->get (e
);
1317 /* If we did not find E in the hash table, then this must be the first
1318 time we have been queried for information about E & T. Add all the
1319 elements from T to the hash table then perform the query again. */
1321 n
= gimple_switch_num_labels (t
);
1322 for (i
= 0; i
< n
; i
++)
1324 tree elt
= gimple_switch_label (t
, i
);
1325 tree lab
= CASE_LABEL (elt
);
1326 basic_block label_bb
= label_to_block (cfun
, lab
);
1327 edge this_edge
= find_edge (e
->src
, label_bb
);
1329 /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
1331 tree
&s
= edge_to_cases
->get_or_insert (this_edge
);
1332 CASE_CHAIN (elt
) = s
;
1336 return *edge_to_cases
->get (e
);
1339 /* Create the edges for a GIMPLE_SWITCH starting at block BB. */
1342 make_gimple_switch_edges (gswitch
*entry
, basic_block bb
)
1346 n
= gimple_switch_num_labels (entry
);
1348 for (i
= 0; i
< n
; ++i
)
1350 basic_block label_bb
= gimple_switch_label_bb (cfun
, entry
, i
);
1351 make_edge (bb
, label_bb
, 0);
1356 /* Return the basic block holding label DEST. */
1359 label_to_block (struct function
*ifun
, tree dest
)
1361 int uid
= LABEL_DECL_UID (dest
);
1363 /* We would die hard when faced by an undefined label. Emit a label to
1364 the very first basic block. This will hopefully make even the dataflow
1365 and undefined variable warnings quite right. */
1366 if (seen_error () && uid
< 0)
1368 gimple_stmt_iterator gsi
=
1369 gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, NUM_FIXED_BLOCKS
));
1372 stmt
= gimple_build_label (dest
);
1373 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
1374 uid
= LABEL_DECL_UID (dest
);
1376 if (vec_safe_length (ifun
->cfg
->x_label_to_block_map
) <= (unsigned int) uid
)
1378 return (*ifun
->cfg
->x_label_to_block_map
)[uid
];
1381 /* Create edges for a goto statement at block BB. Returns true
1382 if abnormal edges should be created. */
1385 make_goto_expr_edges (basic_block bb
)
1387 gimple_stmt_iterator last
= gsi_last_bb (bb
);
1388 gimple
*goto_t
= gsi_stmt (last
);
1390 /* A simple GOTO creates normal edges. */
1391 if (simple_goto_p (goto_t
))
1393 tree dest
= gimple_goto_dest (goto_t
);
1394 basic_block label_bb
= label_to_block (cfun
, dest
);
1395 edge e
= make_edge (bb
, label_bb
, EDGE_FALLTHRU
);
1396 e
->goto_locus
= gimple_location (goto_t
);
1397 gsi_remove (&last
, true);
1401 /* A computed GOTO creates abnormal edges. */
1405 /* Create edges for an asm statement with labels at block BB. */
1408 make_gimple_asm_edges (basic_block bb
)
1410 gasm
*stmt
= as_a
<gasm
*> (last_stmt (bb
));
1411 int i
, n
= gimple_asm_nlabels (stmt
);
1413 for (i
= 0; i
< n
; ++i
)
1415 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
1416 basic_block label_bb
= label_to_block (cfun
, label
);
1417 make_edge (bb
, label_bb
, 0);
1421 /*---------------------------------------------------------------------------
1423 ---------------------------------------------------------------------------*/
1425 /* Cleanup useless labels in basic blocks. This is something we wish
1426 to do early because it allows us to group case labels before creating
1427 the edges for the CFG, and it speeds up block statement iterators in
1428 all passes later on.
1429 We rerun this pass after CFG is created, to get rid of the labels that
1430 are no longer referenced. After then we do not run it any more, since
1431 (almost) no new labels should be created. */
1433 /* A map from basic block index to the leading label of that block. */
1439 /* True if the label is referenced from somewhere. */
1443 /* Given LABEL return the first label in the same basic block. */
1446 main_block_label (tree label
, label_record
*label_for_bb
)
1448 basic_block bb
= label_to_block (cfun
, label
);
1449 tree main_label
= label_for_bb
[bb
->index
].label
;
1451 /* label_to_block possibly inserted undefined label into the chain. */
1454 label_for_bb
[bb
->index
].label
= label
;
1458 label_for_bb
[bb
->index
].used
= true;
1462 /* Clean up redundant labels within the exception tree. */
1465 cleanup_dead_labels_eh (label_record
*label_for_bb
)
1472 if (cfun
->eh
== NULL
)
1475 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1476 if (lp
&& lp
->post_landing_pad
)
1478 lab
= main_block_label (lp
->post_landing_pad
, label_for_bb
);
1479 if (lab
!= lp
->post_landing_pad
)
1481 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1482 EH_LANDING_PAD_NR (lab
) = lp
->index
;
1486 FOR_ALL_EH_REGION (r
)
1490 case ERT_MUST_NOT_THROW
:
1496 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
1500 c
->label
= main_block_label (lab
, label_for_bb
);
1505 case ERT_ALLOWED_EXCEPTIONS
:
1506 lab
= r
->u
.allowed
.label
;
1508 r
->u
.allowed
.label
= main_block_label (lab
, label_for_bb
);
1514 /* Cleanup redundant labels. This is a three-step process:
1515 1) Find the leading label for each block.
1516 2) Redirect all references to labels to the leading labels.
1517 3) Cleanup all useless labels. */
1520 cleanup_dead_labels (void)
1523 label_record
*label_for_bb
= XCNEWVEC (struct label_record
,
1524 last_basic_block_for_fn (cfun
));
1526 /* Find a suitable label for each block. We use the first user-defined
1527 label if there is one, or otherwise just the first label we see. */
1528 FOR_EACH_BB_FN (bb
, cfun
)
1530 gimple_stmt_iterator i
;
1532 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
1535 glabel
*label_stmt
= dyn_cast
<glabel
*> (gsi_stmt (i
));
1540 label
= gimple_label_label (label_stmt
);
1542 /* If we have not yet seen a label for the current block,
1543 remember this one and see if there are more labels. */
1544 if (!label_for_bb
[bb
->index
].label
)
1546 label_for_bb
[bb
->index
].label
= label
;
1550 /* If we did see a label for the current block already, but it
1551 is an artificially created label, replace it if the current
1552 label is a user defined label. */
1553 if (!DECL_ARTIFICIAL (label
)
1554 && DECL_ARTIFICIAL (label_for_bb
[bb
->index
].label
))
1556 label_for_bb
[bb
->index
].label
= label
;
1562 /* Now redirect all jumps/branches to the selected label.
1563 First do so for each block ending in a control statement. */
1564 FOR_EACH_BB_FN (bb
, cfun
)
1566 gimple
*stmt
= last_stmt (bb
);
1567 tree label
, new_label
;
1572 switch (gimple_code (stmt
))
1576 gcond
*cond_stmt
= as_a
<gcond
*> (stmt
);
1577 label
= gimple_cond_true_label (cond_stmt
);
1580 new_label
= main_block_label (label
, label_for_bb
);
1581 if (new_label
!= label
)
1582 gimple_cond_set_true_label (cond_stmt
, new_label
);
1585 label
= gimple_cond_false_label (cond_stmt
);
1588 new_label
= main_block_label (label
, label_for_bb
);
1589 if (new_label
!= label
)
1590 gimple_cond_set_false_label (cond_stmt
, new_label
);
1597 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
1598 size_t i
, n
= gimple_switch_num_labels (switch_stmt
);
1600 /* Replace all destination labels. */
1601 for (i
= 0; i
< n
; ++i
)
1603 tree case_label
= gimple_switch_label (switch_stmt
, i
);
1604 label
= CASE_LABEL (case_label
);
1605 new_label
= main_block_label (label
, label_for_bb
);
1606 if (new_label
!= label
)
1607 CASE_LABEL (case_label
) = new_label
;
1614 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
1615 int i
, n
= gimple_asm_nlabels (asm_stmt
);
1617 for (i
= 0; i
< n
; ++i
)
1619 tree cons
= gimple_asm_label_op (asm_stmt
, i
);
1620 tree label
= main_block_label (TREE_VALUE (cons
), label_for_bb
);
1621 TREE_VALUE (cons
) = label
;
1626 /* We have to handle gotos until they're removed, and we don't
1627 remove them until after we've created the CFG edges. */
1629 if (!computed_goto_p (stmt
))
1631 ggoto
*goto_stmt
= as_a
<ggoto
*> (stmt
);
1632 label
= gimple_goto_dest (goto_stmt
);
1633 new_label
= main_block_label (label
, label_for_bb
);
1634 if (new_label
!= label
)
1635 gimple_goto_set_dest (goto_stmt
, new_label
);
1639 case GIMPLE_TRANSACTION
:
1641 gtransaction
*txn
= as_a
<gtransaction
*> (stmt
);
1643 label
= gimple_transaction_label_norm (txn
);
1646 new_label
= main_block_label (label
, label_for_bb
);
1647 if (new_label
!= label
)
1648 gimple_transaction_set_label_norm (txn
, new_label
);
1651 label
= gimple_transaction_label_uninst (txn
);
1654 new_label
= main_block_label (label
, label_for_bb
);
1655 if (new_label
!= label
)
1656 gimple_transaction_set_label_uninst (txn
, new_label
);
1659 label
= gimple_transaction_label_over (txn
);
1662 new_label
= main_block_label (label
, label_for_bb
);
1663 if (new_label
!= label
)
1664 gimple_transaction_set_label_over (txn
, new_label
);
1674 /* Do the same for the exception region tree labels. */
1675 cleanup_dead_labels_eh (label_for_bb
);
1677 /* Finally, purge dead labels. All user-defined labels and labels that
1678 can be the target of non-local gotos and labels which have their
1679 address taken are preserved. */
1680 FOR_EACH_BB_FN (bb
, cfun
)
1682 gimple_stmt_iterator i
;
1683 tree label_for_this_bb
= label_for_bb
[bb
->index
].label
;
1685 if (!label_for_this_bb
)
1688 /* If the main label of the block is unused, we may still remove it. */
1689 if (!label_for_bb
[bb
->index
].used
)
1690 label_for_this_bb
= NULL
;
1692 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); )
1695 glabel
*label_stmt
= dyn_cast
<glabel
*> (gsi_stmt (i
));
1700 label
= gimple_label_label (label_stmt
);
1702 if (label
== label_for_this_bb
1703 || !DECL_ARTIFICIAL (label
)
1704 || DECL_NONLOCAL (label
)
1705 || FORCED_LABEL (label
))
1708 gsi_remove (&i
, true);
1712 free (label_for_bb
);
1715 /* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
1716 the ones jumping to the same label.
1717 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
1720 group_case_labels_stmt (gswitch
*stmt
)
1722 int old_size
= gimple_switch_num_labels (stmt
);
1723 int i
, next_index
, new_size
;
1724 basic_block default_bb
= NULL
;
1725 hash_set
<tree
> *removed_labels
= NULL
;
1727 default_bb
= gimple_switch_default_bb (cfun
, stmt
);
1729 /* Look for possible opportunities to merge cases. */
1731 while (i
< old_size
)
1733 tree base_case
, base_high
;
1734 basic_block base_bb
;
1736 base_case
= gimple_switch_label (stmt
, i
);
1738 gcc_assert (base_case
);
1739 base_bb
= label_to_block (cfun
, CASE_LABEL (base_case
));
1741 /* Discard cases that have the same destination as the default case or
1742 whose destination blocks have already been removed as unreachable. */
1744 || base_bb
== default_bb
1746 && removed_labels
->contains (CASE_LABEL (base_case
))))
1752 base_high
= CASE_HIGH (base_case
)
1753 ? CASE_HIGH (base_case
)
1754 : CASE_LOW (base_case
);
1757 /* Try to merge case labels. Break out when we reach the end
1758 of the label vector or when we cannot merge the next case
1759 label with the current one. */
1760 while (next_index
< old_size
)
1762 tree merge_case
= gimple_switch_label (stmt
, next_index
);
1763 basic_block merge_bb
= label_to_block (cfun
, CASE_LABEL (merge_case
));
1764 wide_int bhp1
= wi::to_wide (base_high
) + 1;
1766 /* Merge the cases if they jump to the same place,
1767 and their ranges are consecutive. */
1768 if (merge_bb
== base_bb
1769 && (removed_labels
== NULL
1770 || !removed_labels
->contains (CASE_LABEL (merge_case
)))
1771 && wi::to_wide (CASE_LOW (merge_case
)) == bhp1
)
1774 = (CASE_HIGH (merge_case
)
1775 ? CASE_HIGH (merge_case
) : CASE_LOW (merge_case
));
1776 CASE_HIGH (base_case
) = base_high
;
1783 /* Discard cases that have an unreachable destination block. */
1784 if (EDGE_COUNT (base_bb
->succs
) == 0
1785 && gimple_seq_unreachable_p (bb_seq (base_bb
))
1786 /* Don't optimize this if __builtin_unreachable () is the
1787 implicitly added one by the C++ FE too early, before
1788 -Wreturn-type can be diagnosed. We'll optimize it later
1789 during switchconv pass or any other cfg cleanup. */
1790 && (gimple_in_ssa_p (cfun
)
1791 || (LOCATION_LOCUS (gimple_location (last_stmt (base_bb
)))
1792 != BUILTINS_LOCATION
)))
1794 edge base_edge
= find_edge (gimple_bb (stmt
), base_bb
);
1795 if (base_edge
!= NULL
)
1797 for (gimple_stmt_iterator gsi
= gsi_start_bb (base_bb
);
1798 !gsi_end_p (gsi
); gsi_next (&gsi
))
1799 if (glabel
*stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
)))
1801 if (FORCED_LABEL (gimple_label_label (stmt
))
1802 || DECL_NONLOCAL (gimple_label_label (stmt
)))
1804 /* Forced/non-local labels aren't going to be removed,
1805 but they will be moved to some neighbouring basic
1806 block. If some later case label refers to one of
1807 those labels, we should throw that case away rather
1808 than keeping it around and refering to some random
1809 other basic block without an edge to it. */
1810 if (removed_labels
== NULL
)
1811 removed_labels
= new hash_set
<tree
>;
1812 removed_labels
->add (gimple_label_label (stmt
));
1817 remove_edge_and_dominated_blocks (base_edge
);
1824 gimple_switch_set_label (stmt
, new_size
,
1825 gimple_switch_label (stmt
, i
));
1830 gcc_assert (new_size
<= old_size
);
1832 if (new_size
< old_size
)
1833 gimple_switch_set_num_labels (stmt
, new_size
);
1835 delete removed_labels
;
1836 return new_size
< old_size
;
1839 /* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
1840 and scan the sorted vector of cases. Combine the ones jumping to the
1844 group_case_labels (void)
1847 bool changed
= false;
1849 FOR_EACH_BB_FN (bb
, cfun
)
1851 gimple
*stmt
= last_stmt (bb
);
1852 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1853 changed
|= group_case_labels_stmt (as_a
<gswitch
*> (stmt
));
1859 /* Checks whether we can merge block B into block A. */
1862 gimple_can_merge_blocks_p (basic_block a
, basic_block b
)
1866 if (!single_succ_p (a
))
1869 if (single_succ_edge (a
)->flags
& EDGE_COMPLEX
)
1872 if (single_succ (a
) != b
)
1875 if (!single_pred_p (b
))
1878 if (a
== ENTRY_BLOCK_PTR_FOR_FN (cfun
)
1879 || b
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
1882 /* If A ends by a statement causing exceptions or something similar, we
1883 cannot merge the blocks. */
1884 stmt
= last_stmt (a
);
1885 if (stmt
&& stmt_ends_bb_p (stmt
))
1888 /* Do not allow a block with only a non-local label to be merged. */
1890 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
1891 if (DECL_NONLOCAL (gimple_label_label (label_stmt
)))
1894 /* Examine the labels at the beginning of B. */
1895 for (gimple_stmt_iterator gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
);
1899 glabel
*label_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
1902 lab
= gimple_label_label (label_stmt
);
1904 /* Do not remove user forced labels or for -O0 any user labels. */
1905 if (!DECL_ARTIFICIAL (lab
) && (!optimize
|| FORCED_LABEL (lab
)))
1909 /* Protect simple loop latches. We only want to avoid merging
1910 the latch with the loop header or with a block in another
1911 loop in this case. */
1913 && b
->loop_father
->latch
== b
1914 && loops_state_satisfies_p (LOOPS_HAVE_SIMPLE_LATCHES
)
1915 && (b
->loop_father
->header
== a
1916 || b
->loop_father
!= a
->loop_father
))
1919 /* It must be possible to eliminate all phi nodes in B. If ssa form
1920 is not up-to-date and a name-mapping is registered, we cannot eliminate
1921 any phis. Symbols marked for renaming are never a problem though. */
1922 for (gphi_iterator gsi
= gsi_start_phis (b
); !gsi_end_p (gsi
);
1925 gphi
*phi
= gsi
.phi ();
1926 /* Technically only new names matter. */
1927 if (name_registered_for_update_p (PHI_RESULT (phi
)))
1931 /* When not optimizing, don't merge if we'd lose goto_locus. */
1933 && single_succ_edge (a
)->goto_locus
!= UNKNOWN_LOCATION
)
1935 location_t goto_locus
= single_succ_edge (a
)->goto_locus
;
1936 gimple_stmt_iterator prev
, next
;
1937 prev
= gsi_last_nondebug_bb (a
);
1938 next
= gsi_after_labels (b
);
1939 if (!gsi_end_p (next
) && is_gimple_debug (gsi_stmt (next
)))
1940 gsi_next_nondebug (&next
);
1941 if ((gsi_end_p (prev
)
1942 || gimple_location (gsi_stmt (prev
)) != goto_locus
)
1943 && (gsi_end_p (next
)
1944 || gimple_location (gsi_stmt (next
)) != goto_locus
))
1951 /* Replaces all uses of NAME by VAL. */
1954 replace_uses_by (tree name
, tree val
)
1956 imm_use_iterator imm_iter
;
1961 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, name
)
1963 /* Mark the block if we change the last stmt in it. */
1964 if (cfgcleanup_altered_bbs
1965 && stmt_ends_bb_p (stmt
))
1966 bitmap_set_bit (cfgcleanup_altered_bbs
, gimple_bb (stmt
)->index
);
1968 FOR_EACH_IMM_USE_ON_STMT (use
, imm_iter
)
1970 replace_exp (use
, val
);
1972 if (gimple_code (stmt
) == GIMPLE_PHI
)
1974 e
= gimple_phi_arg_edge (as_a
<gphi
*> (stmt
),
1975 PHI_ARG_INDEX_FROM_USE (use
));
1976 if (e
->flags
& EDGE_ABNORMAL
1977 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val
))
1979 /* This can only occur for virtual operands, since
1980 for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
1981 would prevent replacement. */
1982 gcc_checking_assert (virtual_operand_p (name
));
1983 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val
) = 1;
1988 if (gimple_code (stmt
) != GIMPLE_PHI
)
1990 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
1991 gimple
*orig_stmt
= stmt
;
1994 /* FIXME. It shouldn't be required to keep TREE_CONSTANT
1995 on ADDR_EXPRs up-to-date on GIMPLE. Propagation will
1996 only change sth from non-invariant to invariant, and only
1997 when propagating constants. */
1998 if (is_gimple_min_invariant (val
))
1999 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
2001 tree op
= gimple_op (stmt
, i
);
2002 /* Operands may be empty here. For example, the labels
2003 of a GIMPLE_COND are nulled out following the creation
2004 of the corresponding CFG edges. */
2005 if (op
&& TREE_CODE (op
) == ADDR_EXPR
)
2006 recompute_tree_invariant_for_addr_expr (op
);
2009 if (fold_stmt (&gsi
))
2010 stmt
= gsi_stmt (gsi
);
2012 if (maybe_clean_or_replace_eh_stmt (orig_stmt
, stmt
))
2013 gimple_purge_dead_eh_edges (gimple_bb (stmt
));
2019 gcc_checking_assert (has_zero_uses (name
));
2021 /* Also update the trees stored in loop structures. */
2026 FOR_EACH_LOOP (loop
, 0)
2028 substitute_in_loop_info (loop
, name
, val
);
2033 /* Merge block B into block A. */
2036 gimple_merge_blocks (basic_block a
, basic_block b
)
2038 gimple_stmt_iterator last
, gsi
;
2042 fprintf (dump_file
, "Merging blocks %d and %d\n", a
->index
, b
->index
);
2044 /* Remove all single-valued PHI nodes from block B of the form
2045 V_i = PHI <V_j> by propagating V_j to all the uses of V_i. */
2046 gsi
= gsi_last_bb (a
);
2047 for (psi
= gsi_start_phis (b
); !gsi_end_p (psi
); )
2049 gimple
*phi
= gsi_stmt (psi
);
2050 tree def
= gimple_phi_result (phi
), use
= gimple_phi_arg_def (phi
, 0);
2052 bool may_replace_uses
= (virtual_operand_p (def
)
2053 || may_propagate_copy (def
, use
));
2055 /* In case we maintain loop closed ssa form, do not propagate arguments
2056 of loop exit phi nodes. */
2058 && loops_state_satisfies_p (LOOP_CLOSED_SSA
)
2059 && !virtual_operand_p (def
)
2060 && TREE_CODE (use
) == SSA_NAME
2061 && a
->loop_father
!= b
->loop_father
)
2062 may_replace_uses
= false;
2064 if (!may_replace_uses
)
2066 gcc_assert (!virtual_operand_p (def
));
2068 /* Note that just emitting the copies is fine -- there is no problem
2069 with ordering of phi nodes. This is because A is the single
2070 predecessor of B, therefore results of the phi nodes cannot
2071 appear as arguments of the phi nodes. */
2072 copy
= gimple_build_assign (def
, use
);
2073 gsi_insert_after (&gsi
, copy
, GSI_NEW_STMT
);
2074 remove_phi_node (&psi
, false);
2078 /* If we deal with a PHI for virtual operands, we can simply
2079 propagate these without fussing with folding or updating
2081 if (virtual_operand_p (def
))
2083 imm_use_iterator iter
;
2084 use_operand_p use_p
;
2087 FOR_EACH_IMM_USE_STMT (stmt
, iter
, def
)
2088 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
2089 SET_USE (use_p
, use
);
2091 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
2092 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use
) = 1;
2095 replace_uses_by (def
, use
);
2097 remove_phi_node (&psi
, true);
2101 /* Ensure that B follows A. */
2102 move_block_after (b
, a
);
2104 gcc_assert (single_succ_edge (a
)->flags
& EDGE_FALLTHRU
);
2105 gcc_assert (!last_stmt (a
) || !stmt_ends_bb_p (last_stmt (a
)));
2107 /* Remove labels from B and set gimple_bb to A for other statements. */
2108 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
);)
2110 gimple
*stmt
= gsi_stmt (gsi
);
2111 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
2113 tree label
= gimple_label_label (label_stmt
);
2116 gsi_remove (&gsi
, false);
2118 /* Now that we can thread computed gotos, we might have
2119 a situation where we have a forced label in block B
2120 However, the label at the start of block B might still be
2121 used in other ways (think about the runtime checking for
2122 Fortran assigned gotos). So we cannot just delete the
2123 label. Instead we move the label to the start of block A. */
2124 if (FORCED_LABEL (label
))
2126 gimple_stmt_iterator dest_gsi
= gsi_start_bb (a
);
2127 gsi_insert_before (&dest_gsi
, stmt
, GSI_NEW_STMT
);
2129 /* Other user labels keep around in a form of a debug stmt. */
2130 else if (!DECL_ARTIFICIAL (label
) && MAY_HAVE_DEBUG_BIND_STMTS
)
2132 gimple
*dbg
= gimple_build_debug_bind (label
,
2135 gimple_debug_bind_reset_value (dbg
);
2136 gsi_insert_before (&gsi
, dbg
, GSI_SAME_STMT
);
2139 lp_nr
= EH_LANDING_PAD_NR (label
);
2142 eh_landing_pad lp
= get_eh_landing_pad_from_number (lp_nr
);
2143 lp
->post_landing_pad
= NULL
;
2148 gimple_set_bb (stmt
, a
);
2153 /* When merging two BBs, if their counts are different, the larger count
2154 is selected as the new bb count. This is to handle inconsistent
2156 if (a
->loop_father
== b
->loop_father
)
2158 a
->count
= a
->count
.merge (b
->count
);
2161 /* Merge the sequences. */
2162 last
= gsi_last_bb (a
);
2163 gsi_insert_seq_after (&last
, bb_seq (b
), GSI_NEW_STMT
);
2164 set_bb_seq (b
, NULL
);
2166 if (cfgcleanup_altered_bbs
)
2167 bitmap_set_bit (cfgcleanup_altered_bbs
, a
->index
);
2171 /* Return the one of two successors of BB that is not reachable by a
2172 complex edge, if there is one. Else, return BB. We use
2173 this in optimizations that use post-dominators for their heuristics,
2174 to catch the cases in C++ where function calls are involved. */
2177 single_noncomplex_succ (basic_block bb
)
2180 if (EDGE_COUNT (bb
->succs
) != 2)
2183 e0
= EDGE_SUCC (bb
, 0);
2184 e1
= EDGE_SUCC (bb
, 1);
2185 if (e0
->flags
& EDGE_COMPLEX
)
2187 if (e1
->flags
& EDGE_COMPLEX
)
2193 /* T is CALL_EXPR. Set current_function_calls_* flags. */
2196 notice_special_calls (gcall
*call
)
2198 int flags
= gimple_call_flags (call
);
2200 if (flags
& ECF_MAY_BE_ALLOCA
)
2201 cfun
->calls_alloca
= true;
2202 if (flags
& ECF_RETURNS_TWICE
)
2203 cfun
->calls_setjmp
= true;
2207 /* Clear flags set by notice_special_calls. Used by dead code removal
2208 to update the flags. */
2211 clear_special_calls (void)
2213 cfun
->calls_alloca
= false;
2214 cfun
->calls_setjmp
= false;
2217 /* Remove PHI nodes associated with basic block BB and all edges out of BB. */
2220 remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb
)
2222 /* Since this block is no longer reachable, we can just delete all
2223 of its PHI nodes. */
2224 remove_phi_nodes (bb
);
2226 /* Remove edges to BB's successors. */
2227 while (EDGE_COUNT (bb
->succs
) > 0)
2228 remove_edge (EDGE_SUCC (bb
, 0));
2232 /* Remove statements of basic block BB. */
2235 remove_bb (basic_block bb
)
2237 gimple_stmt_iterator i
;
2241 fprintf (dump_file
, "Removing basic block %d\n", bb
->index
);
2242 if (dump_flags
& TDF_DETAILS
)
2244 dump_bb (dump_file
, bb
, 0, TDF_BLOCKS
);
2245 fprintf (dump_file
, "\n");
2251 class loop
*loop
= bb
->loop_father
;
2253 /* If a loop gets removed, clean up the information associated
2255 if (loop
->latch
== bb
2256 || loop
->header
== bb
)
2257 free_numbers_of_iterations_estimates (loop
);
2260 /* Remove all the instructions in the block. */
2261 if (bb_seq (bb
) != NULL
)
2263 /* Walk backwards so as to get a chance to substitute all
2264 released DEFs into debug stmts. See
2265 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
2267 for (i
= gsi_last_bb (bb
); !gsi_end_p (i
);)
2269 gimple
*stmt
= gsi_stmt (i
);
2270 glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
);
2272 && (FORCED_LABEL (gimple_label_label (label_stmt
))
2273 || DECL_NONLOCAL (gimple_label_label (label_stmt
))))
2276 gimple_stmt_iterator new_gsi
;
2278 /* A non-reachable non-local label may still be referenced.
2279 But it no longer needs to carry the extra semantics of
2281 if (DECL_NONLOCAL (gimple_label_label (label_stmt
)))
2283 DECL_NONLOCAL (gimple_label_label (label_stmt
)) = 0;
2284 FORCED_LABEL (gimple_label_label (label_stmt
)) = 1;
2287 new_bb
= bb
->prev_bb
;
2288 /* Don't move any labels into ENTRY block. */
2289 if (new_bb
== ENTRY_BLOCK_PTR_FOR_FN (cfun
))
2291 new_bb
= single_succ (new_bb
);
2292 gcc_assert (new_bb
!= bb
);
2294 new_gsi
= gsi_after_labels (new_bb
);
2295 gsi_remove (&i
, false);
2296 gsi_insert_before (&new_gsi
, stmt
, GSI_NEW_STMT
);
2300 /* Release SSA definitions. */
2301 release_defs (stmt
);
2302 gsi_remove (&i
, true);
2306 i
= gsi_last_bb (bb
);
2312 remove_phi_nodes_and_edges_for_unreachable_block (bb
);
2313 bb
->il
.gimple
.seq
= NULL
;
2314 bb
->il
.gimple
.phi_nodes
= NULL
;
2318 /* Given a basic block BB and a value VAL for use in the final statement
2319 of the block (if a GIMPLE_COND, GIMPLE_SWITCH, or computed goto), return
2320 the edge that will be taken out of the block.
2321 If VAL is NULL_TREE, then the current value of the final statement's
2322 predicate or index is used.
2323 If the value does not match a unique edge, NULL is returned. */
2326 find_taken_edge (basic_block bb
, tree val
)
2330 stmt
= last_stmt (bb
);
2332 /* Handle ENTRY and EXIT. */
2336 if (gimple_code (stmt
) == GIMPLE_COND
)
2337 return find_taken_edge_cond_expr (as_a
<gcond
*> (stmt
), val
);
2339 if (gimple_code (stmt
) == GIMPLE_SWITCH
)
2340 return find_taken_edge_switch_expr (as_a
<gswitch
*> (stmt
), val
);
2342 if (computed_goto_p (stmt
))
2344 /* Only optimize if the argument is a label, if the argument is
2345 not a label then we cannot construct a proper CFG.
2347 It may be the case that we only need to allow the LABEL_REF to
2348 appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
2349 appear inside a LABEL_EXPR just to be safe. */
2351 && (TREE_CODE (val
) == ADDR_EXPR
|| TREE_CODE (val
) == LABEL_EXPR
)
2352 && TREE_CODE (TREE_OPERAND (val
, 0)) == LABEL_DECL
)
2353 return find_taken_edge_computed_goto (bb
, TREE_OPERAND (val
, 0));
2356 /* Otherwise we only know the taken successor edge if it's unique. */
2357 return single_succ_p (bb
) ? single_succ_edge (bb
) : NULL
;
2360 /* Given a constant value VAL and the entry block BB to a GOTO_EXPR
2361 statement, determine which of the outgoing edges will be taken out of the
2362 block. Return NULL if either edge may be taken. */
2365 find_taken_edge_computed_goto (basic_block bb
, tree val
)
2370 dest
= label_to_block (cfun
, val
);
2372 e
= find_edge (bb
, dest
);
2374 /* It's possible for find_edge to return NULL here on invalid code
2375 that abuses the labels-as-values extension (e.g. code that attempts to
2376 jump *between* functions via stored labels-as-values; PR 84136).
2377 If so, then we simply return that NULL for the edge.
2378 We don't currently have a way of detecting such invalid code, so we
2379 can't assert that it was the case when a NULL edge occurs here. */
2384 /* Given COND_STMT and a constant value VAL for use as the predicate,
2385 determine which of the two edges will be taken out of
2386 the statement's block. Return NULL if either edge may be taken.
2387 If VAL is NULL_TREE, then the current value of COND_STMT's predicate
2391 find_taken_edge_cond_expr (const gcond
*cond_stmt
, tree val
)
2393 edge true_edge
, false_edge
;
2395 if (val
== NULL_TREE
)
2397 /* Use the current value of the predicate. */
2398 if (gimple_cond_true_p (cond_stmt
))
2399 val
= integer_one_node
;
2400 else if (gimple_cond_false_p (cond_stmt
))
2401 val
= integer_zero_node
;
2405 else if (TREE_CODE (val
) != INTEGER_CST
)
2408 extract_true_false_edges_from_block (gimple_bb (cond_stmt
),
2409 &true_edge
, &false_edge
);
2411 return (integer_zerop (val
) ? false_edge
: true_edge
);
2414 /* Given SWITCH_STMT and an INTEGER_CST VAL for use as the index, determine
2415 which edge will be taken out of the statement's block. Return NULL if any
2417 If VAL is NULL_TREE, then the current value of SWITCH_STMT's index
2421 find_taken_edge_switch_expr (const gswitch
*switch_stmt
, tree val
)
2423 basic_block dest_bb
;
2427 if (gimple_switch_num_labels (switch_stmt
) == 1)
2428 taken_case
= gimple_switch_default_label (switch_stmt
);
2431 if (val
== NULL_TREE
)
2432 val
= gimple_switch_index (switch_stmt
);
2433 if (TREE_CODE (val
) != INTEGER_CST
)
2436 taken_case
= find_case_label_for_value (switch_stmt
, val
);
2438 dest_bb
= label_to_block (cfun
, CASE_LABEL (taken_case
));
2440 e
= find_edge (gimple_bb (switch_stmt
), dest_bb
);
2446 /* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
2447 We can make optimal use here of the fact that the case labels are
2448 sorted: We can do a binary search for a case matching VAL. */
2451 find_case_label_for_value (const gswitch
*switch_stmt
, tree val
)
2453 size_t low
, high
, n
= gimple_switch_num_labels (switch_stmt
);
2454 tree default_case
= gimple_switch_default_label (switch_stmt
);
2456 for (low
= 0, high
= n
; high
- low
> 1; )
2458 size_t i
= (high
+ low
) / 2;
2459 tree t
= gimple_switch_label (switch_stmt
, i
);
2462 /* Cache the result of comparing CASE_LOW and val. */
2463 cmp
= tree_int_cst_compare (CASE_LOW (t
), val
);
2470 if (CASE_HIGH (t
) == NULL
)
2472 /* A singe-valued case label. */
2478 /* A case range. We can only handle integer ranges. */
2479 if (cmp
<= 0 && tree_int_cst_compare (CASE_HIGH (t
), val
) >= 0)
2484 return default_case
;
2488 /* Dump a basic block on stderr. */
2491 gimple_debug_bb (basic_block bb
)
2493 dump_bb (stderr
, bb
, 0, TDF_VOPS
|TDF_MEMSYMS
|TDF_BLOCKS
);
2497 /* Dump basic block with index N on stderr. */
2500 gimple_debug_bb_n (int n
)
2502 gimple_debug_bb (BASIC_BLOCK_FOR_FN (cfun
, n
));
2503 return BASIC_BLOCK_FOR_FN (cfun
, n
);
2507 /* Dump the CFG on stderr.
2509 FLAGS are the same used by the tree dumping functions
2510 (see TDF_* in dumpfile.h). */
2513 gimple_debug_cfg (dump_flags_t flags
)
2515 gimple_dump_cfg (stderr
, flags
);
2519 /* Dump the program showing basic block boundaries on the given FILE.
2521 FLAGS are the same used by the tree dumping functions (see TDF_* in
2525 gimple_dump_cfg (FILE *file
, dump_flags_t flags
)
2527 if (flags
& TDF_DETAILS
)
2529 dump_function_header (file
, current_function_decl
, flags
);
2530 fprintf (file
, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
2531 n_basic_blocks_for_fn (cfun
), n_edges_for_fn (cfun
),
2532 last_basic_block_for_fn (cfun
));
2534 brief_dump_cfg (file
, flags
);
2535 fprintf (file
, "\n");
2538 if (flags
& TDF_STATS
)
2539 dump_cfg_stats (file
);
2541 dump_function_to_file (current_function_decl
, file
, flags
| TDF_BLOCKS
);
2545 /* Dump CFG statistics on FILE. */
2548 dump_cfg_stats (FILE *file
)
2550 static long max_num_merged_labels
= 0;
2551 unsigned long size
, total
= 0;
2554 const char * const fmt_str
= "%-30s%-13s%12s\n";
2555 const char * const fmt_str_1
= "%-30s%13d" PRsa (11) "\n";
2556 const char * const fmt_str_2
= "%-30s%13ld" PRsa (11) "\n";
2557 const char * const fmt_str_3
= "%-43s" PRsa (11) "\n";
2558 const char *funcname
= current_function_name ();
2560 fprintf (file
, "\nCFG Statistics for %s\n\n", funcname
);
2562 fprintf (file
, "---------------------------------------------------------\n");
2563 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
2564 fprintf (file
, fmt_str
, "", " instances ", "used ");
2565 fprintf (file
, "---------------------------------------------------------\n");
2567 size
= n_basic_blocks_for_fn (cfun
) * sizeof (struct basic_block_def
);
2569 fprintf (file
, fmt_str_1
, "Basic blocks", n_basic_blocks_for_fn (cfun
),
2570 SIZE_AMOUNT (size
));
2573 FOR_EACH_BB_FN (bb
, cfun
)
2574 num_edges
+= EDGE_COUNT (bb
->succs
);
2575 size
= num_edges
* sizeof (class edge_def
);
2577 fprintf (file
, fmt_str_2
, "Edges", num_edges
, SIZE_AMOUNT (size
));
2579 fprintf (file
, "---------------------------------------------------------\n");
2580 fprintf (file
, fmt_str_3
, "Total memory used by CFG data",
2581 SIZE_AMOUNT (total
));
2582 fprintf (file
, "---------------------------------------------------------\n");
2583 fprintf (file
, "\n");
2585 if (cfg_stats
.num_merged_labels
> max_num_merged_labels
)
2586 max_num_merged_labels
= cfg_stats
.num_merged_labels
;
2588 fprintf (file
, "Coalesced label blocks: %ld (Max so far: %ld)\n",
2589 cfg_stats
.num_merged_labels
, max_num_merged_labels
);
2591 fprintf (file
, "\n");
2595 /* Dump CFG statistics on stderr. Keep extern so that it's always
2596 linked in the final executable. */
2599 debug_cfg_stats (void)
2601 dump_cfg_stats (stderr
);
2604 /*---------------------------------------------------------------------------
2605 Miscellaneous helpers
2606 ---------------------------------------------------------------------------*/
2608 /* Return true if T, a GIMPLE_CALL, can make an abnormal transfer of control
2609 flow. Transfers of control flow associated with EH are excluded. */
2612 call_can_make_abnormal_goto (gimple
*t
)
2614 /* If the function has no non-local labels, then a call cannot make an
2615 abnormal transfer of control. */
2616 if (!cfun
->has_nonlocal_label
2617 && !cfun
->calls_setjmp
)
2620 /* Likewise if the call has no side effects. */
2621 if (!gimple_has_side_effects (t
))
2624 /* Likewise if the called function is leaf. */
2625 if (gimple_call_flags (t
) & ECF_LEAF
)
2632 /* Return true if T can make an abnormal transfer of control flow.
2633 Transfers of control flow associated with EH are excluded. */
2636 stmt_can_make_abnormal_goto (gimple
*t
)
2638 if (computed_goto_p (t
))
2640 if (is_gimple_call (t
))
2641 return call_can_make_abnormal_goto (t
);
2646 /* Return true if T represents a stmt that always transfers control. */
2649 is_ctrl_stmt (gimple
*t
)
2651 switch (gimple_code (t
))
2665 /* Return true if T is a statement that may alter the flow of control
2666 (e.g., a call to a non-returning function). */
2669 is_ctrl_altering_stmt (gimple
*t
)
2673 switch (gimple_code (t
))
2676 /* Per stmt call flag indicates whether the call could alter
2678 if (gimple_call_ctrl_altering_p (t
))
2682 case GIMPLE_EH_DISPATCH
:
2683 /* EH_DISPATCH branches to the individual catch handlers at
2684 this level of a try or allowed-exceptions region. It can
2685 fallthru to the next statement as well. */
2689 if (gimple_asm_nlabels (as_a
<gasm
*> (t
)) > 0)
2694 /* OpenMP directives alter control flow. */
2697 case GIMPLE_TRANSACTION
:
2698 /* A transaction start alters control flow. */
2705 /* If a statement can throw, it alters control flow. */
2706 return stmt_can_throw_internal (cfun
, t
);
2710 /* Return true if T is a simple local goto. */
2713 simple_goto_p (gimple
*t
)
2715 return (gimple_code (t
) == GIMPLE_GOTO
2716 && TREE_CODE (gimple_goto_dest (t
)) == LABEL_DECL
);
2720 /* Return true if STMT should start a new basic block. PREV_STMT is
2721 the statement preceding STMT. It is used when STMT is a label or a
2722 case label. Labels should only start a new basic block if their
2723 previous statement wasn't a label. Otherwise, sequence of labels
2724 would generate unnecessary basic blocks that only contain a single
2728 stmt_starts_bb_p (gimple
*stmt
, gimple
*prev_stmt
)
2733 /* PREV_STMT is only set to a debug stmt if the debug stmt is before
2734 any nondebug stmts in the block. We don't want to start another
2735 block in this case: the debug stmt will already have started the
2736 one STMT would start if we weren't outputting debug stmts. */
2737 if (prev_stmt
&& is_gimple_debug (prev_stmt
))
2740 /* Labels start a new basic block only if the preceding statement
2741 wasn't a label of the same type. This prevents the creation of
2742 consecutive blocks that have nothing but a single label. */
2743 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
2745 /* Nonlocal and computed GOTO targets always start a new block. */
2746 if (DECL_NONLOCAL (gimple_label_label (label_stmt
))
2747 || FORCED_LABEL (gimple_label_label (label_stmt
)))
2750 if (glabel
*plabel
= safe_dyn_cast
<glabel
*> (prev_stmt
))
2752 if (DECL_NONLOCAL (gimple_label_label (plabel
))
2753 || !DECL_ARTIFICIAL (gimple_label_label (plabel
)))
2756 cfg_stats
.num_merged_labels
++;
2762 else if (gimple_code (stmt
) == GIMPLE_CALL
)
2764 if (gimple_call_flags (stmt
) & ECF_RETURNS_TWICE
)
2765 /* setjmp acts similar to a nonlocal GOTO target and thus should
2766 start a new block. */
2768 if (gimple_call_internal_p (stmt
, IFN_PHI
)
2770 && gimple_code (prev_stmt
) != GIMPLE_LABEL
2771 && (gimple_code (prev_stmt
) != GIMPLE_CALL
2772 || ! gimple_call_internal_p (prev_stmt
, IFN_PHI
)))
2773 /* PHI nodes start a new block unless preceeded by a label
2782 /* Return true if T should end a basic block. */
2785 stmt_ends_bb_p (gimple
*t
)
2787 return is_ctrl_stmt (t
) || is_ctrl_altering_stmt (t
);
2790 /* Remove block annotations and other data structures. */
2793 delete_tree_cfg_annotations (struct function
*fn
)
2795 vec_free (label_to_block_map_for_fn (fn
));
2798 /* Return the virtual phi in BB. */
2801 get_virtual_phi (basic_block bb
)
2803 for (gphi_iterator gsi
= gsi_start_phis (bb
);
2807 gphi
*phi
= gsi
.phi ();
2809 if (virtual_operand_p (PHI_RESULT (phi
)))
2816 /* Return the first statement in basic block BB. */
2819 first_stmt (basic_block bb
)
2821 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2822 gimple
*stmt
= NULL
;
2824 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2832 /* Return the first non-label statement in basic block BB. */
2835 first_non_label_stmt (basic_block bb
)
2837 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2838 while (!gsi_end_p (i
) && gimple_code (gsi_stmt (i
)) == GIMPLE_LABEL
)
2840 return !gsi_end_p (i
) ? gsi_stmt (i
) : NULL
;
2843 /* Return the last statement in basic block BB. */
2846 last_stmt (basic_block bb
)
2848 gimple_stmt_iterator i
= gsi_last_bb (bb
);
2849 gimple
*stmt
= NULL
;
2851 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2859 /* Return the last statement of an otherwise empty block. Return NULL
2860 if the block is totally empty, or if it contains more than one
2864 last_and_only_stmt (basic_block bb
)
2866 gimple_stmt_iterator i
= gsi_last_nondebug_bb (bb
);
2867 gimple
*last
, *prev
;
2872 last
= gsi_stmt (i
);
2873 gsi_prev_nondebug (&i
);
2877 /* Empty statements should no longer appear in the instruction stream.
2878 Everything that might have appeared before should be deleted by
2879 remove_useless_stmts, and the optimizers should just gsi_remove
2880 instead of smashing with build_empty_stmt.
2882 Thus the only thing that should appear here in a block containing
2883 one executable statement is a label. */
2884 prev
= gsi_stmt (i
);
2885 if (gimple_code (prev
) == GIMPLE_LABEL
)
2891 /* Reinstall those PHI arguments queued in OLD_EDGE to NEW_EDGE. */
2894 reinstall_phi_args (edge new_edge
, edge old_edge
)
2900 vec
<edge_var_map
> *v
= redirect_edge_var_map_vector (old_edge
);
2904 for (i
= 0, phis
= gsi_start_phis (new_edge
->dest
);
2905 v
->iterate (i
, &vm
) && !gsi_end_p (phis
);
2906 i
++, gsi_next (&phis
))
2908 gphi
*phi
= phis
.phi ();
2909 tree result
= redirect_edge_var_map_result (vm
);
2910 tree arg
= redirect_edge_var_map_def (vm
);
2912 gcc_assert (result
== gimple_phi_result (phi
));
2914 add_phi_arg (phi
, arg
, new_edge
, redirect_edge_var_map_location (vm
));
2917 redirect_edge_var_map_clear (old_edge
);
2920 /* Returns the basic block after which the new basic block created
2921 by splitting edge EDGE_IN should be placed. Tries to keep the new block
2922 near its "logical" location. This is of most help to humans looking
2923 at debugging dumps. */
2926 split_edge_bb_loc (edge edge_in
)
2928 basic_block dest
= edge_in
->dest
;
2929 basic_block dest_prev
= dest
->prev_bb
;
2933 edge e
= find_edge (dest_prev
, dest
);
2934 if (e
&& !(e
->flags
& EDGE_COMPLEX
))
2935 return edge_in
->src
;
2940 /* Split a (typically critical) edge EDGE_IN. Return the new block.
2941 Abort on abnormal edges. */
2944 gimple_split_edge (edge edge_in
)
2946 basic_block new_bb
, after_bb
, dest
;
2949 /* Abnormal edges cannot be split. */
2950 gcc_assert (!(edge_in
->flags
& EDGE_ABNORMAL
));
2952 dest
= edge_in
->dest
;
2954 after_bb
= split_edge_bb_loc (edge_in
);
2956 new_bb
= create_empty_bb (after_bb
);
2957 new_bb
->count
= edge_in
->count ();
2959 e
= redirect_edge_and_branch (edge_in
, new_bb
);
2960 gcc_assert (e
== edge_in
);
2962 new_edge
= make_single_succ_edge (new_bb
, dest
, EDGE_FALLTHRU
);
2963 reinstall_phi_args (new_edge
, e
);
2969 /* Verify properties of the address expression T whose base should be
2970 TREE_ADDRESSABLE if VERIFY_ADDRESSABLE is true. */
2973 verify_address (tree t
, bool verify_addressable
)
2976 bool old_side_effects
;
2978 bool new_side_effects
;
2980 old_constant
= TREE_CONSTANT (t
);
2981 old_side_effects
= TREE_SIDE_EFFECTS (t
);
2983 recompute_tree_invariant_for_addr_expr (t
);
2984 new_side_effects
= TREE_SIDE_EFFECTS (t
);
2985 new_constant
= TREE_CONSTANT (t
);
2987 if (old_constant
!= new_constant
)
2989 error ("constant not recomputed when %<ADDR_EXPR%> changed");
2992 if (old_side_effects
!= new_side_effects
)
2994 error ("side effects not recomputed when %<ADDR_EXPR%> changed");
2998 tree base
= TREE_OPERAND (t
, 0);
2999 while (handled_component_p (base
))
3000 base
= TREE_OPERAND (base
, 0);
3003 || TREE_CODE (base
) == PARM_DECL
3004 || TREE_CODE (base
) == RESULT_DECL
))
3007 if (verify_addressable
&& !TREE_ADDRESSABLE (base
))
3009 error ("address taken but %<TREE_ADDRESSABLE%> bit not set");
3017 /* Verify if EXPR is either a GIMPLE ID or a GIMPLE indirect reference.
3018 Returns true if there is an error, otherwise false. */
3021 verify_types_in_gimple_min_lval (tree expr
)
3025 if (is_gimple_id (expr
))
3028 if (TREE_CODE (expr
) != TARGET_MEM_REF
3029 && TREE_CODE (expr
) != MEM_REF
)
3031 error ("invalid expression for min lvalue");
3035 /* TARGET_MEM_REFs are strange beasts. */
3036 if (TREE_CODE (expr
) == TARGET_MEM_REF
)
3039 op
= TREE_OPERAND (expr
, 0);
3040 if (!is_gimple_val (op
))
3042 error ("invalid operand in indirect reference");
3043 debug_generic_stmt (op
);
3046 /* Memory references now generally can involve a value conversion. */
3051 /* Verify if EXPR is a valid GIMPLE reference expression. If
3052 REQUIRE_LVALUE is true verifies it is an lvalue. Returns true
3053 if there is an error, otherwise false. */
3056 verify_types_in_gimple_reference (tree expr
, bool require_lvalue
)
3058 const char *code_name
= get_tree_code_name (TREE_CODE (expr
));
3060 if (TREE_CODE (expr
) == REALPART_EXPR
3061 || TREE_CODE (expr
) == IMAGPART_EXPR
3062 || TREE_CODE (expr
) == BIT_FIELD_REF
)
3064 tree op
= TREE_OPERAND (expr
, 0);
3065 if (!is_gimple_reg_type (TREE_TYPE (expr
)))
3067 error ("non-scalar %qs", code_name
);
3071 if (TREE_CODE (expr
) == BIT_FIELD_REF
)
3073 tree t1
= TREE_OPERAND (expr
, 1);
3074 tree t2
= TREE_OPERAND (expr
, 2);
3075 poly_uint64 size
, bitpos
;
3076 if (!poly_int_tree_p (t1
, &size
)
3077 || !poly_int_tree_p (t2
, &bitpos
)
3078 || !types_compatible_p (bitsizetype
, TREE_TYPE (t1
))
3079 || !types_compatible_p (bitsizetype
, TREE_TYPE (t2
)))
3081 error ("invalid position or size operand to %qs", code_name
);
3084 if (INTEGRAL_TYPE_P (TREE_TYPE (expr
))
3085 && maybe_ne (TYPE_PRECISION (TREE_TYPE (expr
)), size
))
3087 error ("integral result type precision does not match "
3088 "field size of %qs", code_name
);
3091 else if (!INTEGRAL_TYPE_P (TREE_TYPE (expr
))
3092 && TYPE_MODE (TREE_TYPE (expr
)) != BLKmode
3093 && maybe_ne (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr
))),
3096 error ("mode size of non-integral result does not "
3097 "match field size of %qs",
3101 if (INTEGRAL_TYPE_P (TREE_TYPE (op
))
3102 && !type_has_mode_precision_p (TREE_TYPE (op
)))
3104 error ("%qs of non-mode-precision operand", code_name
);
3107 if (!AGGREGATE_TYPE_P (TREE_TYPE (op
))
3108 && maybe_gt (size
+ bitpos
,
3109 tree_to_poly_uint64 (TYPE_SIZE (TREE_TYPE (op
)))))
3111 error ("position plus size exceeds size of referenced object in "
3117 if ((TREE_CODE (expr
) == REALPART_EXPR
3118 || TREE_CODE (expr
) == IMAGPART_EXPR
)
3119 && !useless_type_conversion_p (TREE_TYPE (expr
),
3120 TREE_TYPE (TREE_TYPE (op
))))
3122 error ("type mismatch in %qs reference", code_name
);
3123 debug_generic_stmt (TREE_TYPE (expr
));
3124 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3130 while (handled_component_p (expr
))
3132 code_name
= get_tree_code_name (TREE_CODE (expr
));
3134 if (TREE_CODE (expr
) == REALPART_EXPR
3135 || TREE_CODE (expr
) == IMAGPART_EXPR
3136 || TREE_CODE (expr
) == BIT_FIELD_REF
)
3138 error ("non-top-level %qs", code_name
);
3142 tree op
= TREE_OPERAND (expr
, 0);
3144 if (TREE_CODE (expr
) == ARRAY_REF
3145 || TREE_CODE (expr
) == ARRAY_RANGE_REF
)
3147 if (!is_gimple_val (TREE_OPERAND (expr
, 1))
3148 || (TREE_OPERAND (expr
, 2)
3149 && !is_gimple_val (TREE_OPERAND (expr
, 2)))
3150 || (TREE_OPERAND (expr
, 3)
3151 && !is_gimple_val (TREE_OPERAND (expr
, 3))))
3153 error ("invalid operands to %qs", code_name
);
3154 debug_generic_stmt (expr
);
3159 /* Verify if the reference array element types are compatible. */
3160 if (TREE_CODE (expr
) == ARRAY_REF
3161 && !useless_type_conversion_p (TREE_TYPE (expr
),
3162 TREE_TYPE (TREE_TYPE (op
))))
3164 error ("type mismatch in %qs", code_name
);
3165 debug_generic_stmt (TREE_TYPE (expr
));
3166 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3169 if (TREE_CODE (expr
) == ARRAY_RANGE_REF
3170 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr
)),
3171 TREE_TYPE (TREE_TYPE (op
))))
3173 error ("type mismatch in %qs", code_name
);
3174 debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr
)));
3175 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3179 if (TREE_CODE (expr
) == COMPONENT_REF
)
3181 if (TREE_OPERAND (expr
, 2)
3182 && !is_gimple_val (TREE_OPERAND (expr
, 2)))
3184 error ("invalid %qs offset operator", code_name
);
3187 if (!useless_type_conversion_p (TREE_TYPE (expr
),
3188 TREE_TYPE (TREE_OPERAND (expr
, 1))))
3190 error ("type mismatch in %qs", code_name
);
3191 debug_generic_stmt (TREE_TYPE (expr
));
3192 debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr
, 1)));
3197 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
)
3199 /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
3200 that their operand is not an SSA name or an invariant when
3201 requiring an lvalue (this usually means there is a SRA or IPA-SRA
3202 bug). Otherwise there is nothing to verify, gross mismatches at
3203 most invoke undefined behavior. */
3205 && (TREE_CODE (op
) == SSA_NAME
3206 || is_gimple_min_invariant (op
)))
3208 error ("conversion of %qs on the left hand side of %qs",
3209 get_tree_code_name (TREE_CODE (op
)), code_name
);
3210 debug_generic_stmt (expr
);
3213 else if (TREE_CODE (op
) == SSA_NAME
3214 && TYPE_SIZE (TREE_TYPE (expr
)) != TYPE_SIZE (TREE_TYPE (op
)))
3216 error ("conversion of register to a different size in %qs",
3218 debug_generic_stmt (expr
);
3221 else if (!handled_component_p (op
))
3228 code_name
= get_tree_code_name (TREE_CODE (expr
));
3230 if (TREE_CODE (expr
) == MEM_REF
)
3232 if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr
, 0))
3233 || (TREE_CODE (TREE_OPERAND (expr
, 0)) == ADDR_EXPR
3234 && verify_address (TREE_OPERAND (expr
, 0), false)))
3236 error ("invalid address operand in %qs", code_name
);
3237 debug_generic_stmt (expr
);
3240 if (!poly_int_tree_p (TREE_OPERAND (expr
, 1))
3241 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr
, 1))))
3243 error ("invalid offset operand in %qs", code_name
);
3244 debug_generic_stmt (expr
);
3247 if (MR_DEPENDENCE_CLIQUE (expr
) != 0
3248 && MR_DEPENDENCE_CLIQUE (expr
) > cfun
->last_clique
)
3250 error ("invalid clique in %qs", code_name
);
3251 debug_generic_stmt (expr
);
3255 else if (TREE_CODE (expr
) == TARGET_MEM_REF
)
3257 if (!TMR_BASE (expr
)
3258 || !is_gimple_mem_ref_addr (TMR_BASE (expr
))
3259 || (TREE_CODE (TMR_BASE (expr
)) == ADDR_EXPR
3260 && verify_address (TMR_BASE (expr
), false)))
3262 error ("invalid address operand in %qs", code_name
);
3265 if (!TMR_OFFSET (expr
)
3266 || !poly_int_tree_p (TMR_OFFSET (expr
))
3267 || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr
))))
3269 error ("invalid offset operand in %qs", code_name
);
3270 debug_generic_stmt (expr
);
3273 if (MR_DEPENDENCE_CLIQUE (expr
) != 0
3274 && MR_DEPENDENCE_CLIQUE (expr
) > cfun
->last_clique
)
3276 error ("invalid clique in %qs", code_name
);
3277 debug_generic_stmt (expr
);
3281 else if (TREE_CODE (expr
) == INDIRECT_REF
)
3283 error ("%qs in gimple IL", code_name
);
3284 debug_generic_stmt (expr
);
3288 return ((require_lvalue
|| !is_gimple_min_invariant (expr
))
3289 && verify_types_in_gimple_min_lval (expr
));
3292 /* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
3293 list of pointer-to types that is trivially convertible to DEST. */
3296 one_pointer_to_useless_type_conversion_p (tree dest
, tree src_obj
)
3300 if (!TYPE_POINTER_TO (src_obj
))
3303 for (src
= TYPE_POINTER_TO (src_obj
); src
; src
= TYPE_NEXT_PTR_TO (src
))
3304 if (useless_type_conversion_p (dest
, src
))
3310 /* Return true if TYPE1 is a fixed-point type and if conversions to and
3311 from TYPE2 can be handled by FIXED_CONVERT_EXPR. */
3314 valid_fixed_convert_types_p (tree type1
, tree type2
)
3316 return (FIXED_POINT_TYPE_P (type1
)
3317 && (INTEGRAL_TYPE_P (type2
)
3318 || SCALAR_FLOAT_TYPE_P (type2
)
3319 || FIXED_POINT_TYPE_P (type2
)));
3322 /* Verify the contents of a GIMPLE_CALL STMT. Returns true when there
3323 is a problem, otherwise false. */
3326 verify_gimple_call (gcall
*stmt
)
3328 tree fn
= gimple_call_fn (stmt
);
3329 tree fntype
, fndecl
;
3332 if (gimple_call_internal_p (stmt
))
3336 error ("gimple call has two targets");
3337 debug_generic_stmt (fn
);
3345 error ("gimple call has no target");
3350 if (fn
&& !is_gimple_call_addr (fn
))
3352 error ("invalid function in gimple call");
3353 debug_generic_stmt (fn
);
3358 && (!POINTER_TYPE_P (TREE_TYPE (fn
))
3359 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != FUNCTION_TYPE
3360 && TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != METHOD_TYPE
)))
3362 error ("non-function in gimple call");
3366 fndecl
= gimple_call_fndecl (stmt
);
3368 && TREE_CODE (fndecl
) == FUNCTION_DECL
3369 && DECL_LOOPING_CONST_OR_PURE_P (fndecl
)
3370 && !DECL_PURE_P (fndecl
)
3371 && !TREE_READONLY (fndecl
))
3373 error ("invalid pure const state for function");
3377 tree lhs
= gimple_call_lhs (stmt
);
3379 && (!is_gimple_lvalue (lhs
)
3380 || verify_types_in_gimple_reference (lhs
, true)))
3382 error ("invalid LHS in gimple call");
3386 if (gimple_call_ctrl_altering_p (stmt
)
3387 && gimple_call_noreturn_p (stmt
)
3388 && should_remove_lhs_p (lhs
))
3390 error ("LHS in %<noreturn%> call");
3394 fntype
= gimple_call_fntype (stmt
);
3397 && !useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (fntype
))
3398 /* ??? At least C++ misses conversions at assignments from
3399 void * call results.
3400 For now simply allow arbitrary pointer type conversions. */
3401 && !(POINTER_TYPE_P (TREE_TYPE (lhs
))
3402 && POINTER_TYPE_P (TREE_TYPE (fntype
))))
3404 error ("invalid conversion in gimple call");
3405 debug_generic_stmt (TREE_TYPE (lhs
));
3406 debug_generic_stmt (TREE_TYPE (fntype
));
3410 if (gimple_call_chain (stmt
)
3411 && !is_gimple_val (gimple_call_chain (stmt
)))
3413 error ("invalid static chain in gimple call");
3414 debug_generic_stmt (gimple_call_chain (stmt
));
3418 /* If there is a static chain argument, the call should either be
3419 indirect, or the decl should have DECL_STATIC_CHAIN set. */
3420 if (gimple_call_chain (stmt
)
3422 && !DECL_STATIC_CHAIN (fndecl
))
3424 error ("static chain with function that doesn%'t use one");
3428 if (fndecl
&& fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
))
3430 switch (DECL_FUNCTION_CODE (fndecl
))
3432 case BUILT_IN_UNREACHABLE
:
3434 if (gimple_call_num_args (stmt
) > 0)
3436 /* Built-in unreachable with parameters might not be caught by
3437 undefined behavior sanitizer. Front-ends do check users do not
3438 call them that way but we also produce calls to
3439 __builtin_unreachable internally, for example when IPA figures
3440 out a call cannot happen in a legal program. In such cases,
3441 we must make sure arguments are stripped off. */
3442 error ("%<__builtin_unreachable%> or %<__builtin_trap%> call "
3452 /* ??? The C frontend passes unpromoted arguments in case it
3453 didn't see a function declaration before the call. So for now
3454 leave the call arguments mostly unverified. Once we gimplify
3455 unit-at-a-time we have a chance to fix this. */
3457 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
3459 tree arg
= gimple_call_arg (stmt
, i
);
3460 if ((is_gimple_reg_type (TREE_TYPE (arg
))
3461 && !is_gimple_val (arg
))
3462 || (!is_gimple_reg_type (TREE_TYPE (arg
))
3463 && !is_gimple_lvalue (arg
)))
3465 error ("invalid argument to gimple call");
3466 debug_generic_expr (arg
);
3474 /* Verifies the gimple comparison with the result type TYPE and
3475 the operands OP0 and OP1, comparison code is CODE. */
3478 verify_gimple_comparison (tree type
, tree op0
, tree op1
, enum tree_code code
)
3480 tree op0_type
= TREE_TYPE (op0
);
3481 tree op1_type
= TREE_TYPE (op1
);
3483 if (!is_gimple_val (op0
) || !is_gimple_val (op1
))
3485 error ("invalid operands in gimple comparison");
3489 /* For comparisons we do not have the operations type as the
3490 effective type the comparison is carried out in. Instead
3491 we require that either the first operand is trivially
3492 convertible into the second, or the other way around.
3493 Because we special-case pointers to void we allow
3494 comparisons of pointers with the same mode as well. */
3495 if (!useless_type_conversion_p (op0_type
, op1_type
)
3496 && !useless_type_conversion_p (op1_type
, op0_type
)
3497 && (!POINTER_TYPE_P (op0_type
)
3498 || !POINTER_TYPE_P (op1_type
)
3499 || TYPE_MODE (op0_type
) != TYPE_MODE (op1_type
)))
3501 error ("mismatching comparison operand types");
3502 debug_generic_expr (op0_type
);
3503 debug_generic_expr (op1_type
);
3507 /* The resulting type of a comparison may be an effective boolean type. */
3508 if (INTEGRAL_TYPE_P (type
)
3509 && (TREE_CODE (type
) == BOOLEAN_TYPE
3510 || TYPE_PRECISION (type
) == 1))
3512 if ((TREE_CODE (op0_type
) == VECTOR_TYPE
3513 || TREE_CODE (op1_type
) == VECTOR_TYPE
)
3514 && code
!= EQ_EXPR
&& code
!= NE_EXPR
3515 && !VECTOR_BOOLEAN_TYPE_P (op0_type
)
3516 && !VECTOR_INTEGER_TYPE_P (op0_type
))
3518 error ("unsupported operation or type for vector comparison"
3519 " returning a boolean");
3520 debug_generic_expr (op0_type
);
3521 debug_generic_expr (op1_type
);
3525 /* Or a boolean vector type with the same element count
3526 as the comparison operand types. */
3527 else if (TREE_CODE (type
) == VECTOR_TYPE
3528 && TREE_CODE (TREE_TYPE (type
)) == BOOLEAN_TYPE
)
3530 if (TREE_CODE (op0_type
) != VECTOR_TYPE
3531 || TREE_CODE (op1_type
) != VECTOR_TYPE
)
3533 error ("non-vector operands in vector comparison");
3534 debug_generic_expr (op0_type
);
3535 debug_generic_expr (op1_type
);
3539 if (maybe_ne (TYPE_VECTOR_SUBPARTS (type
),
3540 TYPE_VECTOR_SUBPARTS (op0_type
)))
3542 error ("invalid vector comparison resulting type");
3543 debug_generic_expr (type
);
3549 error ("bogus comparison result type");
3550 debug_generic_expr (type
);
3557 /* Verify a gimple assignment statement STMT with an unary rhs.
3558 Returns true if anything is wrong. */
3561 verify_gimple_assign_unary (gassign
*stmt
)
3563 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3564 tree lhs
= gimple_assign_lhs (stmt
);
3565 tree lhs_type
= TREE_TYPE (lhs
);
3566 tree rhs1
= gimple_assign_rhs1 (stmt
);
3567 tree rhs1_type
= TREE_TYPE (rhs1
);
3569 if (!is_gimple_reg (lhs
))
3571 error ("non-register as LHS of unary operation");
3575 if (!is_gimple_val (rhs1
))
3577 error ("invalid operand in unary operation");
3581 const char* const code_name
= get_tree_code_name (rhs_code
);
3583 /* First handle conversions. */
3588 /* Allow conversions between vectors with the same number of elements,
3589 provided that the conversion is OK for the element types too. */
3590 if (VECTOR_TYPE_P (lhs_type
)
3591 && VECTOR_TYPE_P (rhs1_type
)
3592 && known_eq (TYPE_VECTOR_SUBPARTS (lhs_type
),
3593 TYPE_VECTOR_SUBPARTS (rhs1_type
)))
3595 lhs_type
= TREE_TYPE (lhs_type
);
3596 rhs1_type
= TREE_TYPE (rhs1_type
);
3598 else if (VECTOR_TYPE_P (lhs_type
) || VECTOR_TYPE_P (rhs1_type
))
3600 error ("invalid vector types in nop conversion");
3601 debug_generic_expr (lhs_type
);
3602 debug_generic_expr (rhs1_type
);
3606 /* Allow conversions from pointer type to integral type only if
3607 there is no sign or zero extension involved.
3608 For targets were the precision of ptrofftype doesn't match that
3609 of pointers we allow conversions to types where
3610 POINTERS_EXTEND_UNSIGNED specifies how that works. */
3611 if ((POINTER_TYPE_P (lhs_type
)
3612 && INTEGRAL_TYPE_P (rhs1_type
))
3613 || (POINTER_TYPE_P (rhs1_type
)
3614 && INTEGRAL_TYPE_P (lhs_type
)
3615 && (TYPE_PRECISION (rhs1_type
) >= TYPE_PRECISION (lhs_type
)
3616 #if defined(POINTERS_EXTEND_UNSIGNED)
3617 || (TYPE_MODE (rhs1_type
) == ptr_mode
3618 && (TYPE_PRECISION (lhs_type
)
3619 == BITS_PER_WORD
/* word_mode */
3620 || (TYPE_PRECISION (lhs_type
)
3621 == GET_MODE_PRECISION (Pmode
))))
3626 /* Allow conversion from integral to offset type and vice versa. */
3627 if ((TREE_CODE (lhs_type
) == OFFSET_TYPE
3628 && INTEGRAL_TYPE_P (rhs1_type
))
3629 || (INTEGRAL_TYPE_P (lhs_type
)
3630 && TREE_CODE (rhs1_type
) == OFFSET_TYPE
))
3633 /* Otherwise assert we are converting between types of the
3635 if (INTEGRAL_TYPE_P (lhs_type
) != INTEGRAL_TYPE_P (rhs1_type
))
3637 error ("invalid types in nop conversion");
3638 debug_generic_expr (lhs_type
);
3639 debug_generic_expr (rhs1_type
);
3646 case ADDR_SPACE_CONVERT_EXPR
:
3648 if (!POINTER_TYPE_P (rhs1_type
) || !POINTER_TYPE_P (lhs_type
)
3649 || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type
))
3650 == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type
))))
3652 error ("invalid types in address space conversion");
3653 debug_generic_expr (lhs_type
);
3654 debug_generic_expr (rhs1_type
);
3661 case FIXED_CONVERT_EXPR
:
3663 if (!valid_fixed_convert_types_p (lhs_type
, rhs1_type
)
3664 && !valid_fixed_convert_types_p (rhs1_type
, lhs_type
))
3666 error ("invalid types in fixed-point conversion");
3667 debug_generic_expr (lhs_type
);
3668 debug_generic_expr (rhs1_type
);
3677 if ((!INTEGRAL_TYPE_P (rhs1_type
) || !SCALAR_FLOAT_TYPE_P (lhs_type
))
3678 && (!VECTOR_INTEGER_TYPE_P (rhs1_type
)
3679 || !VECTOR_FLOAT_TYPE_P (lhs_type
)))
3681 error ("invalid types in conversion to floating-point");
3682 debug_generic_expr (lhs_type
);
3683 debug_generic_expr (rhs1_type
);
3690 case FIX_TRUNC_EXPR
:
3692 if ((!INTEGRAL_TYPE_P (lhs_type
) || !SCALAR_FLOAT_TYPE_P (rhs1_type
))
3693 && (!VECTOR_INTEGER_TYPE_P (lhs_type
)
3694 || !VECTOR_FLOAT_TYPE_P (rhs1_type
)))
3696 error ("invalid types in conversion to integer");
3697 debug_generic_expr (lhs_type
);
3698 debug_generic_expr (rhs1_type
);
3705 case VEC_UNPACK_HI_EXPR
:
3706 case VEC_UNPACK_LO_EXPR
:
3707 case VEC_UNPACK_FLOAT_HI_EXPR
:
3708 case VEC_UNPACK_FLOAT_LO_EXPR
:
3709 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3710 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3711 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3712 || TREE_CODE (lhs_type
) != VECTOR_TYPE
3713 || (!INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3714 && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type
)))
3715 || (!INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3716 && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
)))
3717 || ((rhs_code
== VEC_UNPACK_HI_EXPR
3718 || rhs_code
== VEC_UNPACK_LO_EXPR
)
3719 && (INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3720 != INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))))
3721 || ((rhs_code
== VEC_UNPACK_FLOAT_HI_EXPR
3722 || rhs_code
== VEC_UNPACK_FLOAT_LO_EXPR
)
3723 && (INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3724 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
))))
3725 || ((rhs_code
== VEC_UNPACK_FIX_TRUNC_HI_EXPR
3726 || rhs_code
== VEC_UNPACK_FIX_TRUNC_LO_EXPR
)
3727 && (INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3728 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type
))))
3729 || (maybe_ne (GET_MODE_SIZE (element_mode (lhs_type
)),
3730 2 * GET_MODE_SIZE (element_mode (rhs1_type
)))
3731 && (!VECTOR_BOOLEAN_TYPE_P (lhs_type
)
3732 || !VECTOR_BOOLEAN_TYPE_P (rhs1_type
)))
3733 || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (lhs_type
),
3734 TYPE_VECTOR_SUBPARTS (rhs1_type
)))
3736 error ("type mismatch in %qs expression", code_name
);
3737 debug_generic_expr (lhs_type
);
3738 debug_generic_expr (rhs1_type
);
3752 if (!ANY_INTEGRAL_TYPE_P (lhs_type
)
3753 || !TYPE_UNSIGNED (lhs_type
)
3754 || !ANY_INTEGRAL_TYPE_P (rhs1_type
)
3755 || TYPE_UNSIGNED (rhs1_type
)
3756 || element_precision (lhs_type
) != element_precision (rhs1_type
))
3758 error ("invalid types for %qs", code_name
);
3759 debug_generic_expr (lhs_type
);
3760 debug_generic_expr (rhs1_type
);
3765 case VEC_DUPLICATE_EXPR
:
3766 if (TREE_CODE (lhs_type
) != VECTOR_TYPE
3767 || !useless_type_conversion_p (TREE_TYPE (lhs_type
), rhs1_type
))
3769 error ("%qs should be from a scalar to a like vector", code_name
);
3770 debug_generic_expr (lhs_type
);
3771 debug_generic_expr (rhs1_type
);
3780 /* For the remaining codes assert there is no conversion involved. */
3781 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3783 error ("non-trivial conversion in unary operation");
3784 debug_generic_expr (lhs_type
);
3785 debug_generic_expr (rhs1_type
);
3792 /* Verify a gimple assignment statement STMT with a binary rhs.
3793 Returns true if anything is wrong. */
3796 verify_gimple_assign_binary (gassign
*stmt
)
3798 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3799 tree lhs
= gimple_assign_lhs (stmt
);
3800 tree lhs_type
= TREE_TYPE (lhs
);
3801 tree rhs1
= gimple_assign_rhs1 (stmt
);
3802 tree rhs1_type
= TREE_TYPE (rhs1
);
3803 tree rhs2
= gimple_assign_rhs2 (stmt
);
3804 tree rhs2_type
= TREE_TYPE (rhs2
);
3806 if (!is_gimple_reg (lhs
))
3808 error ("non-register as LHS of binary operation");
3812 if (!is_gimple_val (rhs1
)
3813 || !is_gimple_val (rhs2
))
3815 error ("invalid operands in binary operation");
3819 const char* const code_name
= get_tree_code_name (rhs_code
);
3821 /* First handle operations that involve different types. */
3826 if (TREE_CODE (lhs_type
) != COMPLEX_TYPE
3827 || !(INTEGRAL_TYPE_P (rhs1_type
)
3828 || SCALAR_FLOAT_TYPE_P (rhs1_type
))
3829 || !(INTEGRAL_TYPE_P (rhs2_type
)
3830 || SCALAR_FLOAT_TYPE_P (rhs2_type
)))
3832 error ("type mismatch in %qs", code_name
);
3833 debug_generic_expr (lhs_type
);
3834 debug_generic_expr (rhs1_type
);
3835 debug_generic_expr (rhs2_type
);
3847 /* Shifts and rotates are ok on integral types, fixed point
3848 types and integer vector types. */
3849 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3850 && !FIXED_POINT_TYPE_P (rhs1_type
)
3851 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3852 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))))
3853 || (!INTEGRAL_TYPE_P (rhs2_type
)
3854 /* Vector shifts of vectors are also ok. */
3855 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3856 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3857 && TREE_CODE (rhs2_type
) == VECTOR_TYPE
3858 && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3859 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3861 error ("type mismatch in %qs", code_name
);
3862 debug_generic_expr (lhs_type
);
3863 debug_generic_expr (rhs1_type
);
3864 debug_generic_expr (rhs2_type
);
3871 case WIDEN_LSHIFT_EXPR
:
3873 if (!INTEGRAL_TYPE_P (lhs_type
)
3874 || !INTEGRAL_TYPE_P (rhs1_type
)
3875 || TREE_CODE (rhs2
) != INTEGER_CST
3876 || (2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)))
3878 error ("type mismatch in %qs", code_name
);
3879 debug_generic_expr (lhs_type
);
3880 debug_generic_expr (rhs1_type
);
3881 debug_generic_expr (rhs2_type
);
3888 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3889 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3891 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3892 || TREE_CODE (lhs_type
) != VECTOR_TYPE
3893 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3894 || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3895 || TREE_CODE (rhs2
) != INTEGER_CST
3896 || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type
))
3897 > TYPE_PRECISION (TREE_TYPE (lhs_type
))))
3899 error ("type mismatch in %qs", code_name
);
3900 debug_generic_expr (lhs_type
);
3901 debug_generic_expr (rhs1_type
);
3902 debug_generic_expr (rhs2_type
);
3912 tree lhs_etype
= lhs_type
;
3913 tree rhs1_etype
= rhs1_type
;
3914 tree rhs2_etype
= rhs2_type
;
3915 if (TREE_CODE (lhs_type
) == VECTOR_TYPE
)
3917 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3918 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
)
3920 error ("invalid non-vector operands to %qs", code_name
);
3923 lhs_etype
= TREE_TYPE (lhs_type
);
3924 rhs1_etype
= TREE_TYPE (rhs1_type
);
3925 rhs2_etype
= TREE_TYPE (rhs2_type
);
3927 if (POINTER_TYPE_P (lhs_etype
)
3928 || POINTER_TYPE_P (rhs1_etype
)
3929 || POINTER_TYPE_P (rhs2_etype
))
3931 error ("invalid (pointer) operands %qs", code_name
);
3935 /* Continue with generic binary expression handling. */
3939 case POINTER_PLUS_EXPR
:
3941 if (!POINTER_TYPE_P (rhs1_type
)
3942 || !useless_type_conversion_p (lhs_type
, rhs1_type
)
3943 || !ptrofftype_p (rhs2_type
))
3945 error ("type mismatch in %qs", code_name
);
3946 debug_generic_stmt (lhs_type
);
3947 debug_generic_stmt (rhs1_type
);
3948 debug_generic_stmt (rhs2_type
);
3955 case POINTER_DIFF_EXPR
:
3957 if (!POINTER_TYPE_P (rhs1_type
)
3958 || !POINTER_TYPE_P (rhs2_type
)
3959 /* Because we special-case pointers to void we allow difference
3960 of arbitrary pointers with the same mode. */
3961 || TYPE_MODE (rhs1_type
) != TYPE_MODE (rhs2_type
)
3962 || TREE_CODE (lhs_type
) != INTEGER_TYPE
3963 || TYPE_UNSIGNED (lhs_type
)
3964 || TYPE_PRECISION (lhs_type
) != TYPE_PRECISION (rhs1_type
))
3966 error ("type mismatch in %qs", code_name
);
3967 debug_generic_stmt (lhs_type
);
3968 debug_generic_stmt (rhs1_type
);
3969 debug_generic_stmt (rhs2_type
);
3976 case TRUTH_ANDIF_EXPR
:
3977 case TRUTH_ORIF_EXPR
:
3978 case TRUTH_AND_EXPR
:
3980 case TRUTH_XOR_EXPR
:
3990 case UNORDERED_EXPR
:
3998 /* Comparisons are also binary, but the result type is not
3999 connected to the operand types. */
4000 return verify_gimple_comparison (lhs_type
, rhs1
, rhs2
, rhs_code
);
4002 case WIDEN_MULT_EXPR
:
4003 if (TREE_CODE (lhs_type
) != INTEGER_TYPE
)
4005 return ((2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
))
4006 || (TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
)));
4008 case WIDEN_SUM_EXPR
:
4010 if (((TREE_CODE (rhs1_type
) != VECTOR_TYPE
4011 || TREE_CODE (lhs_type
) != VECTOR_TYPE
)
4012 && ((!INTEGRAL_TYPE_P (rhs1_type
)
4013 && !SCALAR_FLOAT_TYPE_P (rhs1_type
))
4014 || (!INTEGRAL_TYPE_P (lhs_type
)
4015 && !SCALAR_FLOAT_TYPE_P (lhs_type
))))
4016 || !useless_type_conversion_p (lhs_type
, rhs2_type
)
4017 || maybe_lt (GET_MODE_SIZE (element_mode (rhs2_type
)),
4018 2 * GET_MODE_SIZE (element_mode (rhs1_type
))))
4020 error ("type mismatch in %qs", code_name
);
4021 debug_generic_expr (lhs_type
);
4022 debug_generic_expr (rhs1_type
);
4023 debug_generic_expr (rhs2_type
);
4029 case VEC_WIDEN_MULT_HI_EXPR
:
4030 case VEC_WIDEN_MULT_LO_EXPR
:
4031 case VEC_WIDEN_MULT_EVEN_EXPR
:
4032 case VEC_WIDEN_MULT_ODD_EXPR
:
4034 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4035 || TREE_CODE (lhs_type
) != VECTOR_TYPE
4036 || !types_compatible_p (rhs1_type
, rhs2_type
)
4037 || maybe_ne (GET_MODE_SIZE (element_mode (lhs_type
)),
4038 2 * GET_MODE_SIZE (element_mode (rhs1_type
))))
4040 error ("type mismatch in %qs", code_name
);
4041 debug_generic_expr (lhs_type
);
4042 debug_generic_expr (rhs1_type
);
4043 debug_generic_expr (rhs2_type
);
4049 case VEC_PACK_TRUNC_EXPR
:
4050 /* ??? We currently use VEC_PACK_TRUNC_EXPR to simply concat
4051 vector boolean types. */
4052 if (VECTOR_BOOLEAN_TYPE_P (lhs_type
)
4053 && VECTOR_BOOLEAN_TYPE_P (rhs1_type
)
4054 && types_compatible_p (rhs1_type
, rhs2_type
)
4055 && known_eq (TYPE_VECTOR_SUBPARTS (lhs_type
),
4056 2 * TYPE_VECTOR_SUBPARTS (rhs1_type
)))
4060 case VEC_PACK_SAT_EXPR
:
4061 case VEC_PACK_FIX_TRUNC_EXPR
:
4063 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4064 || TREE_CODE (lhs_type
) != VECTOR_TYPE
4065 || !((rhs_code
== VEC_PACK_FIX_TRUNC_EXPR
4066 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
))
4067 && INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
)))
4068 || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
4069 == INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))))
4070 || !types_compatible_p (rhs1_type
, rhs2_type
)
4071 || maybe_ne (GET_MODE_SIZE (element_mode (rhs1_type
)),
4072 2 * GET_MODE_SIZE (element_mode (lhs_type
)))
4073 || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (rhs1_type
),
4074 TYPE_VECTOR_SUBPARTS (lhs_type
)))
4076 error ("type mismatch in %qs", code_name
);
4077 debug_generic_expr (lhs_type
);
4078 debug_generic_expr (rhs1_type
);
4079 debug_generic_expr (rhs2_type
);
4086 case VEC_PACK_FLOAT_EXPR
:
4087 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4088 || TREE_CODE (lhs_type
) != VECTOR_TYPE
4089 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
4090 || !SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type
))
4091 || !types_compatible_p (rhs1_type
, rhs2_type
)
4092 || maybe_ne (GET_MODE_SIZE (element_mode (rhs1_type
)),
4093 2 * GET_MODE_SIZE (element_mode (lhs_type
)))
4094 || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (rhs1_type
),
4095 TYPE_VECTOR_SUBPARTS (lhs_type
)))
4097 error ("type mismatch in %qs", code_name
);
4098 debug_generic_expr (lhs_type
);
4099 debug_generic_expr (rhs1_type
);
4100 debug_generic_expr (rhs2_type
);
4107 case MULT_HIGHPART_EXPR
:
4108 case TRUNC_DIV_EXPR
:
4110 case FLOOR_DIV_EXPR
:
4111 case ROUND_DIV_EXPR
:
4112 case TRUNC_MOD_EXPR
:
4114 case FLOOR_MOD_EXPR
:
4115 case ROUND_MOD_EXPR
:
4117 case EXACT_DIV_EXPR
:
4123 /* Continue with generic binary expression handling. */
4126 case VEC_SERIES_EXPR
:
4127 if (!useless_type_conversion_p (rhs1_type
, rhs2_type
))
4129 error ("type mismatch in %qs", code_name
);
4130 debug_generic_expr (rhs1_type
);
4131 debug_generic_expr (rhs2_type
);
4134 if (TREE_CODE (lhs_type
) != VECTOR_TYPE
4135 || !useless_type_conversion_p (TREE_TYPE (lhs_type
), rhs1_type
))
4137 error ("vector type expected in %qs", code_name
);
4138 debug_generic_expr (lhs_type
);
4147 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
4148 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
4150 error ("type mismatch in binary expression");
4151 debug_generic_stmt (lhs_type
);
4152 debug_generic_stmt (rhs1_type
);
4153 debug_generic_stmt (rhs2_type
);
4160 /* Verify a gimple assignment statement STMT with a ternary rhs.
4161 Returns true if anything is wrong. */
4164 verify_gimple_assign_ternary (gassign
*stmt
)
4166 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
4167 tree lhs
= gimple_assign_lhs (stmt
);
4168 tree lhs_type
= TREE_TYPE (lhs
);
4169 tree rhs1
= gimple_assign_rhs1 (stmt
);
4170 tree rhs1_type
= TREE_TYPE (rhs1
);
4171 tree rhs2
= gimple_assign_rhs2 (stmt
);
4172 tree rhs2_type
= TREE_TYPE (rhs2
);
4173 tree rhs3
= gimple_assign_rhs3 (stmt
);
4174 tree rhs3_type
= TREE_TYPE (rhs3
);
4176 if (!is_gimple_reg (lhs
))
4178 error ("non-register as LHS of ternary operation");
4182 if ((rhs_code
== COND_EXPR
4183 ? !is_gimple_condexpr (rhs1
) : !is_gimple_val (rhs1
))
4184 || !is_gimple_val (rhs2
)
4185 || !is_gimple_val (rhs3
))
4187 error ("invalid operands in ternary operation");
4191 const char* const code_name
= get_tree_code_name (rhs_code
);
4193 /* First handle operations that involve different types. */
4196 case WIDEN_MULT_PLUS_EXPR
:
4197 case WIDEN_MULT_MINUS_EXPR
:
4198 if ((!INTEGRAL_TYPE_P (rhs1_type
)
4199 && !FIXED_POINT_TYPE_P (rhs1_type
))
4200 || !useless_type_conversion_p (rhs1_type
, rhs2_type
)
4201 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
4202 || 2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)
4203 || TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
))
4205 error ("type mismatch in %qs", code_name
);
4206 debug_generic_expr (lhs_type
);
4207 debug_generic_expr (rhs1_type
);
4208 debug_generic_expr (rhs2_type
);
4209 debug_generic_expr (rhs3_type
);
4215 if (!VECTOR_BOOLEAN_TYPE_P (rhs1_type
)
4216 || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs1_type
),
4217 TYPE_VECTOR_SUBPARTS (lhs_type
)))
4219 error ("the first argument of a %qs must be of a "
4220 "boolean vector type of the same number of elements "
4221 "as the result", code_name
);
4222 debug_generic_expr (lhs_type
);
4223 debug_generic_expr (rhs1_type
);
4228 if (!is_gimple_val (rhs1
)
4229 && verify_gimple_comparison (TREE_TYPE (rhs1
),
4230 TREE_OPERAND (rhs1
, 0),
4231 TREE_OPERAND (rhs1
, 1),
4234 if (!useless_type_conversion_p (lhs_type
, rhs2_type
)
4235 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
4237 error ("type mismatch in %qs", code_name
);
4238 debug_generic_expr (lhs_type
);
4239 debug_generic_expr (rhs2_type
);
4240 debug_generic_expr (rhs3_type
);
4246 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
4247 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
4249 error ("type mismatch in %qs", code_name
);
4250 debug_generic_expr (lhs_type
);
4251 debug_generic_expr (rhs1_type
);
4252 debug_generic_expr (rhs2_type
);
4253 debug_generic_expr (rhs3_type
);
4257 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4258 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
4259 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
4261 error ("vector types expected in %qs", code_name
);
4262 debug_generic_expr (lhs_type
);
4263 debug_generic_expr (rhs1_type
);
4264 debug_generic_expr (rhs2_type
);
4265 debug_generic_expr (rhs3_type
);
4269 if (maybe_ne (TYPE_VECTOR_SUBPARTS (rhs1_type
),
4270 TYPE_VECTOR_SUBPARTS (rhs2_type
))
4271 || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs2_type
),
4272 TYPE_VECTOR_SUBPARTS (rhs3_type
))
4273 || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs3_type
),
4274 TYPE_VECTOR_SUBPARTS (lhs_type
)))
4276 error ("vectors with different element number found in %qs",
4278 debug_generic_expr (lhs_type
);
4279 debug_generic_expr (rhs1_type
);
4280 debug_generic_expr (rhs2_type
);
4281 debug_generic_expr (rhs3_type
);
4285 if (TREE_CODE (TREE_TYPE (rhs3_type
)) != INTEGER_TYPE
4286 || (TREE_CODE (rhs3
) != VECTOR_CST
4287 && (GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE
4288 (TREE_TYPE (rhs3_type
)))
4289 != GET_MODE_BITSIZE (SCALAR_TYPE_MODE
4290 (TREE_TYPE (rhs1_type
))))))
4292 error ("invalid mask type in %qs", code_name
);
4293 debug_generic_expr (lhs_type
);
4294 debug_generic_expr (rhs1_type
);
4295 debug_generic_expr (rhs2_type
);
4296 debug_generic_expr (rhs3_type
);
4303 if (!useless_type_conversion_p (rhs1_type
, rhs2_type
)
4304 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
4305 || 2 * GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type
)))
4306 > GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (lhs_type
))))
4308 error ("type mismatch in %qs", code_name
);
4309 debug_generic_expr (lhs_type
);
4310 debug_generic_expr (rhs1_type
);
4311 debug_generic_expr (rhs2_type
);
4312 debug_generic_expr (rhs3_type
);
4316 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4317 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
4318 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
4320 error ("vector types expected in %qs", code_name
);
4321 debug_generic_expr (lhs_type
);
4322 debug_generic_expr (rhs1_type
);
4323 debug_generic_expr (rhs2_type
);
4324 debug_generic_expr (rhs3_type
);
4330 case BIT_INSERT_EXPR
:
4331 if (! useless_type_conversion_p (lhs_type
, rhs1_type
))
4333 error ("type mismatch in %qs", code_name
);
4334 debug_generic_expr (lhs_type
);
4335 debug_generic_expr (rhs1_type
);
4338 if (! ((INTEGRAL_TYPE_P (rhs1_type
)
4339 && INTEGRAL_TYPE_P (rhs2_type
))
4340 /* Vector element insert. */
4341 || (VECTOR_TYPE_P (rhs1_type
)
4342 && types_compatible_p (TREE_TYPE (rhs1_type
), rhs2_type
))
4343 /* Aligned sub-vector insert. */
4344 || (VECTOR_TYPE_P (rhs1_type
)
4345 && VECTOR_TYPE_P (rhs2_type
)
4346 && types_compatible_p (TREE_TYPE (rhs1_type
),
4347 TREE_TYPE (rhs2_type
))
4348 && multiple_p (TYPE_VECTOR_SUBPARTS (rhs1_type
),
4349 TYPE_VECTOR_SUBPARTS (rhs2_type
))
4350 && multiple_of_p (bitsizetype
, rhs3
, TYPE_SIZE (rhs2_type
)))))
4352 error ("not allowed type combination in %qs", code_name
);
4353 debug_generic_expr (rhs1_type
);
4354 debug_generic_expr (rhs2_type
);
4357 if (! tree_fits_uhwi_p (rhs3
)
4358 || ! types_compatible_p (bitsizetype
, TREE_TYPE (rhs3
))
4359 || ! tree_fits_uhwi_p (TYPE_SIZE (rhs2_type
)))
4361 error ("invalid position or size in %qs", code_name
);
4364 if (INTEGRAL_TYPE_P (rhs1_type
)
4365 && !type_has_mode_precision_p (rhs1_type
))
4367 error ("%qs into non-mode-precision operand", code_name
);
4370 if (INTEGRAL_TYPE_P (rhs1_type
))
4372 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (rhs3
);
4373 if (bitpos
>= TYPE_PRECISION (rhs1_type
)
4374 || (bitpos
+ TYPE_PRECISION (rhs2_type
)
4375 > TYPE_PRECISION (rhs1_type
)))
4377 error ("insertion out of range in %qs", code_name
);
4381 else if (VECTOR_TYPE_P (rhs1_type
))
4383 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (rhs3
);
4384 unsigned HOST_WIDE_INT bitsize
= tree_to_uhwi (TYPE_SIZE (rhs2_type
));
4385 if (bitpos
% bitsize
!= 0)
4387 error ("%qs not at element boundary", code_name
);
4395 if (((TREE_CODE (rhs1_type
) != VECTOR_TYPE
4396 || TREE_CODE (lhs_type
) != VECTOR_TYPE
)
4397 && ((!INTEGRAL_TYPE_P (rhs1_type
)
4398 && !SCALAR_FLOAT_TYPE_P (rhs1_type
))
4399 || (!INTEGRAL_TYPE_P (lhs_type
)
4400 && !SCALAR_FLOAT_TYPE_P (lhs_type
))))
4401 || !types_compatible_p (rhs1_type
, rhs2_type
)
4402 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
4403 || maybe_lt (GET_MODE_SIZE (element_mode (rhs3_type
)),
4404 2 * GET_MODE_SIZE (element_mode (rhs1_type
))))
4406 error ("type mismatch in %qs", code_name
);
4407 debug_generic_expr (lhs_type
);
4408 debug_generic_expr (rhs1_type
);
4409 debug_generic_expr (rhs2_type
);
4415 case REALIGN_LOAD_EXPR
:
4425 /* Verify a gimple assignment statement STMT with a single rhs.
4426 Returns true if anything is wrong. */
4429 verify_gimple_assign_single (gassign
*stmt
)
4431 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
4432 tree lhs
= gimple_assign_lhs (stmt
);
4433 tree lhs_type
= TREE_TYPE (lhs
);
4434 tree rhs1
= gimple_assign_rhs1 (stmt
);
4435 tree rhs1_type
= TREE_TYPE (rhs1
);
4438 const char* const code_name
= get_tree_code_name (rhs_code
);
4440 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
4442 error ("non-trivial conversion in %qs", code_name
);
4443 debug_generic_expr (lhs_type
);
4444 debug_generic_expr (rhs1_type
);
4448 if (gimple_clobber_p (stmt
)
4449 && !(DECL_P (lhs
) || TREE_CODE (lhs
) == MEM_REF
))
4451 error ("%qs LHS in clobber statement",
4452 get_tree_code_name (TREE_CODE (lhs
)));
4453 debug_generic_expr (lhs
);
4457 if (handled_component_p (lhs
)
4458 || TREE_CODE (lhs
) == MEM_REF
4459 || TREE_CODE (lhs
) == TARGET_MEM_REF
)
4460 res
|= verify_types_in_gimple_reference (lhs
, true);
4462 /* Special codes we cannot handle via their class. */
4467 tree op
= TREE_OPERAND (rhs1
, 0);
4468 if (!is_gimple_addressable (op
))
4470 error ("invalid operand in %qs", code_name
);
4474 /* Technically there is no longer a need for matching types, but
4475 gimple hygiene asks for this check. In LTO we can end up
4476 combining incompatible units and thus end up with addresses
4477 of globals that change their type to a common one. */
4479 && !types_compatible_p (TREE_TYPE (op
),
4480 TREE_TYPE (TREE_TYPE (rhs1
)))
4481 && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1
),
4484 error ("type mismatch in %qs", code_name
);
4485 debug_generic_stmt (TREE_TYPE (rhs1
));
4486 debug_generic_stmt (TREE_TYPE (op
));
4490 return (verify_address (rhs1
, true)
4491 || verify_types_in_gimple_reference (op
, true));
4496 error ("%qs in gimple IL", code_name
);
4502 case ARRAY_RANGE_REF
:
4503 case VIEW_CONVERT_EXPR
:
4506 case TARGET_MEM_REF
:
4508 if (!is_gimple_reg (lhs
)
4509 && is_gimple_reg_type (TREE_TYPE (lhs
)))
4511 error ("invalid RHS for gimple memory store: %qs", code_name
);
4512 debug_generic_stmt (lhs
);
4513 debug_generic_stmt (rhs1
);
4516 return res
|| verify_types_in_gimple_reference (rhs1
, false);
4528 /* tcc_declaration */
4533 if (!is_gimple_reg (lhs
)
4534 && !is_gimple_reg (rhs1
)
4535 && is_gimple_reg_type (TREE_TYPE (lhs
)))
4537 error ("invalid RHS for gimple memory store: %qs", code_name
);
4538 debug_generic_stmt (lhs
);
4539 debug_generic_stmt (rhs1
);
4545 if (TREE_CODE (rhs1_type
) == VECTOR_TYPE
)
4548 tree elt_i
, elt_v
, elt_t
= NULL_TREE
;
4550 if (CONSTRUCTOR_NELTS (rhs1
) == 0)
4552 /* For vector CONSTRUCTORs we require that either it is empty
4553 CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
4554 (then the element count must be correct to cover the whole
4555 outer vector and index must be NULL on all elements, or it is
4556 a CONSTRUCTOR of scalar elements, where we as an exception allow
4557 smaller number of elements (assuming zero filling) and
4558 consecutive indexes as compared to NULL indexes (such
4559 CONSTRUCTORs can appear in the IL from FEs). */
4560 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1
), i
, elt_i
, elt_v
)
4562 if (elt_t
== NULL_TREE
)
4564 elt_t
= TREE_TYPE (elt_v
);
4565 if (TREE_CODE (elt_t
) == VECTOR_TYPE
)
4567 tree elt_t
= TREE_TYPE (elt_v
);
4568 if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
4571 error ("incorrect type of vector %qs elements",
4573 debug_generic_stmt (rhs1
);
4576 else if (maybe_ne (CONSTRUCTOR_NELTS (rhs1
)
4577 * TYPE_VECTOR_SUBPARTS (elt_t
),
4578 TYPE_VECTOR_SUBPARTS (rhs1_type
)))
4580 error ("incorrect number of vector %qs elements",
4582 debug_generic_stmt (rhs1
);
4586 else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
4589 error ("incorrect type of vector %qs elements",
4591 debug_generic_stmt (rhs1
);
4594 else if (maybe_gt (CONSTRUCTOR_NELTS (rhs1
),
4595 TYPE_VECTOR_SUBPARTS (rhs1_type
)))
4597 error ("incorrect number of vector %qs elements",
4599 debug_generic_stmt (rhs1
);
4603 else if (!useless_type_conversion_p (elt_t
, TREE_TYPE (elt_v
)))
4605 error ("incorrect type of vector CONSTRUCTOR elements");
4606 debug_generic_stmt (rhs1
);
4609 if (elt_i
!= NULL_TREE
4610 && (TREE_CODE (elt_t
) == VECTOR_TYPE
4611 || TREE_CODE (elt_i
) != INTEGER_CST
4612 || compare_tree_int (elt_i
, i
) != 0))
4614 error ("vector %qs with non-NULL element index",
4616 debug_generic_stmt (rhs1
);
4619 if (!is_gimple_val (elt_v
))
4621 error ("vector %qs element is not a GIMPLE value",
4623 debug_generic_stmt (rhs1
);
4628 else if (CONSTRUCTOR_NELTS (rhs1
) != 0)
4630 error ("non-vector %qs with elements", code_name
);
4631 debug_generic_stmt (rhs1
);
4638 rhs1
= fold (ASSERT_EXPR_COND (rhs1
));
4639 if (rhs1
== boolean_false_node
)
4641 error ("%qs with an always-false condition", code_name
);
4642 debug_generic_stmt (rhs1
);
4648 case WITH_SIZE_EXPR
:
4658 /* Verify the contents of a GIMPLE_ASSIGN STMT. Returns true when there
4659 is a problem, otherwise false. */
4662 verify_gimple_assign (gassign
*stmt
)
4664 switch (gimple_assign_rhs_class (stmt
))
4666 case GIMPLE_SINGLE_RHS
:
4667 return verify_gimple_assign_single (stmt
);
4669 case GIMPLE_UNARY_RHS
:
4670 return verify_gimple_assign_unary (stmt
);
4672 case GIMPLE_BINARY_RHS
:
4673 return verify_gimple_assign_binary (stmt
);
4675 case GIMPLE_TERNARY_RHS
:
4676 return verify_gimple_assign_ternary (stmt
);
4683 /* Verify the contents of a GIMPLE_RETURN STMT. Returns true when there
4684 is a problem, otherwise false. */
4687 verify_gimple_return (greturn
*stmt
)
4689 tree op
= gimple_return_retval (stmt
);
4690 tree restype
= TREE_TYPE (TREE_TYPE (cfun
->decl
));
4692 /* We cannot test for present return values as we do not fix up missing
4693 return values from the original source. */
4697 if (!is_gimple_val (op
)
4698 && TREE_CODE (op
) != RESULT_DECL
)
4700 error ("invalid operand in return statement");
4701 debug_generic_stmt (op
);
4705 if ((TREE_CODE (op
) == RESULT_DECL
4706 && DECL_BY_REFERENCE (op
))
4707 || (TREE_CODE (op
) == SSA_NAME
4708 && SSA_NAME_VAR (op
)
4709 && TREE_CODE (SSA_NAME_VAR (op
)) == RESULT_DECL
4710 && DECL_BY_REFERENCE (SSA_NAME_VAR (op
))))
4711 op
= TREE_TYPE (op
);
4713 if (!useless_type_conversion_p (restype
, TREE_TYPE (op
)))
4715 error ("invalid conversion in return statement");
4716 debug_generic_stmt (restype
);
4717 debug_generic_stmt (TREE_TYPE (op
));
4725 /* Verify the contents of a GIMPLE_GOTO STMT. Returns true when there
4726 is a problem, otherwise false. */
4729 verify_gimple_goto (ggoto
*stmt
)
4731 tree dest
= gimple_goto_dest (stmt
);
4733 /* ??? We have two canonical forms of direct goto destinations, a
4734 bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
4735 if (TREE_CODE (dest
) != LABEL_DECL
4736 && (!is_gimple_val (dest
)
4737 || !POINTER_TYPE_P (TREE_TYPE (dest
))))
4739 error ("goto destination is neither a label nor a pointer");
4746 /* Verify the contents of a GIMPLE_SWITCH STMT. Returns true when there
4747 is a problem, otherwise false. */
4750 verify_gimple_switch (gswitch
*stmt
)
4753 tree elt
, prev_upper_bound
= NULL_TREE
;
4754 tree index_type
, elt_type
= NULL_TREE
;
4756 if (!is_gimple_val (gimple_switch_index (stmt
)))
4758 error ("invalid operand to switch statement");
4759 debug_generic_stmt (gimple_switch_index (stmt
));
4763 index_type
= TREE_TYPE (gimple_switch_index (stmt
));
4764 if (! INTEGRAL_TYPE_P (index_type
))
4766 error ("non-integral type switch statement");
4767 debug_generic_expr (index_type
);
4771 elt
= gimple_switch_label (stmt
, 0);
4772 if (CASE_LOW (elt
) != NULL_TREE
4773 || CASE_HIGH (elt
) != NULL_TREE
4774 || CASE_CHAIN (elt
) != NULL_TREE
)
4776 error ("invalid default case label in switch statement");
4777 debug_generic_expr (elt
);
4781 n
= gimple_switch_num_labels (stmt
);
4782 for (i
= 1; i
< n
; i
++)
4784 elt
= gimple_switch_label (stmt
, i
);
4786 if (CASE_CHAIN (elt
))
4788 error ("invalid %<CASE_CHAIN%>");
4789 debug_generic_expr (elt
);
4792 if (! CASE_LOW (elt
))
4794 error ("invalid case label in switch statement");
4795 debug_generic_expr (elt
);
4799 && ! tree_int_cst_lt (CASE_LOW (elt
), CASE_HIGH (elt
)))
4801 error ("invalid case range in switch statement");
4802 debug_generic_expr (elt
);
4808 elt_type
= TREE_TYPE (CASE_LOW (elt
));
4809 if (TYPE_PRECISION (index_type
) < TYPE_PRECISION (elt_type
))
4811 error ("type precision mismatch in switch statement");
4815 if (TREE_TYPE (CASE_LOW (elt
)) != elt_type
4816 || (CASE_HIGH (elt
) && TREE_TYPE (CASE_HIGH (elt
)) != elt_type
))
4818 error ("type mismatch for case label in switch statement");
4819 debug_generic_expr (elt
);
4823 if (prev_upper_bound
)
4825 if (! tree_int_cst_lt (prev_upper_bound
, CASE_LOW (elt
)))
4827 error ("case labels not sorted in switch statement");
4832 prev_upper_bound
= CASE_HIGH (elt
);
4833 if (! prev_upper_bound
)
4834 prev_upper_bound
= CASE_LOW (elt
);
4840 /* Verify a gimple debug statement STMT.
4841 Returns true if anything is wrong. */
4844 verify_gimple_debug (gimple
*stmt ATTRIBUTE_UNUSED
)
4846 /* There isn't much that could be wrong in a gimple debug stmt. A
4847 gimple debug bind stmt, for example, maps a tree, that's usually
4848 a VAR_DECL or a PARM_DECL, but that could also be some scalarized
4849 component or member of an aggregate type, to another tree, that
4850 can be an arbitrary expression. These stmts expand into debug
4851 insns, and are converted to debug notes by var-tracking.c. */
4855 /* Verify a gimple label statement STMT.
4856 Returns true if anything is wrong. */
4859 verify_gimple_label (glabel
*stmt
)
4861 tree decl
= gimple_label_label (stmt
);
4865 if (TREE_CODE (decl
) != LABEL_DECL
)
4867 if (!DECL_NONLOCAL (decl
) && !FORCED_LABEL (decl
)
4868 && DECL_CONTEXT (decl
) != current_function_decl
)
4870 error ("label context is not the current function declaration");
4874 uid
= LABEL_DECL_UID (decl
);
4877 || (*label_to_block_map_for_fn (cfun
))[uid
] != gimple_bb (stmt
)))
4879 error ("incorrect entry in %<label_to_block_map%>");
4883 uid
= EH_LANDING_PAD_NR (decl
);
4886 eh_landing_pad lp
= get_eh_landing_pad_from_number (uid
);
4887 if (decl
!= lp
->post_landing_pad
)
4889 error ("incorrect setting of landing pad number");
4897 /* Verify a gimple cond statement STMT.
4898 Returns true if anything is wrong. */
4901 verify_gimple_cond (gcond
*stmt
)
4903 if (TREE_CODE_CLASS (gimple_cond_code (stmt
)) != tcc_comparison
)
4905 error ("invalid comparison code in gimple cond");
4908 if (!(!gimple_cond_true_label (stmt
)
4909 || TREE_CODE (gimple_cond_true_label (stmt
)) == LABEL_DECL
)
4910 || !(!gimple_cond_false_label (stmt
)
4911 || TREE_CODE (gimple_cond_false_label (stmt
)) == LABEL_DECL
))
4913 error ("invalid labels in gimple cond");
4917 return verify_gimple_comparison (boolean_type_node
,
4918 gimple_cond_lhs (stmt
),
4919 gimple_cond_rhs (stmt
),
4920 gimple_cond_code (stmt
));
4923 /* Verify the GIMPLE statement STMT. Returns true if there is an
4924 error, otherwise false. */
4927 verify_gimple_stmt (gimple
*stmt
)
4929 switch (gimple_code (stmt
))
4932 return verify_gimple_assign (as_a
<gassign
*> (stmt
));
4935 return verify_gimple_label (as_a
<glabel
*> (stmt
));
4938 return verify_gimple_call (as_a
<gcall
*> (stmt
));
4941 return verify_gimple_cond (as_a
<gcond
*> (stmt
));
4944 return verify_gimple_goto (as_a
<ggoto
*> (stmt
));
4947 return verify_gimple_switch (as_a
<gswitch
*> (stmt
));
4950 return verify_gimple_return (as_a
<greturn
*> (stmt
));
4955 case GIMPLE_TRANSACTION
:
4956 return verify_gimple_transaction (as_a
<gtransaction
*> (stmt
));
4958 /* Tuples that do not have tree operands. */
4960 case GIMPLE_PREDICT
:
4962 case GIMPLE_EH_DISPATCH
:
4963 case GIMPLE_EH_MUST_NOT_THROW
:
4967 /* OpenMP directives are validated by the FE and never operated
4968 on by the optimizers. Furthermore, GIMPLE_OMP_FOR may contain
4969 non-gimple expressions when the main index variable has had
4970 its address taken. This does not affect the loop itself
4971 because the header of an GIMPLE_OMP_FOR is merely used to determine
4972 how to setup the parallel iteration. */
4976 return verify_gimple_debug (stmt
);
4983 /* Verify the contents of a GIMPLE_PHI. Returns true if there is a problem,
4984 and false otherwise. */
4987 verify_gimple_phi (gphi
*phi
)
4991 tree phi_result
= gimple_phi_result (phi
);
4996 error ("invalid %<PHI%> result");
5000 virtual_p
= virtual_operand_p (phi_result
);
5001 if (TREE_CODE (phi_result
) != SSA_NAME
5003 && SSA_NAME_VAR (phi_result
) != gimple_vop (cfun
)))
5005 error ("invalid %<PHI%> result");
5009 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
5011 tree t
= gimple_phi_arg_def (phi
, i
);
5015 error ("missing %<PHI%> def");
5019 /* Addressable variables do have SSA_NAMEs but they
5020 are not considered gimple values. */
5021 else if ((TREE_CODE (t
) == SSA_NAME
5022 && virtual_p
!= virtual_operand_p (t
))
5024 && (TREE_CODE (t
) != SSA_NAME
5025 || SSA_NAME_VAR (t
) != gimple_vop (cfun
)))
5027 && !is_gimple_val (t
)))
5029 error ("invalid %<PHI%> argument");
5030 debug_generic_expr (t
);
5033 #ifdef ENABLE_TYPES_CHECKING
5034 if (!useless_type_conversion_p (TREE_TYPE (phi_result
), TREE_TYPE (t
)))
5036 error ("incompatible types in %<PHI%> argument %u", i
);
5037 debug_generic_stmt (TREE_TYPE (phi_result
));
5038 debug_generic_stmt (TREE_TYPE (t
));
5047 /* Verify the GIMPLE statements inside the sequence STMTS. */
5050 verify_gimple_in_seq_2 (gimple_seq stmts
)
5052 gimple_stmt_iterator ittr
;
5055 for (ittr
= gsi_start (stmts
); !gsi_end_p (ittr
); gsi_next (&ittr
))
5057 gimple
*stmt
= gsi_stmt (ittr
);
5059 switch (gimple_code (stmt
))
5062 err
|= verify_gimple_in_seq_2 (
5063 gimple_bind_body (as_a
<gbind
*> (stmt
)));
5067 err
|= verify_gimple_in_seq_2 (gimple_try_eval (stmt
));
5068 err
|= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt
));
5071 case GIMPLE_EH_FILTER
:
5072 err
|= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt
));
5075 case GIMPLE_EH_ELSE
:
5077 geh_else
*eh_else
= as_a
<geh_else
*> (stmt
);
5078 err
|= verify_gimple_in_seq_2 (gimple_eh_else_n_body (eh_else
));
5079 err
|= verify_gimple_in_seq_2 (gimple_eh_else_e_body (eh_else
));
5084 err
|= verify_gimple_in_seq_2 (gimple_catch_handler (
5085 as_a
<gcatch
*> (stmt
)));
5088 case GIMPLE_TRANSACTION
:
5089 err
|= verify_gimple_transaction (as_a
<gtransaction
*> (stmt
));
5094 bool err2
= verify_gimple_stmt (stmt
);
5096 debug_gimple_stmt (stmt
);
5105 /* Verify the contents of a GIMPLE_TRANSACTION. Returns true if there
5106 is a problem, otherwise false. */
5109 verify_gimple_transaction (gtransaction
*stmt
)
5113 lab
= gimple_transaction_label_norm (stmt
);
5114 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
5116 lab
= gimple_transaction_label_uninst (stmt
);
5117 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
5119 lab
= gimple_transaction_label_over (stmt
);
5120 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
5123 return verify_gimple_in_seq_2 (gimple_transaction_body (stmt
));
5127 /* Verify the GIMPLE statements inside the statement list STMTS. */
5130 verify_gimple_in_seq (gimple_seq stmts
)
5132 timevar_push (TV_TREE_STMT_VERIFY
);
5133 if (verify_gimple_in_seq_2 (stmts
))
5134 internal_error ("%<verify_gimple%> failed");
5135 timevar_pop (TV_TREE_STMT_VERIFY
);
5138 /* Return true when the T can be shared. */
5141 tree_node_can_be_shared (tree t
)
5143 if (IS_TYPE_OR_DECL_P (t
)
5144 || TREE_CODE (t
) == SSA_NAME
5145 || TREE_CODE (t
) == IDENTIFIER_NODE
5146 || TREE_CODE (t
) == CASE_LABEL_EXPR
5147 || is_gimple_min_invariant (t
))
5150 if (t
== error_mark_node
)
5156 /* Called via walk_tree. Verify tree sharing. */
5159 verify_node_sharing_1 (tree
*tp
, int *walk_subtrees
, void *data
)
5161 hash_set
<void *> *visited
= (hash_set
<void *> *) data
;
5163 if (tree_node_can_be_shared (*tp
))
5165 *walk_subtrees
= false;
5169 if (visited
->add (*tp
))
5175 /* Called via walk_gimple_stmt. Verify tree sharing. */
5178 verify_node_sharing (tree
*tp
, int *walk_subtrees
, void *data
)
5180 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
5181 return verify_node_sharing_1 (tp
, walk_subtrees
, wi
->info
);
5184 static bool eh_error_found
;
5186 verify_eh_throw_stmt_node (gimple
*const &stmt
, const int &,
5187 hash_set
<gimple
*> *visited
)
5189 if (!visited
->contains (stmt
))
5191 error ("dead statement in EH table");
5192 debug_gimple_stmt (stmt
);
5193 eh_error_found
= true;
5198 /* Verify if the location LOCs block is in BLOCKS. */
5201 verify_location (hash_set
<tree
> *blocks
, location_t loc
)
5203 tree block
= LOCATION_BLOCK (loc
);
5204 if (block
!= NULL_TREE
5205 && !blocks
->contains (block
))
5207 error ("location references block not in block tree");
5210 if (block
!= NULL_TREE
)
5211 return verify_location (blocks
, BLOCK_SOURCE_LOCATION (block
));
5215 /* Called via walk_tree. Verify that expressions have no blocks. */
5218 verify_expr_no_block (tree
*tp
, int *walk_subtrees
, void *)
5222 *walk_subtrees
= false;
5226 location_t loc
= EXPR_LOCATION (*tp
);
5227 if (LOCATION_BLOCK (loc
) != NULL
)
5233 /* Called via walk_tree. Verify locations of expressions. */
5236 verify_expr_location_1 (tree
*tp
, int *walk_subtrees
, void *data
)
5238 hash_set
<tree
> *blocks
= (hash_set
<tree
> *) data
;
5241 /* ??? This doesn't really belong here but there's no good place to
5242 stick this remainder of old verify_expr. */
5243 /* ??? This barfs on debug stmts which contain binds to vars with
5244 different function context. */
5247 || TREE_CODE (t
) == PARM_DECL
5248 || TREE_CODE (t
) == RESULT_DECL
)
5250 tree context
= decl_function_context (t
);
5251 if (context
!= cfun
->decl
5252 && !SCOPE_FILE_SCOPE_P (context
)
5254 && !DECL_EXTERNAL (t
))
5256 error ("local declaration from a different function");
5262 if (VAR_P (t
) && DECL_HAS_DEBUG_EXPR_P (t
))
5264 tree x
= DECL_DEBUG_EXPR (t
);
5265 tree addr
= walk_tree (&x
, verify_expr_no_block
, NULL
, NULL
);
5270 || TREE_CODE (t
) == PARM_DECL
5271 || TREE_CODE (t
) == RESULT_DECL
)
5272 && DECL_HAS_VALUE_EXPR_P (t
))
5274 tree x
= DECL_VALUE_EXPR (t
);
5275 tree addr
= walk_tree (&x
, verify_expr_no_block
, NULL
, NULL
);
5282 *walk_subtrees
= false;
5286 location_t loc
= EXPR_LOCATION (t
);
5287 if (verify_location (blocks
, loc
))
5293 /* Called via walk_gimple_op. Verify locations of expressions. */
5296 verify_expr_location (tree
*tp
, int *walk_subtrees
, void *data
)
5298 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
5299 return verify_expr_location_1 (tp
, walk_subtrees
, wi
->info
);
5302 /* Insert all subblocks of BLOCK into BLOCKS and recurse. */
5305 collect_subblocks (hash_set
<tree
> *blocks
, tree block
)
5308 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
5311 collect_subblocks (blocks
, t
);
5315 /* Disable warnings about missing quoting in GCC diagnostics for
5316 the verification errors. Their format strings don't follow
5317 GCC diagnostic conventions and trigger an ICE in the end. */
5319 # pragma GCC diagnostic push
5320 # pragma GCC diagnostic ignored "-Wformat-diag"
5323 /* Verify the GIMPLE statements in the CFG of FN. */
5326 verify_gimple_in_cfg (struct function
*fn
, bool verify_nothrow
)
5331 timevar_push (TV_TREE_STMT_VERIFY
);
5332 hash_set
<void *> visited
;
5333 hash_set
<gimple
*> visited_throwing_stmts
;
5335 /* Collect all BLOCKs referenced by the BLOCK tree of FN. */
5336 hash_set
<tree
> blocks
;
5337 if (DECL_INITIAL (fn
->decl
))
5339 blocks
.add (DECL_INITIAL (fn
->decl
));
5340 collect_subblocks (&blocks
, DECL_INITIAL (fn
->decl
));
5343 FOR_EACH_BB_FN (bb
, fn
)
5345 gimple_stmt_iterator gsi
;
5349 for (gphi_iterator gpi
= gsi_start_phis (bb
);
5353 gphi
*phi
= gpi
.phi ();
5357 if (gimple_bb (phi
) != bb
)
5359 error ("gimple_bb (phi) is set to a wrong basic block");
5363 err2
|= verify_gimple_phi (phi
);
5365 /* Only PHI arguments have locations. */
5366 if (gimple_location (phi
) != UNKNOWN_LOCATION
)
5368 error ("PHI node with location");
5372 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
5374 tree arg
= gimple_phi_arg_def (phi
, i
);
5375 tree addr
= walk_tree (&arg
, verify_node_sharing_1
,
5379 error ("incorrect sharing of tree nodes");
5380 debug_generic_expr (addr
);
5383 location_t loc
= gimple_phi_arg_location (phi
, i
);
5384 if (virtual_operand_p (gimple_phi_result (phi
))
5385 && loc
!= UNKNOWN_LOCATION
)
5387 error ("virtual PHI with argument locations");
5390 addr
= walk_tree (&arg
, verify_expr_location_1
, &blocks
, NULL
);
5393 debug_generic_expr (addr
);
5396 err2
|= verify_location (&blocks
, loc
);
5400 debug_gimple_stmt (phi
);
5404 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5406 gimple
*stmt
= gsi_stmt (gsi
);
5408 struct walk_stmt_info wi
;
5412 if (gimple_bb (stmt
) != bb
)
5414 error ("gimple_bb (stmt) is set to a wrong basic block");
5418 err2
|= verify_gimple_stmt (stmt
);
5419 err2
|= verify_location (&blocks
, gimple_location (stmt
));
5421 memset (&wi
, 0, sizeof (wi
));
5422 wi
.info
= (void *) &visited
;
5423 addr
= walk_gimple_op (stmt
, verify_node_sharing
, &wi
);
5426 error ("incorrect sharing of tree nodes");
5427 debug_generic_expr (addr
);
5431 memset (&wi
, 0, sizeof (wi
));
5432 wi
.info
= (void *) &blocks
;
5433 addr
= walk_gimple_op (stmt
, verify_expr_location
, &wi
);
5436 debug_generic_expr (addr
);
5440 /* If the statement is marked as part of an EH region, then it is
5441 expected that the statement could throw. Verify that when we
5442 have optimizations that simplify statements such that we prove
5443 that they cannot throw, that we update other data structures
5445 lp_nr
= lookup_stmt_eh_lp (stmt
);
5447 visited_throwing_stmts
.add (stmt
);
5450 if (!stmt_could_throw_p (cfun
, stmt
))
5454 error ("statement marked for throw, but doesn%'t");
5458 else if (!gsi_one_before_end_p (gsi
))
5460 error ("statement marked for throw in middle of block");
5466 debug_gimple_stmt (stmt
);
5470 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5471 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
5472 err
|= verify_location (&blocks
, e
->goto_locus
);
5475 hash_map
<gimple
*, int> *eh_table
= get_eh_throw_stmt_table (cfun
);
5476 eh_error_found
= false;
5478 eh_table
->traverse
<hash_set
<gimple
*> *, verify_eh_throw_stmt_node
>
5479 (&visited_throwing_stmts
);
5481 if (err
|| eh_error_found
)
5482 internal_error ("verify_gimple failed");
5484 verify_histograms ();
5485 timevar_pop (TV_TREE_STMT_VERIFY
);
5489 /* Verifies that the flow information is OK. */
5492 gimple_verify_flow_info (void)
5496 gimple_stmt_iterator gsi
;
5501 if (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.seq
5502 || ENTRY_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.phi_nodes
)
5504 error ("ENTRY_BLOCK has IL associated with it");
5508 if (EXIT_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.seq
5509 || EXIT_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.phi_nodes
)
5511 error ("EXIT_BLOCK has IL associated with it");
5515 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5516 if (e
->flags
& EDGE_FALLTHRU
)
5518 error ("fallthru to exit from bb %d", e
->src
->index
);
5522 FOR_EACH_BB_FN (bb
, cfun
)
5524 bool found_ctrl_stmt
= false;
5528 /* Skip labels on the start of basic block. */
5529 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5532 gimple
*prev_stmt
= stmt
;
5534 stmt
= gsi_stmt (gsi
);
5536 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5539 label
= gimple_label_label (as_a
<glabel
*> (stmt
));
5540 if (prev_stmt
&& DECL_NONLOCAL (label
))
5542 error ("nonlocal label ");
5543 print_generic_expr (stderr
, label
);
5544 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
5549 if (prev_stmt
&& EH_LANDING_PAD_NR (label
) != 0)
5551 error ("EH landing pad label ");
5552 print_generic_expr (stderr
, label
);
5553 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
5558 if (label_to_block (cfun
, label
) != bb
)
5561 print_generic_expr (stderr
, label
);
5562 fprintf (stderr
, " to block does not match in bb %d",
5567 if (decl_function_context (label
) != current_function_decl
)
5570 print_generic_expr (stderr
, label
);
5571 fprintf (stderr
, " has incorrect context in bb %d",
5577 /* Verify that body of basic block BB is free of control flow. */
5578 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5580 gimple
*stmt
= gsi_stmt (gsi
);
5582 if (found_ctrl_stmt
)
5584 error ("control flow in the middle of basic block %d",
5589 if (stmt_ends_bb_p (stmt
))
5590 found_ctrl_stmt
= true;
5592 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
5595 print_generic_expr (stderr
, gimple_label_label (label_stmt
));
5596 fprintf (stderr
, " in the middle of basic block %d", bb
->index
);
5601 gsi
= gsi_last_nondebug_bb (bb
);
5602 if (gsi_end_p (gsi
))
5605 stmt
= gsi_stmt (gsi
);
5607 if (gimple_code (stmt
) == GIMPLE_LABEL
)
5610 err
|= verify_eh_edges (stmt
);
5612 if (is_ctrl_stmt (stmt
))
5614 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5615 if (e
->flags
& EDGE_FALLTHRU
)
5617 error ("fallthru edge after a control statement in bb %d",
5623 if (gimple_code (stmt
) != GIMPLE_COND
)
5625 /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
5626 after anything else but if statement. */
5627 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5628 if (e
->flags
& (EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
))
5630 error ("true/false edge after a non-GIMPLE_COND in bb %d",
5636 switch (gimple_code (stmt
))
5643 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
5647 || !(true_edge
->flags
& EDGE_TRUE_VALUE
)
5648 || !(false_edge
->flags
& EDGE_FALSE_VALUE
)
5649 || (true_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
5650 || (false_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
5651 || EDGE_COUNT (bb
->succs
) >= 3)
5653 error ("wrong outgoing edge flags at end of bb %d",
5661 if (simple_goto_p (stmt
))
5663 error ("explicit goto at end of bb %d", bb
->index
);
5668 /* FIXME. We should double check that the labels in the
5669 destination blocks have their address taken. */
5670 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5671 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_TRUE_VALUE
5672 | EDGE_FALSE_VALUE
))
5673 || !(e
->flags
& EDGE_ABNORMAL
))
5675 error ("wrong outgoing edge flags at end of bb %d",
5683 if (!gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
))
5687 if (!single_succ_p (bb
)
5688 || (single_succ_edge (bb
)->flags
5689 & (EDGE_FALLTHRU
| EDGE_ABNORMAL
5690 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5692 error ("wrong outgoing edge flags at end of bb %d", bb
->index
);
5695 if (single_succ (bb
) != EXIT_BLOCK_PTR_FOR_FN (cfun
))
5697 error ("return edge does not point to exit in bb %d",
5705 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
5710 n
= gimple_switch_num_labels (switch_stmt
);
5712 /* Mark all the destination basic blocks. */
5713 for (i
= 0; i
< n
; ++i
)
5715 basic_block label_bb
= gimple_switch_label_bb (cfun
, switch_stmt
, i
);
5716 gcc_assert (!label_bb
->aux
|| label_bb
->aux
== (void *)1);
5717 label_bb
->aux
= (void *)1;
5720 /* Verify that the case labels are sorted. */
5721 prev
= gimple_switch_label (switch_stmt
, 0);
5722 for (i
= 1; i
< n
; ++i
)
5724 tree c
= gimple_switch_label (switch_stmt
, i
);
5727 error ("found default case not at the start of "
5733 && !tree_int_cst_lt (CASE_LOW (prev
), CASE_LOW (c
)))
5735 error ("case labels not sorted: ");
5736 print_generic_expr (stderr
, prev
);
5737 fprintf (stderr
," is greater than ");
5738 print_generic_expr (stderr
, c
);
5739 fprintf (stderr
," but comes before it.\n");
5744 /* VRP will remove the default case if it can prove it will
5745 never be executed. So do not verify there always exists
5746 a default case here. */
5748 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5752 error ("extra outgoing edge %d->%d",
5753 bb
->index
, e
->dest
->index
);
5757 e
->dest
->aux
= (void *)2;
5758 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
5759 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5761 error ("wrong outgoing edge flags at end of bb %d",
5767 /* Check that we have all of them. */
5768 for (i
= 0; i
< n
; ++i
)
5770 basic_block label_bb
= gimple_switch_label_bb (cfun
,
5773 if (label_bb
->aux
!= (void *)2)
5775 error ("missing edge %i->%i", bb
->index
, label_bb
->index
);
5780 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5781 e
->dest
->aux
= (void *)0;
5785 case GIMPLE_EH_DISPATCH
:
5786 err
|= verify_eh_dispatch_edge (as_a
<geh_dispatch
*> (stmt
));
5794 if (dom_info_state (CDI_DOMINATORS
) >= DOM_NO_FAST_QUERY
)
5795 verify_dominators (CDI_DOMINATORS
);
5801 # pragma GCC diagnostic pop
5804 /* Updates phi nodes after creating a forwarder block joined
5805 by edge FALLTHRU. */
5808 gimple_make_forwarder_block (edge fallthru
)
5812 basic_block dummy
, bb
;
5815 bool forward_location_p
;
5817 dummy
= fallthru
->src
;
5818 bb
= fallthru
->dest
;
5820 if (single_pred_p (bb
))
5823 /* We can forward location info if we have only one predecessor. */
5824 forward_location_p
= single_pred_p (dummy
);
5826 /* If we redirected a branch we must create new PHI nodes at the
5828 for (gsi
= gsi_start_phis (dummy
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5830 gphi
*phi
, *new_phi
;
5833 var
= gimple_phi_result (phi
);
5834 new_phi
= create_phi_node (var
, bb
);
5835 gimple_phi_set_result (phi
, copy_ssa_name (var
, phi
));
5836 add_phi_arg (new_phi
, gimple_phi_result (phi
), fallthru
,
5838 ? gimple_phi_arg_location (phi
, 0) : UNKNOWN_LOCATION
);
5841 /* Add the arguments we have stored on edges. */
5842 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
5847 flush_pending_stmts (e
);
5852 /* Return a non-special label in the head of basic block BLOCK.
5853 Create one if it doesn't exist. */
5856 gimple_block_label (basic_block bb
)
5858 gimple_stmt_iterator i
, s
= gsi_start_bb (bb
);
5863 for (i
= s
; !gsi_end_p (i
); first
= false, gsi_next (&i
))
5865 stmt
= dyn_cast
<glabel
*> (gsi_stmt (i
));
5868 label
= gimple_label_label (stmt
);
5869 if (!DECL_NONLOCAL (label
))
5872 gsi_move_before (&i
, &s
);
5877 label
= create_artificial_label (UNKNOWN_LOCATION
);
5878 stmt
= gimple_build_label (label
);
5879 gsi_insert_before (&s
, stmt
, GSI_NEW_STMT
);
5884 /* Attempt to perform edge redirection by replacing a possibly complex
5885 jump instruction by a goto or by removing the jump completely.
5886 This can apply only if all edges now point to the same block. The
5887 parameters and return values are equivalent to
5888 redirect_edge_and_branch. */
5891 gimple_try_redirect_by_replacing_jump (edge e
, basic_block target
)
5893 basic_block src
= e
->src
;
5894 gimple_stmt_iterator i
;
5897 /* We can replace or remove a complex jump only when we have exactly
5899 if (EDGE_COUNT (src
->succs
) != 2
5900 /* Verify that all targets will be TARGET. Specifically, the
5901 edge that is not E must also go to TARGET. */
5902 || EDGE_SUCC (src
, EDGE_SUCC (src
, 0) == e
)->dest
!= target
)
5905 i
= gsi_last_bb (src
);
5909 stmt
= gsi_stmt (i
);
5911 if (gimple_code (stmt
) == GIMPLE_COND
|| gimple_code (stmt
) == GIMPLE_SWITCH
)
5913 gsi_remove (&i
, true);
5914 e
= ssa_redirect_edge (e
, target
);
5915 e
->flags
= EDGE_FALLTHRU
;
5923 /* Redirect E to DEST. Return NULL on failure. Otherwise, return the
5924 edge representing the redirected branch. */
5927 gimple_redirect_edge_and_branch (edge e
, basic_block dest
)
5929 basic_block bb
= e
->src
;
5930 gimple_stmt_iterator gsi
;
5934 if (e
->flags
& EDGE_ABNORMAL
)
5937 if (e
->dest
== dest
)
5940 if (e
->flags
& EDGE_EH
)
5941 return redirect_eh_edge (e
, dest
);
5943 if (e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
))
5945 ret
= gimple_try_redirect_by_replacing_jump (e
, dest
);
5950 gsi
= gsi_last_nondebug_bb (bb
);
5951 stmt
= gsi_end_p (gsi
) ? NULL
: gsi_stmt (gsi
);
5953 switch (stmt
? gimple_code (stmt
) : GIMPLE_ERROR_MARK
)
5956 /* For COND_EXPR, we only need to redirect the edge. */
5960 /* No non-abnormal edges should lead from a non-simple goto, and
5961 simple ones should be represented implicitly. */
5966 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
5967 tree label
= gimple_block_label (dest
);
5968 tree cases
= get_cases_for_edge (e
, switch_stmt
);
5970 /* If we have a list of cases associated with E, then use it
5971 as it's a lot faster than walking the entire case vector. */
5974 edge e2
= find_edge (e
->src
, dest
);
5981 CASE_LABEL (cases
) = label
;
5982 cases
= CASE_CHAIN (cases
);
5985 /* If there was already an edge in the CFG, then we need
5986 to move all the cases associated with E to E2. */
5989 tree cases2
= get_cases_for_edge (e2
, switch_stmt
);
5991 CASE_CHAIN (last
) = CASE_CHAIN (cases2
);
5992 CASE_CHAIN (cases2
) = first
;
5994 bitmap_set_bit (touched_switch_bbs
, gimple_bb (stmt
)->index
);
5998 size_t i
, n
= gimple_switch_num_labels (switch_stmt
);
6000 for (i
= 0; i
< n
; i
++)
6002 tree elt
= gimple_switch_label (switch_stmt
, i
);
6003 if (label_to_block (cfun
, CASE_LABEL (elt
)) == e
->dest
)
6004 CASE_LABEL (elt
) = label
;
6012 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
6013 int i
, n
= gimple_asm_nlabels (asm_stmt
);
6016 for (i
= 0; i
< n
; ++i
)
6018 tree cons
= gimple_asm_label_op (asm_stmt
, i
);
6019 if (label_to_block (cfun
, TREE_VALUE (cons
)) == e
->dest
)
6022 label
= gimple_block_label (dest
);
6023 TREE_VALUE (cons
) = label
;
6027 /* If we didn't find any label matching the former edge in the
6028 asm labels, we must be redirecting the fallthrough
6030 gcc_assert (label
|| (e
->flags
& EDGE_FALLTHRU
));
6035 gsi_remove (&gsi
, true);
6036 e
->flags
|= EDGE_FALLTHRU
;
6039 case GIMPLE_OMP_RETURN
:
6040 case GIMPLE_OMP_CONTINUE
:
6041 case GIMPLE_OMP_SECTIONS_SWITCH
:
6042 case GIMPLE_OMP_FOR
:
6043 /* The edges from OMP constructs can be simply redirected. */
6046 case GIMPLE_EH_DISPATCH
:
6047 if (!(e
->flags
& EDGE_FALLTHRU
))
6048 redirect_eh_dispatch_edge (as_a
<geh_dispatch
*> (stmt
), e
, dest
);
6051 case GIMPLE_TRANSACTION
:
6052 if (e
->flags
& EDGE_TM_ABORT
)
6053 gimple_transaction_set_label_over (as_a
<gtransaction
*> (stmt
),
6054 gimple_block_label (dest
));
6055 else if (e
->flags
& EDGE_TM_UNINSTRUMENTED
)
6056 gimple_transaction_set_label_uninst (as_a
<gtransaction
*> (stmt
),
6057 gimple_block_label (dest
));
6059 gimple_transaction_set_label_norm (as_a
<gtransaction
*> (stmt
),
6060 gimple_block_label (dest
));
6064 /* Otherwise it must be a fallthru edge, and we don't need to
6065 do anything besides redirecting it. */
6066 gcc_assert (e
->flags
& EDGE_FALLTHRU
);
6070 /* Update/insert PHI nodes as necessary. */
6072 /* Now update the edges in the CFG. */
6073 e
= ssa_redirect_edge (e
, dest
);
6078 /* Returns true if it is possible to remove edge E by redirecting
6079 it to the destination of the other edge from E->src. */
6082 gimple_can_remove_branch_p (const_edge e
)
6084 if (e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
))
6090 /* Simple wrapper, as we can always redirect fallthru edges. */
6093 gimple_redirect_edge_and_branch_force (edge e
, basic_block dest
)
6095 e
= gimple_redirect_edge_and_branch (e
, dest
);
6102 /* Splits basic block BB after statement STMT (but at least after the
6103 labels). If STMT is NULL, BB is split just after the labels. */
6106 gimple_split_block (basic_block bb
, void *stmt
)
6108 gimple_stmt_iterator gsi
;
6109 gimple_stmt_iterator gsi_tgt
;
6115 new_bb
= create_empty_bb (bb
);
6117 /* Redirect the outgoing edges. */
6118 new_bb
->succs
= bb
->succs
;
6120 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
6123 /* Get a stmt iterator pointing to the first stmt to move. */
6124 if (!stmt
|| gimple_code ((gimple
*) stmt
) == GIMPLE_LABEL
)
6125 gsi
= gsi_after_labels (bb
);
6128 gsi
= gsi_for_stmt ((gimple
*) stmt
);
6132 /* Move everything from GSI to the new basic block. */
6133 if (gsi_end_p (gsi
))
6136 /* Split the statement list - avoid re-creating new containers as this
6137 brings ugly quadratic memory consumption in the inliner.
6138 (We are still quadratic since we need to update stmt BB pointers,
6140 gsi_split_seq_before (&gsi
, &list
);
6141 set_bb_seq (new_bb
, list
);
6142 for (gsi_tgt
= gsi_start (list
);
6143 !gsi_end_p (gsi_tgt
); gsi_next (&gsi_tgt
))
6144 gimple_set_bb (gsi_stmt (gsi_tgt
), new_bb
);
6150 /* Moves basic block BB after block AFTER. */
6153 gimple_move_block_after (basic_block bb
, basic_block after
)
6155 if (bb
->prev_bb
== after
)
6159 link_block (bb
, after
);
6165 /* Return TRUE if block BB has no executable statements, otherwise return
6169 gimple_empty_block_p (basic_block bb
)
6171 /* BB must have no executable statements. */
6172 gimple_stmt_iterator gsi
= gsi_after_labels (bb
);
6175 while (!gsi_end_p (gsi
))
6177 gimple
*stmt
= gsi_stmt (gsi
);
6178 if (is_gimple_debug (stmt
))
6180 else if (gimple_code (stmt
) == GIMPLE_NOP
6181 || gimple_code (stmt
) == GIMPLE_PREDICT
)
6191 /* Split a basic block if it ends with a conditional branch and if the
6192 other part of the block is not empty. */
6195 gimple_split_block_before_cond_jump (basic_block bb
)
6197 gimple
*last
, *split_point
;
6198 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
6199 if (gsi_end_p (gsi
))
6201 last
= gsi_stmt (gsi
);
6202 if (gimple_code (last
) != GIMPLE_COND
6203 && gimple_code (last
) != GIMPLE_SWITCH
)
6206 split_point
= gsi_stmt (gsi
);
6207 return split_block (bb
, split_point
)->dest
;
6211 /* Return true if basic_block can be duplicated. */
6214 gimple_can_duplicate_bb_p (const_basic_block bb ATTRIBUTE_UNUSED
)
6219 /* Create a duplicate of the basic block BB. NOTE: This does not
6220 preserve SSA form. */
6223 gimple_duplicate_bb (basic_block bb
, copy_bb_data
*id
)
6226 gimple_stmt_iterator gsi_tgt
;
6228 new_bb
= create_empty_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
);
6230 /* Copy the PHI nodes. We ignore PHI node arguments here because
6231 the incoming edges have not been setup yet. */
6232 for (gphi_iterator gpi
= gsi_start_phis (bb
);
6238 copy
= create_phi_node (NULL_TREE
, new_bb
);
6239 create_new_def_for (gimple_phi_result (phi
), copy
,
6240 gimple_phi_result_ptr (copy
));
6241 gimple_set_uid (copy
, gimple_uid (phi
));
6244 gsi_tgt
= gsi_start_bb (new_bb
);
6245 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
6249 def_operand_p def_p
;
6250 ssa_op_iter op_iter
;
6252 gimple
*stmt
, *copy
;
6254 stmt
= gsi_stmt (gsi
);
6255 if (gimple_code (stmt
) == GIMPLE_LABEL
)
6258 /* Don't duplicate label debug stmts. */
6259 if (gimple_debug_bind_p (stmt
)
6260 && TREE_CODE (gimple_debug_bind_get_var (stmt
))
6264 /* Create a new copy of STMT and duplicate STMT's virtual
6266 copy
= gimple_copy (stmt
);
6267 gsi_insert_after (&gsi_tgt
, copy
, GSI_NEW_STMT
);
6269 maybe_duplicate_eh_stmt (copy
, stmt
);
6270 gimple_duplicate_stmt_histograms (cfun
, copy
, cfun
, stmt
);
6272 /* When copying around a stmt writing into a local non-user
6273 aggregate, make sure it won't share stack slot with other
6275 lhs
= gimple_get_lhs (stmt
);
6276 if (lhs
&& TREE_CODE (lhs
) != SSA_NAME
)
6278 tree base
= get_base_address (lhs
);
6280 && (VAR_P (base
) || TREE_CODE (base
) == RESULT_DECL
)
6281 && DECL_IGNORED_P (base
)
6282 && !TREE_STATIC (base
)
6283 && !DECL_EXTERNAL (base
)
6284 && (!VAR_P (base
) || !DECL_HAS_VALUE_EXPR_P (base
)))
6285 DECL_NONSHAREABLE (base
) = 1;
6288 /* If requested remap dependence info of cliques brought in
6291 for (unsigned i
= 0; i
< gimple_num_ops (copy
); ++i
)
6293 tree op
= gimple_op (copy
, i
);
6296 if (TREE_CODE (op
) == ADDR_EXPR
6297 || TREE_CODE (op
) == WITH_SIZE_EXPR
)
6298 op
= TREE_OPERAND (op
, 0);
6299 while (handled_component_p (op
))
6300 op
= TREE_OPERAND (op
, 0);
6301 if ((TREE_CODE (op
) == MEM_REF
6302 || TREE_CODE (op
) == TARGET_MEM_REF
)
6303 && MR_DEPENDENCE_CLIQUE (op
) > 1
6304 && MR_DEPENDENCE_CLIQUE (op
) != bb
->loop_father
->owned_clique
)
6306 if (!id
->dependence_map
)
6307 id
->dependence_map
= new hash_map
<dependence_hash
,
6310 unsigned short &newc
= id
->dependence_map
->get_or_insert
6311 (MR_DEPENDENCE_CLIQUE (op
), &existed
);
6314 gcc_assert (MR_DEPENDENCE_CLIQUE (op
) <= cfun
->last_clique
);
6315 newc
= ++cfun
->last_clique
;
6317 MR_DEPENDENCE_CLIQUE (op
) = newc
;
6321 /* Create new names for all the definitions created by COPY and
6322 add replacement mappings for each new name. */
6323 FOR_EACH_SSA_DEF_OPERAND (def_p
, copy
, op_iter
, SSA_OP_ALL_DEFS
)
6324 create_new_def_for (DEF_FROM_PTR (def_p
), copy
, def_p
);
6330 /* Adds phi node arguments for edge E_COPY after basic block duplication. */
6333 add_phi_args_after_copy_edge (edge e_copy
)
6335 basic_block bb
, bb_copy
= e_copy
->src
, dest
;
6338 gphi
*phi
, *phi_copy
;
6340 gphi_iterator psi
, psi_copy
;
6342 if (gimple_seq_empty_p (phi_nodes (e_copy
->dest
)))
6345 bb
= bb_copy
->flags
& BB_DUPLICATED
? get_bb_original (bb_copy
) : bb_copy
;
6347 if (e_copy
->dest
->flags
& BB_DUPLICATED
)
6348 dest
= get_bb_original (e_copy
->dest
);
6350 dest
= e_copy
->dest
;
6352 e
= find_edge (bb
, dest
);
6355 /* During loop unrolling the target of the latch edge is copied.
6356 In this case we are not looking for edge to dest, but to
6357 duplicated block whose original was dest. */
6358 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6360 if ((e
->dest
->flags
& BB_DUPLICATED
)
6361 && get_bb_original (e
->dest
) == dest
)
6365 gcc_assert (e
!= NULL
);
6368 for (psi
= gsi_start_phis (e
->dest
),
6369 psi_copy
= gsi_start_phis (e_copy
->dest
);
6371 gsi_next (&psi
), gsi_next (&psi_copy
))
6374 phi_copy
= psi_copy
.phi ();
6375 def
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
6376 add_phi_arg (phi_copy
, def
, e_copy
,
6377 gimple_phi_arg_location_from_edge (phi
, e
));
6382 /* Basic block BB_COPY was created by code duplication. Add phi node
6383 arguments for edges going out of BB_COPY. The blocks that were
6384 duplicated have BB_DUPLICATED set. */
6387 add_phi_args_after_copy_bb (basic_block bb_copy
)
6392 FOR_EACH_EDGE (e_copy
, ei
, bb_copy
->succs
)
6394 add_phi_args_after_copy_edge (e_copy
);
6398 /* Blocks in REGION_COPY array of length N_REGION were created by
6399 duplication of basic blocks. Add phi node arguments for edges
6400 going from these blocks. If E_COPY is not NULL, also add
6401 phi node arguments for its destination.*/
6404 add_phi_args_after_copy (basic_block
*region_copy
, unsigned n_region
,
6409 for (i
= 0; i
< n_region
; i
++)
6410 region_copy
[i
]->flags
|= BB_DUPLICATED
;
6412 for (i
= 0; i
< n_region
; i
++)
6413 add_phi_args_after_copy_bb (region_copy
[i
]);
6415 add_phi_args_after_copy_edge (e_copy
);
6417 for (i
= 0; i
< n_region
; i
++)
6418 region_copy
[i
]->flags
&= ~BB_DUPLICATED
;
6421 /* Duplicates a REGION (set of N_REGION basic blocks) with just a single
6422 important exit edge EXIT. By important we mean that no SSA name defined
6423 inside region is live over the other exit edges of the region. All entry
6424 edges to the region must go to ENTRY->dest. The edge ENTRY is redirected
6425 to the duplicate of the region. Dominance and loop information is
6426 updated if UPDATE_DOMINANCE is true, but not the SSA web. If
6427 UPDATE_DOMINANCE is false then we assume that the caller will update the
6428 dominance information after calling this function. The new basic
6429 blocks are stored to REGION_COPY in the same order as they had in REGION,
6430 provided that REGION_COPY is not NULL.
6431 The function returns false if it is unable to copy the region,
6435 gimple_duplicate_sese_region (edge entry
, edge exit
,
6436 basic_block
*region
, unsigned n_region
,
6437 basic_block
*region_copy
,
6438 bool update_dominance
)
6441 bool free_region_copy
= false, copying_header
= false;
6442 class loop
*loop
= entry
->dest
->loop_father
;
6444 vec
<basic_block
> doms
= vNULL
;
6446 profile_count total_count
= profile_count::uninitialized ();
6447 profile_count entry_count
= profile_count::uninitialized ();
6449 if (!can_copy_bbs_p (region
, n_region
))
6452 /* Some sanity checking. Note that we do not check for all possible
6453 missuses of the functions. I.e. if you ask to copy something weird,
6454 it will work, but the state of structures probably will not be
6456 for (i
= 0; i
< n_region
; i
++)
6458 /* We do not handle subloops, i.e. all the blocks must belong to the
6460 if (region
[i
]->loop_father
!= loop
)
6463 if (region
[i
] != entry
->dest
6464 && region
[i
] == loop
->header
)
6468 /* In case the function is used for loop header copying (which is the primary
6469 use), ensure that EXIT and its copy will be new latch and entry edges. */
6470 if (loop
->header
== entry
->dest
)
6472 copying_header
= true;
6474 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, exit
->src
))
6477 for (i
= 0; i
< n_region
; i
++)
6478 if (region
[i
] != exit
->src
6479 && dominated_by_p (CDI_DOMINATORS
, region
[i
], exit
->src
))
6483 initialize_original_copy_tables ();
6486 set_loop_copy (loop
, loop_outer (loop
));
6488 set_loop_copy (loop
, loop
);
6492 region_copy
= XNEWVEC (basic_block
, n_region
);
6493 free_region_copy
= true;
6496 /* Record blocks outside the region that are dominated by something
6498 if (update_dominance
)
6501 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
6504 if (entry
->dest
->count
.initialized_p ())
6506 total_count
= entry
->dest
->count
;
6507 entry_count
= entry
->count ();
6508 /* Fix up corner cases, to avoid division by zero or creation of negative
6510 if (entry_count
> total_count
)
6511 entry_count
= total_count
;
6514 copy_bbs (region
, n_region
, region_copy
, &exit
, 1, &exit_copy
, loop
,
6515 split_edge_bb_loc (entry
), update_dominance
);
6516 if (total_count
.initialized_p () && entry_count
.initialized_p ())
6518 scale_bbs_frequencies_profile_count (region
, n_region
,
6519 total_count
- entry_count
,
6521 scale_bbs_frequencies_profile_count (region_copy
, n_region
, entry_count
,
6527 loop
->header
= exit
->dest
;
6528 loop
->latch
= exit
->src
;
6531 /* Redirect the entry and add the phi node arguments. */
6532 redirected
= redirect_edge_and_branch (entry
, get_bb_copy (entry
->dest
));
6533 gcc_assert (redirected
!= NULL
);
6534 flush_pending_stmts (entry
);
6536 /* Concerning updating of dominators: We must recount dominators
6537 for entry block and its copy. Anything that is outside of the
6538 region, but was dominated by something inside needs recounting as
6540 if (update_dominance
)
6542 set_immediate_dominator (CDI_DOMINATORS
, entry
->dest
, entry
->src
);
6543 doms
.safe_push (get_bb_original (entry
->dest
));
6544 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6548 /* Add the other PHI node arguments. */
6549 add_phi_args_after_copy (region_copy
, n_region
, NULL
);
6551 if (free_region_copy
)
6554 free_original_copy_tables ();
6558 /* Checks if BB is part of the region defined by N_REGION BBS. */
6560 bb_part_of_region_p (basic_block bb
, basic_block
* bbs
, unsigned n_region
)
6564 for (n
= 0; n
< n_region
; n
++)
6572 /* Duplicates REGION consisting of N_REGION blocks. The new blocks
6573 are stored to REGION_COPY in the same order in that they appear
6574 in REGION, if REGION_COPY is not NULL. ENTRY is the entry to
6575 the region, EXIT an exit from it. The condition guarding EXIT
6576 is moved to ENTRY. Returns true if duplication succeeds, false
6602 gimple_duplicate_sese_tail (edge entry
, edge exit
,
6603 basic_block
*region
, unsigned n_region
,
6604 basic_block
*region_copy
)
6607 bool free_region_copy
= false;
6608 class loop
*loop
= exit
->dest
->loop_father
;
6609 class loop
*orig_loop
= entry
->dest
->loop_father
;
6610 basic_block switch_bb
, entry_bb
, nentry_bb
;
6611 vec
<basic_block
> doms
;
6612 profile_count total_count
= profile_count::uninitialized (),
6613 exit_count
= profile_count::uninitialized ();
6614 edge exits
[2], nexits
[2], e
;
6615 gimple_stmt_iterator gsi
;
6618 basic_block exit_bb
;
6622 class loop
*target
, *aloop
, *cloop
;
6624 gcc_assert (EDGE_COUNT (exit
->src
->succs
) == 2);
6626 exits
[1] = EDGE_SUCC (exit
->src
, EDGE_SUCC (exit
->src
, 0) == exit
);
6628 if (!can_copy_bbs_p (region
, n_region
))
6631 initialize_original_copy_tables ();
6632 set_loop_copy (orig_loop
, loop
);
6635 for (aloop
= orig_loop
->inner
; aloop
; aloop
= aloop
->next
)
6637 if (bb_part_of_region_p (aloop
->header
, region
, n_region
))
6639 cloop
= duplicate_loop (aloop
, target
);
6640 duplicate_subloops (aloop
, cloop
);
6646 region_copy
= XNEWVEC (basic_block
, n_region
);
6647 free_region_copy
= true;
6650 gcc_assert (!need_ssa_update_p (cfun
));
6652 /* Record blocks outside the region that are dominated by something
6654 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
6656 total_count
= exit
->src
->count
;
6657 exit_count
= exit
->count ();
6658 /* Fix up corner cases, to avoid division by zero or creation of negative
6660 if (exit_count
> total_count
)
6661 exit_count
= total_count
;
6663 copy_bbs (region
, n_region
, region_copy
, exits
, 2, nexits
, orig_loop
,
6664 split_edge_bb_loc (exit
), true);
6665 if (total_count
.initialized_p () && exit_count
.initialized_p ())
6667 scale_bbs_frequencies_profile_count (region
, n_region
,
6668 total_count
- exit_count
,
6670 scale_bbs_frequencies_profile_count (region_copy
, n_region
, exit_count
,
6674 /* Create the switch block, and put the exit condition to it. */
6675 entry_bb
= entry
->dest
;
6676 nentry_bb
= get_bb_copy (entry_bb
);
6677 if (!last_stmt (entry
->src
)
6678 || !stmt_ends_bb_p (last_stmt (entry
->src
)))
6679 switch_bb
= entry
->src
;
6681 switch_bb
= split_edge (entry
);
6682 set_immediate_dominator (CDI_DOMINATORS
, nentry_bb
, switch_bb
);
6684 gsi
= gsi_last_bb (switch_bb
);
6685 cond_stmt
= last_stmt (exit
->src
);
6686 gcc_assert (gimple_code (cond_stmt
) == GIMPLE_COND
);
6687 cond_stmt
= gimple_copy (cond_stmt
);
6689 gsi_insert_after (&gsi
, cond_stmt
, GSI_NEW_STMT
);
6691 sorig
= single_succ_edge (switch_bb
);
6692 sorig
->flags
= exits
[1]->flags
;
6693 sorig
->probability
= exits
[1]->probability
;
6694 snew
= make_edge (switch_bb
, nentry_bb
, exits
[0]->flags
);
6695 snew
->probability
= exits
[0]->probability
;
6698 /* Register the new edge from SWITCH_BB in loop exit lists. */
6699 rescan_loop_exit (snew
, true, false);
6701 /* Add the PHI node arguments. */
6702 add_phi_args_after_copy (region_copy
, n_region
, snew
);
6704 /* Get rid of now superfluous conditions and associated edges (and phi node
6706 exit_bb
= exit
->dest
;
6708 e
= redirect_edge_and_branch (exits
[0], exits
[1]->dest
);
6709 PENDING_STMT (e
) = NULL
;
6711 /* The latch of ORIG_LOOP was copied, and so was the backedge
6712 to the original header. We redirect this backedge to EXIT_BB. */
6713 for (i
= 0; i
< n_region
; i
++)
6714 if (get_bb_original (region_copy
[i
]) == orig_loop
->latch
)
6716 gcc_assert (single_succ_edge (region_copy
[i
]));
6717 e
= redirect_edge_and_branch (single_succ_edge (region_copy
[i
]), exit_bb
);
6718 PENDING_STMT (e
) = NULL
;
6719 for (psi
= gsi_start_phis (exit_bb
);
6724 def
= PHI_ARG_DEF (phi
, nexits
[0]->dest_idx
);
6725 add_phi_arg (phi
, def
, e
, gimple_phi_arg_location_from_edge (phi
, e
));
6728 e
= redirect_edge_and_branch (nexits
[1], nexits
[0]->dest
);
6729 PENDING_STMT (e
) = NULL
;
6731 /* Anything that is outside of the region, but was dominated by something
6732 inside needs to update dominance info. */
6733 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6735 /* Update the SSA web. */
6736 update_ssa (TODO_update_ssa
);
6738 if (free_region_copy
)
6741 free_original_copy_tables ();
6745 /* Add all the blocks dominated by ENTRY to the array BBS_P. Stop
6746 adding blocks when the dominator traversal reaches EXIT. This
6747 function silently assumes that ENTRY strictly dominates EXIT. */
6750 gather_blocks_in_sese_region (basic_block entry
, basic_block exit
,
6751 vec
<basic_block
> *bbs_p
)
6755 for (son
= first_dom_son (CDI_DOMINATORS
, entry
);
6757 son
= next_dom_son (CDI_DOMINATORS
, son
))
6759 bbs_p
->safe_push (son
);
6761 gather_blocks_in_sese_region (son
, exit
, bbs_p
);
6765 /* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
6766 The duplicates are recorded in VARS_MAP. */
6769 replace_by_duplicate_decl (tree
*tp
, hash_map
<tree
, tree
> *vars_map
,
6772 tree t
= *tp
, new_t
;
6773 struct function
*f
= DECL_STRUCT_FUNCTION (to_context
);
6775 if (DECL_CONTEXT (t
) == to_context
)
6779 tree
&loc
= vars_map
->get_or_insert (t
, &existed
);
6785 new_t
= copy_var_decl (t
, DECL_NAME (t
), TREE_TYPE (t
));
6786 add_local_decl (f
, new_t
);
6790 gcc_assert (TREE_CODE (t
) == CONST_DECL
);
6791 new_t
= copy_node (t
);
6793 DECL_CONTEXT (new_t
) = to_context
;
6804 /* Creates an ssa name in TO_CONTEXT equivalent to NAME.
6805 VARS_MAP maps old ssa names and var_decls to the new ones. */
6808 replace_ssa_name (tree name
, hash_map
<tree
, tree
> *vars_map
,
6813 gcc_assert (!virtual_operand_p (name
));
6815 tree
*loc
= vars_map
->get (name
);
6819 tree decl
= SSA_NAME_VAR (name
);
6822 gcc_assert (!SSA_NAME_IS_DEFAULT_DEF (name
));
6823 replace_by_duplicate_decl (&decl
, vars_map
, to_context
);
6824 new_name
= make_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6825 decl
, SSA_NAME_DEF_STMT (name
));
6828 new_name
= copy_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6829 name
, SSA_NAME_DEF_STMT (name
));
6831 /* Now that we've used the def stmt to define new_name, make sure it
6832 doesn't define name anymore. */
6833 SSA_NAME_DEF_STMT (name
) = NULL
;
6835 vars_map
->put (name
, new_name
);
6849 hash_map
<tree
, tree
> *vars_map
;
6850 htab_t new_label_map
;
6851 hash_map
<void *, void *> *eh_map
;
6855 /* Helper for move_block_to_fn. Set TREE_BLOCK in every expression
6856 contained in *TP if it has been ORIG_BLOCK previously and change the
6857 DECL_CONTEXT of every local variable referenced in *TP. */
6860 move_stmt_op (tree
*tp
, int *walk_subtrees
, void *data
)
6862 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
6863 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6868 tree block
= TREE_BLOCK (t
);
6869 if (block
== NULL_TREE
)
6871 else if (block
== p
->orig_block
6872 || p
->orig_block
== NULL_TREE
)
6874 /* tree_node_can_be_shared says we can share invariant
6875 addresses but unshare_expr copies them anyways. Make sure
6876 to unshare before adjusting the block in place - we do not
6877 always see a copy here. */
6878 if (TREE_CODE (t
) == ADDR_EXPR
6879 && is_gimple_min_invariant (t
))
6880 *tp
= t
= unshare_expr (t
);
6881 TREE_SET_BLOCK (t
, p
->new_block
);
6883 else if (flag_checking
)
6885 while (block
&& TREE_CODE (block
) == BLOCK
&& block
!= p
->orig_block
)
6886 block
= BLOCK_SUPERCONTEXT (block
);
6887 gcc_assert (block
== p
->orig_block
);
6890 else if (DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
)
6892 if (TREE_CODE (t
) == SSA_NAME
)
6893 *tp
= replace_ssa_name (t
, p
->vars_map
, p
->to_context
);
6894 else if (TREE_CODE (t
) == PARM_DECL
6895 && gimple_in_ssa_p (cfun
))
6896 *tp
= *(p
->vars_map
->get (t
));
6897 else if (TREE_CODE (t
) == LABEL_DECL
)
6899 if (p
->new_label_map
)
6901 struct tree_map in
, *out
;
6903 out
= (struct tree_map
*)
6904 htab_find_with_hash (p
->new_label_map
, &in
, DECL_UID (t
));
6909 /* For FORCED_LABELs we can end up with references from other
6910 functions if some SESE regions are outlined. It is UB to
6911 jump in between them, but they could be used just for printing
6912 addresses etc. In that case, DECL_CONTEXT on the label should
6913 be the function containing the glabel stmt with that LABEL_DECL,
6914 rather than whatever function a reference to the label was seen
6916 if (!FORCED_LABEL (t
) && !DECL_NONLOCAL (t
))
6917 DECL_CONTEXT (t
) = p
->to_context
;
6919 else if (p
->remap_decls_p
)
6921 /* Replace T with its duplicate. T should no longer appear in the
6922 parent function, so this looks wasteful; however, it may appear
6923 in referenced_vars, and more importantly, as virtual operands of
6924 statements, and in alias lists of other variables. It would be
6925 quite difficult to expunge it from all those places. ??? It might
6926 suffice to do this for addressable variables. */
6927 if ((VAR_P (t
) && !is_global_var (t
))
6928 || TREE_CODE (t
) == CONST_DECL
)
6929 replace_by_duplicate_decl (tp
, p
->vars_map
, p
->to_context
);
6933 else if (TYPE_P (t
))
6939 /* Helper for move_stmt_r. Given an EH region number for the source
6940 function, map that to the duplicate EH regio number in the dest. */
6943 move_stmt_eh_region_nr (int old_nr
, struct move_stmt_d
*p
)
6945 eh_region old_r
, new_r
;
6947 old_r
= get_eh_region_from_number (old_nr
);
6948 new_r
= static_cast<eh_region
> (*p
->eh_map
->get (old_r
));
6950 return new_r
->index
;
6953 /* Similar, but operate on INTEGER_CSTs. */
6956 move_stmt_eh_region_tree_nr (tree old_t_nr
, struct move_stmt_d
*p
)
6960 old_nr
= tree_to_shwi (old_t_nr
);
6961 new_nr
= move_stmt_eh_region_nr (old_nr
, p
);
6963 return build_int_cst (integer_type_node
, new_nr
);
6966 /* Like move_stmt_op, but for gimple statements.
6968 Helper for move_block_to_fn. Set GIMPLE_BLOCK in every expression
6969 contained in the current statement in *GSI_P and change the
6970 DECL_CONTEXT of every local variable referenced in the current
6974 move_stmt_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
6975 struct walk_stmt_info
*wi
)
6977 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6978 gimple
*stmt
= gsi_stmt (*gsi_p
);
6979 tree block
= gimple_block (stmt
);
6981 if (block
== p
->orig_block
6982 || (p
->orig_block
== NULL_TREE
6983 && block
!= NULL_TREE
))
6984 gimple_set_block (stmt
, p
->new_block
);
6986 switch (gimple_code (stmt
))
6989 /* Remap the region numbers for __builtin_eh_{pointer,filter}. */
6991 tree r
, fndecl
= gimple_call_fndecl (stmt
);
6992 if (fndecl
&& fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
))
6993 switch (DECL_FUNCTION_CODE (fndecl
))
6995 case BUILT_IN_EH_COPY_VALUES
:
6996 r
= gimple_call_arg (stmt
, 1);
6997 r
= move_stmt_eh_region_tree_nr (r
, p
);
6998 gimple_call_set_arg (stmt
, 1, r
);
7001 case BUILT_IN_EH_POINTER
:
7002 case BUILT_IN_EH_FILTER
:
7003 r
= gimple_call_arg (stmt
, 0);
7004 r
= move_stmt_eh_region_tree_nr (r
, p
);
7005 gimple_call_set_arg (stmt
, 0, r
);
7016 gresx
*resx_stmt
= as_a
<gresx
*> (stmt
);
7017 int r
= gimple_resx_region (resx_stmt
);
7018 r
= move_stmt_eh_region_nr (r
, p
);
7019 gimple_resx_set_region (resx_stmt
, r
);
7023 case GIMPLE_EH_DISPATCH
:
7025 geh_dispatch
*eh_dispatch_stmt
= as_a
<geh_dispatch
*> (stmt
);
7026 int r
= gimple_eh_dispatch_region (eh_dispatch_stmt
);
7027 r
= move_stmt_eh_region_nr (r
, p
);
7028 gimple_eh_dispatch_set_region (eh_dispatch_stmt
, r
);
7032 case GIMPLE_OMP_RETURN
:
7033 case GIMPLE_OMP_CONTINUE
:
7038 /* For FORCED_LABEL, move_stmt_op doesn't adjust DECL_CONTEXT,
7039 so that such labels can be referenced from other regions.
7040 Make sure to update it when seeing a GIMPLE_LABEL though,
7041 that is the owner of the label. */
7042 walk_gimple_op (stmt
, move_stmt_op
, wi
);
7043 *handled_ops_p
= true;
7044 tree label
= gimple_label_label (as_a
<glabel
*> (stmt
));
7045 if (FORCED_LABEL (label
) || DECL_NONLOCAL (label
))
7046 DECL_CONTEXT (label
) = p
->to_context
;
7051 if (is_gimple_omp (stmt
))
7053 /* Do not remap variables inside OMP directives. Variables
7054 referenced in clauses and directive header belong to the
7055 parent function and should not be moved into the child
7057 bool save_remap_decls_p
= p
->remap_decls_p
;
7058 p
->remap_decls_p
= false;
7059 *handled_ops_p
= true;
7061 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt
), move_stmt_r
,
7064 p
->remap_decls_p
= save_remap_decls_p
;
7072 /* Move basic block BB from function CFUN to function DEST_FN. The
7073 block is moved out of the original linked list and placed after
7074 block AFTER in the new list. Also, the block is removed from the
7075 original array of blocks and placed in DEST_FN's array of blocks.
7076 If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
7077 updated to reflect the moved edges.
7079 The local variables are remapped to new instances, VARS_MAP is used
7080 to record the mapping. */
7083 move_block_to_fn (struct function
*dest_cfun
, basic_block bb
,
7084 basic_block after
, bool update_edge_count_p
,
7085 struct move_stmt_d
*d
)
7087 struct control_flow_graph
*cfg
;
7090 gimple_stmt_iterator si
;
7093 /* Remove BB from dominance structures. */
7094 delete_from_dominance_info (CDI_DOMINATORS
, bb
);
7096 /* Move BB from its current loop to the copy in the new function. */
7099 class loop
*new_loop
= (class loop
*)bb
->loop_father
->aux
;
7101 bb
->loop_father
= new_loop
;
7104 /* Link BB to the new linked list. */
7105 move_block_after (bb
, after
);
7107 /* Update the edge count in the corresponding flowgraphs. */
7108 if (update_edge_count_p
)
7109 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7111 cfun
->cfg
->x_n_edges
--;
7112 dest_cfun
->cfg
->x_n_edges
++;
7115 /* Remove BB from the original basic block array. */
7116 (*cfun
->cfg
->x_basic_block_info
)[bb
->index
] = NULL
;
7117 cfun
->cfg
->x_n_basic_blocks
--;
7119 /* Grow DEST_CFUN's basic block array if needed. */
7120 cfg
= dest_cfun
->cfg
;
7121 cfg
->x_n_basic_blocks
++;
7122 if (bb
->index
>= cfg
->x_last_basic_block
)
7123 cfg
->x_last_basic_block
= bb
->index
+ 1;
7125 old_len
= vec_safe_length (cfg
->x_basic_block_info
);
7126 if ((unsigned) cfg
->x_last_basic_block
>= old_len
)
7127 vec_safe_grow_cleared (cfg
->x_basic_block_info
,
7128 cfg
->x_last_basic_block
+ 1);
7130 (*cfg
->x_basic_block_info
)[bb
->index
] = bb
;
7132 /* Remap the variables in phi nodes. */
7133 for (gphi_iterator psi
= gsi_start_phis (bb
);
7136 gphi
*phi
= psi
.phi ();
7138 tree op
= PHI_RESULT (phi
);
7142 if (virtual_operand_p (op
))
7144 /* Remove the phi nodes for virtual operands (alias analysis will be
7145 run for the new function, anyway). But replace all uses that
7146 might be outside of the region we move. */
7147 use_operand_p use_p
;
7148 imm_use_iterator iter
;
7150 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, op
)
7151 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
7152 SET_USE (use_p
, SSA_NAME_VAR (op
));
7153 remove_phi_node (&psi
, true);
7157 SET_PHI_RESULT (phi
,
7158 replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
7159 FOR_EACH_PHI_ARG (use
, phi
, oi
, SSA_OP_USE
)
7161 op
= USE_FROM_PTR (use
);
7162 if (TREE_CODE (op
) == SSA_NAME
)
7163 SET_USE (use
, replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
7166 for (i
= 0; i
< EDGE_COUNT (bb
->preds
); i
++)
7168 location_t locus
= gimple_phi_arg_location (phi
, i
);
7169 tree block
= LOCATION_BLOCK (locus
);
7171 if (locus
== UNKNOWN_LOCATION
)
7173 if (d
->orig_block
== NULL_TREE
|| block
== d
->orig_block
)
7175 locus
= set_block (locus
, d
->new_block
);
7176 gimple_phi_arg_set_location (phi
, i
, locus
);
7183 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
7185 gimple
*stmt
= gsi_stmt (si
);
7186 struct walk_stmt_info wi
;
7188 memset (&wi
, 0, sizeof (wi
));
7190 walk_gimple_stmt (&si
, move_stmt_r
, move_stmt_op
, &wi
);
7192 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
7194 tree label
= gimple_label_label (label_stmt
);
7195 int uid
= LABEL_DECL_UID (label
);
7197 gcc_assert (uid
> -1);
7199 old_len
= vec_safe_length (cfg
->x_label_to_block_map
);
7200 if (old_len
<= (unsigned) uid
)
7201 vec_safe_grow_cleared (cfg
->x_label_to_block_map
, uid
+ 1);
7203 (*cfg
->x_label_to_block_map
)[uid
] = bb
;
7204 (*cfun
->cfg
->x_label_to_block_map
)[uid
] = NULL
;
7206 gcc_assert (DECL_CONTEXT (label
) == dest_cfun
->decl
);
7208 if (uid
>= dest_cfun
->cfg
->last_label_uid
)
7209 dest_cfun
->cfg
->last_label_uid
= uid
+ 1;
7212 maybe_duplicate_eh_stmt_fn (dest_cfun
, stmt
, cfun
, stmt
, d
->eh_map
, 0);
7213 remove_stmt_from_eh_lp_fn (cfun
, stmt
);
7215 gimple_duplicate_stmt_histograms (dest_cfun
, stmt
, cfun
, stmt
);
7216 gimple_remove_stmt_histograms (cfun
, stmt
);
7218 /* We cannot leave any operands allocated from the operand caches of
7219 the current function. */
7220 free_stmt_operands (cfun
, stmt
);
7221 push_cfun (dest_cfun
);
7226 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7227 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
7229 tree block
= LOCATION_BLOCK (e
->goto_locus
);
7230 if (d
->orig_block
== NULL_TREE
7231 || block
== d
->orig_block
)
7232 e
->goto_locus
= set_block (e
->goto_locus
, d
->new_block
);
7236 /* Examine the statements in BB (which is in SRC_CFUN); find and return
7237 the outermost EH region. Use REGION as the incoming base EH region.
7238 If there is no single outermost region, return NULL and set *ALL to
7242 find_outermost_region_in_block (struct function
*src_cfun
,
7243 basic_block bb
, eh_region region
,
7246 gimple_stmt_iterator si
;
7248 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
7250 gimple
*stmt
= gsi_stmt (si
);
7251 eh_region stmt_region
;
7254 lp_nr
= lookup_stmt_eh_lp_fn (src_cfun
, stmt
);
7255 stmt_region
= get_eh_region_from_lp_number_fn (src_cfun
, lp_nr
);
7259 region
= stmt_region
;
7260 else if (stmt_region
!= region
)
7262 region
= eh_region_outermost (src_cfun
, stmt_region
, region
);
7276 new_label_mapper (tree decl
, void *data
)
7278 htab_t hash
= (htab_t
) data
;
7282 gcc_assert (TREE_CODE (decl
) == LABEL_DECL
);
7284 m
= XNEW (struct tree_map
);
7285 m
->hash
= DECL_UID (decl
);
7286 m
->base
.from
= decl
;
7287 m
->to
= create_artificial_label (UNKNOWN_LOCATION
);
7288 LABEL_DECL_UID (m
->to
) = LABEL_DECL_UID (decl
);
7289 if (LABEL_DECL_UID (m
->to
) >= cfun
->cfg
->last_label_uid
)
7290 cfun
->cfg
->last_label_uid
= LABEL_DECL_UID (m
->to
) + 1;
7292 slot
= htab_find_slot_with_hash (hash
, m
, m
->hash
, INSERT
);
7293 gcc_assert (*slot
== NULL
);
7300 /* Tree walker to replace the decls used inside value expressions by
7304 replace_block_vars_by_duplicates_1 (tree
*tp
, int *walk_subtrees
, void *data
)
7306 struct replace_decls_d
*rd
= (struct replace_decls_d
*)data
;
7308 switch (TREE_CODE (*tp
))
7313 replace_by_duplicate_decl (tp
, rd
->vars_map
, rd
->to_context
);
7319 if (IS_TYPE_OR_DECL_P (*tp
))
7320 *walk_subtrees
= false;
7325 /* Change DECL_CONTEXT of all BLOCK_VARS in block, including
7329 replace_block_vars_by_duplicates (tree block
, hash_map
<tree
, tree
> *vars_map
,
7334 for (tp
= &BLOCK_VARS (block
); *tp
; tp
= &DECL_CHAIN (*tp
))
7337 if (!VAR_P (t
) && TREE_CODE (t
) != CONST_DECL
)
7339 replace_by_duplicate_decl (&t
, vars_map
, to_context
);
7342 if (VAR_P (*tp
) && DECL_HAS_VALUE_EXPR_P (*tp
))
7344 tree x
= DECL_VALUE_EXPR (*tp
);
7345 struct replace_decls_d rd
= { vars_map
, to_context
};
7347 walk_tree (&x
, replace_block_vars_by_duplicates_1
, &rd
, NULL
);
7348 SET_DECL_VALUE_EXPR (t
, x
);
7349 DECL_HAS_VALUE_EXPR_P (t
) = 1;
7351 DECL_CHAIN (t
) = DECL_CHAIN (*tp
);
7356 for (block
= BLOCK_SUBBLOCKS (block
); block
; block
= BLOCK_CHAIN (block
))
7357 replace_block_vars_by_duplicates (block
, vars_map
, to_context
);
7360 /* Fixup the loop arrays and numbers after moving LOOP and its subloops
7364 fixup_loop_arrays_after_move (struct function
*fn1
, struct function
*fn2
,
7367 /* Discard it from the old loop array. */
7368 (*get_loops (fn1
))[loop
->num
] = NULL
;
7370 /* Place it in the new loop array, assigning it a new number. */
7371 loop
->num
= number_of_loops (fn2
);
7372 vec_safe_push (loops_for_fn (fn2
)->larray
, loop
);
7374 /* Recurse to children. */
7375 for (loop
= loop
->inner
; loop
; loop
= loop
->next
)
7376 fixup_loop_arrays_after_move (fn1
, fn2
, loop
);
7379 /* Verify that the blocks in BBS_P are a single-entry, single-exit region
7380 delimited by ENTRY_BB and EXIT_BB, possibly containing noreturn blocks. */
7383 verify_sese (basic_block entry
, basic_block exit
, vec
<basic_block
> *bbs_p
)
7388 bitmap bbs
= BITMAP_ALLOC (NULL
);
7391 gcc_assert (entry
!= NULL
);
7392 gcc_assert (entry
!= exit
);
7393 gcc_assert (bbs_p
!= NULL
);
7395 gcc_assert (bbs_p
->length () > 0);
7397 FOR_EACH_VEC_ELT (*bbs_p
, i
, bb
)
7398 bitmap_set_bit (bbs
, bb
->index
);
7400 gcc_assert (bitmap_bit_p (bbs
, entry
->index
));
7401 gcc_assert (exit
== NULL
|| bitmap_bit_p (bbs
, exit
->index
));
7403 FOR_EACH_VEC_ELT (*bbs_p
, i
, bb
)
7407 gcc_assert (single_pred_p (entry
));
7408 gcc_assert (!bitmap_bit_p (bbs
, single_pred (entry
)->index
));
7411 for (ei
= ei_start (bb
->preds
); !ei_end_p (ei
); ei_next (&ei
))
7414 gcc_assert (bitmap_bit_p (bbs
, e
->src
->index
));
7419 gcc_assert (single_succ_p (exit
));
7420 gcc_assert (!bitmap_bit_p (bbs
, single_succ (exit
)->index
));
7423 for (ei
= ei_start (bb
->succs
); !ei_end_p (ei
); ei_next (&ei
))
7426 gcc_assert (bitmap_bit_p (bbs
, e
->dest
->index
));
7433 /* If FROM is an SSA_NAME, mark the version in bitmap DATA. */
7436 gather_ssa_name_hash_map_from (tree
const &from
, tree
const &, void *data
)
7438 bitmap release_names
= (bitmap
)data
;
7440 if (TREE_CODE (from
) != SSA_NAME
)
7443 bitmap_set_bit (release_names
, SSA_NAME_VERSION (from
));
7447 /* Return LOOP_DIST_ALIAS call if present in BB. */
7450 find_loop_dist_alias (basic_block bb
)
7452 gimple
*g
= last_stmt (bb
);
7453 if (g
== NULL
|| gimple_code (g
) != GIMPLE_COND
)
7456 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
7458 if (gsi_end_p (gsi
))
7462 if (gimple_call_internal_p (g
, IFN_LOOP_DIST_ALIAS
))
7467 /* Fold loop internal call G like IFN_LOOP_VECTORIZED/IFN_LOOP_DIST_ALIAS
7468 to VALUE and update any immediate uses of it's LHS. */
7471 fold_loop_internal_call (gimple
*g
, tree value
)
7473 tree lhs
= gimple_call_lhs (g
);
7474 use_operand_p use_p
;
7475 imm_use_iterator iter
;
7477 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
7479 update_call_from_tree (&gsi
, value
);
7480 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, lhs
)
7482 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
7483 SET_USE (use_p
, value
);
7484 update_stmt (use_stmt
);
7488 /* Move a single-entry, single-exit region delimited by ENTRY_BB and
7489 EXIT_BB to function DEST_CFUN. The whole region is replaced by a
7490 single basic block in the original CFG and the new basic block is
7491 returned. DEST_CFUN must not have a CFG yet.
7493 Note that the region need not be a pure SESE region. Blocks inside
7494 the region may contain calls to abort/exit. The only restriction
7495 is that ENTRY_BB should be the only entry point and it must
7498 Change TREE_BLOCK of all statements in ORIG_BLOCK to the new
7499 functions outermost BLOCK, move all subblocks of ORIG_BLOCK
7500 to the new function.
7502 All local variables referenced in the region are assumed to be in
7503 the corresponding BLOCK_VARS and unexpanded variable lists
7504 associated with DEST_CFUN.
7506 TODO: investigate whether we can reuse gimple_duplicate_sese_region to
7507 reimplement move_sese_region_to_fn by duplicating the region rather than
7511 move_sese_region_to_fn (struct function
*dest_cfun
, basic_block entry_bb
,
7512 basic_block exit_bb
, tree orig_block
)
7514 vec
<basic_block
> bbs
, dom_bbs
;
7515 basic_block dom_entry
= get_immediate_dominator (CDI_DOMINATORS
, entry_bb
);
7516 basic_block after
, bb
, *entry_pred
, *exit_succ
, abb
;
7517 struct function
*saved_cfun
= cfun
;
7518 int *entry_flag
, *exit_flag
;
7519 profile_probability
*entry_prob
, *exit_prob
;
7520 unsigned i
, num_entry_edges
, num_exit_edges
, num_nodes
;
7523 htab_t new_label_map
;
7524 hash_map
<void *, void *> *eh_map
;
7525 class loop
*loop
= entry_bb
->loop_father
;
7526 class loop
*loop0
= get_loop (saved_cfun
, 0);
7527 struct move_stmt_d d
;
7529 /* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
7531 gcc_assert (entry_bb
!= exit_bb
7533 || dominated_by_p (CDI_DOMINATORS
, exit_bb
, entry_bb
)));
7535 /* Collect all the blocks in the region. Manually add ENTRY_BB
7536 because it won't be added by dfs_enumerate_from. */
7538 bbs
.safe_push (entry_bb
);
7539 gather_blocks_in_sese_region (entry_bb
, exit_bb
, &bbs
);
7542 verify_sese (entry_bb
, exit_bb
, &bbs
);
7544 /* The blocks that used to be dominated by something in BBS will now be
7545 dominated by the new block. */
7546 dom_bbs
= get_dominated_by_region (CDI_DOMINATORS
,
7550 /* Detach ENTRY_BB and EXIT_BB from CFUN->CFG. We need to remember
7551 the predecessor edges to ENTRY_BB and the successor edges to
7552 EXIT_BB so that we can re-attach them to the new basic block that
7553 will replace the region. */
7554 num_entry_edges
= EDGE_COUNT (entry_bb
->preds
);
7555 entry_pred
= XNEWVEC (basic_block
, num_entry_edges
);
7556 entry_flag
= XNEWVEC (int, num_entry_edges
);
7557 entry_prob
= XNEWVEC (profile_probability
, num_entry_edges
);
7559 for (ei
= ei_start (entry_bb
->preds
); (e
= ei_safe_edge (ei
)) != NULL
;)
7561 entry_prob
[i
] = e
->probability
;
7562 entry_flag
[i
] = e
->flags
;
7563 entry_pred
[i
++] = e
->src
;
7569 num_exit_edges
= EDGE_COUNT (exit_bb
->succs
);
7570 exit_succ
= XNEWVEC (basic_block
, num_exit_edges
);
7571 exit_flag
= XNEWVEC (int, num_exit_edges
);
7572 exit_prob
= XNEWVEC (profile_probability
, num_exit_edges
);
7574 for (ei
= ei_start (exit_bb
->succs
); (e
= ei_safe_edge (ei
)) != NULL
;)
7576 exit_prob
[i
] = e
->probability
;
7577 exit_flag
[i
] = e
->flags
;
7578 exit_succ
[i
++] = e
->dest
;
7590 /* Switch context to the child function to initialize DEST_FN's CFG. */
7591 gcc_assert (dest_cfun
->cfg
== NULL
);
7592 push_cfun (dest_cfun
);
7594 init_empty_tree_cfg ();
7596 /* Initialize EH information for the new function. */
7598 new_label_map
= NULL
;
7601 eh_region region
= NULL
;
7604 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7606 region
= find_outermost_region_in_block (saved_cfun
, bb
, region
, &all
);
7611 init_eh_for_function ();
7612 if (region
!= NULL
|| all
)
7614 new_label_map
= htab_create (17, tree_map_hash
, tree_map_eq
, free
);
7615 eh_map
= duplicate_eh_regions (saved_cfun
, region
, 0,
7616 new_label_mapper
, new_label_map
);
7620 /* Initialize an empty loop tree. */
7621 struct loops
*loops
= ggc_cleared_alloc
<struct loops
> ();
7622 init_loops_structure (dest_cfun
, loops
, 1);
7623 loops
->state
= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
7624 set_loops_for_fn (dest_cfun
, loops
);
7626 vec
<loop_p
, va_gc
> *larray
= get_loops (saved_cfun
)->copy ();
7628 /* Move the outlined loop tree part. */
7629 num_nodes
= bbs
.length ();
7630 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7632 if (bb
->loop_father
->header
== bb
)
7634 class loop
*this_loop
= bb
->loop_father
;
7635 class loop
*outer
= loop_outer (this_loop
);
7637 /* If the SESE region contains some bbs ending with
7638 a noreturn call, those are considered to belong
7639 to the outermost loop in saved_cfun, rather than
7640 the entry_bb's loop_father. */
7644 num_nodes
-= this_loop
->num_nodes
;
7645 flow_loop_tree_node_remove (bb
->loop_father
);
7646 flow_loop_tree_node_add (get_loop (dest_cfun
, 0), this_loop
);
7647 fixup_loop_arrays_after_move (saved_cfun
, cfun
, this_loop
);
7650 else if (bb
->loop_father
== loop0
&& loop0
!= loop
)
7653 /* Remove loop exits from the outlined region. */
7654 if (loops_for_fn (saved_cfun
)->exits
)
7655 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7657 struct loops
*l
= loops_for_fn (saved_cfun
);
7659 = l
->exits
->find_slot_with_hash (e
, htab_hash_pointer (e
),
7662 l
->exits
->clear_slot (slot
);
7666 /* Adjust the number of blocks in the tree root of the outlined part. */
7667 get_loop (dest_cfun
, 0)->num_nodes
= bbs
.length () + 2;
7669 /* Setup a mapping to be used by move_block_to_fn. */
7670 loop
->aux
= current_loops
->tree_root
;
7671 loop0
->aux
= current_loops
->tree_root
;
7673 /* Fix up orig_loop_num. If the block referenced in it has been moved
7674 to dest_cfun, update orig_loop_num field, otherwise clear it. */
7676 signed char *moved_orig_loop_num
= NULL
;
7677 FOR_EACH_LOOP_FN (dest_cfun
, dloop
, 0)
7678 if (dloop
->orig_loop_num
)
7680 if (moved_orig_loop_num
== NULL
)
7682 = XCNEWVEC (signed char, vec_safe_length (larray
));
7683 if ((*larray
)[dloop
->orig_loop_num
] != NULL
7684 && get_loop (saved_cfun
, dloop
->orig_loop_num
) == NULL
)
7686 if (moved_orig_loop_num
[dloop
->orig_loop_num
] >= 0
7687 && moved_orig_loop_num
[dloop
->orig_loop_num
] < 2)
7688 moved_orig_loop_num
[dloop
->orig_loop_num
]++;
7689 dloop
->orig_loop_num
= (*larray
)[dloop
->orig_loop_num
]->num
;
7693 moved_orig_loop_num
[dloop
->orig_loop_num
] = -1;
7694 dloop
->orig_loop_num
= 0;
7699 if (moved_orig_loop_num
)
7701 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7703 gimple
*g
= find_loop_dist_alias (bb
);
7707 int orig_loop_num
= tree_to_shwi (gimple_call_arg (g
, 0));
7708 gcc_assert (orig_loop_num
7709 && (unsigned) orig_loop_num
< vec_safe_length (larray
));
7710 if (moved_orig_loop_num
[orig_loop_num
] == 2)
7712 /* If we have moved both loops with this orig_loop_num into
7713 dest_cfun and the LOOP_DIST_ALIAS call is being moved there
7714 too, update the first argument. */
7715 gcc_assert ((*larray
)[dloop
->orig_loop_num
] != NULL
7716 && (get_loop (saved_cfun
, dloop
->orig_loop_num
)
7718 tree t
= build_int_cst (integer_type_node
,
7719 (*larray
)[dloop
->orig_loop_num
]->num
);
7720 gimple_call_set_arg (g
, 0, t
);
7722 /* Make sure the following loop will not update it. */
7723 moved_orig_loop_num
[orig_loop_num
] = 0;
7726 /* Otherwise at least one of the loops stayed in saved_cfun.
7727 Remove the LOOP_DIST_ALIAS call. */
7728 fold_loop_internal_call (g
, gimple_call_arg (g
, 1));
7730 FOR_EACH_BB_FN (bb
, saved_cfun
)
7732 gimple
*g
= find_loop_dist_alias (bb
);
7735 int orig_loop_num
= tree_to_shwi (gimple_call_arg (g
, 0));
7736 gcc_assert (orig_loop_num
7737 && (unsigned) orig_loop_num
< vec_safe_length (larray
));
7738 if (moved_orig_loop_num
[orig_loop_num
])
7739 /* LOOP_DIST_ALIAS call remained in saved_cfun, if at least one
7740 of the corresponding loops was moved, remove it. */
7741 fold_loop_internal_call (g
, gimple_call_arg (g
, 1));
7743 XDELETEVEC (moved_orig_loop_num
);
7747 /* Move blocks from BBS into DEST_CFUN. */
7748 gcc_assert (bbs
.length () >= 2);
7749 after
= dest_cfun
->cfg
->x_entry_block_ptr
;
7750 hash_map
<tree
, tree
> vars_map
;
7752 memset (&d
, 0, sizeof (d
));
7753 d
.orig_block
= orig_block
;
7754 d
.new_block
= DECL_INITIAL (dest_cfun
->decl
);
7755 d
.from_context
= cfun
->decl
;
7756 d
.to_context
= dest_cfun
->decl
;
7757 d
.vars_map
= &vars_map
;
7758 d
.new_label_map
= new_label_map
;
7760 d
.remap_decls_p
= true;
7762 if (gimple_in_ssa_p (cfun
))
7763 for (tree arg
= DECL_ARGUMENTS (d
.to_context
); arg
; arg
= DECL_CHAIN (arg
))
7765 tree narg
= make_ssa_name_fn (dest_cfun
, arg
, gimple_build_nop ());
7766 set_ssa_default_def (dest_cfun
, arg
, narg
);
7767 vars_map
.put (arg
, narg
);
7770 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7772 /* No need to update edge counts on the last block. It has
7773 already been updated earlier when we detached the region from
7774 the original CFG. */
7775 move_block_to_fn (dest_cfun
, bb
, after
, bb
!= exit_bb
, &d
);
7779 /* Adjust the maximum clique used. */
7780 dest_cfun
->last_clique
= saved_cfun
->last_clique
;
7784 /* Loop sizes are no longer correct, fix them up. */
7785 loop
->num_nodes
-= num_nodes
;
7786 for (class loop
*outer
= loop_outer (loop
);
7787 outer
; outer
= loop_outer (outer
))
7788 outer
->num_nodes
-= num_nodes
;
7789 loop0
->num_nodes
-= bbs
.length () - num_nodes
;
7791 if (saved_cfun
->has_simduid_loops
|| saved_cfun
->has_force_vectorize_loops
)
7794 for (i
= 0; vec_safe_iterate (loops
->larray
, i
, &aloop
); i
++)
7799 replace_by_duplicate_decl (&aloop
->simduid
, d
.vars_map
,
7801 dest_cfun
->has_simduid_loops
= true;
7803 if (aloop
->force_vectorize
)
7804 dest_cfun
->has_force_vectorize_loops
= true;
7808 /* Rewire BLOCK_SUBBLOCKS of orig_block. */
7812 gcc_assert (BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
7814 BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
7815 = BLOCK_SUBBLOCKS (orig_block
);
7816 for (block
= BLOCK_SUBBLOCKS (orig_block
);
7817 block
; block
= BLOCK_CHAIN (block
))
7818 BLOCK_SUPERCONTEXT (block
) = DECL_INITIAL (dest_cfun
->decl
);
7819 BLOCK_SUBBLOCKS (orig_block
) = NULL_TREE
;
7822 replace_block_vars_by_duplicates (DECL_INITIAL (dest_cfun
->decl
),
7823 &vars_map
, dest_cfun
->decl
);
7826 htab_delete (new_label_map
);
7830 if (gimple_in_ssa_p (cfun
))
7832 /* We need to release ssa-names in a defined order, so first find them,
7833 and then iterate in ascending version order. */
7834 bitmap release_names
= BITMAP_ALLOC (NULL
);
7835 vars_map
.traverse
<void *, gather_ssa_name_hash_map_from
> (release_names
);
7838 EXECUTE_IF_SET_IN_BITMAP (release_names
, 0, i
, bi
)
7839 release_ssa_name (ssa_name (i
));
7840 BITMAP_FREE (release_names
);
7843 /* Rewire the entry and exit blocks. The successor to the entry
7844 block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
7845 the child function. Similarly, the predecessor of DEST_FN's
7846 EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR. We
7847 need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
7848 various CFG manipulation function get to the right CFG.
7850 FIXME, this is silly. The CFG ought to become a parameter to
7852 push_cfun (dest_cfun
);
7853 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= entry_bb
->count
;
7854 make_single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
), entry_bb
, EDGE_FALLTHRU
);
7857 make_single_succ_edge (exit_bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
7858 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
= exit_bb
->count
;
7861 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
= profile_count::zero ();
7864 /* Back in the original function, the SESE region has disappeared,
7865 create a new basic block in its place. */
7866 bb
= create_empty_bb (entry_pred
[0]);
7868 add_bb_to_loop (bb
, loop
);
7869 for (i
= 0; i
< num_entry_edges
; i
++)
7871 e
= make_edge (entry_pred
[i
], bb
, entry_flag
[i
]);
7872 e
->probability
= entry_prob
[i
];
7875 for (i
= 0; i
< num_exit_edges
; i
++)
7877 e
= make_edge (bb
, exit_succ
[i
], exit_flag
[i
]);
7878 e
->probability
= exit_prob
[i
];
7881 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom_entry
);
7882 FOR_EACH_VEC_ELT (dom_bbs
, i
, abb
)
7883 set_immediate_dominator (CDI_DOMINATORS
, abb
, bb
);
7900 /* Dump default def DEF to file FILE using FLAGS and indentation
7904 dump_default_def (FILE *file
, tree def
, int spc
, dump_flags_t flags
)
7906 for (int i
= 0; i
< spc
; ++i
)
7907 fprintf (file
, " ");
7908 dump_ssaname_info_to_file (file
, def
, spc
);
7910 print_generic_expr (file
, TREE_TYPE (def
), flags
);
7911 fprintf (file
, " ");
7912 print_generic_expr (file
, def
, flags
);
7913 fprintf (file
, " = ");
7914 print_generic_expr (file
, SSA_NAME_VAR (def
), flags
);
7915 fprintf (file
, ";\n");
7918 /* Print no_sanitize attribute to FILE for a given attribute VALUE. */
7921 print_no_sanitize_attr_value (FILE *file
, tree value
)
7923 unsigned int flags
= tree_to_uhwi (value
);
7925 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
7927 if ((sanitizer_opts
[i
].flag
& flags
) == sanitizer_opts
[i
].flag
)
7930 fprintf (file
, " | ");
7931 fprintf (file
, "%s", sanitizer_opts
[i
].name
);
7937 /* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in dumpfile.h)
7941 dump_function_to_file (tree fndecl
, FILE *file
, dump_flags_t flags
)
7943 tree arg
, var
, old_current_fndecl
= current_function_decl
;
7944 struct function
*dsf
;
7945 bool ignore_topmost_bind
= false, any_var
= false;
7948 bool tmclone
= (TREE_CODE (fndecl
) == FUNCTION_DECL
7949 && decl_is_tm_clone (fndecl
));
7950 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
7952 if (DECL_ATTRIBUTES (fndecl
) != NULL_TREE
)
7954 fprintf (file
, "__attribute__((");
7958 for (chain
= DECL_ATTRIBUTES (fndecl
); chain
;
7959 first
= false, chain
= TREE_CHAIN (chain
))
7962 fprintf (file
, ", ");
7964 tree name
= get_attribute_name (chain
);
7965 print_generic_expr (file
, name
, dump_flags
);
7966 if (TREE_VALUE (chain
) != NULL_TREE
)
7968 fprintf (file
, " (");
7970 if (strstr (IDENTIFIER_POINTER (name
), "no_sanitize"))
7971 print_no_sanitize_attr_value (file
, TREE_VALUE (chain
));
7973 print_generic_expr (file
, TREE_VALUE (chain
), dump_flags
);
7974 fprintf (file
, ")");
7978 fprintf (file
, "))\n");
7981 current_function_decl
= fndecl
;
7982 if (flags
& TDF_GIMPLE
)
7984 static bool hotness_bb_param_printed
= false;
7985 if (profile_info
!= NULL
7986 && !hotness_bb_param_printed
)
7988 hotness_bb_param_printed
= true;
7990 "/* --param=gimple-fe-computed-hot-bb-threshold=%" PRId64
7991 " */\n", get_hot_bb_threshold ());
7994 print_generic_expr (file
, TREE_TYPE (TREE_TYPE (fndecl
)),
7995 dump_flags
| TDF_SLIM
);
7996 fprintf (file
, " __GIMPLE (%s",
7997 (fun
->curr_properties
& PROP_ssa
) ? "ssa"
7998 : (fun
->curr_properties
& PROP_cfg
) ? "cfg"
8003 basic_block bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
8004 if (bb
->count
.initialized_p ())
8005 fprintf (file
, ",%s(%d)",
8006 profile_quality_as_string (bb
->count
.quality ()),
8007 bb
->count
.value ());
8008 fprintf (file
, ")\n%s (", function_name (fun
));
8012 fprintf (file
, "%s %s(", function_name (fun
), tmclone
? "[tm-clone] " : "");
8014 arg
= DECL_ARGUMENTS (fndecl
);
8017 print_generic_expr (file
, TREE_TYPE (arg
), dump_flags
);
8018 fprintf (file
, " ");
8019 print_generic_expr (file
, arg
, dump_flags
);
8020 if (DECL_CHAIN (arg
))
8021 fprintf (file
, ", ");
8022 arg
= DECL_CHAIN (arg
);
8024 fprintf (file
, ")\n");
8026 dsf
= DECL_STRUCT_FUNCTION (fndecl
);
8027 if (dsf
&& (flags
& TDF_EH
))
8028 dump_eh_tree (file
, dsf
);
8030 if (flags
& TDF_RAW
&& !gimple_has_body_p (fndecl
))
8032 dump_node (fndecl
, TDF_SLIM
| flags
, file
);
8033 current_function_decl
= old_current_fndecl
;
8037 /* When GIMPLE is lowered, the variables are no longer available in
8038 BIND_EXPRs, so display them separately. */
8039 if (fun
&& fun
->decl
== fndecl
&& (fun
->curr_properties
& PROP_gimple_lcf
))
8042 ignore_topmost_bind
= true;
8044 fprintf (file
, "{\n");
8045 if (gimple_in_ssa_p (fun
)
8046 && (flags
& TDF_ALIAS
))
8048 for (arg
= DECL_ARGUMENTS (fndecl
); arg
!= NULL
;
8049 arg
= DECL_CHAIN (arg
))
8051 tree def
= ssa_default_def (fun
, arg
);
8053 dump_default_def (file
, def
, 2, flags
);
8056 tree res
= DECL_RESULT (fun
->decl
);
8057 if (res
!= NULL_TREE
8058 && DECL_BY_REFERENCE (res
))
8060 tree def
= ssa_default_def (fun
, res
);
8062 dump_default_def (file
, def
, 2, flags
);
8065 tree static_chain
= fun
->static_chain_decl
;
8066 if (static_chain
!= NULL_TREE
)
8068 tree def
= ssa_default_def (fun
, static_chain
);
8070 dump_default_def (file
, def
, 2, flags
);
8074 if (!vec_safe_is_empty (fun
->local_decls
))
8075 FOR_EACH_LOCAL_DECL (fun
, ix
, var
)
8077 print_generic_decl (file
, var
, flags
);
8078 fprintf (file
, "\n");
8085 if (gimple_in_ssa_p (cfun
))
8086 FOR_EACH_SSA_NAME (ix
, name
, cfun
)
8088 if (!SSA_NAME_VAR (name
))
8090 fprintf (file
, " ");
8091 print_generic_expr (file
, TREE_TYPE (name
), flags
);
8092 fprintf (file
, " ");
8093 print_generic_expr (file
, name
, flags
);
8094 fprintf (file
, ";\n");
8101 if (fun
&& fun
->decl
== fndecl
8103 && basic_block_info_for_fn (fun
))
8105 /* If the CFG has been built, emit a CFG-based dump. */
8106 if (!ignore_topmost_bind
)
8107 fprintf (file
, "{\n");
8109 if (any_var
&& n_basic_blocks_for_fn (fun
))
8110 fprintf (file
, "\n");
8112 FOR_EACH_BB_FN (bb
, fun
)
8113 dump_bb (file
, bb
, 2, flags
);
8115 fprintf (file
, "}\n");
8117 else if (fun
->curr_properties
& PROP_gimple_any
)
8119 /* The function is now in GIMPLE form but the CFG has not been
8120 built yet. Emit the single sequence of GIMPLE statements
8121 that make up its body. */
8122 gimple_seq body
= gimple_body (fndecl
);
8124 if (gimple_seq_first_stmt (body
)
8125 && gimple_seq_first_stmt (body
) == gimple_seq_last_stmt (body
)
8126 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
)
8127 print_gimple_seq (file
, body
, 0, flags
);
8130 if (!ignore_topmost_bind
)
8131 fprintf (file
, "{\n");
8134 fprintf (file
, "\n");
8136 print_gimple_seq (file
, body
, 2, flags
);
8137 fprintf (file
, "}\n");
8144 /* Make a tree based dump. */
8145 chain
= DECL_SAVED_TREE (fndecl
);
8146 if (chain
&& TREE_CODE (chain
) == BIND_EXPR
)
8148 if (ignore_topmost_bind
)
8150 chain
= BIND_EXPR_BODY (chain
);
8158 if (!ignore_topmost_bind
)
8160 fprintf (file
, "{\n");
8161 /* No topmost bind, pretend it's ignored for later. */
8162 ignore_topmost_bind
= true;
8168 fprintf (file
, "\n");
8170 print_generic_stmt_indented (file
, chain
, flags
, indent
);
8171 if (ignore_topmost_bind
)
8172 fprintf (file
, "}\n");
8175 if (flags
& TDF_ENUMERATE_LOCALS
)
8176 dump_enumerated_decls (file
, flags
);
8177 fprintf (file
, "\n\n");
8179 current_function_decl
= old_current_fndecl
;
8182 /* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h) */
8185 debug_function (tree fn
, dump_flags_t flags
)
8187 dump_function_to_file (fn
, stderr
, flags
);
8191 /* Print on FILE the indexes for the predecessors of basic_block BB. */
8194 print_pred_bbs (FILE *file
, basic_block bb
)
8199 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
8200 fprintf (file
, "bb_%d ", e
->src
->index
);
8204 /* Print on FILE the indexes for the successors of basic_block BB. */
8207 print_succ_bbs (FILE *file
, basic_block bb
)
8212 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8213 fprintf (file
, "bb_%d ", e
->dest
->index
);
8216 /* Print to FILE the basic block BB following the VERBOSITY level. */
8219 print_loops_bb (FILE *file
, basic_block bb
, int indent
, int verbosity
)
8221 char *s_indent
= (char *) alloca ((size_t) indent
+ 1);
8222 memset ((void *) s_indent
, ' ', (size_t) indent
);
8223 s_indent
[indent
] = '\0';
8225 /* Print basic_block's header. */
8228 fprintf (file
, "%s bb_%d (preds = {", s_indent
, bb
->index
);
8229 print_pred_bbs (file
, bb
);
8230 fprintf (file
, "}, succs = {");
8231 print_succ_bbs (file
, bb
);
8232 fprintf (file
, "})\n");
8235 /* Print basic_block's body. */
8238 fprintf (file
, "%s {\n", s_indent
);
8239 dump_bb (file
, bb
, indent
+ 4, TDF_VOPS
|TDF_MEMSYMS
);
8240 fprintf (file
, "%s }\n", s_indent
);
8244 static void print_loop_and_siblings (FILE *, class loop
*, int, int);
8246 /* Pretty print LOOP on FILE, indented INDENT spaces. Following
8247 VERBOSITY level this outputs the contents of the loop, or just its
8251 print_loop (FILE *file
, class loop
*loop
, int indent
, int verbosity
)
8259 s_indent
= (char *) alloca ((size_t) indent
+ 1);
8260 memset ((void *) s_indent
, ' ', (size_t) indent
);
8261 s_indent
[indent
] = '\0';
8263 /* Print loop's header. */
8264 fprintf (file
, "%sloop_%d (", s_indent
, loop
->num
);
8266 fprintf (file
, "header = %d", loop
->header
->index
);
8269 fprintf (file
, "deleted)\n");
8273 fprintf (file
, ", latch = %d", loop
->latch
->index
);
8275 fprintf (file
, ", multiple latches");
8276 fprintf (file
, ", niter = ");
8277 print_generic_expr (file
, loop
->nb_iterations
);
8279 if (loop
->any_upper_bound
)
8281 fprintf (file
, ", upper_bound = ");
8282 print_decu (loop
->nb_iterations_upper_bound
, file
);
8284 if (loop
->any_likely_upper_bound
)
8286 fprintf (file
, ", likely_upper_bound = ");
8287 print_decu (loop
->nb_iterations_likely_upper_bound
, file
);
8290 if (loop
->any_estimate
)
8292 fprintf (file
, ", estimate = ");
8293 print_decu (loop
->nb_iterations_estimate
, file
);
8296 fprintf (file
, ", unroll = %d", loop
->unroll
);
8297 fprintf (file
, ")\n");
8299 /* Print loop's body. */
8302 fprintf (file
, "%s{\n", s_indent
);
8303 FOR_EACH_BB_FN (bb
, cfun
)
8304 if (bb
->loop_father
== loop
)
8305 print_loops_bb (file
, bb
, indent
, verbosity
);
8307 print_loop_and_siblings (file
, loop
->inner
, indent
+ 2, verbosity
);
8308 fprintf (file
, "%s}\n", s_indent
);
8312 /* Print the LOOP and its sibling loops on FILE, indented INDENT
8313 spaces. Following VERBOSITY level this outputs the contents of the
8314 loop, or just its structure. */
8317 print_loop_and_siblings (FILE *file
, class loop
*loop
, int indent
,
8323 print_loop (file
, loop
, indent
, verbosity
);
8324 print_loop_and_siblings (file
, loop
->next
, indent
, verbosity
);
8327 /* Follow a CFG edge from the entry point of the program, and on entry
8328 of a loop, pretty print the loop structure on FILE. */
8331 print_loops (FILE *file
, int verbosity
)
8335 bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
8336 fprintf (file
, "\nLoops in function: %s\n", current_function_name ());
8337 if (bb
&& bb
->loop_father
)
8338 print_loop_and_siblings (file
, bb
->loop_father
, 0, verbosity
);
8344 debug (class loop
&ref
)
8346 print_loop (stderr
, &ref
, 0, /*verbosity*/0);
8350 debug (class loop
*ptr
)
8355 fprintf (stderr
, "<nil>\n");
8358 /* Dump a loop verbosely. */
8361 debug_verbose (class loop
&ref
)
8363 print_loop (stderr
, &ref
, 0, /*verbosity*/3);
8367 debug_verbose (class loop
*ptr
)
8372 fprintf (stderr
, "<nil>\n");
8376 /* Debugging loops structure at tree level, at some VERBOSITY level. */
8379 debug_loops (int verbosity
)
8381 print_loops (stderr
, verbosity
);
8384 /* Print on stderr the code of LOOP, at some VERBOSITY level. */
8387 debug_loop (class loop
*loop
, int verbosity
)
8389 print_loop (stderr
, loop
, 0, verbosity
);
8392 /* Print on stderr the code of loop number NUM, at some VERBOSITY
8396 debug_loop_num (unsigned num
, int verbosity
)
8398 debug_loop (get_loop (cfun
, num
), verbosity
);
8401 /* Return true if BB ends with a call, possibly followed by some
8402 instructions that must stay with the call. Return false,
8406 gimple_block_ends_with_call_p (basic_block bb
)
8408 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
8409 return !gsi_end_p (gsi
) && is_gimple_call (gsi_stmt (gsi
));
8413 /* Return true if BB ends with a conditional branch. Return false,
8417 gimple_block_ends_with_condjump_p (const_basic_block bb
)
8419 gimple
*stmt
= last_stmt (CONST_CAST_BB (bb
));
8420 return (stmt
&& gimple_code (stmt
) == GIMPLE_COND
);
8424 /* Return true if statement T may terminate execution of BB in ways not
8425 explicitly represtented in the CFG. */
8428 stmt_can_terminate_bb_p (gimple
*t
)
8430 tree fndecl
= NULL_TREE
;
8433 /* Eh exception not handled internally terminates execution of the whole
8435 if (stmt_can_throw_external (cfun
, t
))
8438 /* NORETURN and LONGJMP calls already have an edge to exit.
8439 CONST and PURE calls do not need one.
8440 We don't currently check for CONST and PURE here, although
8441 it would be a good idea, because those attributes are
8442 figured out from the RTL in mark_constant_function, and
8443 the counter incrementation code from -fprofile-arcs
8444 leads to different results from -fbranch-probabilities. */
8445 if (is_gimple_call (t
))
8447 fndecl
= gimple_call_fndecl (t
);
8448 call_flags
= gimple_call_flags (t
);
8451 if (is_gimple_call (t
)
8453 && fndecl_built_in_p (fndecl
)
8454 && (call_flags
& ECF_NOTHROW
)
8455 && !(call_flags
& ECF_RETURNS_TWICE
)
8456 /* fork() doesn't really return twice, but the effect of
8457 wrapping it in __gcov_fork() which calls __gcov_dump() and
8458 __gcov_reset() and clears the counters before forking has the same
8459 effect as returning twice. Force a fake edge. */
8460 && !fndecl_built_in_p (fndecl
, BUILT_IN_FORK
))
8463 if (is_gimple_call (t
))
8469 if (call_flags
& (ECF_PURE
| ECF_CONST
)
8470 && !(call_flags
& ECF_LOOPING_CONST_OR_PURE
))
8473 /* Function call may do longjmp, terminate program or do other things.
8474 Special case noreturn that have non-abnormal edges out as in this case
8475 the fact is sufficiently represented by lack of edges out of T. */
8476 if (!(call_flags
& ECF_NORETURN
))
8480 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8481 if ((e
->flags
& EDGE_FAKE
) == 0)
8485 if (gasm
*asm_stmt
= dyn_cast
<gasm
*> (t
))
8486 if (gimple_asm_volatile_p (asm_stmt
) || gimple_asm_input_p (asm_stmt
))
8493 /* Add fake edges to the function exit for any non constant and non
8494 noreturn calls (or noreturn calls with EH/abnormal edges),
8495 volatile inline assembly in the bitmap of blocks specified by BLOCKS
8496 or to the whole CFG if BLOCKS is zero. Return the number of blocks
8499 The goal is to expose cases in which entering a basic block does
8500 not imply that all subsequent instructions must be executed. */
8503 gimple_flow_call_edges_add (sbitmap blocks
)
8506 int blocks_split
= 0;
8507 int last_bb
= last_basic_block_for_fn (cfun
);
8508 bool check_last_block
= false;
8510 if (n_basic_blocks_for_fn (cfun
) == NUM_FIXED_BLOCKS
)
8514 check_last_block
= true;
8516 check_last_block
= bitmap_bit_p (blocks
,
8517 EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
->index
);
8519 /* In the last basic block, before epilogue generation, there will be
8520 a fallthru edge to EXIT. Special care is required if the last insn
8521 of the last basic block is a call because make_edge folds duplicate
8522 edges, which would result in the fallthru edge also being marked
8523 fake, which would result in the fallthru edge being removed by
8524 remove_fake_edges, which would result in an invalid CFG.
8526 Moreover, we can't elide the outgoing fake edge, since the block
8527 profiler needs to take this into account in order to solve the minimal
8528 spanning tree in the case that the call doesn't return.
8530 Handle this by adding a dummy instruction in a new last basic block. */
8531 if (check_last_block
)
8533 basic_block bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
8534 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
8537 if (!gsi_end_p (gsi
))
8540 if (t
&& stmt_can_terminate_bb_p (t
))
8544 e
= find_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
8547 gsi_insert_on_edge (e
, gimple_build_nop ());
8548 gsi_commit_edge_inserts ();
8553 /* Now add fake edges to the function exit for any non constant
8554 calls since there is no way that we can determine if they will
8556 for (i
= 0; i
< last_bb
; i
++)
8558 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8559 gimple_stmt_iterator gsi
;
8560 gimple
*stmt
, *last_stmt
;
8565 if (blocks
&& !bitmap_bit_p (blocks
, i
))
8568 gsi
= gsi_last_nondebug_bb (bb
);
8569 if (!gsi_end_p (gsi
))
8571 last_stmt
= gsi_stmt (gsi
);
8574 stmt
= gsi_stmt (gsi
);
8575 if (stmt_can_terminate_bb_p (stmt
))
8579 /* The handling above of the final block before the
8580 epilogue should be enough to verify that there is
8581 no edge to the exit block in CFG already.
8582 Calling make_edge in such case would cause us to
8583 mark that edge as fake and remove it later. */
8584 if (flag_checking
&& stmt
== last_stmt
)
8586 e
= find_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
8587 gcc_assert (e
== NULL
);
8590 /* Note that the following may create a new basic block
8591 and renumber the existing basic blocks. */
8592 if (stmt
!= last_stmt
)
8594 e
= split_block (bb
, stmt
);
8598 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FAKE
);
8599 e
->probability
= profile_probability::guessed_never ();
8603 while (!gsi_end_p (gsi
));
8608 checking_verify_flow_info ();
8610 return blocks_split
;
8613 /* Removes edge E and all the blocks dominated by it, and updates dominance
8614 information. The IL in E->src needs to be updated separately.
8615 If dominance info is not available, only the edge E is removed.*/
8618 remove_edge_and_dominated_blocks (edge e
)
8620 vec
<basic_block
> bbs_to_remove
= vNULL
;
8621 vec
<basic_block
> bbs_to_fix_dom
= vNULL
;
8624 bool none_removed
= false;
8626 basic_block bb
, dbb
;
8629 /* If we are removing a path inside a non-root loop that may change
8630 loop ownership of blocks or remove loops. Mark loops for fixup. */
8632 && loop_outer (e
->src
->loop_father
) != NULL
8633 && e
->src
->loop_father
== e
->dest
->loop_father
)
8634 loops_state_set (LOOPS_NEED_FIXUP
);
8636 if (!dom_info_available_p (CDI_DOMINATORS
))
8642 /* No updating is needed for edges to exit. */
8643 if (e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
8645 if (cfgcleanup_altered_bbs
)
8646 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
8651 /* First, we find the basic blocks to remove. If E->dest has a predecessor
8652 that is not dominated by E->dest, then this set is empty. Otherwise,
8653 all the basic blocks dominated by E->dest are removed.
8655 Also, to DF_IDOM we store the immediate dominators of the blocks in
8656 the dominance frontier of E (i.e., of the successors of the
8657 removed blocks, if there are any, and of E->dest otherwise). */
8658 FOR_EACH_EDGE (f
, ei
, e
->dest
->preds
)
8663 if (!dominated_by_p (CDI_DOMINATORS
, f
->src
, e
->dest
))
8665 none_removed
= true;
8670 auto_bitmap df
, df_idom
;
8672 bitmap_set_bit (df_idom
,
8673 get_immediate_dominator (CDI_DOMINATORS
, e
->dest
)->index
);
8676 bbs_to_remove
= get_all_dominated_blocks (CDI_DOMINATORS
, e
->dest
);
8677 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
8679 FOR_EACH_EDGE (f
, ei
, bb
->succs
)
8681 if (f
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
8682 bitmap_set_bit (df
, f
->dest
->index
);
8685 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
8686 bitmap_clear_bit (df
, bb
->index
);
8688 EXECUTE_IF_SET_IN_BITMAP (df
, 0, i
, bi
)
8690 bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8691 bitmap_set_bit (df_idom
,
8692 get_immediate_dominator (CDI_DOMINATORS
, bb
)->index
);
8696 if (cfgcleanup_altered_bbs
)
8698 /* Record the set of the altered basic blocks. */
8699 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
8700 bitmap_ior_into (cfgcleanup_altered_bbs
, df
);
8703 /* Remove E and the cancelled blocks. */
8708 /* Walk backwards so as to get a chance to substitute all
8709 released DEFs into debug stmts. See
8710 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
8712 for (i
= bbs_to_remove
.length (); i
-- > 0; )
8713 delete_basic_block (bbs_to_remove
[i
]);
8716 /* Update the dominance information. The immediate dominator may change only
8717 for blocks whose immediate dominator belongs to DF_IDOM:
8719 Suppose that idom(X) = Y before removal of E and idom(X) != Y after the
8720 removal. Let Z the arbitrary block such that idom(Z) = Y and
8721 Z dominates X after the removal. Before removal, there exists a path P
8722 from Y to X that avoids Z. Let F be the last edge on P that is
8723 removed, and let W = F->dest. Before removal, idom(W) = Y (since Y
8724 dominates W, and because of P, Z does not dominate W), and W belongs to
8725 the dominance frontier of E. Therefore, Y belongs to DF_IDOM. */
8726 EXECUTE_IF_SET_IN_BITMAP (df_idom
, 0, i
, bi
)
8728 bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8729 for (dbb
= first_dom_son (CDI_DOMINATORS
, bb
);
8731 dbb
= next_dom_son (CDI_DOMINATORS
, dbb
))
8732 bbs_to_fix_dom
.safe_push (dbb
);
8735 iterate_fix_dominators (CDI_DOMINATORS
, bbs_to_fix_dom
, true);
8737 bbs_to_remove
.release ();
8738 bbs_to_fix_dom
.release ();
8741 /* Purge dead EH edges from basic block BB. */
8744 gimple_purge_dead_eh_edges (basic_block bb
)
8746 bool changed
= false;
8749 gimple
*stmt
= last_stmt (bb
);
8751 if (stmt
&& stmt_can_throw_internal (cfun
, stmt
))
8754 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
8756 if (e
->flags
& EDGE_EH
)
8758 remove_edge_and_dominated_blocks (e
);
8768 /* Purge dead EH edges from basic block listed in BLOCKS. */
8771 gimple_purge_all_dead_eh_edges (const_bitmap blocks
)
8773 bool changed
= false;
8777 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
8779 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8781 /* Earlier gimple_purge_dead_eh_edges could have removed
8782 this basic block already. */
8783 gcc_assert (bb
|| changed
);
8785 changed
|= gimple_purge_dead_eh_edges (bb
);
8791 /* Purge dead abnormal call edges from basic block BB. */
8794 gimple_purge_dead_abnormal_call_edges (basic_block bb
)
8796 bool changed
= false;
8799 gimple
*stmt
= last_stmt (bb
);
8801 if (!cfun
->has_nonlocal_label
8802 && !cfun
->calls_setjmp
)
8805 if (stmt
&& stmt_can_make_abnormal_goto (stmt
))
8808 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
8810 if (e
->flags
& EDGE_ABNORMAL
)
8812 if (e
->flags
& EDGE_FALLTHRU
)
8813 e
->flags
&= ~EDGE_ABNORMAL
;
8815 remove_edge_and_dominated_blocks (e
);
8825 /* Purge dead abnormal call edges from basic block listed in BLOCKS. */
8828 gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks
)
8830 bool changed
= false;
8834 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
8836 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8838 /* Earlier gimple_purge_dead_abnormal_call_edges could have removed
8839 this basic block already. */
8840 gcc_assert (bb
|| changed
);
8842 changed
|= gimple_purge_dead_abnormal_call_edges (bb
);
8848 /* This function is called whenever a new edge is created or
8852 gimple_execute_on_growing_pred (edge e
)
8854 basic_block bb
= e
->dest
;
8856 if (!gimple_seq_empty_p (phi_nodes (bb
)))
8857 reserve_phi_args_for_new_edge (bb
);
8860 /* This function is called immediately before edge E is removed from
8861 the edge vector E->dest->preds. */
8864 gimple_execute_on_shrinking_pred (edge e
)
8866 if (!gimple_seq_empty_p (phi_nodes (e
->dest
)))
8867 remove_phi_args (e
);
8870 /*---------------------------------------------------------------------------
8871 Helper functions for Loop versioning
8872 ---------------------------------------------------------------------------*/
8874 /* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy
8875 of 'first'. Both of them are dominated by 'new_head' basic block. When
8876 'new_head' was created by 'second's incoming edge it received phi arguments
8877 on the edge by split_edge(). Later, additional edge 'e' was created to
8878 connect 'new_head' and 'first'. Now this routine adds phi args on this
8879 additional edge 'e' that new_head to second edge received as part of edge
8883 gimple_lv_adjust_loop_header_phi (basic_block first
, basic_block second
,
8884 basic_block new_head
, edge e
)
8887 gphi_iterator psi1
, psi2
;
8889 edge e2
= find_edge (new_head
, second
);
8891 /* Because NEW_HEAD has been created by splitting SECOND's incoming
8892 edge, we should always have an edge from NEW_HEAD to SECOND. */
8893 gcc_assert (e2
!= NULL
);
8895 /* Browse all 'second' basic block phi nodes and add phi args to
8896 edge 'e' for 'first' head. PHI args are always in correct order. */
8898 for (psi2
= gsi_start_phis (second
),
8899 psi1
= gsi_start_phis (first
);
8900 !gsi_end_p (psi2
) && !gsi_end_p (psi1
);
8901 gsi_next (&psi2
), gsi_next (&psi1
))
8905 def
= PHI_ARG_DEF (phi2
, e2
->dest_idx
);
8906 add_phi_arg (phi1
, def
, e
, gimple_phi_arg_location_from_edge (phi2
, e2
));
8911 /* Adds a if else statement to COND_BB with condition COND_EXPR.
8912 SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
8913 the destination of the ELSE part. */
8916 gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED
,
8917 basic_block second_head ATTRIBUTE_UNUSED
,
8918 basic_block cond_bb
, void *cond_e
)
8920 gimple_stmt_iterator gsi
;
8921 gimple
*new_cond_expr
;
8922 tree cond_expr
= (tree
) cond_e
;
8925 /* Build new conditional expr */
8926 new_cond_expr
= gimple_build_cond_from_tree (cond_expr
,
8927 NULL_TREE
, NULL_TREE
);
8929 /* Add new cond in cond_bb. */
8930 gsi
= gsi_last_bb (cond_bb
);
8931 gsi_insert_after (&gsi
, new_cond_expr
, GSI_NEW_STMT
);
8933 /* Adjust edges appropriately to connect new head with first head
8934 as well as second head. */
8935 e0
= single_succ_edge (cond_bb
);
8936 e0
->flags
&= ~EDGE_FALLTHRU
;
8937 e0
->flags
|= EDGE_FALSE_VALUE
;
8941 /* Do book-keeping of basic block BB for the profile consistency checker.
8942 Store the counting in RECORD. */
8944 gimple_account_profile_record (basic_block bb
,
8945 struct profile_record
*record
)
8947 gimple_stmt_iterator i
;
8948 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
8951 += estimate_num_insns (gsi_stmt (i
), &eni_size_weights
);
8952 if (bb
->count
.initialized_p ())
8954 += estimate_num_insns (gsi_stmt (i
),
8955 &eni_time_weights
) * bb
->count
.to_gcov_type ();
8956 else if (profile_status_for_fn (cfun
) == PROFILE_GUESSED
)
8958 += estimate_num_insns (gsi_stmt (i
),
8959 &eni_time_weights
) * bb
->count
.to_frequency (cfun
);
8963 struct cfg_hooks gimple_cfg_hooks
= {
8965 gimple_verify_flow_info
,
8966 gimple_dump_bb
, /* dump_bb */
8967 gimple_dump_bb_for_graph
, /* dump_bb_for_graph */
8968 create_bb
, /* create_basic_block */
8969 gimple_redirect_edge_and_branch
, /* redirect_edge_and_branch */
8970 gimple_redirect_edge_and_branch_force
, /* redirect_edge_and_branch_force */
8971 gimple_can_remove_branch_p
, /* can_remove_branch_p */
8972 remove_bb
, /* delete_basic_block */
8973 gimple_split_block
, /* split_block */
8974 gimple_move_block_after
, /* move_block_after */
8975 gimple_can_merge_blocks_p
, /* can_merge_blocks_p */
8976 gimple_merge_blocks
, /* merge_blocks */
8977 gimple_predict_edge
, /* predict_edge */
8978 gimple_predicted_by_p
, /* predicted_by_p */
8979 gimple_can_duplicate_bb_p
, /* can_duplicate_block_p */
8980 gimple_duplicate_bb
, /* duplicate_block */
8981 gimple_split_edge
, /* split_edge */
8982 gimple_make_forwarder_block
, /* make_forward_block */
8983 NULL
, /* tidy_fallthru_edge */
8984 NULL
, /* force_nonfallthru */
8985 gimple_block_ends_with_call_p
,/* block_ends_with_call_p */
8986 gimple_block_ends_with_condjump_p
, /* block_ends_with_condjump_p */
8987 gimple_flow_call_edges_add
, /* flow_call_edges_add */
8988 gimple_execute_on_growing_pred
, /* execute_on_growing_pred */
8989 gimple_execute_on_shrinking_pred
, /* execute_on_shrinking_pred */
8990 gimple_duplicate_loop_to_header_edge
, /* duplicate loop for trees */
8991 gimple_lv_add_condition_to_bb
, /* lv_add_condition_to_bb */
8992 gimple_lv_adjust_loop_header_phi
, /* lv_adjust_loop_header_phi*/
8993 extract_true_false_edges_from_block
, /* extract_cond_bb_edges */
8994 flush_pending_stmts
, /* flush_pending_stmts */
8995 gimple_empty_block_p
, /* block_empty_p */
8996 gimple_split_block_before_cond_jump
, /* split_block_before_cond_jump */
8997 gimple_account_profile_record
,
9001 /* Split all critical edges. Split some extra (not necessarily critical) edges
9002 if FOR_EDGE_INSERTION_P is true. */
9005 split_critical_edges (bool for_edge_insertion_p
/* = false */)
9011 /* split_edge can redirect edges out of SWITCH_EXPRs, which can get
9012 expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
9013 mappings around the calls to split_edge. */
9014 start_recording_case_labels ();
9015 FOR_ALL_BB_FN (bb
, cfun
)
9017 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
9019 if (EDGE_CRITICAL_P (e
) && !(e
->flags
& EDGE_ABNORMAL
))
9021 /* PRE inserts statements to edges and expects that
9022 since split_critical_edges was done beforehand, committing edge
9023 insertions will not split more edges. In addition to critical
9024 edges we must split edges that have multiple successors and
9025 end by control flow statements, such as RESX.
9026 Go ahead and split them too. This matches the logic in
9027 gimple_find_edge_insert_loc. */
9028 else if (for_edge_insertion_p
9029 && (!single_pred_p (e
->dest
)
9030 || !gimple_seq_empty_p (phi_nodes (e
->dest
))
9031 || e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
9032 && e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)
9033 && !(e
->flags
& EDGE_ABNORMAL
))
9035 gimple_stmt_iterator gsi
;
9037 gsi
= gsi_last_bb (e
->src
);
9038 if (!gsi_end_p (gsi
)
9039 && stmt_ends_bb_p (gsi_stmt (gsi
))
9040 && (gimple_code (gsi_stmt (gsi
)) != GIMPLE_RETURN
9041 && !gimple_call_builtin_p (gsi_stmt (gsi
),
9047 end_recording_case_labels ();
9053 const pass_data pass_data_split_crit_edges
=
9055 GIMPLE_PASS
, /* type */
9056 "crited", /* name */
9057 OPTGROUP_NONE
, /* optinfo_flags */
9058 TV_TREE_SPLIT_EDGES
, /* tv_id */
9059 PROP_cfg
, /* properties_required */
9060 PROP_no_crit_edges
, /* properties_provided */
9061 0, /* properties_destroyed */
9062 0, /* todo_flags_start */
9063 0, /* todo_flags_finish */
9066 class pass_split_crit_edges
: public gimple_opt_pass
9069 pass_split_crit_edges (gcc::context
*ctxt
)
9070 : gimple_opt_pass (pass_data_split_crit_edges
, ctxt
)
9073 /* opt_pass methods: */
9074 virtual unsigned int execute (function
*) { return split_critical_edges (); }
9076 opt_pass
* clone () { return new pass_split_crit_edges (m_ctxt
); }
9077 }; // class pass_split_crit_edges
9082 make_pass_split_crit_edges (gcc::context
*ctxt
)
9084 return new pass_split_crit_edges (ctxt
);
9088 /* Insert COND expression which is GIMPLE_COND after STMT
9089 in basic block BB with appropriate basic block split
9090 and creation of a new conditionally executed basic block.
9091 Update profile so the new bb is visited with probability PROB.
9092 Return created basic block. */
9094 insert_cond_bb (basic_block bb
, gimple
*stmt
, gimple
*cond
,
9095 profile_probability prob
)
9097 edge fall
= split_block (bb
, stmt
);
9098 gimple_stmt_iterator iter
= gsi_last_bb (bb
);
9101 /* Insert cond statement. */
9102 gcc_assert (gimple_code (cond
) == GIMPLE_COND
);
9103 if (gsi_end_p (iter
))
9104 gsi_insert_before (&iter
, cond
, GSI_CONTINUE_LINKING
);
9106 gsi_insert_after (&iter
, cond
, GSI_CONTINUE_LINKING
);
9108 /* Create conditionally executed block. */
9109 new_bb
= create_empty_bb (bb
);
9110 edge e
= make_edge (bb
, new_bb
, EDGE_TRUE_VALUE
);
9111 e
->probability
= prob
;
9112 new_bb
->count
= e
->count ();
9113 make_single_succ_edge (new_bb
, fall
->dest
, EDGE_FALLTHRU
);
9115 /* Fix edge for split bb. */
9116 fall
->flags
= EDGE_FALSE_VALUE
;
9117 fall
->probability
-= e
->probability
;
9119 /* Update dominance info. */
9120 if (dom_info_available_p (CDI_DOMINATORS
))
9122 set_immediate_dominator (CDI_DOMINATORS
, new_bb
, bb
);
9123 set_immediate_dominator (CDI_DOMINATORS
, fall
->dest
, bb
);
9126 /* Update loop info. */
9128 add_bb_to_loop (new_bb
, bb
->loop_father
);
9133 /* Build a ternary operation and gimplify it. Emit code before GSI.
9134 Return the gimple_val holding the result. */
9137 gimplify_build3 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
9138 tree type
, tree a
, tree b
, tree c
)
9141 location_t loc
= gimple_location (gsi_stmt (*gsi
));
9143 ret
= fold_build3_loc (loc
, code
, type
, a
, b
, c
);
9144 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
9148 /* Build a binary operation and gimplify it. Emit code before GSI.
9149 Return the gimple_val holding the result. */
9152 gimplify_build2 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
9153 tree type
, tree a
, tree b
)
9157 ret
= fold_build2_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
, b
);
9158 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
9162 /* Build a unary operation and gimplify it. Emit code before GSI.
9163 Return the gimple_val holding the result. */
9166 gimplify_build1 (gimple_stmt_iterator
*gsi
, enum tree_code code
, tree type
,
9171 ret
= fold_build1_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
);
9172 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
9178 /* Given a basic block B which ends with a conditional and has
9179 precisely two successors, determine which of the edges is taken if
9180 the conditional is true and which is taken if the conditional is
9181 false. Set TRUE_EDGE and FALSE_EDGE appropriately. */
9184 extract_true_false_edges_from_block (basic_block b
,
9188 edge e
= EDGE_SUCC (b
, 0);
9190 if (e
->flags
& EDGE_TRUE_VALUE
)
9193 *false_edge
= EDGE_SUCC (b
, 1);
9198 *true_edge
= EDGE_SUCC (b
, 1);
9203 /* From a controlling predicate in the immediate dominator DOM of
9204 PHIBLOCK determine the edges into PHIBLOCK that are chosen if the
9205 predicate evaluates to true and false and store them to
9206 *TRUE_CONTROLLED_EDGE and *FALSE_CONTROLLED_EDGE if
9207 they are non-NULL. Returns true if the edges can be determined,
9208 else return false. */
9211 extract_true_false_controlled_edges (basic_block dom
, basic_block phiblock
,
9212 edge
*true_controlled_edge
,
9213 edge
*false_controlled_edge
)
9215 basic_block bb
= phiblock
;
9216 edge true_edge
, false_edge
, tem
;
9217 edge e0
= NULL
, e1
= NULL
;
9219 /* We have to verify that one edge into the PHI node is dominated
9220 by the true edge of the predicate block and the other edge
9221 dominated by the false edge. This ensures that the PHI argument
9222 we are going to take is completely determined by the path we
9223 take from the predicate block.
9224 We can only use BB dominance checks below if the destination of
9225 the true/false edges are dominated by their edge, thus only
9226 have a single predecessor. */
9227 extract_true_false_edges_from_block (dom
, &true_edge
, &false_edge
);
9228 tem
= EDGE_PRED (bb
, 0);
9229 if (tem
== true_edge
9230 || (single_pred_p (true_edge
->dest
)
9231 && (tem
->src
== true_edge
->dest
9232 || dominated_by_p (CDI_DOMINATORS
,
9233 tem
->src
, true_edge
->dest
))))
9235 else if (tem
== false_edge
9236 || (single_pred_p (false_edge
->dest
)
9237 && (tem
->src
== false_edge
->dest
9238 || dominated_by_p (CDI_DOMINATORS
,
9239 tem
->src
, false_edge
->dest
))))
9243 tem
= EDGE_PRED (bb
, 1);
9244 if (tem
== true_edge
9245 || (single_pred_p (true_edge
->dest
)
9246 && (tem
->src
== true_edge
->dest
9247 || dominated_by_p (CDI_DOMINATORS
,
9248 tem
->src
, true_edge
->dest
))))
9250 else if (tem
== false_edge
9251 || (single_pred_p (false_edge
->dest
)
9252 && (tem
->src
== false_edge
->dest
9253 || dominated_by_p (CDI_DOMINATORS
,
9254 tem
->src
, false_edge
->dest
))))
9261 if (true_controlled_edge
)
9262 *true_controlled_edge
= e0
;
9263 if (false_controlled_edge
)
9264 *false_controlled_edge
= e1
;
9269 /* Generate a range test LHS CODE RHS that determines whether INDEX is in the
9270 range [low, high]. Place associated stmts before *GSI. */
9273 generate_range_test (basic_block bb
, tree index
, tree low
, tree high
,
9274 tree
*lhs
, tree
*rhs
)
9276 tree type
= TREE_TYPE (index
);
9277 tree utype
= range_check_type (type
);
9279 low
= fold_convert (utype
, low
);
9280 high
= fold_convert (utype
, high
);
9282 gimple_seq seq
= NULL
;
9283 index
= gimple_convert (&seq
, utype
, index
);
9284 *lhs
= gimple_build (&seq
, MINUS_EXPR
, utype
, index
, low
);
9285 *rhs
= const_binop (MINUS_EXPR
, utype
, high
, low
);
9287 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
9288 gsi_insert_seq_before (&gsi
, seq
, GSI_SAME_STMT
);
9291 /* Return the basic block that belongs to label numbered INDEX
9292 of a switch statement. */
9295 gimple_switch_label_bb (function
*ifun
, gswitch
*gs
, unsigned index
)
9297 return label_to_block (ifun
, CASE_LABEL (gimple_switch_label (gs
, index
)));
9300 /* Return the default basic block of a switch statement. */
9303 gimple_switch_default_bb (function
*ifun
, gswitch
*gs
)
9305 return gimple_switch_label_bb (ifun
, gs
, 0);
9308 /* Return the edge that belongs to label numbered INDEX
9309 of a switch statement. */
9312 gimple_switch_edge (function
*ifun
, gswitch
*gs
, unsigned index
)
9314 return find_edge (gimple_bb (gs
), gimple_switch_label_bb (ifun
, gs
, index
));
9317 /* Return the default edge of a switch statement. */
9320 gimple_switch_default_edge (function
*ifun
, gswitch
*gs
)
9322 return gimple_switch_edge (ifun
, gs
, 0);
9326 /* Emit return warnings. */
9330 const pass_data pass_data_warn_function_return
=
9332 GIMPLE_PASS
, /* type */
9333 "*warn_function_return", /* name */
9334 OPTGROUP_NONE
, /* optinfo_flags */
9335 TV_NONE
, /* tv_id */
9336 PROP_cfg
, /* properties_required */
9337 0, /* properties_provided */
9338 0, /* properties_destroyed */
9339 0, /* todo_flags_start */
9340 0, /* todo_flags_finish */
9343 class pass_warn_function_return
: public gimple_opt_pass
9346 pass_warn_function_return (gcc::context
*ctxt
)
9347 : gimple_opt_pass (pass_data_warn_function_return
, ctxt
)
9350 /* opt_pass methods: */
9351 virtual unsigned int execute (function
*);
9353 }; // class pass_warn_function_return
9356 pass_warn_function_return::execute (function
*fun
)
9358 location_t location
;
9363 if (!targetm
.warn_func_return (fun
->decl
))
9366 /* If we have a path to EXIT, then we do return. */
9367 if (TREE_THIS_VOLATILE (fun
->decl
)
9368 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) > 0)
9370 location
= UNKNOWN_LOCATION
;
9371 for (ei
= ei_start (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
);
9372 (e
= ei_safe_edge (ei
)); )
9374 last
= last_stmt (e
->src
);
9375 if ((gimple_code (last
) == GIMPLE_RETURN
9376 || gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
9377 && location
== UNKNOWN_LOCATION
9378 && ((location
= LOCATION_LOCUS (gimple_location (last
)))
9379 != UNKNOWN_LOCATION
)
9382 /* When optimizing, replace return stmts in noreturn functions
9383 with __builtin_unreachable () call. */
9384 if (optimize
&& gimple_code (last
) == GIMPLE_RETURN
)
9386 tree fndecl
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
9387 gimple
*new_stmt
= gimple_build_call (fndecl
, 0);
9388 gimple_set_location (new_stmt
, gimple_location (last
));
9389 gimple_stmt_iterator gsi
= gsi_for_stmt (last
);
9390 gsi_replace (&gsi
, new_stmt
, true);
9396 if (location
== UNKNOWN_LOCATION
)
9397 location
= cfun
->function_end_locus
;
9398 warning_at (location
, 0, "%<noreturn%> function does return");
9401 /* If we see "return;" in some basic block, then we do reach the end
9402 without returning a value. */
9403 else if (warn_return_type
> 0
9404 && !TREE_NO_WARNING (fun
->decl
)
9405 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fun
->decl
))))
9407 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
)
9409 gimple
*last
= last_stmt (e
->src
);
9410 greturn
*return_stmt
= dyn_cast
<greturn
*> (last
);
9412 && gimple_return_retval (return_stmt
) == NULL
9413 && !gimple_no_warning_p (last
))
9415 location
= gimple_location (last
);
9416 if (LOCATION_LOCUS (location
) == UNKNOWN_LOCATION
)
9417 location
= fun
->function_end_locus
;
9418 if (warning_at (location
, OPT_Wreturn_type
,
9419 "control reaches end of non-void function"))
9420 TREE_NO_WARNING (fun
->decl
) = 1;
9424 /* The C++ FE turns fallthrough from the end of non-void function
9425 into __builtin_unreachable () call with BUILTINS_LOCATION.
9426 Recognize those too. */
9428 if (!TREE_NO_WARNING (fun
->decl
))
9429 FOR_EACH_BB_FN (bb
, fun
)
9430 if (EDGE_COUNT (bb
->succs
) == 0)
9432 gimple
*last
= last_stmt (bb
);
9433 const enum built_in_function ubsan_missing_ret
9434 = BUILT_IN_UBSAN_HANDLE_MISSING_RETURN
;
9436 && ((LOCATION_LOCUS (gimple_location (last
))
9437 == BUILTINS_LOCATION
9438 && gimple_call_builtin_p (last
, BUILT_IN_UNREACHABLE
))
9439 || gimple_call_builtin_p (last
, ubsan_missing_ret
)))
9441 gimple_stmt_iterator gsi
= gsi_for_stmt (last
);
9442 gsi_prev_nondebug (&gsi
);
9443 gimple
*prev
= gsi_stmt (gsi
);
9445 location
= UNKNOWN_LOCATION
;
9447 location
= gimple_location (prev
);
9448 if (LOCATION_LOCUS (location
) == UNKNOWN_LOCATION
)
9449 location
= fun
->function_end_locus
;
9450 if (warning_at (location
, OPT_Wreturn_type
,
9451 "control reaches end of non-void function"))
9452 TREE_NO_WARNING (fun
->decl
) = 1;
9463 make_pass_warn_function_return (gcc::context
*ctxt
)
9465 return new pass_warn_function_return (ctxt
);
9468 /* Walk a gimplified function and warn for functions whose return value is
9469 ignored and attribute((warn_unused_result)) is set. This is done before
9470 inlining, so we don't have to worry about that. */
9473 do_warn_unused_result (gimple_seq seq
)
9476 gimple_stmt_iterator i
;
9478 for (i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
9480 gimple
*g
= gsi_stmt (i
);
9482 switch (gimple_code (g
))
9485 do_warn_unused_result (gimple_bind_body (as_a
<gbind
*>(g
)));
9488 do_warn_unused_result (gimple_try_eval (g
));
9489 do_warn_unused_result (gimple_try_cleanup (g
));
9492 do_warn_unused_result (gimple_catch_handler (
9493 as_a
<gcatch
*> (g
)));
9495 case GIMPLE_EH_FILTER
:
9496 do_warn_unused_result (gimple_eh_filter_failure (g
));
9500 if (gimple_call_lhs (g
))
9502 if (gimple_call_internal_p (g
))
9505 /* This is a naked call, as opposed to a GIMPLE_CALL with an
9506 LHS. All calls whose value is ignored should be
9507 represented like this. Look for the attribute. */
9508 fdecl
= gimple_call_fndecl (g
);
9509 ftype
= gimple_call_fntype (g
);
9511 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
9513 location_t loc
= gimple_location (g
);
9516 warning_at (loc
, OPT_Wunused_result
,
9517 "ignoring return value of %qD "
9518 "declared with attribute %<warn_unused_result%>",
9521 warning_at (loc
, OPT_Wunused_result
,
9522 "ignoring return value of function "
9523 "declared with attribute %<warn_unused_result%>");
9528 /* Not a container, not a call, or a call whose value is used. */
9536 const pass_data pass_data_warn_unused_result
=
9538 GIMPLE_PASS
, /* type */
9539 "*warn_unused_result", /* name */
9540 OPTGROUP_NONE
, /* optinfo_flags */
9541 TV_NONE
, /* tv_id */
9542 PROP_gimple_any
, /* properties_required */
9543 0, /* properties_provided */
9544 0, /* properties_destroyed */
9545 0, /* todo_flags_start */
9546 0, /* todo_flags_finish */
9549 class pass_warn_unused_result
: public gimple_opt_pass
9552 pass_warn_unused_result (gcc::context
*ctxt
)
9553 : gimple_opt_pass (pass_data_warn_unused_result
, ctxt
)
9556 /* opt_pass methods: */
9557 virtual bool gate (function
*) { return flag_warn_unused_result
; }
9558 virtual unsigned int execute (function
*)
9560 do_warn_unused_result (gimple_body (current_function_decl
));
9564 }; // class pass_warn_unused_result
9569 make_pass_warn_unused_result (gcc::context
*ctxt
)
9571 return new pass_warn_unused_result (ctxt
);
9574 /* IPA passes, compilation of earlier functions or inlining
9575 might have changed some properties, such as marked functions nothrow,
9576 pure, const or noreturn.
9577 Remove redundant edges and basic blocks, and create new ones if necessary.
9579 This pass can't be executed as stand alone pass from pass manager, because
9580 in between inlining and this fixup the verify_flow_info would fail. */
9583 execute_fixup_cfg (void)
9586 gimple_stmt_iterator gsi
;
9588 cgraph_node
*node
= cgraph_node::get (current_function_decl
);
9589 /* Same scaling is also done by ipa_merge_profiles. */
9590 profile_count num
= node
->count
;
9591 profile_count den
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
9592 bool scale
= num
.initialized_p () && !(num
== den
);
9596 profile_count::adjust_for_ipa_scaling (&num
, &den
);
9597 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= node
->count
;
9598 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
9599 = EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
.apply_scale (num
, den
);
9602 FOR_EACH_BB_FN (bb
, cfun
)
9605 bb
->count
= bb
->count
.apply_scale (num
, den
);
9606 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
9608 gimple
*stmt
= gsi_stmt (gsi
);
9609 tree decl
= is_gimple_call (stmt
)
9610 ? gimple_call_fndecl (stmt
)
9614 int flags
= gimple_call_flags (stmt
);
9615 if (flags
& (ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
))
9617 if (gimple_purge_dead_abnormal_call_edges (bb
))
9618 todo
|= TODO_cleanup_cfg
;
9620 if (gimple_in_ssa_p (cfun
))
9622 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
9627 if (flags
& ECF_NORETURN
9628 && fixup_noreturn_call (stmt
))
9629 todo
|= TODO_cleanup_cfg
;
9632 /* Remove stores to variables we marked write-only.
9633 Keep access when store has side effect, i.e. in case when source
9635 if (gimple_store_p (stmt
)
9636 && !gimple_has_side_effects (stmt
)
9639 tree lhs
= get_base_address (gimple_get_lhs (stmt
));
9642 && (TREE_STATIC (lhs
) || DECL_EXTERNAL (lhs
))
9643 && varpool_node::get (lhs
)->writeonly
)
9645 unlink_stmt_vdef (stmt
);
9646 gsi_remove (&gsi
, true);
9647 release_defs (stmt
);
9648 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
9652 /* For calls we can simply remove LHS when it is known
9653 to be write-only. */
9654 if (is_gimple_call (stmt
)
9655 && gimple_get_lhs (stmt
))
9657 tree lhs
= get_base_address (gimple_get_lhs (stmt
));
9660 && (TREE_STATIC (lhs
) || DECL_EXTERNAL (lhs
))
9661 && varpool_node::get (lhs
)->writeonly
)
9663 gimple_call_set_lhs (stmt
, NULL
);
9665 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
9669 if (maybe_clean_eh_stmt (stmt
)
9670 && gimple_purge_dead_eh_edges (bb
))
9671 todo
|= TODO_cleanup_cfg
;
9675 /* If we have a basic block with no successors that does not
9676 end with a control statement or a noreturn call end it with
9677 a call to __builtin_unreachable. This situation can occur
9678 when inlining a noreturn call that does in fact return. */
9679 if (EDGE_COUNT (bb
->succs
) == 0)
9681 gimple
*stmt
= last_stmt (bb
);
9683 || (!is_ctrl_stmt (stmt
)
9684 && (!is_gimple_call (stmt
)
9685 || !gimple_call_noreturn_p (stmt
))))
9687 if (stmt
&& is_gimple_call (stmt
))
9688 gimple_call_set_ctrl_altering (stmt
, false);
9689 tree fndecl
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
9690 stmt
= gimple_build_call (fndecl
, 0);
9691 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
9692 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
9693 if (!cfun
->after_inlining
)
9695 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
9696 node
->create_edge (cgraph_node::get_create (fndecl
),
9697 call_stmt
, bb
->count
);
9704 update_max_bb_count ();
9705 compute_function_frequency ();
9709 && (todo
& TODO_cleanup_cfg
))
9710 loops_state_set (LOOPS_NEED_FIXUP
);
9717 const pass_data pass_data_fixup_cfg
=
9719 GIMPLE_PASS
, /* type */
9720 "fixup_cfg", /* name */
9721 OPTGROUP_NONE
, /* optinfo_flags */
9722 TV_NONE
, /* tv_id */
9723 PROP_cfg
, /* properties_required */
9724 0, /* properties_provided */
9725 0, /* properties_destroyed */
9726 0, /* todo_flags_start */
9727 0, /* todo_flags_finish */
9730 class pass_fixup_cfg
: public gimple_opt_pass
9733 pass_fixup_cfg (gcc::context
*ctxt
)
9734 : gimple_opt_pass (pass_data_fixup_cfg
, ctxt
)
9737 /* opt_pass methods: */
9738 opt_pass
* clone () { return new pass_fixup_cfg (m_ctxt
); }
9739 virtual unsigned int execute (function
*) { return execute_fixup_cfg (); }
9741 }; // class pass_fixup_cfg
9746 make_pass_fixup_cfg (gcc::context
*ctxt
)
9748 return new pass_fixup_cfg (ctxt
);
9751 /* Garbage collection support for edge_def. */
9753 extern void gt_ggc_mx (tree
&);
9754 extern void gt_ggc_mx (gimple
*&);
9755 extern void gt_ggc_mx (rtx
&);
9756 extern void gt_ggc_mx (basic_block
&);
9759 gt_ggc_mx (rtx_insn
*& x
)
9762 gt_ggc_mx_rtx_def ((void *) x
);
9766 gt_ggc_mx (edge_def
*e
)
9768 tree block
= LOCATION_BLOCK (e
->goto_locus
);
9770 gt_ggc_mx (e
->dest
);
9771 if (current_ir_type () == IR_GIMPLE
)
9772 gt_ggc_mx (e
->insns
.g
);
9774 gt_ggc_mx (e
->insns
.r
);
9778 /* PCH support for edge_def. */
9780 extern void gt_pch_nx (tree
&);
9781 extern void gt_pch_nx (gimple
*&);
9782 extern void gt_pch_nx (rtx
&);
9783 extern void gt_pch_nx (basic_block
&);
9786 gt_pch_nx (rtx_insn
*& x
)
9789 gt_pch_nx_rtx_def ((void *) x
);
9793 gt_pch_nx (edge_def
*e
)
9795 tree block
= LOCATION_BLOCK (e
->goto_locus
);
9797 gt_pch_nx (e
->dest
);
9798 if (current_ir_type () == IR_GIMPLE
)
9799 gt_pch_nx (e
->insns
.g
);
9801 gt_pch_nx (e
->insns
.r
);
9806 gt_pch_nx (edge_def
*e
, gt_pointer_operator op
, void *cookie
)
9808 tree block
= LOCATION_BLOCK (e
->goto_locus
);
9809 op (&(e
->src
), cookie
);
9810 op (&(e
->dest
), cookie
);
9811 if (current_ir_type () == IR_GIMPLE
)
9812 op (&(e
->insns
.g
), cookie
);
9814 op (&(e
->insns
.r
), cookie
);
9815 op (&(block
), cookie
);
9820 namespace selftest
{
9822 /* Helper function for CFG selftests: create a dummy function decl
9823 and push it as cfun. */
9826 push_fndecl (const char *name
)
9828 tree fn_type
= build_function_type_array (integer_type_node
, 0, NULL
);
9829 /* FIXME: this uses input_location: */
9830 tree fndecl
= build_fn_decl (name
, fn_type
);
9831 tree retval
= build_decl (UNKNOWN_LOCATION
, RESULT_DECL
,
9832 NULL_TREE
, integer_type_node
);
9833 DECL_RESULT (fndecl
) = retval
;
9834 push_struct_function (fndecl
);
9835 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
9836 ASSERT_TRUE (fun
!= NULL
);
9837 init_empty_tree_cfg_for_function (fun
);
9838 ASSERT_EQ (2, n_basic_blocks_for_fn (fun
));
9839 ASSERT_EQ (0, n_edges_for_fn (fun
));
9843 /* These tests directly create CFGs.
9844 Compare with the static fns within tree-cfg.c:
9846 - make_blocks: calls create_basic_block (seq, bb);
9849 /* Verify a simple cfg of the form:
9850 ENTRY -> A -> B -> C -> EXIT. */
9853 test_linear_chain ()
9855 gimple_register_cfg_hooks ();
9857 tree fndecl
= push_fndecl ("cfg_test_linear_chain");
9858 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
9860 /* Create some empty blocks. */
9861 basic_block bb_a
= create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
9862 basic_block bb_b
= create_empty_bb (bb_a
);
9863 basic_block bb_c
= create_empty_bb (bb_b
);
9865 ASSERT_EQ (5, n_basic_blocks_for_fn (fun
));
9866 ASSERT_EQ (0, n_edges_for_fn (fun
));
9868 /* Create some edges: a simple linear chain of BBs. */
9869 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
), bb_a
, EDGE_FALLTHRU
);
9870 make_edge (bb_a
, bb_b
, 0);
9871 make_edge (bb_b
, bb_c
, 0);
9872 make_edge (bb_c
, EXIT_BLOCK_PTR_FOR_FN (fun
), 0);
9874 /* Verify the edges. */
9875 ASSERT_EQ (4, n_edges_for_fn (fun
));
9876 ASSERT_EQ (NULL
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->preds
);
9877 ASSERT_EQ (1, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
->length ());
9878 ASSERT_EQ (1, bb_a
->preds
->length ());
9879 ASSERT_EQ (1, bb_a
->succs
->length ());
9880 ASSERT_EQ (1, bb_b
->preds
->length ());
9881 ASSERT_EQ (1, bb_b
->succs
->length ());
9882 ASSERT_EQ (1, bb_c
->preds
->length ());
9883 ASSERT_EQ (1, bb_c
->succs
->length ());
9884 ASSERT_EQ (1, EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
->length ());
9885 ASSERT_EQ (NULL
, EXIT_BLOCK_PTR_FOR_FN (fun
)->succs
);
9887 /* Verify the dominance information
9888 Each BB in our simple chain should be dominated by the one before
9890 calculate_dominance_info (CDI_DOMINATORS
);
9891 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_b
));
9892 ASSERT_EQ (bb_b
, get_immediate_dominator (CDI_DOMINATORS
, bb_c
));
9893 vec
<basic_block
> dom_by_b
= get_dominated_by (CDI_DOMINATORS
, bb_b
);
9894 ASSERT_EQ (1, dom_by_b
.length ());
9895 ASSERT_EQ (bb_c
, dom_by_b
[0]);
9896 free_dominance_info (CDI_DOMINATORS
);
9897 dom_by_b
.release ();
9899 /* Similarly for post-dominance: each BB in our chain is post-dominated
9900 by the one after it. */
9901 calculate_dominance_info (CDI_POST_DOMINATORS
);
9902 ASSERT_EQ (bb_b
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_a
));
9903 ASSERT_EQ (bb_c
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_b
));
9904 vec
<basic_block
> postdom_by_b
= get_dominated_by (CDI_POST_DOMINATORS
, bb_b
);
9905 ASSERT_EQ (1, postdom_by_b
.length ());
9906 ASSERT_EQ (bb_a
, postdom_by_b
[0]);
9907 free_dominance_info (CDI_POST_DOMINATORS
);
9908 postdom_by_b
.release ();
9913 /* Verify a simple CFG of the form:
9929 gimple_register_cfg_hooks ();
9931 tree fndecl
= push_fndecl ("cfg_test_diamond");
9932 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
9934 /* Create some empty blocks. */
9935 basic_block bb_a
= create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
9936 basic_block bb_b
= create_empty_bb (bb_a
);
9937 basic_block bb_c
= create_empty_bb (bb_a
);
9938 basic_block bb_d
= create_empty_bb (bb_b
);
9940 ASSERT_EQ (6, n_basic_blocks_for_fn (fun
));
9941 ASSERT_EQ (0, n_edges_for_fn (fun
));
9943 /* Create the edges. */
9944 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
), bb_a
, EDGE_FALLTHRU
);
9945 make_edge (bb_a
, bb_b
, EDGE_TRUE_VALUE
);
9946 make_edge (bb_a
, bb_c
, EDGE_FALSE_VALUE
);
9947 make_edge (bb_b
, bb_d
, 0);
9948 make_edge (bb_c
, bb_d
, 0);
9949 make_edge (bb_d
, EXIT_BLOCK_PTR_FOR_FN (fun
), 0);
9951 /* Verify the edges. */
9952 ASSERT_EQ (6, n_edges_for_fn (fun
));
9953 ASSERT_EQ (1, bb_a
->preds
->length ());
9954 ASSERT_EQ (2, bb_a
->succs
->length ());
9955 ASSERT_EQ (1, bb_b
->preds
->length ());
9956 ASSERT_EQ (1, bb_b
->succs
->length ());
9957 ASSERT_EQ (1, bb_c
->preds
->length ());
9958 ASSERT_EQ (1, bb_c
->succs
->length ());
9959 ASSERT_EQ (2, bb_d
->preds
->length ());
9960 ASSERT_EQ (1, bb_d
->succs
->length ());
9962 /* Verify the dominance information. */
9963 calculate_dominance_info (CDI_DOMINATORS
);
9964 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_b
));
9965 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_c
));
9966 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_d
));
9967 vec
<basic_block
> dom_by_a
= get_dominated_by (CDI_DOMINATORS
, bb_a
);
9968 ASSERT_EQ (3, dom_by_a
.length ()); /* B, C, D, in some order. */
9969 dom_by_a
.release ();
9970 vec
<basic_block
> dom_by_b
= get_dominated_by (CDI_DOMINATORS
, bb_b
);
9971 ASSERT_EQ (0, dom_by_b
.length ());
9972 dom_by_b
.release ();
9973 free_dominance_info (CDI_DOMINATORS
);
9975 /* Similarly for post-dominance. */
9976 calculate_dominance_info (CDI_POST_DOMINATORS
);
9977 ASSERT_EQ (bb_d
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_a
));
9978 ASSERT_EQ (bb_d
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_b
));
9979 ASSERT_EQ (bb_d
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_c
));
9980 vec
<basic_block
> postdom_by_d
= get_dominated_by (CDI_POST_DOMINATORS
, bb_d
);
9981 ASSERT_EQ (3, postdom_by_d
.length ()); /* A, B, C in some order. */
9982 postdom_by_d
.release ();
9983 vec
<basic_block
> postdom_by_b
= get_dominated_by (CDI_POST_DOMINATORS
, bb_b
);
9984 ASSERT_EQ (0, postdom_by_b
.length ());
9985 postdom_by_b
.release ();
9986 free_dominance_info (CDI_POST_DOMINATORS
);
9991 /* Verify that we can handle a CFG containing a "complete" aka
9992 fully-connected subgraph (where A B C D below all have edges
9993 pointing to each other node, also to themselves).
10011 test_fully_connected ()
10013 gimple_register_cfg_hooks ();
10015 tree fndecl
= push_fndecl ("cfg_fully_connected");
10016 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
10020 /* Create some empty blocks. */
10021 auto_vec
<basic_block
> subgraph_nodes
;
10022 for (int i
= 0; i
< n
; i
++)
10023 subgraph_nodes
.safe_push (create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
)));
10025 ASSERT_EQ (n
+ 2, n_basic_blocks_for_fn (fun
));
10026 ASSERT_EQ (0, n_edges_for_fn (fun
));
10028 /* Create the edges. */
10029 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
), subgraph_nodes
[0], EDGE_FALLTHRU
);
10030 make_edge (subgraph_nodes
[0], EXIT_BLOCK_PTR_FOR_FN (fun
), 0);
10031 for (int i
= 0; i
< n
; i
++)
10032 for (int j
= 0; j
< n
; j
++)
10033 make_edge (subgraph_nodes
[i
], subgraph_nodes
[j
], 0);
10035 /* Verify the edges. */
10036 ASSERT_EQ (2 + (n
* n
), n_edges_for_fn (fun
));
10037 /* The first one is linked to ENTRY/EXIT as well as itself and
10038 everything else. */
10039 ASSERT_EQ (n
+ 1, subgraph_nodes
[0]->preds
->length ());
10040 ASSERT_EQ (n
+ 1, subgraph_nodes
[0]->succs
->length ());
10041 /* The other ones in the subgraph are linked to everything in
10042 the subgraph (including themselves). */
10043 for (int i
= 1; i
< n
; i
++)
10045 ASSERT_EQ (n
, subgraph_nodes
[i
]->preds
->length ());
10046 ASSERT_EQ (n
, subgraph_nodes
[i
]->succs
->length ());
10049 /* Verify the dominance information. */
10050 calculate_dominance_info (CDI_DOMINATORS
);
10051 /* The initial block in the subgraph should be dominated by ENTRY. */
10052 ASSERT_EQ (ENTRY_BLOCK_PTR_FOR_FN (fun
),
10053 get_immediate_dominator (CDI_DOMINATORS
,
10054 subgraph_nodes
[0]));
10055 /* Every other block in the subgraph should be dominated by the
10057 for (int i
= 1; i
< n
; i
++)
10058 ASSERT_EQ (subgraph_nodes
[0],
10059 get_immediate_dominator (CDI_DOMINATORS
,
10060 subgraph_nodes
[i
]));
10061 free_dominance_info (CDI_DOMINATORS
);
10063 /* Similarly for post-dominance. */
10064 calculate_dominance_info (CDI_POST_DOMINATORS
);
10065 /* The initial block in the subgraph should be postdominated by EXIT. */
10066 ASSERT_EQ (EXIT_BLOCK_PTR_FOR_FN (fun
),
10067 get_immediate_dominator (CDI_POST_DOMINATORS
,
10068 subgraph_nodes
[0]));
10069 /* Every other block in the subgraph should be postdominated by the
10070 initial block, since that leads to EXIT. */
10071 for (int i
= 1; i
< n
; i
++)
10072 ASSERT_EQ (subgraph_nodes
[0],
10073 get_immediate_dominator (CDI_POST_DOMINATORS
,
10074 subgraph_nodes
[i
]));
10075 free_dominance_info (CDI_POST_DOMINATORS
);
10080 /* Run all of the selftests within this file. */
10083 tree_cfg_c_tests ()
10085 test_linear_chain ();
10087 test_fully_connected ();
10090 } // namespace selftest
10092 /* TODO: test the dominator/postdominator logic with various graphs/nodes:
10095 - switch statement (a block with many out-edges)
10096 - something that jumps to itself
10099 #endif /* CHECKING_P */