1 /* Control flow functions for trees.
2 Copyright (C) 2001-2017 Free Software Foundation, Inc.
3 Contributed by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
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"
65 /* This file contains functions for building the Control Flow Graph (CFG)
66 for a function tree. */
68 /* Local declarations. */
70 /* Initial capacity for the basic block array. */
71 static const int initial_cfg_capacity
= 20;
73 /* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
74 which use a particular edge. The CASE_LABEL_EXPRs are chained together
75 via their CASE_CHAIN field, which we clear after we're done with the
76 hash table to prevent problems with duplication of GIMPLE_SWITCHes.
78 Access to this list of CASE_LABEL_EXPRs allows us to efficiently
79 update the case vector in response to edge redirections.
81 Right now this table is set up and torn down at key points in the
82 compilation process. It would be nice if we could make the table
83 more persistent. The key is getting notification of changes to
84 the CFG (particularly edge removal, creation and redirection). */
86 static hash_map
<edge
, tree
> *edge_to_cases
;
88 /* If we record edge_to_cases, this bitmap will hold indexes
89 of basic blocks that end in a GIMPLE_SWITCH which we touched
90 due to edge manipulations. */
92 static bitmap touched_switch_bbs
;
97 long num_merged_labels
;
100 static struct cfg_stats_d cfg_stats
;
102 /* Data to pass to replace_block_vars_by_duplicates_1. */
103 struct replace_decls_d
105 hash_map
<tree
, tree
> *vars_map
;
109 /* Hash table to store last discriminator assigned for each locus. */
110 struct locus_discrim_map
116 /* Hashtable helpers. */
118 struct locus_discrim_hasher
: free_ptr_hash
<locus_discrim_map
>
120 static inline hashval_t
hash (const locus_discrim_map
*);
121 static inline bool equal (const locus_discrim_map
*,
122 const locus_discrim_map
*);
125 /* Trivial hash function for a location_t. ITEM is a pointer to
126 a hash table entry that maps a location_t to a discriminator. */
129 locus_discrim_hasher::hash (const locus_discrim_map
*item
)
131 return LOCATION_LINE (item
->locus
);
134 /* Equality function for the locus-to-discriminator map. A and B
135 point to the two hash table entries to compare. */
138 locus_discrim_hasher::equal (const locus_discrim_map
*a
,
139 const locus_discrim_map
*b
)
141 return LOCATION_LINE (a
->locus
) == LOCATION_LINE (b
->locus
);
144 static hash_table
<locus_discrim_hasher
> *discriminator_per_locus
;
146 /* Basic blocks and flowgraphs. */
147 static void make_blocks (gimple_seq
);
150 static void make_edges (void);
151 static void assign_discriminators (void);
152 static void make_cond_expr_edges (basic_block
);
153 static void make_gimple_switch_edges (gswitch
*, basic_block
);
154 static bool make_goto_expr_edges (basic_block
);
155 static void make_gimple_asm_edges (basic_block
);
156 static edge
gimple_redirect_edge_and_branch (edge
, basic_block
);
157 static edge
gimple_try_redirect_by_replacing_jump (edge
, basic_block
);
159 /* Various helpers. */
160 static inline bool stmt_starts_bb_p (gimple
*, gimple
*);
161 static int gimple_verify_flow_info (void);
162 static void gimple_make_forwarder_block (edge
);
163 static gimple
*first_non_label_stmt (basic_block
);
164 static bool verify_gimple_transaction (gtransaction
*);
165 static bool call_can_make_abnormal_goto (gimple
*);
167 /* Flowgraph optimization and cleanup. */
168 static void gimple_merge_blocks (basic_block
, basic_block
);
169 static bool gimple_can_merge_blocks_p (basic_block
, basic_block
);
170 static void remove_bb (basic_block
);
171 static edge
find_taken_edge_computed_goto (basic_block
, tree
);
172 static edge
find_taken_edge_cond_expr (basic_block
, tree
);
173 static edge
find_taken_edge_switch_expr (gswitch
*, basic_block
, tree
);
174 static tree
find_case_label_for_value (gswitch
*, tree
);
175 static void lower_phi_internal_fn ();
178 init_empty_tree_cfg_for_function (struct function
*fn
)
180 /* Initialize the basic block array. */
182 profile_status_for_fn (fn
) = PROFILE_ABSENT
;
183 n_basic_blocks_for_fn (fn
) = NUM_FIXED_BLOCKS
;
184 last_basic_block_for_fn (fn
) = NUM_FIXED_BLOCKS
;
185 vec_alloc (basic_block_info_for_fn (fn
), initial_cfg_capacity
);
186 vec_safe_grow_cleared (basic_block_info_for_fn (fn
),
187 initial_cfg_capacity
);
189 /* Build a mapping of labels to their associated blocks. */
190 vec_alloc (label_to_block_map_for_fn (fn
), initial_cfg_capacity
);
191 vec_safe_grow_cleared (label_to_block_map_for_fn (fn
),
192 initial_cfg_capacity
);
194 SET_BASIC_BLOCK_FOR_FN (fn
, ENTRY_BLOCK
, ENTRY_BLOCK_PTR_FOR_FN (fn
));
195 SET_BASIC_BLOCK_FOR_FN (fn
, EXIT_BLOCK
, EXIT_BLOCK_PTR_FOR_FN (fn
));
197 ENTRY_BLOCK_PTR_FOR_FN (fn
)->next_bb
198 = EXIT_BLOCK_PTR_FOR_FN (fn
);
199 EXIT_BLOCK_PTR_FOR_FN (fn
)->prev_bb
200 = ENTRY_BLOCK_PTR_FOR_FN (fn
);
204 init_empty_tree_cfg (void)
206 init_empty_tree_cfg_for_function (cfun
);
209 /*---------------------------------------------------------------------------
211 ---------------------------------------------------------------------------*/
213 /* Entry point to the CFG builder for trees. SEQ is the sequence of
214 statements to be added to the flowgraph. */
217 build_gimple_cfg (gimple_seq seq
)
219 /* Register specific gimple functions. */
220 gimple_register_cfg_hooks ();
222 memset ((void *) &cfg_stats
, 0, sizeof (cfg_stats
));
224 init_empty_tree_cfg ();
228 /* Make sure there is always at least one block, even if it's empty. */
229 if (n_basic_blocks_for_fn (cfun
) == NUM_FIXED_BLOCKS
)
230 create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
232 /* Adjust the size of the array. */
233 if (basic_block_info_for_fn (cfun
)->length ()
234 < (size_t) n_basic_blocks_for_fn (cfun
))
235 vec_safe_grow_cleared (basic_block_info_for_fn (cfun
),
236 n_basic_blocks_for_fn (cfun
));
238 /* To speed up statement iterator walks, we first purge dead labels. */
239 cleanup_dead_labels ();
241 /* Group case nodes to reduce the number of edges.
242 We do this after cleaning up dead labels because otherwise we miss
243 a lot of obvious case merging opportunities. */
244 group_case_labels ();
246 /* Create the edges of the flowgraph. */
247 discriminator_per_locus
= new hash_table
<locus_discrim_hasher
> (13);
249 assign_discriminators ();
250 lower_phi_internal_fn ();
251 cleanup_dead_labels ();
252 delete discriminator_per_locus
;
253 discriminator_per_locus
= NULL
;
256 /* Look for ANNOTATE calls with loop annotation kind in BB; if found, remove
257 them and propagate the information to LOOP. We assume that the annotations
258 come immediately before the condition in BB, if any. */
261 replace_loop_annotate_in_block (basic_block bb
, struct loop
*loop
)
263 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
264 gimple
*stmt
= gsi_stmt (gsi
);
266 if (!(stmt
&& gimple_code (stmt
) == GIMPLE_COND
))
269 for (gsi_prev_nondebug (&gsi
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
271 stmt
= gsi_stmt (gsi
);
272 if (gimple_code (stmt
) != GIMPLE_CALL
)
274 if (!gimple_call_internal_p (stmt
)
275 || gimple_call_internal_fn (stmt
) != IFN_ANNOTATE
)
278 switch ((annot_expr_kind
) tree_to_shwi (gimple_call_arg (stmt
, 1)))
280 case annot_expr_ivdep_kind
:
281 loop
->safelen
= INT_MAX
;
283 case annot_expr_no_vector_kind
:
284 loop
->dont_vectorize
= true;
286 case annot_expr_vector_kind
:
287 loop
->force_vectorize
= true;
288 cfun
->has_force_vectorize_loops
= true;
294 stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
295 gimple_call_arg (stmt
, 0));
296 gsi_replace (&gsi
, stmt
, true);
300 /* Look for ANNOTATE calls with loop annotation kind; if found, remove
301 them and propagate the information to the loop. We assume that the
302 annotations come immediately before the condition of the loop. */
305 replace_loop_annotate (void)
309 gimple_stmt_iterator gsi
;
312 FOR_EACH_LOOP (loop
, 0)
314 /* First look into the header. */
315 replace_loop_annotate_in_block (loop
->header
, loop
);
317 /* Then look into the latch, if any. */
319 replace_loop_annotate_in_block (loop
->latch
, loop
);
322 /* Remove IFN_ANNOTATE. Safeguard for the case loop->latch == NULL. */
323 FOR_EACH_BB_FN (bb
, cfun
)
325 for (gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
327 stmt
= gsi_stmt (gsi
);
328 if (gimple_code (stmt
) != GIMPLE_CALL
)
330 if (!gimple_call_internal_p (stmt
)
331 || gimple_call_internal_fn (stmt
) != IFN_ANNOTATE
)
334 switch ((annot_expr_kind
) tree_to_shwi (gimple_call_arg (stmt
, 1)))
336 case annot_expr_ivdep_kind
:
337 case annot_expr_no_vector_kind
:
338 case annot_expr_vector_kind
:
344 warning_at (gimple_location (stmt
), 0, "ignoring loop annotation");
345 stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
346 gimple_call_arg (stmt
, 0));
347 gsi_replace (&gsi
, stmt
, true);
352 /* Lower internal PHI function from GIMPLE FE. */
355 lower_phi_internal_fn ()
357 basic_block bb
, pred
= NULL
;
358 gimple_stmt_iterator gsi
;
363 /* After edge creation, handle __PHI function from GIMPLE FE. */
364 FOR_EACH_BB_FN (bb
, cfun
)
366 for (gsi
= gsi_after_labels (bb
); !gsi_end_p (gsi
);)
368 stmt
= gsi_stmt (gsi
);
369 if (! gimple_call_internal_p (stmt
, IFN_PHI
))
372 lhs
= gimple_call_lhs (stmt
);
373 phi_node
= create_phi_node (lhs
, bb
);
375 /* Add arguments to the PHI node. */
376 for (unsigned i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
378 tree arg
= gimple_call_arg (stmt
, i
);
379 if (TREE_CODE (arg
) == LABEL_DECL
)
380 pred
= label_to_block (arg
);
383 edge e
= find_edge (pred
, bb
);
384 add_phi_arg (phi_node
, arg
, e
, UNKNOWN_LOCATION
);
388 gsi_remove (&gsi
, true);
394 execute_build_cfg (void)
396 gimple_seq body
= gimple_body (current_function_decl
);
398 build_gimple_cfg (body
);
399 gimple_set_body (current_function_decl
, NULL
);
400 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
402 fprintf (dump_file
, "Scope blocks:\n");
403 dump_scope_blocks (dump_file
, dump_flags
);
406 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
407 replace_loop_annotate ();
413 const pass_data pass_data_build_cfg
=
415 GIMPLE_PASS
, /* type */
417 OPTGROUP_NONE
, /* optinfo_flags */
418 TV_TREE_CFG
, /* tv_id */
419 PROP_gimple_leh
, /* properties_required */
420 ( PROP_cfg
| PROP_loops
), /* properties_provided */
421 0, /* properties_destroyed */
422 0, /* todo_flags_start */
423 0, /* todo_flags_finish */
426 class pass_build_cfg
: public gimple_opt_pass
429 pass_build_cfg (gcc::context
*ctxt
)
430 : gimple_opt_pass (pass_data_build_cfg
, ctxt
)
433 /* opt_pass methods: */
434 virtual unsigned int execute (function
*) { return execute_build_cfg (); }
436 }; // class pass_build_cfg
441 make_pass_build_cfg (gcc::context
*ctxt
)
443 return new pass_build_cfg (ctxt
);
447 /* Return true if T is a computed goto. */
450 computed_goto_p (gimple
*t
)
452 return (gimple_code (t
) == GIMPLE_GOTO
453 && TREE_CODE (gimple_goto_dest (t
)) != LABEL_DECL
);
456 /* Returns true if the sequence of statements STMTS only contains
457 a call to __builtin_unreachable (). */
460 gimple_seq_unreachable_p (gimple_seq stmts
)
465 gimple_stmt_iterator gsi
= gsi_last (stmts
);
467 if (!gimple_call_builtin_p (gsi_stmt (gsi
), BUILT_IN_UNREACHABLE
))
470 for (gsi_prev (&gsi
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
472 gimple
*stmt
= gsi_stmt (gsi
);
473 if (gimple_code (stmt
) != GIMPLE_LABEL
474 && !is_gimple_debug (stmt
)
475 && !gimple_clobber_p (stmt
))
481 /* Returns true for edge E where e->src ends with a GIMPLE_COND and
482 the other edge points to a bb with just __builtin_unreachable ().
483 I.e. return true for C->M edge in:
491 __builtin_unreachable ();
495 assert_unreachable_fallthru_edge_p (edge e
)
497 basic_block pred_bb
= e
->src
;
498 gimple
*last
= last_stmt (pred_bb
);
499 if (last
&& gimple_code (last
) == GIMPLE_COND
)
501 basic_block other_bb
= EDGE_SUCC (pred_bb
, 0)->dest
;
502 if (other_bb
== e
->dest
)
503 other_bb
= EDGE_SUCC (pred_bb
, 1)->dest
;
504 if (EDGE_COUNT (other_bb
->succs
) == 0)
505 return gimple_seq_unreachable_p (bb_seq (other_bb
));
511 /* Initialize GF_CALL_CTRL_ALTERING flag, which indicates the call
512 could alter control flow except via eh. We initialize the flag at
513 CFG build time and only ever clear it later. */
516 gimple_call_initialize_ctrl_altering (gimple
*stmt
)
518 int flags
= gimple_call_flags (stmt
);
520 /* A call alters control flow if it can make an abnormal goto. */
521 if (call_can_make_abnormal_goto (stmt
)
522 /* A call also alters control flow if it does not return. */
523 || flags
& ECF_NORETURN
524 /* TM ending statements have backedges out of the transaction.
525 Return true so we split the basic block containing them.
526 Note that the TM_BUILTIN test is merely an optimization. */
527 || ((flags
& ECF_TM_BUILTIN
)
528 && is_tm_ending_fndecl (gimple_call_fndecl (stmt
)))
529 /* BUILT_IN_RETURN call is same as return statement. */
530 || gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
)
531 /* IFN_UNIQUE should be the last insn, to make checking for it
532 as cheap as possible. */
533 || (gimple_call_internal_p (stmt
)
534 && gimple_call_internal_unique_p (stmt
)))
535 gimple_call_set_ctrl_altering (stmt
, true);
537 gimple_call_set_ctrl_altering (stmt
, false);
541 /* Insert SEQ after BB and build a flowgraph. */
544 make_blocks_1 (gimple_seq seq
, basic_block bb
)
546 gimple_stmt_iterator i
= gsi_start (seq
);
548 bool start_new_block
= true;
549 bool first_stmt_of_seq
= true;
551 while (!gsi_end_p (i
))
558 if (stmt
&& is_gimple_call (stmt
))
559 gimple_call_initialize_ctrl_altering (stmt
);
561 /* If the statement starts a new basic block or if we have determined
562 in a previous pass that we need to create a new block for STMT, do
564 if (start_new_block
|| stmt_starts_bb_p (stmt
, prev_stmt
))
566 if (!first_stmt_of_seq
)
567 gsi_split_seq_before (&i
, &seq
);
568 bb
= create_basic_block (seq
, bb
);
569 start_new_block
= false;
572 /* Now add STMT to BB and create the subgraphs for special statement
574 gimple_set_bb (stmt
, bb
);
576 /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
578 if (stmt_ends_bb_p (stmt
))
580 /* If the stmt can make abnormal goto use a new temporary
581 for the assignment to the LHS. This makes sure the old value
582 of the LHS is available on the abnormal edge. Otherwise
583 we will end up with overlapping life-ranges for abnormal
585 if (gimple_has_lhs (stmt
)
586 && stmt_can_make_abnormal_goto (stmt
)
587 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt
))))
589 tree lhs
= gimple_get_lhs (stmt
);
590 tree tmp
= create_tmp_var (TREE_TYPE (lhs
));
591 gimple
*s
= gimple_build_assign (lhs
, tmp
);
592 gimple_set_location (s
, gimple_location (stmt
));
593 gimple_set_block (s
, gimple_block (stmt
));
594 gimple_set_lhs (stmt
, tmp
);
595 if (TREE_CODE (TREE_TYPE (tmp
)) == COMPLEX_TYPE
596 || TREE_CODE (TREE_TYPE (tmp
)) == VECTOR_TYPE
)
597 DECL_GIMPLE_REG_P (tmp
) = 1;
598 gsi_insert_after (&i
, s
, GSI_SAME_STMT
);
600 start_new_block
= true;
604 first_stmt_of_seq
= false;
609 /* Build a flowgraph for the sequence of stmts SEQ. */
612 make_blocks (gimple_seq seq
)
614 make_blocks_1 (seq
, ENTRY_BLOCK_PTR_FOR_FN (cfun
));
617 /* Create and return a new empty basic block after bb AFTER. */
620 create_bb (void *h
, void *e
, basic_block after
)
626 /* Create and initialize a new basic block. Since alloc_block uses
627 GC allocation that clears memory to allocate a basic block, we do
628 not have to clear the newly allocated basic block here. */
631 bb
->index
= last_basic_block_for_fn (cfun
);
633 set_bb_seq (bb
, h
? (gimple_seq
) h
: NULL
);
635 /* Add the new block to the linked list of blocks. */
636 link_block (bb
, after
);
638 /* Grow the basic block array if needed. */
639 if ((size_t) last_basic_block_for_fn (cfun
)
640 == basic_block_info_for_fn (cfun
)->length ())
643 (last_basic_block_for_fn (cfun
)
644 + (last_basic_block_for_fn (cfun
) + 3) / 4);
645 vec_safe_grow_cleared (basic_block_info_for_fn (cfun
), new_size
);
648 /* Add the newly created block to the array. */
649 SET_BASIC_BLOCK_FOR_FN (cfun
, last_basic_block_for_fn (cfun
), bb
);
651 n_basic_blocks_for_fn (cfun
)++;
652 last_basic_block_for_fn (cfun
)++;
658 /*---------------------------------------------------------------------------
660 ---------------------------------------------------------------------------*/
662 /* If basic block BB has an abnormal edge to a basic block
663 containing IFN_ABNORMAL_DISPATCHER internal call, return
664 that the dispatcher's basic block, otherwise return NULL. */
667 get_abnormal_succ_dispatcher (basic_block bb
)
672 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
673 if ((e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)) == EDGE_ABNORMAL
)
675 gimple_stmt_iterator gsi
676 = gsi_start_nondebug_after_labels_bb (e
->dest
);
677 gimple
*g
= gsi_stmt (gsi
);
678 if (g
&& gimple_call_internal_p (g
, IFN_ABNORMAL_DISPATCHER
))
684 /* Helper function for make_edges. Create a basic block with
685 with ABNORMAL_DISPATCHER internal call in it if needed, and
686 create abnormal edges from BBS to it and from it to FOR_BB
687 if COMPUTED_GOTO is false, otherwise factor the computed gotos. */
690 handle_abnormal_edges (basic_block
*dispatcher_bbs
,
691 basic_block for_bb
, int *bb_to_omp_idx
,
692 auto_vec
<basic_block
> *bbs
, bool computed_goto
)
694 basic_block
*dispatcher
= dispatcher_bbs
+ (computed_goto
? 1 : 0);
695 unsigned int idx
= 0;
701 dispatcher
= dispatcher_bbs
+ 2 * bb_to_omp_idx
[for_bb
->index
];
702 if (bb_to_omp_idx
[for_bb
->index
] != 0)
706 /* If the dispatcher has been created already, then there are basic
707 blocks with abnormal edges to it, so just make a new edge to
709 if (*dispatcher
== NULL
)
711 /* Check if there are any basic blocks that need to have
712 abnormal edges to this dispatcher. If there are none, return
714 if (bb_to_omp_idx
== NULL
)
716 if (bbs
->is_empty ())
721 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
722 if (bb_to_omp_idx
[bb
->index
] == bb_to_omp_idx
[for_bb
->index
])
728 /* Create the dispatcher bb. */
729 *dispatcher
= create_basic_block (NULL
, for_bb
);
732 /* Factor computed gotos into a common computed goto site. Also
733 record the location of that site so that we can un-factor the
734 gotos after we have converted back to normal form. */
735 gimple_stmt_iterator gsi
= gsi_start_bb (*dispatcher
);
737 /* Create the destination of the factored goto. Each original
738 computed goto will put its desired destination into this
739 variable and jump to the label we create immediately below. */
740 tree var
= create_tmp_var (ptr_type_node
, "gotovar");
742 /* Build a label for the new block which will contain the
743 factored computed goto. */
744 tree factored_label_decl
745 = create_artificial_label (UNKNOWN_LOCATION
);
746 gimple
*factored_computed_goto_label
747 = gimple_build_label (factored_label_decl
);
748 gsi_insert_after (&gsi
, factored_computed_goto_label
, GSI_NEW_STMT
);
750 /* Build our new computed goto. */
751 gimple
*factored_computed_goto
= gimple_build_goto (var
);
752 gsi_insert_after (&gsi
, factored_computed_goto
, GSI_NEW_STMT
);
754 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
757 && bb_to_omp_idx
[bb
->index
] != bb_to_omp_idx
[for_bb
->index
])
760 gsi
= gsi_last_bb (bb
);
761 gimple
*last
= gsi_stmt (gsi
);
763 gcc_assert (computed_goto_p (last
));
765 /* Copy the original computed goto's destination into VAR. */
767 = gimple_build_assign (var
, gimple_goto_dest (last
));
768 gsi_insert_before (&gsi
, assignment
, GSI_SAME_STMT
);
770 edge e
= make_edge (bb
, *dispatcher
, EDGE_FALLTHRU
);
771 e
->goto_locus
= gimple_location (last
);
772 gsi_remove (&gsi
, true);
777 tree arg
= inner
? boolean_true_node
: boolean_false_node
;
778 gimple
*g
= gimple_build_call_internal (IFN_ABNORMAL_DISPATCHER
,
780 gimple_stmt_iterator gsi
= gsi_after_labels (*dispatcher
);
781 gsi_insert_after (&gsi
, g
, GSI_NEW_STMT
);
783 /* Create predecessor edges of the dispatcher. */
784 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
787 && bb_to_omp_idx
[bb
->index
] != bb_to_omp_idx
[for_bb
->index
])
789 make_edge (bb
, *dispatcher
, EDGE_ABNORMAL
);
794 make_edge (*dispatcher
, for_bb
, EDGE_ABNORMAL
);
797 /* Creates outgoing edges for BB. Returns 1 when it ends with an
798 computed goto, returns 2 when it ends with a statement that
799 might return to this function via an nonlocal goto, otherwise
800 return 0. Updates *PCUR_REGION with the OMP region this BB is in. */
803 make_edges_bb (basic_block bb
, struct omp_region
**pcur_region
, int *pomp_index
)
805 gimple
*last
= last_stmt (bb
);
806 bool fallthru
= false;
812 switch (gimple_code (last
))
815 if (make_goto_expr_edges (bb
))
821 edge e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
822 e
->goto_locus
= gimple_location (last
);
827 make_cond_expr_edges (bb
);
831 make_gimple_switch_edges (as_a
<gswitch
*> (last
), bb
);
835 make_eh_edges (last
);
838 case GIMPLE_EH_DISPATCH
:
839 fallthru
= make_eh_dispatch_edges (as_a
<geh_dispatch
*> (last
));
843 /* If this function receives a nonlocal goto, then we need to
844 make edges from this call site to all the nonlocal goto
846 if (stmt_can_make_abnormal_goto (last
))
849 /* If this statement has reachable exception handlers, then
850 create abnormal edges to them. */
851 make_eh_edges (last
);
853 /* BUILTIN_RETURN is really a return statement. */
854 if (gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
856 make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
859 /* Some calls are known not to return. */
861 fallthru
= !gimple_call_noreturn_p (last
);
865 /* A GIMPLE_ASSIGN may throw internally and thus be considered
867 if (is_ctrl_altering_stmt (last
))
868 make_eh_edges (last
);
873 make_gimple_asm_edges (bb
);
878 fallthru
= omp_make_gimple_edges (bb
, pcur_region
, pomp_index
);
881 case GIMPLE_TRANSACTION
:
883 gtransaction
*txn
= as_a
<gtransaction
*> (last
);
884 tree label1
= gimple_transaction_label_norm (txn
);
885 tree label2
= gimple_transaction_label_uninst (txn
);
888 make_edge (bb
, label_to_block (label1
), EDGE_FALLTHRU
);
890 make_edge (bb
, label_to_block (label2
),
891 EDGE_TM_UNINSTRUMENTED
| (label1
? 0 : EDGE_FALLTHRU
));
893 tree label3
= gimple_transaction_label_over (txn
);
894 if (gimple_transaction_subcode (txn
)
895 & (GTMA_HAVE_ABORT
| GTMA_IS_OUTER
))
896 make_edge (bb
, label_to_block (label3
), EDGE_TM_ABORT
);
903 gcc_assert (!stmt_ends_bb_p (last
));
909 make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
914 /* Join all the blocks in the flowgraph. */
920 struct omp_region
*cur_region
= NULL
;
921 auto_vec
<basic_block
> ab_edge_goto
;
922 auto_vec
<basic_block
> ab_edge_call
;
923 int *bb_to_omp_idx
= NULL
;
924 int cur_omp_region_idx
= 0;
926 /* Create an edge from entry to the first block with executable
928 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
929 BASIC_BLOCK_FOR_FN (cfun
, NUM_FIXED_BLOCKS
),
932 /* Traverse the basic block array placing edges. */
933 FOR_EACH_BB_FN (bb
, cfun
)
938 bb_to_omp_idx
[bb
->index
] = cur_omp_region_idx
;
940 mer
= make_edges_bb (bb
, &cur_region
, &cur_omp_region_idx
);
942 ab_edge_goto
.safe_push (bb
);
944 ab_edge_call
.safe_push (bb
);
946 if (cur_region
&& bb_to_omp_idx
== NULL
)
947 bb_to_omp_idx
= XCNEWVEC (int, n_basic_blocks_for_fn (cfun
));
950 /* Computed gotos are hell to deal with, especially if there are
951 lots of them with a large number of destinations. So we factor
952 them to a common computed goto location before we build the
953 edge list. After we convert back to normal form, we will un-factor
954 the computed gotos since factoring introduces an unwanted jump.
955 For non-local gotos and abnormal edges from calls to calls that return
956 twice or forced labels, factor the abnormal edges too, by having all
957 abnormal edges from the calls go to a common artificial basic block
958 with ABNORMAL_DISPATCHER internal call and abnormal edges from that
959 basic block to all forced labels and calls returning twice.
960 We do this per-OpenMP structured block, because those regions
961 are guaranteed to be single entry single exit by the standard,
962 so it is not allowed to enter or exit such regions abnormally this way,
963 thus all computed gotos, non-local gotos and setjmp/longjmp calls
964 must not transfer control across SESE region boundaries. */
965 if (!ab_edge_goto
.is_empty () || !ab_edge_call
.is_empty ())
967 gimple_stmt_iterator gsi
;
968 basic_block dispatcher_bb_array
[2] = { NULL
, NULL
};
969 basic_block
*dispatcher_bbs
= dispatcher_bb_array
;
970 int count
= n_basic_blocks_for_fn (cfun
);
973 dispatcher_bbs
= XCNEWVEC (basic_block
, 2 * count
);
975 FOR_EACH_BB_FN (bb
, cfun
)
977 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
979 glabel
*label_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
985 target
= gimple_label_label (label_stmt
);
987 /* Make an edge to every label block that has been marked as a
988 potential target for a computed goto or a non-local goto. */
989 if (FORCED_LABEL (target
))
990 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
991 &ab_edge_goto
, true);
992 if (DECL_NONLOCAL (target
))
994 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
995 &ab_edge_call
, false);
1000 if (!gsi_end_p (gsi
) && is_gimple_debug (gsi_stmt (gsi
)))
1001 gsi_next_nondebug (&gsi
);
1002 if (!gsi_end_p (gsi
))
1004 /* Make an edge to every setjmp-like call. */
1005 gimple
*call_stmt
= gsi_stmt (gsi
);
1006 if (is_gimple_call (call_stmt
)
1007 && ((gimple_call_flags (call_stmt
) & ECF_RETURNS_TWICE
)
1008 || gimple_call_builtin_p (call_stmt
,
1009 BUILT_IN_SETJMP_RECEIVER
)))
1010 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
1011 &ab_edge_call
, false);
1016 XDELETE (dispatcher_bbs
);
1019 XDELETE (bb_to_omp_idx
);
1021 omp_free_regions ();
1024 /* Add SEQ after GSI. Start new bb after GSI, and created further bbs as
1025 needed. Returns true if new bbs were created.
1026 Note: This is transitional code, and should not be used for new code. We
1027 should be able to get rid of this by rewriting all target va-arg
1028 gimplification hooks to use an interface gimple_build_cond_value as described
1029 in https://gcc.gnu.org/ml/gcc-patches/2015-02/msg01194.html. */
1032 gimple_find_sub_bbs (gimple_seq seq
, gimple_stmt_iterator
*gsi
)
1034 gimple
*stmt
= gsi_stmt (*gsi
);
1035 basic_block bb
= gimple_bb (stmt
);
1036 basic_block lastbb
, afterbb
;
1037 int old_num_bbs
= n_basic_blocks_for_fn (cfun
);
1039 lastbb
= make_blocks_1 (seq
, bb
);
1040 if (old_num_bbs
== n_basic_blocks_for_fn (cfun
))
1042 e
= split_block (bb
, stmt
);
1043 /* Move e->dest to come after the new basic blocks. */
1045 unlink_block (afterbb
);
1046 link_block (afterbb
, lastbb
);
1047 redirect_edge_succ (e
, bb
->next_bb
);
1049 while (bb
!= afterbb
)
1051 struct omp_region
*cur_region
= NULL
;
1052 profile_count cnt
= profile_count::zero ();
1056 int cur_omp_region_idx
= 0;
1057 int mer
= make_edges_bb (bb
, &cur_region
, &cur_omp_region_idx
);
1058 gcc_assert (!mer
&& !cur_region
);
1059 add_bb_to_loop (bb
, afterbb
->loop_father
);
1063 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1065 if (e
->count
.initialized_p ())
1069 freq
+= EDGE_FREQUENCY (e
);
1071 tree_guess_outgoing_edge_probabilities (bb
);
1072 if (all
|| profile_status_for_fn (cfun
) == PROFILE_READ
)
1074 bb
->frequency
= freq
;
1075 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1076 e
->count
= bb
->count
.apply_probability (e
->probability
);
1083 /* Find the next available discriminator value for LOCUS. The
1084 discriminator distinguishes among several basic blocks that
1085 share a common locus, allowing for more accurate sample-based
1089 next_discriminator_for_locus (location_t locus
)
1091 struct locus_discrim_map item
;
1092 struct locus_discrim_map
**slot
;
1095 item
.discriminator
= 0;
1096 slot
= discriminator_per_locus
->find_slot_with_hash (
1097 &item
, LOCATION_LINE (locus
), INSERT
);
1099 if (*slot
== HTAB_EMPTY_ENTRY
)
1101 *slot
= XNEW (struct locus_discrim_map
);
1103 (*slot
)->locus
= locus
;
1104 (*slot
)->discriminator
= 0;
1106 (*slot
)->discriminator
++;
1107 return (*slot
)->discriminator
;
1110 /* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line. */
1113 same_line_p (location_t locus1
, location_t locus2
)
1115 expanded_location from
, to
;
1117 if (locus1
== locus2
)
1120 from
= expand_location (locus1
);
1121 to
= expand_location (locus2
);
1123 if (from
.line
!= to
.line
)
1125 if (from
.file
== to
.file
)
1127 return (from
.file
!= NULL
1129 && filename_cmp (from
.file
, to
.file
) == 0);
1132 /* Assign discriminators to each basic block. */
1135 assign_discriminators (void)
1139 FOR_EACH_BB_FN (bb
, cfun
)
1143 gimple
*last
= last_stmt (bb
);
1144 location_t locus
= last
? gimple_location (last
) : UNKNOWN_LOCATION
;
1146 if (locus
== UNKNOWN_LOCATION
)
1149 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1151 gimple
*first
= first_non_label_stmt (e
->dest
);
1152 gimple
*last
= last_stmt (e
->dest
);
1153 if ((first
&& same_line_p (locus
, gimple_location (first
)))
1154 || (last
&& same_line_p (locus
, gimple_location (last
))))
1156 if (e
->dest
->discriminator
!= 0 && bb
->discriminator
== 0)
1157 bb
->discriminator
= next_discriminator_for_locus (locus
);
1159 e
->dest
->discriminator
= next_discriminator_for_locus (locus
);
1165 /* Create the edges for a GIMPLE_COND starting at block BB. */
1168 make_cond_expr_edges (basic_block bb
)
1170 gcond
*entry
= as_a
<gcond
*> (last_stmt (bb
));
1171 gimple
*then_stmt
, *else_stmt
;
1172 basic_block then_bb
, else_bb
;
1173 tree then_label
, else_label
;
1177 gcc_assert (gimple_code (entry
) == GIMPLE_COND
);
1179 /* Entry basic blocks for each component. */
1180 then_label
= gimple_cond_true_label (entry
);
1181 else_label
= gimple_cond_false_label (entry
);
1182 then_bb
= label_to_block (then_label
);
1183 else_bb
= label_to_block (else_label
);
1184 then_stmt
= first_stmt (then_bb
);
1185 else_stmt
= first_stmt (else_bb
);
1187 e
= make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1188 e
->goto_locus
= gimple_location (then_stmt
);
1189 e
= make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1191 e
->goto_locus
= gimple_location (else_stmt
);
1193 /* We do not need the labels anymore. */
1194 gimple_cond_set_true_label (entry
, NULL_TREE
);
1195 gimple_cond_set_false_label (entry
, NULL_TREE
);
1199 /* Called for each element in the hash table (P) as we delete the
1200 edge to cases hash table.
1202 Clear all the CASE_CHAINs to prevent problems with copying of
1203 SWITCH_EXPRs and structure sharing rules, then free the hash table
1207 edge_to_cases_cleanup (edge
const &, tree
const &value
, void *)
1211 for (t
= value
; t
; t
= next
)
1213 next
= CASE_CHAIN (t
);
1214 CASE_CHAIN (t
) = NULL
;
1220 /* Start recording information mapping edges to case labels. */
1223 start_recording_case_labels (void)
1225 gcc_assert (edge_to_cases
== NULL
);
1226 edge_to_cases
= new hash_map
<edge
, tree
>;
1227 touched_switch_bbs
= BITMAP_ALLOC (NULL
);
1230 /* Return nonzero if we are recording information for case labels. */
1233 recording_case_labels_p (void)
1235 return (edge_to_cases
!= NULL
);
1238 /* Stop recording information mapping edges to case labels and
1239 remove any information we have recorded. */
1241 end_recording_case_labels (void)
1245 edge_to_cases
->traverse
<void *, edge_to_cases_cleanup
> (NULL
);
1246 delete edge_to_cases
;
1247 edge_to_cases
= NULL
;
1248 EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs
, 0, i
, bi
)
1250 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
1253 gimple
*stmt
= last_stmt (bb
);
1254 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1255 group_case_labels_stmt (as_a
<gswitch
*> (stmt
));
1258 BITMAP_FREE (touched_switch_bbs
);
1261 /* If we are inside a {start,end}_recording_cases block, then return
1262 a chain of CASE_LABEL_EXPRs from T which reference E.
1264 Otherwise return NULL. */
1267 get_cases_for_edge (edge e
, gswitch
*t
)
1272 /* If we are not recording cases, then we do not have CASE_LABEL_EXPR
1273 chains available. Return NULL so the caller can detect this case. */
1274 if (!recording_case_labels_p ())
1277 slot
= edge_to_cases
->get (e
);
1281 /* If we did not find E in the hash table, then this must be the first
1282 time we have been queried for information about E & T. Add all the
1283 elements from T to the hash table then perform the query again. */
1285 n
= gimple_switch_num_labels (t
);
1286 for (i
= 0; i
< n
; i
++)
1288 tree elt
= gimple_switch_label (t
, i
);
1289 tree lab
= CASE_LABEL (elt
);
1290 basic_block label_bb
= label_to_block (lab
);
1291 edge this_edge
= find_edge (e
->src
, label_bb
);
1293 /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
1295 tree
&s
= edge_to_cases
->get_or_insert (this_edge
);
1296 CASE_CHAIN (elt
) = s
;
1300 return *edge_to_cases
->get (e
);
1303 /* Create the edges for a GIMPLE_SWITCH starting at block BB. */
1306 make_gimple_switch_edges (gswitch
*entry
, basic_block bb
)
1310 n
= gimple_switch_num_labels (entry
);
1312 for (i
= 0; i
< n
; ++i
)
1314 tree lab
= CASE_LABEL (gimple_switch_label (entry
, i
));
1315 basic_block label_bb
= label_to_block (lab
);
1316 make_edge (bb
, label_bb
, 0);
1321 /* Return the basic block holding label DEST. */
1324 label_to_block_fn (struct function
*ifun
, tree dest
)
1326 int uid
= LABEL_DECL_UID (dest
);
1328 /* We would die hard when faced by an undefined label. Emit a label to
1329 the very first basic block. This will hopefully make even the dataflow
1330 and undefined variable warnings quite right. */
1331 if (seen_error () && uid
< 0)
1333 gimple_stmt_iterator gsi
=
1334 gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, NUM_FIXED_BLOCKS
));
1337 stmt
= gimple_build_label (dest
);
1338 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
1339 uid
= LABEL_DECL_UID (dest
);
1341 if (vec_safe_length (ifun
->cfg
->x_label_to_block_map
) <= (unsigned int) uid
)
1343 return (*ifun
->cfg
->x_label_to_block_map
)[uid
];
1346 /* Create edges for a goto statement at block BB. Returns true
1347 if abnormal edges should be created. */
1350 make_goto_expr_edges (basic_block bb
)
1352 gimple_stmt_iterator last
= gsi_last_bb (bb
);
1353 gimple
*goto_t
= gsi_stmt (last
);
1355 /* A simple GOTO creates normal edges. */
1356 if (simple_goto_p (goto_t
))
1358 tree dest
= gimple_goto_dest (goto_t
);
1359 basic_block label_bb
= label_to_block (dest
);
1360 edge e
= make_edge (bb
, label_bb
, EDGE_FALLTHRU
);
1361 e
->goto_locus
= gimple_location (goto_t
);
1362 gsi_remove (&last
, true);
1366 /* A computed GOTO creates abnormal edges. */
1370 /* Create edges for an asm statement with labels at block BB. */
1373 make_gimple_asm_edges (basic_block bb
)
1375 gasm
*stmt
= as_a
<gasm
*> (last_stmt (bb
));
1376 int i
, n
= gimple_asm_nlabels (stmt
);
1378 for (i
= 0; i
< n
; ++i
)
1380 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
1381 basic_block label_bb
= label_to_block (label
);
1382 make_edge (bb
, label_bb
, 0);
1386 /*---------------------------------------------------------------------------
1388 ---------------------------------------------------------------------------*/
1390 /* Cleanup useless labels in basic blocks. This is something we wish
1391 to do early because it allows us to group case labels before creating
1392 the edges for the CFG, and it speeds up block statement iterators in
1393 all passes later on.
1394 We rerun this pass after CFG is created, to get rid of the labels that
1395 are no longer referenced. After then we do not run it any more, since
1396 (almost) no new labels should be created. */
1398 /* A map from basic block index to the leading label of that block. */
1399 static struct label_record
1404 /* True if the label is referenced from somewhere. */
1408 /* Given LABEL return the first label in the same basic block. */
1411 main_block_label (tree label
)
1413 basic_block bb
= label_to_block (label
);
1414 tree main_label
= label_for_bb
[bb
->index
].label
;
1416 /* label_to_block possibly inserted undefined label into the chain. */
1419 label_for_bb
[bb
->index
].label
= label
;
1423 label_for_bb
[bb
->index
].used
= true;
1427 /* Clean up redundant labels within the exception tree. */
1430 cleanup_dead_labels_eh (void)
1437 if (cfun
->eh
== NULL
)
1440 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1441 if (lp
&& lp
->post_landing_pad
)
1443 lab
= main_block_label (lp
->post_landing_pad
);
1444 if (lab
!= lp
->post_landing_pad
)
1446 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1447 EH_LANDING_PAD_NR (lab
) = lp
->index
;
1451 FOR_ALL_EH_REGION (r
)
1455 case ERT_MUST_NOT_THROW
:
1461 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
1465 c
->label
= main_block_label (lab
);
1470 case ERT_ALLOWED_EXCEPTIONS
:
1471 lab
= r
->u
.allowed
.label
;
1473 r
->u
.allowed
.label
= main_block_label (lab
);
1479 /* Cleanup redundant labels. This is a three-step process:
1480 1) Find the leading label for each block.
1481 2) Redirect all references to labels to the leading labels.
1482 3) Cleanup all useless labels. */
1485 cleanup_dead_labels (void)
1488 label_for_bb
= XCNEWVEC (struct label_record
, last_basic_block_for_fn (cfun
));
1490 /* Find a suitable label for each block. We use the first user-defined
1491 label if there is one, or otherwise just the first label we see. */
1492 FOR_EACH_BB_FN (bb
, cfun
)
1494 gimple_stmt_iterator i
;
1496 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
1499 glabel
*label_stmt
= dyn_cast
<glabel
*> (gsi_stmt (i
));
1504 label
= gimple_label_label (label_stmt
);
1506 /* If we have not yet seen a label for the current block,
1507 remember this one and see if there are more labels. */
1508 if (!label_for_bb
[bb
->index
].label
)
1510 label_for_bb
[bb
->index
].label
= label
;
1514 /* If we did see a label for the current block already, but it
1515 is an artificially created label, replace it if the current
1516 label is a user defined label. */
1517 if (!DECL_ARTIFICIAL (label
)
1518 && DECL_ARTIFICIAL (label_for_bb
[bb
->index
].label
))
1520 label_for_bb
[bb
->index
].label
= label
;
1526 /* Now redirect all jumps/branches to the selected label.
1527 First do so for each block ending in a control statement. */
1528 FOR_EACH_BB_FN (bb
, cfun
)
1530 gimple
*stmt
= last_stmt (bb
);
1531 tree label
, new_label
;
1536 switch (gimple_code (stmt
))
1540 gcond
*cond_stmt
= as_a
<gcond
*> (stmt
);
1541 label
= gimple_cond_true_label (cond_stmt
);
1544 new_label
= main_block_label (label
);
1545 if (new_label
!= label
)
1546 gimple_cond_set_true_label (cond_stmt
, new_label
);
1549 label
= gimple_cond_false_label (cond_stmt
);
1552 new_label
= main_block_label (label
);
1553 if (new_label
!= label
)
1554 gimple_cond_set_false_label (cond_stmt
, new_label
);
1561 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
1562 size_t i
, n
= gimple_switch_num_labels (switch_stmt
);
1564 /* Replace all destination labels. */
1565 for (i
= 0; i
< n
; ++i
)
1567 tree case_label
= gimple_switch_label (switch_stmt
, i
);
1568 label
= CASE_LABEL (case_label
);
1569 new_label
= main_block_label (label
);
1570 if (new_label
!= label
)
1571 CASE_LABEL (case_label
) = new_label
;
1578 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
1579 int i
, n
= gimple_asm_nlabels (asm_stmt
);
1581 for (i
= 0; i
< n
; ++i
)
1583 tree cons
= gimple_asm_label_op (asm_stmt
, i
);
1584 tree label
= main_block_label (TREE_VALUE (cons
));
1585 TREE_VALUE (cons
) = label
;
1590 /* We have to handle gotos until they're removed, and we don't
1591 remove them until after we've created the CFG edges. */
1593 if (!computed_goto_p (stmt
))
1595 ggoto
*goto_stmt
= as_a
<ggoto
*> (stmt
);
1596 label
= gimple_goto_dest (goto_stmt
);
1597 new_label
= main_block_label (label
);
1598 if (new_label
!= label
)
1599 gimple_goto_set_dest (goto_stmt
, new_label
);
1603 case GIMPLE_TRANSACTION
:
1605 gtransaction
*txn
= as_a
<gtransaction
*> (stmt
);
1607 label
= gimple_transaction_label_norm (txn
);
1610 new_label
= main_block_label (label
);
1611 if (new_label
!= label
)
1612 gimple_transaction_set_label_norm (txn
, new_label
);
1615 label
= gimple_transaction_label_uninst (txn
);
1618 new_label
= main_block_label (label
);
1619 if (new_label
!= label
)
1620 gimple_transaction_set_label_uninst (txn
, new_label
);
1623 label
= gimple_transaction_label_over (txn
);
1626 new_label
= main_block_label (label
);
1627 if (new_label
!= label
)
1628 gimple_transaction_set_label_over (txn
, new_label
);
1638 /* Do the same for the exception region tree labels. */
1639 cleanup_dead_labels_eh ();
1641 /* Finally, purge dead labels. All user-defined labels and labels that
1642 can be the target of non-local gotos and labels which have their
1643 address taken are preserved. */
1644 FOR_EACH_BB_FN (bb
, cfun
)
1646 gimple_stmt_iterator i
;
1647 tree label_for_this_bb
= label_for_bb
[bb
->index
].label
;
1649 if (!label_for_this_bb
)
1652 /* If the main label of the block is unused, we may still remove it. */
1653 if (!label_for_bb
[bb
->index
].used
)
1654 label_for_this_bb
= NULL
;
1656 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); )
1659 glabel
*label_stmt
= dyn_cast
<glabel
*> (gsi_stmt (i
));
1664 label
= gimple_label_label (label_stmt
);
1666 if (label
== label_for_this_bb
1667 || !DECL_ARTIFICIAL (label
)
1668 || DECL_NONLOCAL (label
)
1669 || FORCED_LABEL (label
))
1672 gsi_remove (&i
, true);
1676 free (label_for_bb
);
1679 /* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
1680 the ones jumping to the same label.
1681 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
1684 group_case_labels_stmt (gswitch
*stmt
)
1686 int old_size
= gimple_switch_num_labels (stmt
);
1687 int i
, next_index
, new_size
;
1688 basic_block default_bb
= NULL
;
1690 default_bb
= label_to_block (CASE_LABEL (gimple_switch_default_label (stmt
)));
1692 /* Look for possible opportunities to merge cases. */
1694 while (i
< old_size
)
1696 tree base_case
, base_high
;
1697 basic_block base_bb
;
1699 base_case
= gimple_switch_label (stmt
, i
);
1701 gcc_assert (base_case
);
1702 base_bb
= label_to_block (CASE_LABEL (base_case
));
1704 /* Discard cases that have the same destination as the default case or
1705 whose destiniation blocks have already been removed as unreachable. */
1706 if (base_bb
== NULL
|| base_bb
== default_bb
)
1712 base_high
= CASE_HIGH (base_case
)
1713 ? CASE_HIGH (base_case
)
1714 : CASE_LOW (base_case
);
1717 /* Try to merge case labels. Break out when we reach the end
1718 of the label vector or when we cannot merge the next case
1719 label with the current one. */
1720 while (next_index
< old_size
)
1722 tree merge_case
= gimple_switch_label (stmt
, next_index
);
1723 basic_block merge_bb
= label_to_block (CASE_LABEL (merge_case
));
1724 wide_int bhp1
= wi::add (base_high
, 1);
1726 /* Merge the cases if they jump to the same place,
1727 and their ranges are consecutive. */
1728 if (merge_bb
== base_bb
1729 && wi::eq_p (CASE_LOW (merge_case
), bhp1
))
1731 base_high
= CASE_HIGH (merge_case
) ?
1732 CASE_HIGH (merge_case
) : CASE_LOW (merge_case
);
1733 CASE_HIGH (base_case
) = base_high
;
1740 /* Discard cases that have an unreachable destination block. */
1741 if (EDGE_COUNT (base_bb
->succs
) == 0
1742 && gimple_seq_unreachable_p (bb_seq (base_bb
)))
1744 edge base_edge
= find_edge (gimple_bb (stmt
), base_bb
);
1745 if (base_edge
!= NULL
)
1746 remove_edge_and_dominated_blocks (base_edge
);
1752 gimple_switch_set_label (stmt
, new_size
,
1753 gimple_switch_label (stmt
, i
));
1758 gcc_assert (new_size
<= old_size
);
1760 if (new_size
< old_size
)
1761 gimple_switch_set_num_labels (stmt
, new_size
);
1763 return new_size
< old_size
;
1766 /* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
1767 and scan the sorted vector of cases. Combine the ones jumping to the
1771 group_case_labels (void)
1774 bool changed
= false;
1776 FOR_EACH_BB_FN (bb
, cfun
)
1778 gimple
*stmt
= last_stmt (bb
);
1779 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1780 changed
|= group_case_labels_stmt (as_a
<gswitch
*> (stmt
));
1786 /* Checks whether we can merge block B into block A. */
1789 gimple_can_merge_blocks_p (basic_block a
, basic_block b
)
1793 if (!single_succ_p (a
))
1796 if (single_succ_edge (a
)->flags
& EDGE_COMPLEX
)
1799 if (single_succ (a
) != b
)
1802 if (!single_pred_p (b
))
1805 if (a
== ENTRY_BLOCK_PTR_FOR_FN (cfun
)
1806 || b
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
1809 /* If A ends by a statement causing exceptions or something similar, we
1810 cannot merge the blocks. */
1811 stmt
= last_stmt (a
);
1812 if (stmt
&& stmt_ends_bb_p (stmt
))
1815 /* Do not allow a block with only a non-local label to be merged. */
1817 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
1818 if (DECL_NONLOCAL (gimple_label_label (label_stmt
)))
1821 /* Examine the labels at the beginning of B. */
1822 for (gimple_stmt_iterator gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
);
1826 glabel
*label_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
1829 lab
= gimple_label_label (label_stmt
);
1831 /* Do not remove user forced labels or for -O0 any user labels. */
1832 if (!DECL_ARTIFICIAL (lab
) && (!optimize
|| FORCED_LABEL (lab
)))
1836 /* Protect simple loop latches. We only want to avoid merging
1837 the latch with the loop header or with a block in another
1838 loop in this case. */
1840 && b
->loop_father
->latch
== b
1841 && loops_state_satisfies_p (LOOPS_HAVE_SIMPLE_LATCHES
)
1842 && (b
->loop_father
->header
== a
1843 || b
->loop_father
!= a
->loop_father
))
1846 /* It must be possible to eliminate all phi nodes in B. If ssa form
1847 is not up-to-date and a name-mapping is registered, we cannot eliminate
1848 any phis. Symbols marked for renaming are never a problem though. */
1849 for (gphi_iterator gsi
= gsi_start_phis (b
); !gsi_end_p (gsi
);
1852 gphi
*phi
= gsi
.phi ();
1853 /* Technically only new names matter. */
1854 if (name_registered_for_update_p (PHI_RESULT (phi
)))
1858 /* When not optimizing, don't merge if we'd lose goto_locus. */
1860 && single_succ_edge (a
)->goto_locus
!= UNKNOWN_LOCATION
)
1862 location_t goto_locus
= single_succ_edge (a
)->goto_locus
;
1863 gimple_stmt_iterator prev
, next
;
1864 prev
= gsi_last_nondebug_bb (a
);
1865 next
= gsi_after_labels (b
);
1866 if (!gsi_end_p (next
) && is_gimple_debug (gsi_stmt (next
)))
1867 gsi_next_nondebug (&next
);
1868 if ((gsi_end_p (prev
)
1869 || gimple_location (gsi_stmt (prev
)) != goto_locus
)
1870 && (gsi_end_p (next
)
1871 || gimple_location (gsi_stmt (next
)) != goto_locus
))
1878 /* Replaces all uses of NAME by VAL. */
1881 replace_uses_by (tree name
, tree val
)
1883 imm_use_iterator imm_iter
;
1888 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, name
)
1890 /* Mark the block if we change the last stmt in it. */
1891 if (cfgcleanup_altered_bbs
1892 && stmt_ends_bb_p (stmt
))
1893 bitmap_set_bit (cfgcleanup_altered_bbs
, gimple_bb (stmt
)->index
);
1895 FOR_EACH_IMM_USE_ON_STMT (use
, imm_iter
)
1897 replace_exp (use
, val
);
1899 if (gimple_code (stmt
) == GIMPLE_PHI
)
1901 e
= gimple_phi_arg_edge (as_a
<gphi
*> (stmt
),
1902 PHI_ARG_INDEX_FROM_USE (use
));
1903 if (e
->flags
& EDGE_ABNORMAL
1904 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val
))
1906 /* This can only occur for virtual operands, since
1907 for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
1908 would prevent replacement. */
1909 gcc_checking_assert (virtual_operand_p (name
));
1910 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val
) = 1;
1915 if (gimple_code (stmt
) != GIMPLE_PHI
)
1917 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
1918 gimple
*orig_stmt
= stmt
;
1921 /* FIXME. It shouldn't be required to keep TREE_CONSTANT
1922 on ADDR_EXPRs up-to-date on GIMPLE. Propagation will
1923 only change sth from non-invariant to invariant, and only
1924 when propagating constants. */
1925 if (is_gimple_min_invariant (val
))
1926 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1928 tree op
= gimple_op (stmt
, i
);
1929 /* Operands may be empty here. For example, the labels
1930 of a GIMPLE_COND are nulled out following the creation
1931 of the corresponding CFG edges. */
1932 if (op
&& TREE_CODE (op
) == ADDR_EXPR
)
1933 recompute_tree_invariant_for_addr_expr (op
);
1936 if (fold_stmt (&gsi
))
1937 stmt
= gsi_stmt (gsi
);
1939 if (maybe_clean_or_replace_eh_stmt (orig_stmt
, stmt
))
1940 gimple_purge_dead_eh_edges (gimple_bb (stmt
));
1946 gcc_checking_assert (has_zero_uses (name
));
1948 /* Also update the trees stored in loop structures. */
1953 FOR_EACH_LOOP (loop
, 0)
1955 substitute_in_loop_info (loop
, name
, val
);
1960 /* Merge block B into block A. */
1963 gimple_merge_blocks (basic_block a
, basic_block b
)
1965 gimple_stmt_iterator last
, gsi
;
1969 fprintf (dump_file
, "Merging blocks %d and %d\n", a
->index
, b
->index
);
1971 /* Remove all single-valued PHI nodes from block B of the form
1972 V_i = PHI <V_j> by propagating V_j to all the uses of V_i. */
1973 gsi
= gsi_last_bb (a
);
1974 for (psi
= gsi_start_phis (b
); !gsi_end_p (psi
); )
1976 gimple
*phi
= gsi_stmt (psi
);
1977 tree def
= gimple_phi_result (phi
), use
= gimple_phi_arg_def (phi
, 0);
1979 bool may_replace_uses
= (virtual_operand_p (def
)
1980 || may_propagate_copy (def
, use
));
1982 /* In case we maintain loop closed ssa form, do not propagate arguments
1983 of loop exit phi nodes. */
1985 && loops_state_satisfies_p (LOOP_CLOSED_SSA
)
1986 && !virtual_operand_p (def
)
1987 && TREE_CODE (use
) == SSA_NAME
1988 && a
->loop_father
!= b
->loop_father
)
1989 may_replace_uses
= false;
1991 if (!may_replace_uses
)
1993 gcc_assert (!virtual_operand_p (def
));
1995 /* Note that just emitting the copies is fine -- there is no problem
1996 with ordering of phi nodes. This is because A is the single
1997 predecessor of B, therefore results of the phi nodes cannot
1998 appear as arguments of the phi nodes. */
1999 copy
= gimple_build_assign (def
, use
);
2000 gsi_insert_after (&gsi
, copy
, GSI_NEW_STMT
);
2001 remove_phi_node (&psi
, false);
2005 /* If we deal with a PHI for virtual operands, we can simply
2006 propagate these without fussing with folding or updating
2008 if (virtual_operand_p (def
))
2010 imm_use_iterator iter
;
2011 use_operand_p use_p
;
2014 FOR_EACH_IMM_USE_STMT (stmt
, iter
, def
)
2015 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
2016 SET_USE (use_p
, use
);
2018 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
2019 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use
) = 1;
2022 replace_uses_by (def
, use
);
2024 remove_phi_node (&psi
, true);
2028 /* Ensure that B follows A. */
2029 move_block_after (b
, a
);
2031 gcc_assert (single_succ_edge (a
)->flags
& EDGE_FALLTHRU
);
2032 gcc_assert (!last_stmt (a
) || !stmt_ends_bb_p (last_stmt (a
)));
2034 /* Remove labels from B and set gimple_bb to A for other statements. */
2035 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
);)
2037 gimple
*stmt
= gsi_stmt (gsi
);
2038 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
2040 tree label
= gimple_label_label (label_stmt
);
2043 gsi_remove (&gsi
, false);
2045 /* Now that we can thread computed gotos, we might have
2046 a situation where we have a forced label in block B
2047 However, the label at the start of block B might still be
2048 used in other ways (think about the runtime checking for
2049 Fortran assigned gotos). So we can not just delete the
2050 label. Instead we move the label to the start of block A. */
2051 if (FORCED_LABEL (label
))
2053 gimple_stmt_iterator dest_gsi
= gsi_start_bb (a
);
2054 gsi_insert_before (&dest_gsi
, stmt
, GSI_NEW_STMT
);
2056 /* Other user labels keep around in a form of a debug stmt. */
2057 else if (!DECL_ARTIFICIAL (label
) && MAY_HAVE_DEBUG_STMTS
)
2059 gimple
*dbg
= gimple_build_debug_bind (label
,
2062 gimple_debug_bind_reset_value (dbg
);
2063 gsi_insert_before (&gsi
, dbg
, GSI_SAME_STMT
);
2066 lp_nr
= EH_LANDING_PAD_NR (label
);
2069 eh_landing_pad lp
= get_eh_landing_pad_from_number (lp_nr
);
2070 lp
->post_landing_pad
= NULL
;
2075 gimple_set_bb (stmt
, a
);
2080 /* When merging two BBs, if their counts are different, the larger count
2081 is selected as the new bb count. This is to handle inconsistent
2083 if (a
->loop_father
== b
->loop_father
)
2085 a
->count
= a
->count
.merge (b
->count
);
2086 a
->frequency
= MAX (a
->frequency
, b
->frequency
);
2089 /* Merge the sequences. */
2090 last
= gsi_last_bb (a
);
2091 gsi_insert_seq_after (&last
, bb_seq (b
), GSI_NEW_STMT
);
2092 set_bb_seq (b
, NULL
);
2094 if (cfgcleanup_altered_bbs
)
2095 bitmap_set_bit (cfgcleanup_altered_bbs
, a
->index
);
2099 /* Return the one of two successors of BB that is not reachable by a
2100 complex edge, if there is one. Else, return BB. We use
2101 this in optimizations that use post-dominators for their heuristics,
2102 to catch the cases in C++ where function calls are involved. */
2105 single_noncomplex_succ (basic_block bb
)
2108 if (EDGE_COUNT (bb
->succs
) != 2)
2111 e0
= EDGE_SUCC (bb
, 0);
2112 e1
= EDGE_SUCC (bb
, 1);
2113 if (e0
->flags
& EDGE_COMPLEX
)
2115 if (e1
->flags
& EDGE_COMPLEX
)
2121 /* T is CALL_EXPR. Set current_function_calls_* flags. */
2124 notice_special_calls (gcall
*call
)
2126 int flags
= gimple_call_flags (call
);
2128 if (flags
& ECF_MAY_BE_ALLOCA
)
2129 cfun
->calls_alloca
= true;
2130 if (flags
& ECF_RETURNS_TWICE
)
2131 cfun
->calls_setjmp
= true;
2135 /* Clear flags set by notice_special_calls. Used by dead code removal
2136 to update the flags. */
2139 clear_special_calls (void)
2141 cfun
->calls_alloca
= false;
2142 cfun
->calls_setjmp
= false;
2145 /* Remove PHI nodes associated with basic block BB and all edges out of BB. */
2148 remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb
)
2150 /* Since this block is no longer reachable, we can just delete all
2151 of its PHI nodes. */
2152 remove_phi_nodes (bb
);
2154 /* Remove edges to BB's successors. */
2155 while (EDGE_COUNT (bb
->succs
) > 0)
2156 remove_edge (EDGE_SUCC (bb
, 0));
2160 /* Remove statements of basic block BB. */
2163 remove_bb (basic_block bb
)
2165 gimple_stmt_iterator i
;
2169 fprintf (dump_file
, "Removing basic block %d\n", bb
->index
);
2170 if (dump_flags
& TDF_DETAILS
)
2172 dump_bb (dump_file
, bb
, 0, TDF_BLOCKS
);
2173 fprintf (dump_file
, "\n");
2179 struct loop
*loop
= bb
->loop_father
;
2181 /* If a loop gets removed, clean up the information associated
2183 if (loop
->latch
== bb
2184 || loop
->header
== bb
)
2185 free_numbers_of_iterations_estimates (loop
);
2188 /* Remove all the instructions in the block. */
2189 if (bb_seq (bb
) != NULL
)
2191 /* Walk backwards so as to get a chance to substitute all
2192 released DEFs into debug stmts. See
2193 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
2195 for (i
= gsi_last_bb (bb
); !gsi_end_p (i
);)
2197 gimple
*stmt
= gsi_stmt (i
);
2198 glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
);
2200 && (FORCED_LABEL (gimple_label_label (label_stmt
))
2201 || DECL_NONLOCAL (gimple_label_label (label_stmt
))))
2204 gimple_stmt_iterator new_gsi
;
2206 /* A non-reachable non-local label may still be referenced.
2207 But it no longer needs to carry the extra semantics of
2209 if (DECL_NONLOCAL (gimple_label_label (label_stmt
)))
2211 DECL_NONLOCAL (gimple_label_label (label_stmt
)) = 0;
2212 FORCED_LABEL (gimple_label_label (label_stmt
)) = 1;
2215 new_bb
= bb
->prev_bb
;
2216 new_gsi
= gsi_start_bb (new_bb
);
2217 gsi_remove (&i
, false);
2218 gsi_insert_before (&new_gsi
, stmt
, GSI_NEW_STMT
);
2222 /* Release SSA definitions. */
2223 release_defs (stmt
);
2224 gsi_remove (&i
, true);
2228 i
= gsi_last_bb (bb
);
2234 remove_phi_nodes_and_edges_for_unreachable_block (bb
);
2235 bb
->il
.gimple
.seq
= NULL
;
2236 bb
->il
.gimple
.phi_nodes
= NULL
;
2240 /* Given a basic block BB ending with COND_EXPR or SWITCH_EXPR, and a
2241 predicate VAL, return the edge that will be taken out of the block.
2242 If VAL does not match a unique edge, NULL is returned. */
2245 find_taken_edge (basic_block bb
, tree val
)
2249 stmt
= last_stmt (bb
);
2251 gcc_assert (is_ctrl_stmt (stmt
));
2253 if (gimple_code (stmt
) == GIMPLE_COND
)
2254 return find_taken_edge_cond_expr (bb
, val
);
2256 if (gimple_code (stmt
) == GIMPLE_SWITCH
)
2257 return find_taken_edge_switch_expr (as_a
<gswitch
*> (stmt
), bb
, val
);
2259 if (computed_goto_p (stmt
))
2261 /* Only optimize if the argument is a label, if the argument is
2262 not a label then we can not construct a proper CFG.
2264 It may be the case that we only need to allow the LABEL_REF to
2265 appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
2266 appear inside a LABEL_EXPR just to be safe. */
2268 && (TREE_CODE (val
) == ADDR_EXPR
|| TREE_CODE (val
) == LABEL_EXPR
)
2269 && TREE_CODE (TREE_OPERAND (val
, 0)) == LABEL_DECL
)
2270 return find_taken_edge_computed_goto (bb
, TREE_OPERAND (val
, 0));
2277 /* Given a constant value VAL and the entry block BB to a GOTO_EXPR
2278 statement, determine which of the outgoing edges will be taken out of the
2279 block. Return NULL if either edge may be taken. */
2282 find_taken_edge_computed_goto (basic_block bb
, tree val
)
2287 dest
= label_to_block (val
);
2290 e
= find_edge (bb
, dest
);
2291 gcc_assert (e
!= NULL
);
2297 /* Given a constant value VAL and the entry block BB to a COND_EXPR
2298 statement, determine which of the two edges will be taken out of the
2299 block. Return NULL if either edge may be taken. */
2302 find_taken_edge_cond_expr (basic_block bb
, tree val
)
2304 edge true_edge
, false_edge
;
2307 || TREE_CODE (val
) != INTEGER_CST
)
2310 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2312 return (integer_zerop (val
) ? false_edge
: true_edge
);
2315 /* Given an INTEGER_CST VAL and the entry block BB to a SWITCH_EXPR
2316 statement, determine which edge will be taken out of the block. Return
2317 NULL if any edge may be taken. */
2320 find_taken_edge_switch_expr (gswitch
*switch_stmt
, basic_block bb
,
2323 basic_block dest_bb
;
2327 if (gimple_switch_num_labels (switch_stmt
) == 1)
2328 taken_case
= gimple_switch_default_label (switch_stmt
);
2329 else if (! val
|| TREE_CODE (val
) != INTEGER_CST
)
2332 taken_case
= find_case_label_for_value (switch_stmt
, val
);
2333 dest_bb
= label_to_block (CASE_LABEL (taken_case
));
2335 e
= find_edge (bb
, dest_bb
);
2341 /* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
2342 We can make optimal use here of the fact that the case labels are
2343 sorted: We can do a binary search for a case matching VAL. */
2346 find_case_label_for_value (gswitch
*switch_stmt
, tree val
)
2348 size_t low
, high
, n
= gimple_switch_num_labels (switch_stmt
);
2349 tree default_case
= gimple_switch_default_label (switch_stmt
);
2351 for (low
= 0, high
= n
; high
- low
> 1; )
2353 size_t i
= (high
+ low
) / 2;
2354 tree t
= gimple_switch_label (switch_stmt
, i
);
2357 /* Cache the result of comparing CASE_LOW and val. */
2358 cmp
= tree_int_cst_compare (CASE_LOW (t
), val
);
2365 if (CASE_HIGH (t
) == NULL
)
2367 /* A singe-valued case label. */
2373 /* A case range. We can only handle integer ranges. */
2374 if (cmp
<= 0 && tree_int_cst_compare (CASE_HIGH (t
), val
) >= 0)
2379 return default_case
;
2383 /* Dump a basic block on stderr. */
2386 gimple_debug_bb (basic_block bb
)
2388 dump_bb (stderr
, bb
, 0, TDF_VOPS
|TDF_MEMSYMS
|TDF_BLOCKS
);
2392 /* Dump basic block with index N on stderr. */
2395 gimple_debug_bb_n (int n
)
2397 gimple_debug_bb (BASIC_BLOCK_FOR_FN (cfun
, n
));
2398 return BASIC_BLOCK_FOR_FN (cfun
, n
);
2402 /* Dump the CFG on stderr.
2404 FLAGS are the same used by the tree dumping functions
2405 (see TDF_* in dumpfile.h). */
2408 gimple_debug_cfg (dump_flags_t flags
)
2410 gimple_dump_cfg (stderr
, flags
);
2414 /* Dump the program showing basic block boundaries on the given FILE.
2416 FLAGS are the same used by the tree dumping functions (see TDF_* in
2420 gimple_dump_cfg (FILE *file
, dump_flags_t flags
)
2422 if (flags
& TDF_DETAILS
)
2424 dump_function_header (file
, current_function_decl
, flags
);
2425 fprintf (file
, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
2426 n_basic_blocks_for_fn (cfun
), n_edges_for_fn (cfun
),
2427 last_basic_block_for_fn (cfun
));
2429 brief_dump_cfg (file
, flags
);
2430 fprintf (file
, "\n");
2433 if (flags
& TDF_STATS
)
2434 dump_cfg_stats (file
);
2436 dump_function_to_file (current_function_decl
, file
, flags
| TDF_BLOCKS
);
2440 /* Dump CFG statistics on FILE. */
2443 dump_cfg_stats (FILE *file
)
2445 static long max_num_merged_labels
= 0;
2446 unsigned long size
, total
= 0;
2449 const char * const fmt_str
= "%-30s%-13s%12s\n";
2450 const char * const fmt_str_1
= "%-30s%13d%11lu%c\n";
2451 const char * const fmt_str_2
= "%-30s%13ld%11lu%c\n";
2452 const char * const fmt_str_3
= "%-43s%11lu%c\n";
2453 const char *funcname
= current_function_name ();
2455 fprintf (file
, "\nCFG Statistics for %s\n\n", funcname
);
2457 fprintf (file
, "---------------------------------------------------------\n");
2458 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
2459 fprintf (file
, fmt_str
, "", " instances ", "used ");
2460 fprintf (file
, "---------------------------------------------------------\n");
2462 size
= n_basic_blocks_for_fn (cfun
) * sizeof (struct basic_block_def
);
2464 fprintf (file
, fmt_str_1
, "Basic blocks", n_basic_blocks_for_fn (cfun
),
2465 SCALE (size
), LABEL (size
));
2468 FOR_EACH_BB_FN (bb
, cfun
)
2469 num_edges
+= EDGE_COUNT (bb
->succs
);
2470 size
= num_edges
* sizeof (struct edge_def
);
2472 fprintf (file
, fmt_str_2
, "Edges", num_edges
, SCALE (size
), LABEL (size
));
2474 fprintf (file
, "---------------------------------------------------------\n");
2475 fprintf (file
, fmt_str_3
, "Total memory used by CFG data", SCALE (total
),
2477 fprintf (file
, "---------------------------------------------------------\n");
2478 fprintf (file
, "\n");
2480 if (cfg_stats
.num_merged_labels
> max_num_merged_labels
)
2481 max_num_merged_labels
= cfg_stats
.num_merged_labels
;
2483 fprintf (file
, "Coalesced label blocks: %ld (Max so far: %ld)\n",
2484 cfg_stats
.num_merged_labels
, max_num_merged_labels
);
2486 fprintf (file
, "\n");
2490 /* Dump CFG statistics on stderr. Keep extern so that it's always
2491 linked in the final executable. */
2494 debug_cfg_stats (void)
2496 dump_cfg_stats (stderr
);
2499 /*---------------------------------------------------------------------------
2500 Miscellaneous helpers
2501 ---------------------------------------------------------------------------*/
2503 /* Return true if T, a GIMPLE_CALL, can make an abnormal transfer of control
2504 flow. Transfers of control flow associated with EH are excluded. */
2507 call_can_make_abnormal_goto (gimple
*t
)
2509 /* If the function has no non-local labels, then a call cannot make an
2510 abnormal transfer of control. */
2511 if (!cfun
->has_nonlocal_label
2512 && !cfun
->calls_setjmp
)
2515 /* Likewise if the call has no side effects. */
2516 if (!gimple_has_side_effects (t
))
2519 /* Likewise if the called function is leaf. */
2520 if (gimple_call_flags (t
) & ECF_LEAF
)
2527 /* Return true if T can make an abnormal transfer of control flow.
2528 Transfers of control flow associated with EH are excluded. */
2531 stmt_can_make_abnormal_goto (gimple
*t
)
2533 if (computed_goto_p (t
))
2535 if (is_gimple_call (t
))
2536 return call_can_make_abnormal_goto (t
);
2541 /* Return true if T represents a stmt that always transfers control. */
2544 is_ctrl_stmt (gimple
*t
)
2546 switch (gimple_code (t
))
2560 /* Return true if T is a statement that may alter the flow of control
2561 (e.g., a call to a non-returning function). */
2564 is_ctrl_altering_stmt (gimple
*t
)
2568 switch (gimple_code (t
))
2571 /* Per stmt call flag indicates whether the call could alter
2573 if (gimple_call_ctrl_altering_p (t
))
2577 case GIMPLE_EH_DISPATCH
:
2578 /* EH_DISPATCH branches to the individual catch handlers at
2579 this level of a try or allowed-exceptions region. It can
2580 fallthru to the next statement as well. */
2584 if (gimple_asm_nlabels (as_a
<gasm
*> (t
)) > 0)
2589 /* OpenMP directives alter control flow. */
2592 case GIMPLE_TRANSACTION
:
2593 /* A transaction start alters control flow. */
2600 /* If a statement can throw, it alters control flow. */
2601 return stmt_can_throw_internal (t
);
2605 /* Return true if T is a simple local goto. */
2608 simple_goto_p (gimple
*t
)
2610 return (gimple_code (t
) == GIMPLE_GOTO
2611 && TREE_CODE (gimple_goto_dest (t
)) == LABEL_DECL
);
2615 /* Return true if STMT should start a new basic block. PREV_STMT is
2616 the statement preceding STMT. It is used when STMT is a label or a
2617 case label. Labels should only start a new basic block if their
2618 previous statement wasn't a label. Otherwise, sequence of labels
2619 would generate unnecessary basic blocks that only contain a single
2623 stmt_starts_bb_p (gimple
*stmt
, gimple
*prev_stmt
)
2628 /* Labels start a new basic block only if the preceding statement
2629 wasn't a label of the same type. This prevents the creation of
2630 consecutive blocks that have nothing but a single label. */
2631 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
2633 /* Nonlocal and computed GOTO targets always start a new block. */
2634 if (DECL_NONLOCAL (gimple_label_label (label_stmt
))
2635 || FORCED_LABEL (gimple_label_label (label_stmt
)))
2638 if (prev_stmt
&& gimple_code (prev_stmt
) == GIMPLE_LABEL
)
2640 if (DECL_NONLOCAL (gimple_label_label (
2641 as_a
<glabel
*> (prev_stmt
))))
2644 cfg_stats
.num_merged_labels
++;
2650 else if (gimple_code (stmt
) == GIMPLE_CALL
)
2652 if (gimple_call_flags (stmt
) & ECF_RETURNS_TWICE
)
2653 /* setjmp acts similar to a nonlocal GOTO target and thus should
2654 start a new block. */
2656 if (gimple_call_internal_p (stmt
, IFN_PHI
)
2658 && gimple_code (prev_stmt
) != GIMPLE_LABEL
2659 && (gimple_code (prev_stmt
) != GIMPLE_CALL
2660 || ! gimple_call_internal_p (prev_stmt
, IFN_PHI
)))
2661 /* PHI nodes start a new block unless preceeded by a label
2670 /* Return true if T should end a basic block. */
2673 stmt_ends_bb_p (gimple
*t
)
2675 return is_ctrl_stmt (t
) || is_ctrl_altering_stmt (t
);
2678 /* Remove block annotations and other data structures. */
2681 delete_tree_cfg_annotations (struct function
*fn
)
2683 vec_free (label_to_block_map_for_fn (fn
));
2686 /* Return the virtual phi in BB. */
2689 get_virtual_phi (basic_block bb
)
2691 for (gphi_iterator gsi
= gsi_start_phis (bb
);
2695 gphi
*phi
= gsi
.phi ();
2697 if (virtual_operand_p (PHI_RESULT (phi
)))
2704 /* Return the first statement in basic block BB. */
2707 first_stmt (basic_block bb
)
2709 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2710 gimple
*stmt
= NULL
;
2712 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2720 /* Return the first non-label statement in basic block BB. */
2723 first_non_label_stmt (basic_block bb
)
2725 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2726 while (!gsi_end_p (i
) && gimple_code (gsi_stmt (i
)) == GIMPLE_LABEL
)
2728 return !gsi_end_p (i
) ? gsi_stmt (i
) : NULL
;
2731 /* Return the last statement in basic block BB. */
2734 last_stmt (basic_block bb
)
2736 gimple_stmt_iterator i
= gsi_last_bb (bb
);
2737 gimple
*stmt
= NULL
;
2739 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2747 /* Return the last statement of an otherwise empty block. Return NULL
2748 if the block is totally empty, or if it contains more than one
2752 last_and_only_stmt (basic_block bb
)
2754 gimple_stmt_iterator i
= gsi_last_nondebug_bb (bb
);
2755 gimple
*last
, *prev
;
2760 last
= gsi_stmt (i
);
2761 gsi_prev_nondebug (&i
);
2765 /* Empty statements should no longer appear in the instruction stream.
2766 Everything that might have appeared before should be deleted by
2767 remove_useless_stmts, and the optimizers should just gsi_remove
2768 instead of smashing with build_empty_stmt.
2770 Thus the only thing that should appear here in a block containing
2771 one executable statement is a label. */
2772 prev
= gsi_stmt (i
);
2773 if (gimple_code (prev
) == GIMPLE_LABEL
)
2779 /* Reinstall those PHI arguments queued in OLD_EDGE to NEW_EDGE. */
2782 reinstall_phi_args (edge new_edge
, edge old_edge
)
2788 vec
<edge_var_map
> *v
= redirect_edge_var_map_vector (old_edge
);
2792 for (i
= 0, phis
= gsi_start_phis (new_edge
->dest
);
2793 v
->iterate (i
, &vm
) && !gsi_end_p (phis
);
2794 i
++, gsi_next (&phis
))
2796 gphi
*phi
= phis
.phi ();
2797 tree result
= redirect_edge_var_map_result (vm
);
2798 tree arg
= redirect_edge_var_map_def (vm
);
2800 gcc_assert (result
== gimple_phi_result (phi
));
2802 add_phi_arg (phi
, arg
, new_edge
, redirect_edge_var_map_location (vm
));
2805 redirect_edge_var_map_clear (old_edge
);
2808 /* Returns the basic block after which the new basic block created
2809 by splitting edge EDGE_IN should be placed. Tries to keep the new block
2810 near its "logical" location. This is of most help to humans looking
2811 at debugging dumps. */
2814 split_edge_bb_loc (edge edge_in
)
2816 basic_block dest
= edge_in
->dest
;
2817 basic_block dest_prev
= dest
->prev_bb
;
2821 edge e
= find_edge (dest_prev
, dest
);
2822 if (e
&& !(e
->flags
& EDGE_COMPLEX
))
2823 return edge_in
->src
;
2828 /* Split a (typically critical) edge EDGE_IN. Return the new block.
2829 Abort on abnormal edges. */
2832 gimple_split_edge (edge edge_in
)
2834 basic_block new_bb
, after_bb
, dest
;
2837 /* Abnormal edges cannot be split. */
2838 gcc_assert (!(edge_in
->flags
& EDGE_ABNORMAL
));
2840 dest
= edge_in
->dest
;
2842 after_bb
= split_edge_bb_loc (edge_in
);
2844 new_bb
= create_empty_bb (after_bb
);
2845 new_bb
->frequency
= EDGE_FREQUENCY (edge_in
);
2846 new_bb
->count
= edge_in
->count
;
2847 new_edge
= make_single_succ_edge (new_bb
, dest
, EDGE_FALLTHRU
);
2849 e
= redirect_edge_and_branch (edge_in
, new_bb
);
2850 gcc_assert (e
== edge_in
);
2851 reinstall_phi_args (new_edge
, e
);
2857 /* Verify properties of the address expression T with base object BASE. */
2860 verify_address (tree t
, tree base
)
2863 bool old_side_effects
;
2865 bool new_side_effects
;
2867 old_constant
= TREE_CONSTANT (t
);
2868 old_side_effects
= TREE_SIDE_EFFECTS (t
);
2870 recompute_tree_invariant_for_addr_expr (t
);
2871 new_side_effects
= TREE_SIDE_EFFECTS (t
);
2872 new_constant
= TREE_CONSTANT (t
);
2874 if (old_constant
!= new_constant
)
2876 error ("constant not recomputed when ADDR_EXPR changed");
2879 if (old_side_effects
!= new_side_effects
)
2881 error ("side effects not recomputed when ADDR_EXPR changed");
2886 || TREE_CODE (base
) == PARM_DECL
2887 || TREE_CODE (base
) == RESULT_DECL
))
2890 if (DECL_GIMPLE_REG_P (base
))
2892 error ("DECL_GIMPLE_REG_P set on a variable with address taken");
2899 /* Callback for walk_tree, check that all elements with address taken are
2900 properly noticed as such. The DATA is an int* that is 1 if TP was seen
2901 inside a PHI node. */
2904 verify_expr (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
2911 /* Check operand N for being valid GIMPLE and give error MSG if not. */
2912 #define CHECK_OP(N, MSG) \
2913 do { if (!is_gimple_val (TREE_OPERAND (t, N))) \
2914 { error (MSG); return TREE_OPERAND (t, N); }} while (0)
2916 switch (TREE_CODE (t
))
2919 if (SSA_NAME_IN_FREE_LIST (t
))
2921 error ("SSA name in freelist but still referenced");
2930 tree context
= decl_function_context (t
);
2931 if (context
!= cfun
->decl
2932 && !SCOPE_FILE_SCOPE_P (context
)
2934 && !DECL_EXTERNAL (t
))
2936 error ("Local declaration from a different function");
2943 error ("INDIRECT_REF in gimple IL");
2947 x
= TREE_OPERAND (t
, 0);
2948 if (!POINTER_TYPE_P (TREE_TYPE (x
))
2949 || !is_gimple_mem_ref_addr (x
))
2951 error ("invalid first operand of MEM_REF");
2954 if (TREE_CODE (TREE_OPERAND (t
, 1)) != INTEGER_CST
2955 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 1))))
2957 error ("invalid offset operand of MEM_REF");
2958 return TREE_OPERAND (t
, 1);
2960 if (TREE_CODE (x
) == ADDR_EXPR
)
2962 tree va
= verify_address (x
, TREE_OPERAND (x
, 0));
2965 x
= TREE_OPERAND (x
, 0);
2967 walk_tree (&x
, verify_expr
, data
, NULL
);
2972 x
= fold (ASSERT_EXPR_COND (t
));
2973 if (x
== boolean_false_node
)
2975 error ("ASSERT_EXPR with an always-false condition");
2981 error ("MODIFY_EXPR not expected while having tuples");
2988 gcc_assert (is_gimple_address (t
));
2990 /* Skip any references (they will be checked when we recurse down the
2991 tree) and ensure that any variable used as a prefix is marked
2993 for (x
= TREE_OPERAND (t
, 0);
2994 handled_component_p (x
);
2995 x
= TREE_OPERAND (x
, 0))
2998 if ((tem
= verify_address (t
, x
)))
3002 || TREE_CODE (x
) == PARM_DECL
3003 || TREE_CODE (x
) == RESULT_DECL
))
3006 if (!TREE_ADDRESSABLE (x
))
3008 error ("address taken, but ADDRESSABLE bit not set");
3016 x
= COND_EXPR_COND (t
);
3017 if (!INTEGRAL_TYPE_P (TREE_TYPE (x
)))
3019 error ("non-integral used in condition");
3022 if (!is_gimple_condexpr (x
))
3024 error ("invalid conditional operand");
3029 case NON_LVALUE_EXPR
:
3030 case TRUTH_NOT_EXPR
:
3034 case FIX_TRUNC_EXPR
:
3039 CHECK_OP (0, "invalid operand to unary operator");
3045 if (!is_gimple_reg_type (TREE_TYPE (t
)))
3047 error ("non-scalar BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR");
3051 if (TREE_CODE (t
) == BIT_FIELD_REF
)
3053 tree t0
= TREE_OPERAND (t
, 0);
3054 tree t1
= TREE_OPERAND (t
, 1);
3055 tree t2
= TREE_OPERAND (t
, 2);
3056 if (!tree_fits_uhwi_p (t1
)
3057 || !tree_fits_uhwi_p (t2
)
3058 || !types_compatible_p (bitsizetype
, TREE_TYPE (t1
))
3059 || !types_compatible_p (bitsizetype
, TREE_TYPE (t2
)))
3061 error ("invalid position or size operand to BIT_FIELD_REF");
3064 if (INTEGRAL_TYPE_P (TREE_TYPE (t
))
3065 && (TYPE_PRECISION (TREE_TYPE (t
))
3066 != tree_to_uhwi (t1
)))
3068 error ("integral result type precision does not match "
3069 "field size of BIT_FIELD_REF");
3072 else if (!INTEGRAL_TYPE_P (TREE_TYPE (t
))
3073 && TYPE_MODE (TREE_TYPE (t
)) != BLKmode
3074 && (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t
)))
3075 != tree_to_uhwi (t1
)))
3077 error ("mode size of non-integral result does not "
3078 "match field size of BIT_FIELD_REF");
3081 if (!AGGREGATE_TYPE_P (TREE_TYPE (t0
))
3082 && (tree_to_uhwi (t1
) + tree_to_uhwi (t2
)
3083 > tree_to_uhwi (TYPE_SIZE (TREE_TYPE (t0
)))))
3085 error ("position plus size exceeds size of referenced object in "
3090 t
= TREE_OPERAND (t
, 0);
3095 case ARRAY_RANGE_REF
:
3096 case VIEW_CONVERT_EXPR
:
3097 /* We have a nest of references. Verify that each of the operands
3098 that determine where to reference is either a constant or a variable,
3099 verify that the base is valid, and then show we've already checked
3101 while (handled_component_p (t
))
3103 if (TREE_CODE (t
) == COMPONENT_REF
&& TREE_OPERAND (t
, 2))
3104 CHECK_OP (2, "invalid COMPONENT_REF offset operator");
3105 else if (TREE_CODE (t
) == ARRAY_REF
3106 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
3108 CHECK_OP (1, "invalid array index");
3109 if (TREE_OPERAND (t
, 2))
3110 CHECK_OP (2, "invalid array lower bound");
3111 if (TREE_OPERAND (t
, 3))
3112 CHECK_OP (3, "invalid array stride");
3114 else if (TREE_CODE (t
) == BIT_FIELD_REF
3115 || TREE_CODE (t
) == REALPART_EXPR
3116 || TREE_CODE (t
) == IMAGPART_EXPR
)
3118 error ("non-top-level BIT_FIELD_REF, IMAGPART_EXPR or "
3123 t
= TREE_OPERAND (t
, 0);
3126 if (!is_gimple_min_invariant (t
) && !is_gimple_lvalue (t
))
3128 error ("invalid reference prefix");
3131 walk_tree (&t
, verify_expr
, data
, NULL
);
3136 /* PLUS_EXPR and MINUS_EXPR don't work on pointers, they should be done using
3137 POINTER_PLUS_EXPR. */
3138 if (POINTER_TYPE_P (TREE_TYPE (t
)))
3140 error ("invalid operand to plus/minus, type is a pointer");
3143 CHECK_OP (0, "invalid operand to binary operator");
3144 CHECK_OP (1, "invalid operand to binary operator");
3147 case POINTER_PLUS_EXPR
:
3148 /* Check to make sure the first operand is a pointer or reference type. */
3149 if (!POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 0))))
3151 error ("invalid operand to pointer plus, first operand is not a pointer");
3154 /* Check to make sure the second operand is a ptrofftype. */
3155 if (!ptrofftype_p (TREE_TYPE (TREE_OPERAND (t
, 1))))
3157 error ("invalid operand to pointer plus, second operand is not an "
3158 "integer type of appropriate width");
3168 case UNORDERED_EXPR
:
3177 case TRUNC_DIV_EXPR
:
3179 case FLOOR_DIV_EXPR
:
3180 case ROUND_DIV_EXPR
:
3181 case TRUNC_MOD_EXPR
:
3183 case FLOOR_MOD_EXPR
:
3184 case ROUND_MOD_EXPR
:
3186 case EXACT_DIV_EXPR
:
3196 CHECK_OP (0, "invalid operand to binary operator");
3197 CHECK_OP (1, "invalid operand to binary operator");
3201 if (TREE_CONSTANT (t
) && TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
3205 case CASE_LABEL_EXPR
:
3208 error ("invalid CASE_CHAIN");
3222 /* Verify if EXPR is either a GIMPLE ID or a GIMPLE indirect reference.
3223 Returns true if there is an error, otherwise false. */
3226 verify_types_in_gimple_min_lval (tree expr
)
3230 if (is_gimple_id (expr
))
3233 if (TREE_CODE (expr
) != TARGET_MEM_REF
3234 && TREE_CODE (expr
) != MEM_REF
)
3236 error ("invalid expression for min lvalue");
3240 /* TARGET_MEM_REFs are strange beasts. */
3241 if (TREE_CODE (expr
) == TARGET_MEM_REF
)
3244 op
= TREE_OPERAND (expr
, 0);
3245 if (!is_gimple_val (op
))
3247 error ("invalid operand in indirect reference");
3248 debug_generic_stmt (op
);
3251 /* Memory references now generally can involve a value conversion. */
3256 /* Verify if EXPR is a valid GIMPLE reference expression. If
3257 REQUIRE_LVALUE is true verifies it is an lvalue. Returns true
3258 if there is an error, otherwise false. */
3261 verify_types_in_gimple_reference (tree expr
, bool require_lvalue
)
3263 while (handled_component_p (expr
))
3265 tree op
= TREE_OPERAND (expr
, 0);
3267 if (TREE_CODE (expr
) == ARRAY_REF
3268 || TREE_CODE (expr
) == ARRAY_RANGE_REF
)
3270 if (!is_gimple_val (TREE_OPERAND (expr
, 1))
3271 || (TREE_OPERAND (expr
, 2)
3272 && !is_gimple_val (TREE_OPERAND (expr
, 2)))
3273 || (TREE_OPERAND (expr
, 3)
3274 && !is_gimple_val (TREE_OPERAND (expr
, 3))))
3276 error ("invalid operands to array reference");
3277 debug_generic_stmt (expr
);
3282 /* Verify if the reference array element types are compatible. */
3283 if (TREE_CODE (expr
) == ARRAY_REF
3284 && !useless_type_conversion_p (TREE_TYPE (expr
),
3285 TREE_TYPE (TREE_TYPE (op
))))
3287 error ("type mismatch in array reference");
3288 debug_generic_stmt (TREE_TYPE (expr
));
3289 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3292 if (TREE_CODE (expr
) == ARRAY_RANGE_REF
3293 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr
)),
3294 TREE_TYPE (TREE_TYPE (op
))))
3296 error ("type mismatch in array range reference");
3297 debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr
)));
3298 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3302 if ((TREE_CODE (expr
) == REALPART_EXPR
3303 || TREE_CODE (expr
) == IMAGPART_EXPR
)
3304 && !useless_type_conversion_p (TREE_TYPE (expr
),
3305 TREE_TYPE (TREE_TYPE (op
))))
3307 error ("type mismatch in real/imagpart reference");
3308 debug_generic_stmt (TREE_TYPE (expr
));
3309 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3313 if (TREE_CODE (expr
) == COMPONENT_REF
3314 && !useless_type_conversion_p (TREE_TYPE (expr
),
3315 TREE_TYPE (TREE_OPERAND (expr
, 1))))
3317 error ("type mismatch in component reference");
3318 debug_generic_stmt (TREE_TYPE (expr
));
3319 debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr
, 1)));
3323 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
)
3325 /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
3326 that their operand is not an SSA name or an invariant when
3327 requiring an lvalue (this usually means there is a SRA or IPA-SRA
3328 bug). Otherwise there is nothing to verify, gross mismatches at
3329 most invoke undefined behavior. */
3331 && (TREE_CODE (op
) == SSA_NAME
3332 || is_gimple_min_invariant (op
)))
3334 error ("conversion of an SSA_NAME on the left hand side");
3335 debug_generic_stmt (expr
);
3338 else if (TREE_CODE (op
) == SSA_NAME
3339 && TYPE_SIZE (TREE_TYPE (expr
)) != TYPE_SIZE (TREE_TYPE (op
)))
3341 error ("conversion of register to a different size");
3342 debug_generic_stmt (expr
);
3345 else if (!handled_component_p (op
))
3352 if (TREE_CODE (expr
) == MEM_REF
)
3354 if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr
, 0)))
3356 error ("invalid address operand in MEM_REF");
3357 debug_generic_stmt (expr
);
3360 if (TREE_CODE (TREE_OPERAND (expr
, 1)) != INTEGER_CST
3361 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr
, 1))))
3363 error ("invalid offset operand in MEM_REF");
3364 debug_generic_stmt (expr
);
3368 else if (TREE_CODE (expr
) == TARGET_MEM_REF
)
3370 if (!TMR_BASE (expr
)
3371 || !is_gimple_mem_ref_addr (TMR_BASE (expr
)))
3373 error ("invalid address operand in TARGET_MEM_REF");
3376 if (!TMR_OFFSET (expr
)
3377 || TREE_CODE (TMR_OFFSET (expr
)) != INTEGER_CST
3378 || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr
))))
3380 error ("invalid offset operand in TARGET_MEM_REF");
3381 debug_generic_stmt (expr
);
3386 return ((require_lvalue
|| !is_gimple_min_invariant (expr
))
3387 && verify_types_in_gimple_min_lval (expr
));
3390 /* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
3391 list of pointer-to types that is trivially convertible to DEST. */
3394 one_pointer_to_useless_type_conversion_p (tree dest
, tree src_obj
)
3398 if (!TYPE_POINTER_TO (src_obj
))
3401 for (src
= TYPE_POINTER_TO (src_obj
); src
; src
= TYPE_NEXT_PTR_TO (src
))
3402 if (useless_type_conversion_p (dest
, src
))
3408 /* Return true if TYPE1 is a fixed-point type and if conversions to and
3409 from TYPE2 can be handled by FIXED_CONVERT_EXPR. */
3412 valid_fixed_convert_types_p (tree type1
, tree type2
)
3414 return (FIXED_POINT_TYPE_P (type1
)
3415 && (INTEGRAL_TYPE_P (type2
)
3416 || SCALAR_FLOAT_TYPE_P (type2
)
3417 || FIXED_POINT_TYPE_P (type2
)));
3420 /* Verify the contents of a GIMPLE_CALL STMT. Returns true when there
3421 is a problem, otherwise false. */
3424 verify_gimple_call (gcall
*stmt
)
3426 tree fn
= gimple_call_fn (stmt
);
3427 tree fntype
, fndecl
;
3430 if (gimple_call_internal_p (stmt
))
3434 error ("gimple call has two targets");
3435 debug_generic_stmt (fn
);
3438 /* FIXME : for passing label as arg in internal fn PHI from GIMPLE FE*/
3439 else if (gimple_call_internal_fn (stmt
) == IFN_PHI
)
3448 error ("gimple call has no target");
3453 if (fn
&& !is_gimple_call_addr (fn
))
3455 error ("invalid function in gimple call");
3456 debug_generic_stmt (fn
);
3461 && (!POINTER_TYPE_P (TREE_TYPE (fn
))
3462 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != FUNCTION_TYPE
3463 && TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != METHOD_TYPE
)))
3465 error ("non-function in gimple call");
3469 fndecl
= gimple_call_fndecl (stmt
);
3471 && TREE_CODE (fndecl
) == FUNCTION_DECL
3472 && DECL_LOOPING_CONST_OR_PURE_P (fndecl
)
3473 && !DECL_PURE_P (fndecl
)
3474 && !TREE_READONLY (fndecl
))
3476 error ("invalid pure const state for function");
3480 tree lhs
= gimple_call_lhs (stmt
);
3482 && (!is_gimple_lvalue (lhs
)
3483 || verify_types_in_gimple_reference (lhs
, true)))
3485 error ("invalid LHS in gimple call");
3489 if (gimple_call_ctrl_altering_p (stmt
)
3490 && gimple_call_noreturn_p (stmt
)
3491 && should_remove_lhs_p (lhs
))
3493 error ("LHS in noreturn call");
3497 fntype
= gimple_call_fntype (stmt
);
3500 && !useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (fntype
))
3501 /* ??? At least C++ misses conversions at assignments from
3502 void * call results.
3503 For now simply allow arbitrary pointer type conversions. */
3504 && !(POINTER_TYPE_P (TREE_TYPE (lhs
))
3505 && POINTER_TYPE_P (TREE_TYPE (fntype
))))
3507 error ("invalid conversion in gimple call");
3508 debug_generic_stmt (TREE_TYPE (lhs
));
3509 debug_generic_stmt (TREE_TYPE (fntype
));
3513 if (gimple_call_chain (stmt
)
3514 && !is_gimple_val (gimple_call_chain (stmt
)))
3516 error ("invalid static chain in gimple call");
3517 debug_generic_stmt (gimple_call_chain (stmt
));
3521 /* If there is a static chain argument, the call should either be
3522 indirect, or the decl should have DECL_STATIC_CHAIN set. */
3523 if (gimple_call_chain (stmt
)
3525 && !DECL_STATIC_CHAIN (fndecl
))
3527 error ("static chain with function that doesn%'t use one");
3531 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
3533 switch (DECL_FUNCTION_CODE (fndecl
))
3535 case BUILT_IN_UNREACHABLE
:
3537 if (gimple_call_num_args (stmt
) > 0)
3539 /* Built-in unreachable with parameters might not be caught by
3540 undefined behavior sanitizer. Front-ends do check users do not
3541 call them that way but we also produce calls to
3542 __builtin_unreachable internally, for example when IPA figures
3543 out a call cannot happen in a legal program. In such cases,
3544 we must make sure arguments are stripped off. */
3545 error ("__builtin_unreachable or __builtin_trap call with "
3555 /* ??? The C frontend passes unpromoted arguments in case it
3556 didn't see a function declaration before the call. So for now
3557 leave the call arguments mostly unverified. Once we gimplify
3558 unit-at-a-time we have a chance to fix this. */
3560 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
3562 tree arg
= gimple_call_arg (stmt
, i
);
3563 if ((is_gimple_reg_type (TREE_TYPE (arg
))
3564 && !is_gimple_val (arg
))
3565 || (!is_gimple_reg_type (TREE_TYPE (arg
))
3566 && !is_gimple_lvalue (arg
)))
3568 error ("invalid argument to gimple call");
3569 debug_generic_expr (arg
);
3577 /* Verifies the gimple comparison with the result type TYPE and
3578 the operands OP0 and OP1, comparison code is CODE. */
3581 verify_gimple_comparison (tree type
, tree op0
, tree op1
, enum tree_code code
)
3583 tree op0_type
= TREE_TYPE (op0
);
3584 tree op1_type
= TREE_TYPE (op1
);
3586 if (!is_gimple_val (op0
) || !is_gimple_val (op1
))
3588 error ("invalid operands in gimple comparison");
3592 /* For comparisons we do not have the operations type as the
3593 effective type the comparison is carried out in. Instead
3594 we require that either the first operand is trivially
3595 convertible into the second, or the other way around.
3596 Because we special-case pointers to void we allow
3597 comparisons of pointers with the same mode as well. */
3598 if (!useless_type_conversion_p (op0_type
, op1_type
)
3599 && !useless_type_conversion_p (op1_type
, op0_type
)
3600 && (!POINTER_TYPE_P (op0_type
)
3601 || !POINTER_TYPE_P (op1_type
)
3602 || TYPE_MODE (op0_type
) != TYPE_MODE (op1_type
)))
3604 error ("mismatching comparison operand types");
3605 debug_generic_expr (op0_type
);
3606 debug_generic_expr (op1_type
);
3610 /* The resulting type of a comparison may be an effective boolean type. */
3611 if (INTEGRAL_TYPE_P (type
)
3612 && (TREE_CODE (type
) == BOOLEAN_TYPE
3613 || TYPE_PRECISION (type
) == 1))
3615 if ((TREE_CODE (op0_type
) == VECTOR_TYPE
3616 || TREE_CODE (op1_type
) == VECTOR_TYPE
)
3617 && code
!= EQ_EXPR
&& code
!= NE_EXPR
3618 && !VECTOR_BOOLEAN_TYPE_P (op0_type
)
3619 && !VECTOR_INTEGER_TYPE_P (op0_type
))
3621 error ("unsupported operation or type for vector comparison"
3622 " returning a boolean");
3623 debug_generic_expr (op0_type
);
3624 debug_generic_expr (op1_type
);
3628 /* Or a boolean vector type with the same element count
3629 as the comparison operand types. */
3630 else if (TREE_CODE (type
) == VECTOR_TYPE
3631 && TREE_CODE (TREE_TYPE (type
)) == BOOLEAN_TYPE
)
3633 if (TREE_CODE (op0_type
) != VECTOR_TYPE
3634 || TREE_CODE (op1_type
) != VECTOR_TYPE
)
3636 error ("non-vector operands in vector comparison");
3637 debug_generic_expr (op0_type
);
3638 debug_generic_expr (op1_type
);
3642 if (TYPE_VECTOR_SUBPARTS (type
) != TYPE_VECTOR_SUBPARTS (op0_type
))
3644 error ("invalid vector comparison resulting type");
3645 debug_generic_expr (type
);
3651 error ("bogus comparison result type");
3652 debug_generic_expr (type
);
3659 /* Verify a gimple assignment statement STMT with an unary rhs.
3660 Returns true if anything is wrong. */
3663 verify_gimple_assign_unary (gassign
*stmt
)
3665 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3666 tree lhs
= gimple_assign_lhs (stmt
);
3667 tree lhs_type
= TREE_TYPE (lhs
);
3668 tree rhs1
= gimple_assign_rhs1 (stmt
);
3669 tree rhs1_type
= TREE_TYPE (rhs1
);
3671 if (!is_gimple_reg (lhs
))
3673 error ("non-register as LHS of unary operation");
3677 if (!is_gimple_val (rhs1
))
3679 error ("invalid operand in unary operation");
3683 /* First handle conversions. */
3688 /* Allow conversions from pointer type to integral type only if
3689 there is no sign or zero extension involved.
3690 For targets were the precision of ptrofftype doesn't match that
3691 of pointers we need to allow arbitrary conversions to ptrofftype. */
3692 if ((POINTER_TYPE_P (lhs_type
)
3693 && INTEGRAL_TYPE_P (rhs1_type
))
3694 || (POINTER_TYPE_P (rhs1_type
)
3695 && INTEGRAL_TYPE_P (lhs_type
)
3696 && (TYPE_PRECISION (rhs1_type
) >= TYPE_PRECISION (lhs_type
)
3697 || ptrofftype_p (sizetype
))))
3700 /* Allow conversion from integral to offset type and vice versa. */
3701 if ((TREE_CODE (lhs_type
) == OFFSET_TYPE
3702 && INTEGRAL_TYPE_P (rhs1_type
))
3703 || (INTEGRAL_TYPE_P (lhs_type
)
3704 && TREE_CODE (rhs1_type
) == OFFSET_TYPE
))
3707 /* Otherwise assert we are converting between types of the
3709 if (INTEGRAL_TYPE_P (lhs_type
) != INTEGRAL_TYPE_P (rhs1_type
))
3711 error ("invalid types in nop conversion");
3712 debug_generic_expr (lhs_type
);
3713 debug_generic_expr (rhs1_type
);
3720 case ADDR_SPACE_CONVERT_EXPR
:
3722 if (!POINTER_TYPE_P (rhs1_type
) || !POINTER_TYPE_P (lhs_type
)
3723 || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type
))
3724 == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type
))))
3726 error ("invalid types in address space conversion");
3727 debug_generic_expr (lhs_type
);
3728 debug_generic_expr (rhs1_type
);
3735 case FIXED_CONVERT_EXPR
:
3737 if (!valid_fixed_convert_types_p (lhs_type
, rhs1_type
)
3738 && !valid_fixed_convert_types_p (rhs1_type
, lhs_type
))
3740 error ("invalid types in fixed-point conversion");
3741 debug_generic_expr (lhs_type
);
3742 debug_generic_expr (rhs1_type
);
3751 if ((!INTEGRAL_TYPE_P (rhs1_type
) || !SCALAR_FLOAT_TYPE_P (lhs_type
))
3752 && (!VECTOR_INTEGER_TYPE_P (rhs1_type
)
3753 || !VECTOR_FLOAT_TYPE_P (lhs_type
)))
3755 error ("invalid types in conversion to floating point");
3756 debug_generic_expr (lhs_type
);
3757 debug_generic_expr (rhs1_type
);
3764 case FIX_TRUNC_EXPR
:
3766 if ((!INTEGRAL_TYPE_P (lhs_type
) || !SCALAR_FLOAT_TYPE_P (rhs1_type
))
3767 && (!VECTOR_INTEGER_TYPE_P (lhs_type
)
3768 || !VECTOR_FLOAT_TYPE_P (rhs1_type
)))
3770 error ("invalid types in conversion to integer");
3771 debug_generic_expr (lhs_type
);
3772 debug_generic_expr (rhs1_type
);
3778 case REDUC_MAX_EXPR
:
3779 case REDUC_MIN_EXPR
:
3780 case REDUC_PLUS_EXPR
:
3781 if (!VECTOR_TYPE_P (rhs1_type
)
3782 || !useless_type_conversion_p (lhs_type
, TREE_TYPE (rhs1_type
)))
3784 error ("reduction should convert from vector to element type");
3785 debug_generic_expr (lhs_type
);
3786 debug_generic_expr (rhs1_type
);
3791 case VEC_UNPACK_HI_EXPR
:
3792 case VEC_UNPACK_LO_EXPR
:
3793 case VEC_UNPACK_FLOAT_HI_EXPR
:
3794 case VEC_UNPACK_FLOAT_LO_EXPR
:
3809 /* For the remaining codes assert there is no conversion involved. */
3810 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3812 error ("non-trivial conversion in unary operation");
3813 debug_generic_expr (lhs_type
);
3814 debug_generic_expr (rhs1_type
);
3821 /* Verify a gimple assignment statement STMT with a binary rhs.
3822 Returns true if anything is wrong. */
3825 verify_gimple_assign_binary (gassign
*stmt
)
3827 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3828 tree lhs
= gimple_assign_lhs (stmt
);
3829 tree lhs_type
= TREE_TYPE (lhs
);
3830 tree rhs1
= gimple_assign_rhs1 (stmt
);
3831 tree rhs1_type
= TREE_TYPE (rhs1
);
3832 tree rhs2
= gimple_assign_rhs2 (stmt
);
3833 tree rhs2_type
= TREE_TYPE (rhs2
);
3835 if (!is_gimple_reg (lhs
))
3837 error ("non-register as LHS of binary operation");
3841 if (!is_gimple_val (rhs1
)
3842 || !is_gimple_val (rhs2
))
3844 error ("invalid operands in binary operation");
3848 /* First handle operations that involve different types. */
3853 if (TREE_CODE (lhs_type
) != COMPLEX_TYPE
3854 || !(INTEGRAL_TYPE_P (rhs1_type
)
3855 || SCALAR_FLOAT_TYPE_P (rhs1_type
))
3856 || !(INTEGRAL_TYPE_P (rhs2_type
)
3857 || SCALAR_FLOAT_TYPE_P (rhs2_type
)))
3859 error ("type mismatch in complex expression");
3860 debug_generic_expr (lhs_type
);
3861 debug_generic_expr (rhs1_type
);
3862 debug_generic_expr (rhs2_type
);
3874 /* Shifts and rotates are ok on integral types, fixed point
3875 types and integer vector types. */
3876 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3877 && !FIXED_POINT_TYPE_P (rhs1_type
)
3878 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3879 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))))
3880 || (!INTEGRAL_TYPE_P (rhs2_type
)
3881 /* Vector shifts of vectors are also ok. */
3882 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3883 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3884 && TREE_CODE (rhs2_type
) == VECTOR_TYPE
3885 && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3886 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3888 error ("type mismatch in shift expression");
3889 debug_generic_expr (lhs_type
);
3890 debug_generic_expr (rhs1_type
);
3891 debug_generic_expr (rhs2_type
);
3898 case WIDEN_LSHIFT_EXPR
:
3900 if (!INTEGRAL_TYPE_P (lhs_type
)
3901 || !INTEGRAL_TYPE_P (rhs1_type
)
3902 || TREE_CODE (rhs2
) != INTEGER_CST
3903 || (2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)))
3905 error ("type mismatch in widening vector shift expression");
3906 debug_generic_expr (lhs_type
);
3907 debug_generic_expr (rhs1_type
);
3908 debug_generic_expr (rhs2_type
);
3915 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3916 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3918 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3919 || TREE_CODE (lhs_type
) != VECTOR_TYPE
3920 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3921 || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3922 || TREE_CODE (rhs2
) != INTEGER_CST
3923 || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type
))
3924 > TYPE_PRECISION (TREE_TYPE (lhs_type
))))
3926 error ("type mismatch in widening vector shift expression");
3927 debug_generic_expr (lhs_type
);
3928 debug_generic_expr (rhs1_type
);
3929 debug_generic_expr (rhs2_type
);
3939 tree lhs_etype
= lhs_type
;
3940 tree rhs1_etype
= rhs1_type
;
3941 tree rhs2_etype
= rhs2_type
;
3942 if (TREE_CODE (lhs_type
) == VECTOR_TYPE
)
3944 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3945 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
)
3947 error ("invalid non-vector operands to vector valued plus");
3950 lhs_etype
= TREE_TYPE (lhs_type
);
3951 rhs1_etype
= TREE_TYPE (rhs1_type
);
3952 rhs2_etype
= TREE_TYPE (rhs2_type
);
3954 if (POINTER_TYPE_P (lhs_etype
)
3955 || POINTER_TYPE_P (rhs1_etype
)
3956 || POINTER_TYPE_P (rhs2_etype
))
3958 error ("invalid (pointer) operands to plus/minus");
3962 /* Continue with generic binary expression handling. */
3966 case POINTER_PLUS_EXPR
:
3968 if (!POINTER_TYPE_P (rhs1_type
)
3969 || !useless_type_conversion_p (lhs_type
, rhs1_type
)
3970 || !ptrofftype_p (rhs2_type
))
3972 error ("type mismatch in pointer plus expression");
3973 debug_generic_stmt (lhs_type
);
3974 debug_generic_stmt (rhs1_type
);
3975 debug_generic_stmt (rhs2_type
);
3982 case TRUTH_ANDIF_EXPR
:
3983 case TRUTH_ORIF_EXPR
:
3984 case TRUTH_AND_EXPR
:
3986 case TRUTH_XOR_EXPR
:
3996 case UNORDERED_EXPR
:
4004 /* Comparisons are also binary, but the result type is not
4005 connected to the operand types. */
4006 return verify_gimple_comparison (lhs_type
, rhs1
, rhs2
, rhs_code
);
4008 case WIDEN_MULT_EXPR
:
4009 if (TREE_CODE (lhs_type
) != INTEGER_TYPE
)
4011 return ((2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
))
4012 || (TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
)));
4014 case WIDEN_SUM_EXPR
:
4015 case VEC_WIDEN_MULT_HI_EXPR
:
4016 case VEC_WIDEN_MULT_LO_EXPR
:
4017 case VEC_WIDEN_MULT_EVEN_EXPR
:
4018 case VEC_WIDEN_MULT_ODD_EXPR
:
4019 case VEC_PACK_TRUNC_EXPR
:
4020 case VEC_PACK_SAT_EXPR
:
4021 case VEC_PACK_FIX_TRUNC_EXPR
:
4026 case MULT_HIGHPART_EXPR
:
4027 case TRUNC_DIV_EXPR
:
4029 case FLOOR_DIV_EXPR
:
4030 case ROUND_DIV_EXPR
:
4031 case TRUNC_MOD_EXPR
:
4033 case FLOOR_MOD_EXPR
:
4034 case ROUND_MOD_EXPR
:
4036 case EXACT_DIV_EXPR
:
4042 /* Continue with generic binary expression handling. */
4049 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
4050 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
4052 error ("type mismatch in binary expression");
4053 debug_generic_stmt (lhs_type
);
4054 debug_generic_stmt (rhs1_type
);
4055 debug_generic_stmt (rhs2_type
);
4062 /* Verify a gimple assignment statement STMT with a ternary rhs.
4063 Returns true if anything is wrong. */
4066 verify_gimple_assign_ternary (gassign
*stmt
)
4068 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
4069 tree lhs
= gimple_assign_lhs (stmt
);
4070 tree lhs_type
= TREE_TYPE (lhs
);
4071 tree rhs1
= gimple_assign_rhs1 (stmt
);
4072 tree rhs1_type
= TREE_TYPE (rhs1
);
4073 tree rhs2
= gimple_assign_rhs2 (stmt
);
4074 tree rhs2_type
= TREE_TYPE (rhs2
);
4075 tree rhs3
= gimple_assign_rhs3 (stmt
);
4076 tree rhs3_type
= TREE_TYPE (rhs3
);
4078 if (!is_gimple_reg (lhs
))
4080 error ("non-register as LHS of ternary operation");
4084 if (((rhs_code
== VEC_COND_EXPR
|| rhs_code
== COND_EXPR
)
4085 ? !is_gimple_condexpr (rhs1
) : !is_gimple_val (rhs1
))
4086 || !is_gimple_val (rhs2
)
4087 || !is_gimple_val (rhs3
))
4089 error ("invalid operands in ternary operation");
4093 /* First handle operations that involve different types. */
4096 case WIDEN_MULT_PLUS_EXPR
:
4097 case WIDEN_MULT_MINUS_EXPR
:
4098 if ((!INTEGRAL_TYPE_P (rhs1_type
)
4099 && !FIXED_POINT_TYPE_P (rhs1_type
))
4100 || !useless_type_conversion_p (rhs1_type
, rhs2_type
)
4101 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
4102 || 2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)
4103 || TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
))
4105 error ("type mismatch in widening multiply-accumulate expression");
4106 debug_generic_expr (lhs_type
);
4107 debug_generic_expr (rhs1_type
);
4108 debug_generic_expr (rhs2_type
);
4109 debug_generic_expr (rhs3_type
);
4115 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
4116 || !useless_type_conversion_p (lhs_type
, rhs2_type
)
4117 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
4119 error ("type mismatch in fused multiply-add expression");
4120 debug_generic_expr (lhs_type
);
4121 debug_generic_expr (rhs1_type
);
4122 debug_generic_expr (rhs2_type
);
4123 debug_generic_expr (rhs3_type
);
4129 if (!VECTOR_BOOLEAN_TYPE_P (rhs1_type
)
4130 || TYPE_VECTOR_SUBPARTS (rhs1_type
)
4131 != TYPE_VECTOR_SUBPARTS (lhs_type
))
4133 error ("the first argument of a VEC_COND_EXPR must be of a "
4134 "boolean vector type of the same number of elements "
4136 debug_generic_expr (lhs_type
);
4137 debug_generic_expr (rhs1_type
);
4142 if (!useless_type_conversion_p (lhs_type
, rhs2_type
)
4143 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
4145 error ("type mismatch in conditional expression");
4146 debug_generic_expr (lhs_type
);
4147 debug_generic_expr (rhs2_type
);
4148 debug_generic_expr (rhs3_type
);
4154 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
4155 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
4157 error ("type mismatch in vector permute expression");
4158 debug_generic_expr (lhs_type
);
4159 debug_generic_expr (rhs1_type
);
4160 debug_generic_expr (rhs2_type
);
4161 debug_generic_expr (rhs3_type
);
4165 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4166 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
4167 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
4169 error ("vector types expected in vector permute expression");
4170 debug_generic_expr (lhs_type
);
4171 debug_generic_expr (rhs1_type
);
4172 debug_generic_expr (rhs2_type
);
4173 debug_generic_expr (rhs3_type
);
4177 if (TYPE_VECTOR_SUBPARTS (rhs1_type
) != TYPE_VECTOR_SUBPARTS (rhs2_type
)
4178 || TYPE_VECTOR_SUBPARTS (rhs2_type
)
4179 != TYPE_VECTOR_SUBPARTS (rhs3_type
)
4180 || TYPE_VECTOR_SUBPARTS (rhs3_type
)
4181 != TYPE_VECTOR_SUBPARTS (lhs_type
))
4183 error ("vectors with different element number found "
4184 "in vector permute expression");
4185 debug_generic_expr (lhs_type
);
4186 debug_generic_expr (rhs1_type
);
4187 debug_generic_expr (rhs2_type
);
4188 debug_generic_expr (rhs3_type
);
4192 if (TREE_CODE (TREE_TYPE (rhs3_type
)) != INTEGER_TYPE
4193 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs3_type
)))
4194 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type
))))
4196 error ("invalid mask type in vector permute expression");
4197 debug_generic_expr (lhs_type
);
4198 debug_generic_expr (rhs1_type
);
4199 debug_generic_expr (rhs2_type
);
4200 debug_generic_expr (rhs3_type
);
4207 if (!useless_type_conversion_p (rhs1_type
, rhs2_type
)
4208 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
4209 || 2 * GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type
)))
4210 > GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (lhs_type
))))
4212 error ("type mismatch in sad expression");
4213 debug_generic_expr (lhs_type
);
4214 debug_generic_expr (rhs1_type
);
4215 debug_generic_expr (rhs2_type
);
4216 debug_generic_expr (rhs3_type
);
4220 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4221 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
4222 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
4224 error ("vector types expected in sad expression");
4225 debug_generic_expr (lhs_type
);
4226 debug_generic_expr (rhs1_type
);
4227 debug_generic_expr (rhs2_type
);
4228 debug_generic_expr (rhs3_type
);
4234 case BIT_INSERT_EXPR
:
4235 if (! useless_type_conversion_p (lhs_type
, rhs1_type
))
4237 error ("type mismatch in BIT_INSERT_EXPR");
4238 debug_generic_expr (lhs_type
);
4239 debug_generic_expr (rhs1_type
);
4242 if (! ((INTEGRAL_TYPE_P (rhs1_type
)
4243 && INTEGRAL_TYPE_P (rhs2_type
))
4244 || (VECTOR_TYPE_P (rhs1_type
)
4245 && types_compatible_p (TREE_TYPE (rhs1_type
), rhs2_type
))))
4247 error ("not allowed type combination in BIT_INSERT_EXPR");
4248 debug_generic_expr (rhs1_type
);
4249 debug_generic_expr (rhs2_type
);
4252 if (! tree_fits_uhwi_p (rhs3
)
4253 || ! types_compatible_p (bitsizetype
, TREE_TYPE (rhs3
))
4254 || ! tree_fits_uhwi_p (TYPE_SIZE (rhs2_type
)))
4256 error ("invalid position or size in BIT_INSERT_EXPR");
4259 if (INTEGRAL_TYPE_P (rhs1_type
))
4261 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (rhs3
);
4262 if (bitpos
>= TYPE_PRECISION (rhs1_type
)
4263 || (bitpos
+ TYPE_PRECISION (rhs2_type
)
4264 > TYPE_PRECISION (rhs1_type
)))
4266 error ("insertion out of range in BIT_INSERT_EXPR");
4270 else if (VECTOR_TYPE_P (rhs1_type
))
4272 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (rhs3
);
4273 unsigned HOST_WIDE_INT bitsize
= tree_to_uhwi (TYPE_SIZE (rhs2_type
));
4274 if (bitpos
% bitsize
!= 0)
4276 error ("vector insertion not at element boundary");
4283 case REALIGN_LOAD_EXPR
:
4293 /* Verify a gimple assignment statement STMT with a single rhs.
4294 Returns true if anything is wrong. */
4297 verify_gimple_assign_single (gassign
*stmt
)
4299 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
4300 tree lhs
= gimple_assign_lhs (stmt
);
4301 tree lhs_type
= TREE_TYPE (lhs
);
4302 tree rhs1
= gimple_assign_rhs1 (stmt
);
4303 tree rhs1_type
= TREE_TYPE (rhs1
);
4306 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
4308 error ("non-trivial conversion at assignment");
4309 debug_generic_expr (lhs_type
);
4310 debug_generic_expr (rhs1_type
);
4314 if (gimple_clobber_p (stmt
)
4315 && !(DECL_P (lhs
) || TREE_CODE (lhs
) == MEM_REF
))
4317 error ("non-decl/MEM_REF LHS in clobber statement");
4318 debug_generic_expr (lhs
);
4322 if (handled_component_p (lhs
)
4323 || TREE_CODE (lhs
) == MEM_REF
4324 || TREE_CODE (lhs
) == TARGET_MEM_REF
)
4325 res
|= verify_types_in_gimple_reference (lhs
, true);
4327 /* Special codes we cannot handle via their class. */
4332 tree op
= TREE_OPERAND (rhs1
, 0);
4333 if (!is_gimple_addressable (op
))
4335 error ("invalid operand in unary expression");
4339 /* Technically there is no longer a need for matching types, but
4340 gimple hygiene asks for this check. In LTO we can end up
4341 combining incompatible units and thus end up with addresses
4342 of globals that change their type to a common one. */
4344 && !types_compatible_p (TREE_TYPE (op
),
4345 TREE_TYPE (TREE_TYPE (rhs1
)))
4346 && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1
),
4349 error ("type mismatch in address expression");
4350 debug_generic_stmt (TREE_TYPE (rhs1
));
4351 debug_generic_stmt (TREE_TYPE (op
));
4355 return verify_types_in_gimple_reference (op
, true);
4360 error ("INDIRECT_REF in gimple IL");
4366 case ARRAY_RANGE_REF
:
4367 case VIEW_CONVERT_EXPR
:
4370 case TARGET_MEM_REF
:
4372 if (!is_gimple_reg (lhs
)
4373 && is_gimple_reg_type (TREE_TYPE (lhs
)))
4375 error ("invalid rhs for gimple memory store");
4376 debug_generic_stmt (lhs
);
4377 debug_generic_stmt (rhs1
);
4380 return res
|| verify_types_in_gimple_reference (rhs1
, false);
4392 /* tcc_declaration */
4397 if (!is_gimple_reg (lhs
)
4398 && !is_gimple_reg (rhs1
)
4399 && is_gimple_reg_type (TREE_TYPE (lhs
)))
4401 error ("invalid rhs for gimple memory store");
4402 debug_generic_stmt (lhs
);
4403 debug_generic_stmt (rhs1
);
4409 if (TREE_CODE (rhs1_type
) == VECTOR_TYPE
)
4412 tree elt_i
, elt_v
, elt_t
= NULL_TREE
;
4414 if (CONSTRUCTOR_NELTS (rhs1
) == 0)
4416 /* For vector CONSTRUCTORs we require that either it is empty
4417 CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
4418 (then the element count must be correct to cover the whole
4419 outer vector and index must be NULL on all elements, or it is
4420 a CONSTRUCTOR of scalar elements, where we as an exception allow
4421 smaller number of elements (assuming zero filling) and
4422 consecutive indexes as compared to NULL indexes (such
4423 CONSTRUCTORs can appear in the IL from FEs). */
4424 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1
), i
, elt_i
, elt_v
)
4426 if (elt_t
== NULL_TREE
)
4428 elt_t
= TREE_TYPE (elt_v
);
4429 if (TREE_CODE (elt_t
) == VECTOR_TYPE
)
4431 tree elt_t
= TREE_TYPE (elt_v
);
4432 if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
4435 error ("incorrect type of vector CONSTRUCTOR"
4437 debug_generic_stmt (rhs1
);
4440 else if (CONSTRUCTOR_NELTS (rhs1
)
4441 * TYPE_VECTOR_SUBPARTS (elt_t
)
4442 != TYPE_VECTOR_SUBPARTS (rhs1_type
))
4444 error ("incorrect number of vector CONSTRUCTOR"
4446 debug_generic_stmt (rhs1
);
4450 else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
4453 error ("incorrect type of vector CONSTRUCTOR elements");
4454 debug_generic_stmt (rhs1
);
4457 else if (CONSTRUCTOR_NELTS (rhs1
)
4458 > TYPE_VECTOR_SUBPARTS (rhs1_type
))
4460 error ("incorrect number of vector CONSTRUCTOR elements");
4461 debug_generic_stmt (rhs1
);
4465 else if (!useless_type_conversion_p (elt_t
, TREE_TYPE (elt_v
)))
4467 error ("incorrect type of vector CONSTRUCTOR elements");
4468 debug_generic_stmt (rhs1
);
4471 if (elt_i
!= NULL_TREE
4472 && (TREE_CODE (elt_t
) == VECTOR_TYPE
4473 || TREE_CODE (elt_i
) != INTEGER_CST
4474 || compare_tree_int (elt_i
, i
) != 0))
4476 error ("vector CONSTRUCTOR with non-NULL element index");
4477 debug_generic_stmt (rhs1
);
4480 if (!is_gimple_val (elt_v
))
4482 error ("vector CONSTRUCTOR element is not a GIMPLE value");
4483 debug_generic_stmt (rhs1
);
4488 else if (CONSTRUCTOR_NELTS (rhs1
) != 0)
4490 error ("non-vector CONSTRUCTOR with elements");
4491 debug_generic_stmt (rhs1
);
4497 case WITH_SIZE_EXPR
:
4507 /* Verify the contents of a GIMPLE_ASSIGN STMT. Returns true when there
4508 is a problem, otherwise false. */
4511 verify_gimple_assign (gassign
*stmt
)
4513 switch (gimple_assign_rhs_class (stmt
))
4515 case GIMPLE_SINGLE_RHS
:
4516 return verify_gimple_assign_single (stmt
);
4518 case GIMPLE_UNARY_RHS
:
4519 return verify_gimple_assign_unary (stmt
);
4521 case GIMPLE_BINARY_RHS
:
4522 return verify_gimple_assign_binary (stmt
);
4524 case GIMPLE_TERNARY_RHS
:
4525 return verify_gimple_assign_ternary (stmt
);
4532 /* Verify the contents of a GIMPLE_RETURN STMT. Returns true when there
4533 is a problem, otherwise false. */
4536 verify_gimple_return (greturn
*stmt
)
4538 tree op
= gimple_return_retval (stmt
);
4539 tree restype
= TREE_TYPE (TREE_TYPE (cfun
->decl
));
4541 /* We cannot test for present return values as we do not fix up missing
4542 return values from the original source. */
4546 if (!is_gimple_val (op
)
4547 && TREE_CODE (op
) != RESULT_DECL
)
4549 error ("invalid operand in return statement");
4550 debug_generic_stmt (op
);
4554 if ((TREE_CODE (op
) == RESULT_DECL
4555 && DECL_BY_REFERENCE (op
))
4556 || (TREE_CODE (op
) == SSA_NAME
4557 && SSA_NAME_VAR (op
)
4558 && TREE_CODE (SSA_NAME_VAR (op
)) == RESULT_DECL
4559 && DECL_BY_REFERENCE (SSA_NAME_VAR (op
))))
4560 op
= TREE_TYPE (op
);
4562 if (!useless_type_conversion_p (restype
, TREE_TYPE (op
)))
4564 error ("invalid conversion in return statement");
4565 debug_generic_stmt (restype
);
4566 debug_generic_stmt (TREE_TYPE (op
));
4574 /* Verify the contents of a GIMPLE_GOTO STMT. Returns true when there
4575 is a problem, otherwise false. */
4578 verify_gimple_goto (ggoto
*stmt
)
4580 tree dest
= gimple_goto_dest (stmt
);
4582 /* ??? We have two canonical forms of direct goto destinations, a
4583 bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
4584 if (TREE_CODE (dest
) != LABEL_DECL
4585 && (!is_gimple_val (dest
)
4586 || !POINTER_TYPE_P (TREE_TYPE (dest
))))
4588 error ("goto destination is neither a label nor a pointer");
4595 /* Verify the contents of a GIMPLE_SWITCH STMT. Returns true when there
4596 is a problem, otherwise false. */
4599 verify_gimple_switch (gswitch
*stmt
)
4602 tree elt
, prev_upper_bound
= NULL_TREE
;
4603 tree index_type
, elt_type
= NULL_TREE
;
4605 if (!is_gimple_val (gimple_switch_index (stmt
)))
4607 error ("invalid operand to switch statement");
4608 debug_generic_stmt (gimple_switch_index (stmt
));
4612 index_type
= TREE_TYPE (gimple_switch_index (stmt
));
4613 if (! INTEGRAL_TYPE_P (index_type
))
4615 error ("non-integral type switch statement");
4616 debug_generic_expr (index_type
);
4620 elt
= gimple_switch_label (stmt
, 0);
4621 if (CASE_LOW (elt
) != NULL_TREE
|| CASE_HIGH (elt
) != NULL_TREE
)
4623 error ("invalid default case label in switch statement");
4624 debug_generic_expr (elt
);
4628 n
= gimple_switch_num_labels (stmt
);
4629 for (i
= 1; i
< n
; i
++)
4631 elt
= gimple_switch_label (stmt
, i
);
4633 if (! CASE_LOW (elt
))
4635 error ("invalid case label in switch statement");
4636 debug_generic_expr (elt
);
4640 && ! tree_int_cst_lt (CASE_LOW (elt
), CASE_HIGH (elt
)))
4642 error ("invalid case range in switch statement");
4643 debug_generic_expr (elt
);
4649 if (TREE_TYPE (CASE_LOW (elt
)) != elt_type
4650 || (CASE_HIGH (elt
) && TREE_TYPE (CASE_HIGH (elt
)) != elt_type
))
4652 error ("type mismatch for case label in switch statement");
4653 debug_generic_expr (elt
);
4659 elt_type
= TREE_TYPE (CASE_LOW (elt
));
4660 if (TYPE_PRECISION (index_type
) < TYPE_PRECISION (elt_type
))
4662 error ("type precision mismatch in switch statement");
4667 if (prev_upper_bound
)
4669 if (! tree_int_cst_lt (prev_upper_bound
, CASE_LOW (elt
)))
4671 error ("case labels not sorted in switch statement");
4676 prev_upper_bound
= CASE_HIGH (elt
);
4677 if (! prev_upper_bound
)
4678 prev_upper_bound
= CASE_LOW (elt
);
4684 /* Verify a gimple debug statement STMT.
4685 Returns true if anything is wrong. */
4688 verify_gimple_debug (gimple
*stmt ATTRIBUTE_UNUSED
)
4690 /* There isn't much that could be wrong in a gimple debug stmt. A
4691 gimple debug bind stmt, for example, maps a tree, that's usually
4692 a VAR_DECL or a PARM_DECL, but that could also be some scalarized
4693 component or member of an aggregate type, to another tree, that
4694 can be an arbitrary expression. These stmts expand into debug
4695 insns, and are converted to debug notes by var-tracking.c. */
4699 /* Verify a gimple label statement STMT.
4700 Returns true if anything is wrong. */
4703 verify_gimple_label (glabel
*stmt
)
4705 tree decl
= gimple_label_label (stmt
);
4709 if (TREE_CODE (decl
) != LABEL_DECL
)
4711 if (!DECL_NONLOCAL (decl
) && !FORCED_LABEL (decl
)
4712 && DECL_CONTEXT (decl
) != current_function_decl
)
4714 error ("label's context is not the current function decl");
4718 uid
= LABEL_DECL_UID (decl
);
4721 || (*label_to_block_map_for_fn (cfun
))[uid
] != gimple_bb (stmt
)))
4723 error ("incorrect entry in label_to_block_map");
4727 uid
= EH_LANDING_PAD_NR (decl
);
4730 eh_landing_pad lp
= get_eh_landing_pad_from_number (uid
);
4731 if (decl
!= lp
->post_landing_pad
)
4733 error ("incorrect setting of landing pad number");
4741 /* Verify a gimple cond statement STMT.
4742 Returns true if anything is wrong. */
4745 verify_gimple_cond (gcond
*stmt
)
4747 if (TREE_CODE_CLASS (gimple_cond_code (stmt
)) != tcc_comparison
)
4749 error ("invalid comparison code in gimple cond");
4752 if (!(!gimple_cond_true_label (stmt
)
4753 || TREE_CODE (gimple_cond_true_label (stmt
)) == LABEL_DECL
)
4754 || !(!gimple_cond_false_label (stmt
)
4755 || TREE_CODE (gimple_cond_false_label (stmt
)) == LABEL_DECL
))
4757 error ("invalid labels in gimple cond");
4761 return verify_gimple_comparison (boolean_type_node
,
4762 gimple_cond_lhs (stmt
),
4763 gimple_cond_rhs (stmt
),
4764 gimple_cond_code (stmt
));
4767 /* Verify the GIMPLE statement STMT. Returns true if there is an
4768 error, otherwise false. */
4771 verify_gimple_stmt (gimple
*stmt
)
4773 switch (gimple_code (stmt
))
4776 return verify_gimple_assign (as_a
<gassign
*> (stmt
));
4779 return verify_gimple_label (as_a
<glabel
*> (stmt
));
4782 return verify_gimple_call (as_a
<gcall
*> (stmt
));
4785 return verify_gimple_cond (as_a
<gcond
*> (stmt
));
4788 return verify_gimple_goto (as_a
<ggoto
*> (stmt
));
4791 return verify_gimple_switch (as_a
<gswitch
*> (stmt
));
4794 return verify_gimple_return (as_a
<greturn
*> (stmt
));
4799 case GIMPLE_TRANSACTION
:
4800 return verify_gimple_transaction (as_a
<gtransaction
*> (stmt
));
4802 /* Tuples that do not have tree operands. */
4804 case GIMPLE_PREDICT
:
4806 case GIMPLE_EH_DISPATCH
:
4807 case GIMPLE_EH_MUST_NOT_THROW
:
4811 /* OpenMP directives are validated by the FE and never operated
4812 on by the optimizers. Furthermore, GIMPLE_OMP_FOR may contain
4813 non-gimple expressions when the main index variable has had
4814 its address taken. This does not affect the loop itself
4815 because the header of an GIMPLE_OMP_FOR is merely used to determine
4816 how to setup the parallel iteration. */
4820 return verify_gimple_debug (stmt
);
4827 /* Verify the contents of a GIMPLE_PHI. Returns true if there is a problem,
4828 and false otherwise. */
4831 verify_gimple_phi (gimple
*phi
)
4835 tree phi_result
= gimple_phi_result (phi
);
4840 error ("invalid PHI result");
4844 virtual_p
= virtual_operand_p (phi_result
);
4845 if (TREE_CODE (phi_result
) != SSA_NAME
4847 && SSA_NAME_VAR (phi_result
) != gimple_vop (cfun
)))
4849 error ("invalid PHI result");
4853 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4855 tree t
= gimple_phi_arg_def (phi
, i
);
4859 error ("missing PHI def");
4863 /* Addressable variables do have SSA_NAMEs but they
4864 are not considered gimple values. */
4865 else if ((TREE_CODE (t
) == SSA_NAME
4866 && virtual_p
!= virtual_operand_p (t
))
4868 && (TREE_CODE (t
) != SSA_NAME
4869 || SSA_NAME_VAR (t
) != gimple_vop (cfun
)))
4871 && !is_gimple_val (t
)))
4873 error ("invalid PHI argument");
4874 debug_generic_expr (t
);
4877 #ifdef ENABLE_TYPES_CHECKING
4878 if (!useless_type_conversion_p (TREE_TYPE (phi_result
), TREE_TYPE (t
)))
4880 error ("incompatible types in PHI argument %u", i
);
4881 debug_generic_stmt (TREE_TYPE (phi_result
));
4882 debug_generic_stmt (TREE_TYPE (t
));
4891 /* Verify the GIMPLE statements inside the sequence STMTS. */
4894 verify_gimple_in_seq_2 (gimple_seq stmts
)
4896 gimple_stmt_iterator ittr
;
4899 for (ittr
= gsi_start (stmts
); !gsi_end_p (ittr
); gsi_next (&ittr
))
4901 gimple
*stmt
= gsi_stmt (ittr
);
4903 switch (gimple_code (stmt
))
4906 err
|= verify_gimple_in_seq_2 (
4907 gimple_bind_body (as_a
<gbind
*> (stmt
)));
4911 err
|= verify_gimple_in_seq_2 (gimple_try_eval (stmt
));
4912 err
|= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt
));
4915 case GIMPLE_EH_FILTER
:
4916 err
|= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt
));
4919 case GIMPLE_EH_ELSE
:
4921 geh_else
*eh_else
= as_a
<geh_else
*> (stmt
);
4922 err
|= verify_gimple_in_seq_2 (gimple_eh_else_n_body (eh_else
));
4923 err
|= verify_gimple_in_seq_2 (gimple_eh_else_e_body (eh_else
));
4928 err
|= verify_gimple_in_seq_2 (gimple_catch_handler (
4929 as_a
<gcatch
*> (stmt
)));
4932 case GIMPLE_TRANSACTION
:
4933 err
|= verify_gimple_transaction (as_a
<gtransaction
*> (stmt
));
4938 bool err2
= verify_gimple_stmt (stmt
);
4940 debug_gimple_stmt (stmt
);
4949 /* Verify the contents of a GIMPLE_TRANSACTION. Returns true if there
4950 is a problem, otherwise false. */
4953 verify_gimple_transaction (gtransaction
*stmt
)
4957 lab
= gimple_transaction_label_norm (stmt
);
4958 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
4960 lab
= gimple_transaction_label_uninst (stmt
);
4961 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
4963 lab
= gimple_transaction_label_over (stmt
);
4964 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
4967 return verify_gimple_in_seq_2 (gimple_transaction_body (stmt
));
4971 /* Verify the GIMPLE statements inside the statement list STMTS. */
4974 verify_gimple_in_seq (gimple_seq stmts
)
4976 timevar_push (TV_TREE_STMT_VERIFY
);
4977 if (verify_gimple_in_seq_2 (stmts
))
4978 internal_error ("verify_gimple failed");
4979 timevar_pop (TV_TREE_STMT_VERIFY
);
4982 /* Return true when the T can be shared. */
4985 tree_node_can_be_shared (tree t
)
4987 if (IS_TYPE_OR_DECL_P (t
)
4988 || is_gimple_min_invariant (t
)
4989 || TREE_CODE (t
) == SSA_NAME
4990 || t
== error_mark_node
4991 || TREE_CODE (t
) == IDENTIFIER_NODE
)
4994 if (TREE_CODE (t
) == CASE_LABEL_EXPR
)
5003 /* Called via walk_tree. Verify tree sharing. */
5006 verify_node_sharing_1 (tree
*tp
, int *walk_subtrees
, void *data
)
5008 hash_set
<void *> *visited
= (hash_set
<void *> *) data
;
5010 if (tree_node_can_be_shared (*tp
))
5012 *walk_subtrees
= false;
5016 if (visited
->add (*tp
))
5022 /* Called via walk_gimple_stmt. Verify tree sharing. */
5025 verify_node_sharing (tree
*tp
, int *walk_subtrees
, void *data
)
5027 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
5028 return verify_node_sharing_1 (tp
, walk_subtrees
, wi
->info
);
5031 static bool eh_error_found
;
5033 verify_eh_throw_stmt_node (gimple
*const &stmt
, const int &,
5034 hash_set
<gimple
*> *visited
)
5036 if (!visited
->contains (stmt
))
5038 error ("dead STMT in EH table");
5039 debug_gimple_stmt (stmt
);
5040 eh_error_found
= true;
5045 /* Verify if the location LOCs block is in BLOCKS. */
5048 verify_location (hash_set
<tree
> *blocks
, location_t loc
)
5050 tree block
= LOCATION_BLOCK (loc
);
5051 if (block
!= NULL_TREE
5052 && !blocks
->contains (block
))
5054 error ("location references block not in block tree");
5057 if (block
!= NULL_TREE
)
5058 return verify_location (blocks
, BLOCK_SOURCE_LOCATION (block
));
5062 /* Called via walk_tree. Verify that expressions have no blocks. */
5065 verify_expr_no_block (tree
*tp
, int *walk_subtrees
, void *)
5069 *walk_subtrees
= false;
5073 location_t loc
= EXPR_LOCATION (*tp
);
5074 if (LOCATION_BLOCK (loc
) != NULL
)
5080 /* Called via walk_tree. Verify locations of expressions. */
5083 verify_expr_location_1 (tree
*tp
, int *walk_subtrees
, void *data
)
5085 hash_set
<tree
> *blocks
= (hash_set
<tree
> *) data
;
5087 if (VAR_P (*tp
) && DECL_HAS_DEBUG_EXPR_P (*tp
))
5089 tree t
= DECL_DEBUG_EXPR (*tp
);
5090 tree addr
= walk_tree (&t
, verify_expr_no_block
, NULL
, NULL
);
5095 || TREE_CODE (*tp
) == PARM_DECL
5096 || TREE_CODE (*tp
) == RESULT_DECL
)
5097 && DECL_HAS_VALUE_EXPR_P (*tp
))
5099 tree t
= DECL_VALUE_EXPR (*tp
);
5100 tree addr
= walk_tree (&t
, verify_expr_no_block
, NULL
, NULL
);
5107 *walk_subtrees
= false;
5111 location_t loc
= EXPR_LOCATION (*tp
);
5112 if (verify_location (blocks
, loc
))
5118 /* Called via walk_gimple_op. Verify locations of expressions. */
5121 verify_expr_location (tree
*tp
, int *walk_subtrees
, void *data
)
5123 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
5124 return verify_expr_location_1 (tp
, walk_subtrees
, wi
->info
);
5127 /* Insert all subblocks of BLOCK into BLOCKS and recurse. */
5130 collect_subblocks (hash_set
<tree
> *blocks
, tree block
)
5133 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
5136 collect_subblocks (blocks
, t
);
5140 /* Verify the GIMPLE statements in the CFG of FN. */
5143 verify_gimple_in_cfg (struct function
*fn
, bool verify_nothrow
)
5148 timevar_push (TV_TREE_STMT_VERIFY
);
5149 hash_set
<void *> visited
;
5150 hash_set
<gimple
*> visited_stmts
;
5152 /* Collect all BLOCKs referenced by the BLOCK tree of FN. */
5153 hash_set
<tree
> blocks
;
5154 if (DECL_INITIAL (fn
->decl
))
5156 blocks
.add (DECL_INITIAL (fn
->decl
));
5157 collect_subblocks (&blocks
, DECL_INITIAL (fn
->decl
));
5160 FOR_EACH_BB_FN (bb
, fn
)
5162 gimple_stmt_iterator gsi
;
5164 for (gphi_iterator gpi
= gsi_start_phis (bb
);
5168 gphi
*phi
= gpi
.phi ();
5172 visited_stmts
.add (phi
);
5174 if (gimple_bb (phi
) != bb
)
5176 error ("gimple_bb (phi) is set to a wrong basic block");
5180 err2
|= verify_gimple_phi (phi
);
5182 /* Only PHI arguments have locations. */
5183 if (gimple_location (phi
) != UNKNOWN_LOCATION
)
5185 error ("PHI node with location");
5189 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
5191 tree arg
= gimple_phi_arg_def (phi
, i
);
5192 tree addr
= walk_tree (&arg
, verify_node_sharing_1
,
5196 error ("incorrect sharing of tree nodes");
5197 debug_generic_expr (addr
);
5200 location_t loc
= gimple_phi_arg_location (phi
, i
);
5201 if (virtual_operand_p (gimple_phi_result (phi
))
5202 && loc
!= UNKNOWN_LOCATION
)
5204 error ("virtual PHI with argument locations");
5207 addr
= walk_tree (&arg
, verify_expr_location_1
, &blocks
, NULL
);
5210 debug_generic_expr (addr
);
5213 err2
|= verify_location (&blocks
, loc
);
5217 debug_gimple_stmt (phi
);
5221 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5223 gimple
*stmt
= gsi_stmt (gsi
);
5225 struct walk_stmt_info wi
;
5229 visited_stmts
.add (stmt
);
5231 if (gimple_bb (stmt
) != bb
)
5233 error ("gimple_bb (stmt) is set to a wrong basic block");
5237 err2
|= verify_gimple_stmt (stmt
);
5238 err2
|= verify_location (&blocks
, gimple_location (stmt
));
5240 memset (&wi
, 0, sizeof (wi
));
5241 wi
.info
= (void *) &visited
;
5242 addr
= walk_gimple_op (stmt
, verify_node_sharing
, &wi
);
5245 error ("incorrect sharing of tree nodes");
5246 debug_generic_expr (addr
);
5250 memset (&wi
, 0, sizeof (wi
));
5251 wi
.info
= (void *) &blocks
;
5252 addr
= walk_gimple_op (stmt
, verify_expr_location
, &wi
);
5255 debug_generic_expr (addr
);
5259 /* ??? Instead of not checking these stmts at all the walker
5260 should know its context via wi. */
5261 if (!is_gimple_debug (stmt
)
5262 && !is_gimple_omp (stmt
))
5264 memset (&wi
, 0, sizeof (wi
));
5265 addr
= walk_gimple_op (stmt
, verify_expr
, &wi
);
5268 debug_generic_expr (addr
);
5269 inform (gimple_location (stmt
), "in statement");
5274 /* If the statement is marked as part of an EH region, then it is
5275 expected that the statement could throw. Verify that when we
5276 have optimizations that simplify statements such that we prove
5277 that they cannot throw, that we update other data structures
5279 lp_nr
= lookup_stmt_eh_lp (stmt
);
5282 if (!stmt_could_throw_p (stmt
))
5286 error ("statement marked for throw, but doesn%'t");
5290 else if (!gsi_one_before_end_p (gsi
))
5292 error ("statement marked for throw in middle of block");
5298 debug_gimple_stmt (stmt
);
5303 eh_error_found
= false;
5304 hash_map
<gimple
*, int> *eh_table
= get_eh_throw_stmt_table (cfun
);
5306 eh_table
->traverse
<hash_set
<gimple
*> *, verify_eh_throw_stmt_node
>
5309 if (err
|| eh_error_found
)
5310 internal_error ("verify_gimple failed");
5312 verify_histograms ();
5313 timevar_pop (TV_TREE_STMT_VERIFY
);
5317 /* Verifies that the flow information is OK. */
5320 gimple_verify_flow_info (void)
5324 gimple_stmt_iterator gsi
;
5329 if (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.seq
5330 || ENTRY_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.phi_nodes
)
5332 error ("ENTRY_BLOCK has IL associated with it");
5336 if (EXIT_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.seq
5337 || EXIT_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.phi_nodes
)
5339 error ("EXIT_BLOCK has IL associated with it");
5343 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5344 if (e
->flags
& EDGE_FALLTHRU
)
5346 error ("fallthru to exit from bb %d", e
->src
->index
);
5350 FOR_EACH_BB_FN (bb
, cfun
)
5352 bool found_ctrl_stmt
= false;
5356 /* Skip labels on the start of basic block. */
5357 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5360 gimple
*prev_stmt
= stmt
;
5362 stmt
= gsi_stmt (gsi
);
5364 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5367 label
= gimple_label_label (as_a
<glabel
*> (stmt
));
5368 if (prev_stmt
&& DECL_NONLOCAL (label
))
5370 error ("nonlocal label ");
5371 print_generic_expr (stderr
, label
);
5372 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
5377 if (prev_stmt
&& EH_LANDING_PAD_NR (label
) != 0)
5379 error ("EH landing pad label ");
5380 print_generic_expr (stderr
, label
);
5381 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
5386 if (label_to_block (label
) != bb
)
5389 print_generic_expr (stderr
, label
);
5390 fprintf (stderr
, " to block does not match in bb %d",
5395 if (decl_function_context (label
) != current_function_decl
)
5398 print_generic_expr (stderr
, label
);
5399 fprintf (stderr
, " has incorrect context in bb %d",
5405 /* Verify that body of basic block BB is free of control flow. */
5406 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5408 gimple
*stmt
= gsi_stmt (gsi
);
5410 if (found_ctrl_stmt
)
5412 error ("control flow in the middle of basic block %d",
5417 if (stmt_ends_bb_p (stmt
))
5418 found_ctrl_stmt
= true;
5420 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
5423 print_generic_expr (stderr
, gimple_label_label (label_stmt
));
5424 fprintf (stderr
, " in the middle of basic block %d", bb
->index
);
5429 gsi
= gsi_last_bb (bb
);
5430 if (gsi_end_p (gsi
))
5433 stmt
= gsi_stmt (gsi
);
5435 if (gimple_code (stmt
) == GIMPLE_LABEL
)
5438 err
|= verify_eh_edges (stmt
);
5440 if (is_ctrl_stmt (stmt
))
5442 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5443 if (e
->flags
& EDGE_FALLTHRU
)
5445 error ("fallthru edge after a control statement in bb %d",
5451 if (gimple_code (stmt
) != GIMPLE_COND
)
5453 /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
5454 after anything else but if statement. */
5455 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5456 if (e
->flags
& (EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
))
5458 error ("true/false edge after a non-GIMPLE_COND in bb %d",
5464 switch (gimple_code (stmt
))
5471 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
5475 || !(true_edge
->flags
& EDGE_TRUE_VALUE
)
5476 || !(false_edge
->flags
& EDGE_FALSE_VALUE
)
5477 || (true_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
5478 || (false_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
5479 || EDGE_COUNT (bb
->succs
) >= 3)
5481 error ("wrong outgoing edge flags at end of bb %d",
5489 if (simple_goto_p (stmt
))
5491 error ("explicit goto at end of bb %d", bb
->index
);
5496 /* FIXME. We should double check that the labels in the
5497 destination blocks have their address taken. */
5498 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5499 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_TRUE_VALUE
5500 | EDGE_FALSE_VALUE
))
5501 || !(e
->flags
& EDGE_ABNORMAL
))
5503 error ("wrong outgoing edge flags at end of bb %d",
5511 if (!gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
))
5515 if (!single_succ_p (bb
)
5516 || (single_succ_edge (bb
)->flags
5517 & (EDGE_FALLTHRU
| EDGE_ABNORMAL
5518 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5520 error ("wrong outgoing edge flags at end of bb %d", bb
->index
);
5523 if (single_succ (bb
) != EXIT_BLOCK_PTR_FOR_FN (cfun
))
5525 error ("return edge does not point to exit in bb %d",
5533 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
5538 n
= gimple_switch_num_labels (switch_stmt
);
5540 /* Mark all the destination basic blocks. */
5541 for (i
= 0; i
< n
; ++i
)
5543 tree lab
= CASE_LABEL (gimple_switch_label (switch_stmt
, i
));
5544 basic_block label_bb
= label_to_block (lab
);
5545 gcc_assert (!label_bb
->aux
|| label_bb
->aux
== (void *)1);
5546 label_bb
->aux
= (void *)1;
5549 /* Verify that the case labels are sorted. */
5550 prev
= gimple_switch_label (switch_stmt
, 0);
5551 for (i
= 1; i
< n
; ++i
)
5553 tree c
= gimple_switch_label (switch_stmt
, i
);
5556 error ("found default case not at the start of "
5562 && !tree_int_cst_lt (CASE_LOW (prev
), CASE_LOW (c
)))
5564 error ("case labels not sorted: ");
5565 print_generic_expr (stderr
, prev
);
5566 fprintf (stderr
," is greater than ");
5567 print_generic_expr (stderr
, c
);
5568 fprintf (stderr
," but comes before it.\n");
5573 /* VRP will remove the default case if it can prove it will
5574 never be executed. So do not verify there always exists
5575 a default case here. */
5577 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5581 error ("extra outgoing edge %d->%d",
5582 bb
->index
, e
->dest
->index
);
5586 e
->dest
->aux
= (void *)2;
5587 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
5588 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5590 error ("wrong outgoing edge flags at end of bb %d",
5596 /* Check that we have all of them. */
5597 for (i
= 0; i
< n
; ++i
)
5599 tree lab
= CASE_LABEL (gimple_switch_label (switch_stmt
, i
));
5600 basic_block label_bb
= label_to_block (lab
);
5602 if (label_bb
->aux
!= (void *)2)
5604 error ("missing edge %i->%i", bb
->index
, label_bb
->index
);
5609 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5610 e
->dest
->aux
= (void *)0;
5614 case GIMPLE_EH_DISPATCH
:
5615 err
|= verify_eh_dispatch_edge (as_a
<geh_dispatch
*> (stmt
));
5623 if (dom_info_state (CDI_DOMINATORS
) >= DOM_NO_FAST_QUERY
)
5624 verify_dominators (CDI_DOMINATORS
);
5630 /* Updates phi nodes after creating a forwarder block joined
5631 by edge FALLTHRU. */
5634 gimple_make_forwarder_block (edge fallthru
)
5638 basic_block dummy
, bb
;
5642 dummy
= fallthru
->src
;
5643 bb
= fallthru
->dest
;
5645 if (single_pred_p (bb
))
5648 /* If we redirected a branch we must create new PHI nodes at the
5650 for (gsi
= gsi_start_phis (dummy
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5652 gphi
*phi
, *new_phi
;
5655 var
= gimple_phi_result (phi
);
5656 new_phi
= create_phi_node (var
, bb
);
5657 gimple_phi_set_result (phi
, copy_ssa_name (var
, phi
));
5658 add_phi_arg (new_phi
, gimple_phi_result (phi
), fallthru
,
5662 /* Add the arguments we have stored on edges. */
5663 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
5668 flush_pending_stmts (e
);
5673 /* Return a non-special label in the head of basic block BLOCK.
5674 Create one if it doesn't exist. */
5677 gimple_block_label (basic_block bb
)
5679 gimple_stmt_iterator i
, s
= gsi_start_bb (bb
);
5684 for (i
= s
; !gsi_end_p (i
); first
= false, gsi_next (&i
))
5686 stmt
= dyn_cast
<glabel
*> (gsi_stmt (i
));
5689 label
= gimple_label_label (stmt
);
5690 if (!DECL_NONLOCAL (label
))
5693 gsi_move_before (&i
, &s
);
5698 label
= create_artificial_label (UNKNOWN_LOCATION
);
5699 stmt
= gimple_build_label (label
);
5700 gsi_insert_before (&s
, stmt
, GSI_NEW_STMT
);
5705 /* Attempt to perform edge redirection by replacing a possibly complex
5706 jump instruction by a goto or by removing the jump completely.
5707 This can apply only if all edges now point to the same block. The
5708 parameters and return values are equivalent to
5709 redirect_edge_and_branch. */
5712 gimple_try_redirect_by_replacing_jump (edge e
, basic_block target
)
5714 basic_block src
= e
->src
;
5715 gimple_stmt_iterator i
;
5718 /* We can replace or remove a complex jump only when we have exactly
5720 if (EDGE_COUNT (src
->succs
) != 2
5721 /* Verify that all targets will be TARGET. Specifically, the
5722 edge that is not E must also go to TARGET. */
5723 || EDGE_SUCC (src
, EDGE_SUCC (src
, 0) == e
)->dest
!= target
)
5726 i
= gsi_last_bb (src
);
5730 stmt
= gsi_stmt (i
);
5732 if (gimple_code (stmt
) == GIMPLE_COND
|| gimple_code (stmt
) == GIMPLE_SWITCH
)
5734 gsi_remove (&i
, true);
5735 e
= ssa_redirect_edge (e
, target
);
5736 e
->flags
= EDGE_FALLTHRU
;
5744 /* Redirect E to DEST. Return NULL on failure. Otherwise, return the
5745 edge representing the redirected branch. */
5748 gimple_redirect_edge_and_branch (edge e
, basic_block dest
)
5750 basic_block bb
= e
->src
;
5751 gimple_stmt_iterator gsi
;
5755 if (e
->flags
& EDGE_ABNORMAL
)
5758 if (e
->dest
== dest
)
5761 if (e
->flags
& EDGE_EH
)
5762 return redirect_eh_edge (e
, dest
);
5764 if (e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
))
5766 ret
= gimple_try_redirect_by_replacing_jump (e
, dest
);
5771 gsi
= gsi_last_bb (bb
);
5772 stmt
= gsi_end_p (gsi
) ? NULL
: gsi_stmt (gsi
);
5774 switch (stmt
? gimple_code (stmt
) : GIMPLE_ERROR_MARK
)
5777 /* For COND_EXPR, we only need to redirect the edge. */
5781 /* No non-abnormal edges should lead from a non-simple goto, and
5782 simple ones should be represented implicitly. */
5787 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
5788 tree label
= gimple_block_label (dest
);
5789 tree cases
= get_cases_for_edge (e
, switch_stmt
);
5791 /* If we have a list of cases associated with E, then use it
5792 as it's a lot faster than walking the entire case vector. */
5795 edge e2
= find_edge (e
->src
, dest
);
5802 CASE_LABEL (cases
) = label
;
5803 cases
= CASE_CHAIN (cases
);
5806 /* If there was already an edge in the CFG, then we need
5807 to move all the cases associated with E to E2. */
5810 tree cases2
= get_cases_for_edge (e2
, switch_stmt
);
5812 CASE_CHAIN (last
) = CASE_CHAIN (cases2
);
5813 CASE_CHAIN (cases2
) = first
;
5815 bitmap_set_bit (touched_switch_bbs
, gimple_bb (stmt
)->index
);
5819 size_t i
, n
= gimple_switch_num_labels (switch_stmt
);
5821 for (i
= 0; i
< n
; i
++)
5823 tree elt
= gimple_switch_label (switch_stmt
, i
);
5824 if (label_to_block (CASE_LABEL (elt
)) == e
->dest
)
5825 CASE_LABEL (elt
) = label
;
5833 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
5834 int i
, n
= gimple_asm_nlabels (asm_stmt
);
5837 for (i
= 0; i
< n
; ++i
)
5839 tree cons
= gimple_asm_label_op (asm_stmt
, i
);
5840 if (label_to_block (TREE_VALUE (cons
)) == e
->dest
)
5843 label
= gimple_block_label (dest
);
5844 TREE_VALUE (cons
) = label
;
5848 /* If we didn't find any label matching the former edge in the
5849 asm labels, we must be redirecting the fallthrough
5851 gcc_assert (label
|| (e
->flags
& EDGE_FALLTHRU
));
5856 gsi_remove (&gsi
, true);
5857 e
->flags
|= EDGE_FALLTHRU
;
5860 case GIMPLE_OMP_RETURN
:
5861 case GIMPLE_OMP_CONTINUE
:
5862 case GIMPLE_OMP_SECTIONS_SWITCH
:
5863 case GIMPLE_OMP_FOR
:
5864 /* The edges from OMP constructs can be simply redirected. */
5867 case GIMPLE_EH_DISPATCH
:
5868 if (!(e
->flags
& EDGE_FALLTHRU
))
5869 redirect_eh_dispatch_edge (as_a
<geh_dispatch
*> (stmt
), e
, dest
);
5872 case GIMPLE_TRANSACTION
:
5873 if (e
->flags
& EDGE_TM_ABORT
)
5874 gimple_transaction_set_label_over (as_a
<gtransaction
*> (stmt
),
5875 gimple_block_label (dest
));
5876 else if (e
->flags
& EDGE_TM_UNINSTRUMENTED
)
5877 gimple_transaction_set_label_uninst (as_a
<gtransaction
*> (stmt
),
5878 gimple_block_label (dest
));
5880 gimple_transaction_set_label_norm (as_a
<gtransaction
*> (stmt
),
5881 gimple_block_label (dest
));
5885 /* Otherwise it must be a fallthru edge, and we don't need to
5886 do anything besides redirecting it. */
5887 gcc_assert (e
->flags
& EDGE_FALLTHRU
);
5891 /* Update/insert PHI nodes as necessary. */
5893 /* Now update the edges in the CFG. */
5894 e
= ssa_redirect_edge (e
, dest
);
5899 /* Returns true if it is possible to remove edge E by redirecting
5900 it to the destination of the other edge from E->src. */
5903 gimple_can_remove_branch_p (const_edge e
)
5905 if (e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
))
5911 /* Simple wrapper, as we can always redirect fallthru edges. */
5914 gimple_redirect_edge_and_branch_force (edge e
, basic_block dest
)
5916 e
= gimple_redirect_edge_and_branch (e
, dest
);
5923 /* Splits basic block BB after statement STMT (but at least after the
5924 labels). If STMT is NULL, BB is split just after the labels. */
5927 gimple_split_block (basic_block bb
, void *stmt
)
5929 gimple_stmt_iterator gsi
;
5930 gimple_stmt_iterator gsi_tgt
;
5936 new_bb
= create_empty_bb (bb
);
5938 /* Redirect the outgoing edges. */
5939 new_bb
->succs
= bb
->succs
;
5941 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
5944 /* Get a stmt iterator pointing to the first stmt to move. */
5945 if (!stmt
|| gimple_code ((gimple
*) stmt
) == GIMPLE_LABEL
)
5946 gsi
= gsi_after_labels (bb
);
5949 gsi
= gsi_for_stmt ((gimple
*) stmt
);
5953 /* Move everything from GSI to the new basic block. */
5954 if (gsi_end_p (gsi
))
5957 /* Split the statement list - avoid re-creating new containers as this
5958 brings ugly quadratic memory consumption in the inliner.
5959 (We are still quadratic since we need to update stmt BB pointers,
5961 gsi_split_seq_before (&gsi
, &list
);
5962 set_bb_seq (new_bb
, list
);
5963 for (gsi_tgt
= gsi_start (list
);
5964 !gsi_end_p (gsi_tgt
); gsi_next (&gsi_tgt
))
5965 gimple_set_bb (gsi_stmt (gsi_tgt
), new_bb
);
5971 /* Moves basic block BB after block AFTER. */
5974 gimple_move_block_after (basic_block bb
, basic_block after
)
5976 if (bb
->prev_bb
== after
)
5980 link_block (bb
, after
);
5986 /* Return TRUE if block BB has no executable statements, otherwise return
5990 gimple_empty_block_p (basic_block bb
)
5992 /* BB must have no executable statements. */
5993 gimple_stmt_iterator gsi
= gsi_after_labels (bb
);
5996 if (gsi_end_p (gsi
))
5998 if (is_gimple_debug (gsi_stmt (gsi
)))
5999 gsi_next_nondebug (&gsi
);
6000 return gsi_end_p (gsi
);
6004 /* Split a basic block if it ends with a conditional branch and if the
6005 other part of the block is not empty. */
6008 gimple_split_block_before_cond_jump (basic_block bb
)
6010 gimple
*last
, *split_point
;
6011 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
6012 if (gsi_end_p (gsi
))
6014 last
= gsi_stmt (gsi
);
6015 if (gimple_code (last
) != GIMPLE_COND
6016 && gimple_code (last
) != GIMPLE_SWITCH
)
6019 split_point
= gsi_stmt (gsi
);
6020 return split_block (bb
, split_point
)->dest
;
6024 /* Return true if basic_block can be duplicated. */
6027 gimple_can_duplicate_bb_p (const_basic_block bb ATTRIBUTE_UNUSED
)
6032 /* Create a duplicate of the basic block BB. NOTE: This does not
6033 preserve SSA form. */
6036 gimple_duplicate_bb (basic_block bb
)
6039 gimple_stmt_iterator gsi_tgt
;
6041 new_bb
= create_empty_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
);
6043 /* Copy the PHI nodes. We ignore PHI node arguments here because
6044 the incoming edges have not been setup yet. */
6045 for (gphi_iterator gpi
= gsi_start_phis (bb
);
6051 copy
= create_phi_node (NULL_TREE
, new_bb
);
6052 create_new_def_for (gimple_phi_result (phi
), copy
,
6053 gimple_phi_result_ptr (copy
));
6054 gimple_set_uid (copy
, gimple_uid (phi
));
6057 gsi_tgt
= gsi_start_bb (new_bb
);
6058 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
6062 def_operand_p def_p
;
6063 ssa_op_iter op_iter
;
6065 gimple
*stmt
, *copy
;
6067 stmt
= gsi_stmt (gsi
);
6068 if (gimple_code (stmt
) == GIMPLE_LABEL
)
6071 /* Don't duplicate label debug stmts. */
6072 if (gimple_debug_bind_p (stmt
)
6073 && TREE_CODE (gimple_debug_bind_get_var (stmt
))
6077 /* Create a new copy of STMT and duplicate STMT's virtual
6079 copy
= gimple_copy (stmt
);
6080 gsi_insert_after (&gsi_tgt
, copy
, GSI_NEW_STMT
);
6082 maybe_duplicate_eh_stmt (copy
, stmt
);
6083 gimple_duplicate_stmt_histograms (cfun
, copy
, cfun
, stmt
);
6085 /* When copying around a stmt writing into a local non-user
6086 aggregate, make sure it won't share stack slot with other
6088 lhs
= gimple_get_lhs (stmt
);
6089 if (lhs
&& TREE_CODE (lhs
) != SSA_NAME
)
6091 tree base
= get_base_address (lhs
);
6093 && (VAR_P (base
) || TREE_CODE (base
) == RESULT_DECL
)
6094 && DECL_IGNORED_P (base
)
6095 && !TREE_STATIC (base
)
6096 && !DECL_EXTERNAL (base
)
6097 && (!VAR_P (base
) || !DECL_HAS_VALUE_EXPR_P (base
)))
6098 DECL_NONSHAREABLE (base
) = 1;
6101 /* Create new names for all the definitions created by COPY and
6102 add replacement mappings for each new name. */
6103 FOR_EACH_SSA_DEF_OPERAND (def_p
, copy
, op_iter
, SSA_OP_ALL_DEFS
)
6104 create_new_def_for (DEF_FROM_PTR (def_p
), copy
, def_p
);
6110 /* Adds phi node arguments for edge E_COPY after basic block duplication. */
6113 add_phi_args_after_copy_edge (edge e_copy
)
6115 basic_block bb
, bb_copy
= e_copy
->src
, dest
;
6118 gphi
*phi
, *phi_copy
;
6120 gphi_iterator psi
, psi_copy
;
6122 if (gimple_seq_empty_p (phi_nodes (e_copy
->dest
)))
6125 bb
= bb_copy
->flags
& BB_DUPLICATED
? get_bb_original (bb_copy
) : bb_copy
;
6127 if (e_copy
->dest
->flags
& BB_DUPLICATED
)
6128 dest
= get_bb_original (e_copy
->dest
);
6130 dest
= e_copy
->dest
;
6132 e
= find_edge (bb
, dest
);
6135 /* During loop unrolling the target of the latch edge is copied.
6136 In this case we are not looking for edge to dest, but to
6137 duplicated block whose original was dest. */
6138 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6140 if ((e
->dest
->flags
& BB_DUPLICATED
)
6141 && get_bb_original (e
->dest
) == dest
)
6145 gcc_assert (e
!= NULL
);
6148 for (psi
= gsi_start_phis (e
->dest
),
6149 psi_copy
= gsi_start_phis (e_copy
->dest
);
6151 gsi_next (&psi
), gsi_next (&psi_copy
))
6154 phi_copy
= psi_copy
.phi ();
6155 def
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
6156 add_phi_arg (phi_copy
, def
, e_copy
,
6157 gimple_phi_arg_location_from_edge (phi
, e
));
6162 /* Basic block BB_COPY was created by code duplication. Add phi node
6163 arguments for edges going out of BB_COPY. The blocks that were
6164 duplicated have BB_DUPLICATED set. */
6167 add_phi_args_after_copy_bb (basic_block bb_copy
)
6172 FOR_EACH_EDGE (e_copy
, ei
, bb_copy
->succs
)
6174 add_phi_args_after_copy_edge (e_copy
);
6178 /* Blocks in REGION_COPY array of length N_REGION were created by
6179 duplication of basic blocks. Add phi node arguments for edges
6180 going from these blocks. If E_COPY is not NULL, also add
6181 phi node arguments for its destination.*/
6184 add_phi_args_after_copy (basic_block
*region_copy
, unsigned n_region
,
6189 for (i
= 0; i
< n_region
; i
++)
6190 region_copy
[i
]->flags
|= BB_DUPLICATED
;
6192 for (i
= 0; i
< n_region
; i
++)
6193 add_phi_args_after_copy_bb (region_copy
[i
]);
6195 add_phi_args_after_copy_edge (e_copy
);
6197 for (i
= 0; i
< n_region
; i
++)
6198 region_copy
[i
]->flags
&= ~BB_DUPLICATED
;
6201 /* Duplicates a REGION (set of N_REGION basic blocks) with just a single
6202 important exit edge EXIT. By important we mean that no SSA name defined
6203 inside region is live over the other exit edges of the region. All entry
6204 edges to the region must go to ENTRY->dest. The edge ENTRY is redirected
6205 to the duplicate of the region. Dominance and loop information is
6206 updated if UPDATE_DOMINANCE is true, but not the SSA web. If
6207 UPDATE_DOMINANCE is false then we assume that the caller will update the
6208 dominance information after calling this function. The new basic
6209 blocks are stored to REGION_COPY in the same order as they had in REGION,
6210 provided that REGION_COPY is not NULL.
6211 The function returns false if it is unable to copy the region,
6215 gimple_duplicate_sese_region (edge entry
, edge exit
,
6216 basic_block
*region
, unsigned n_region
,
6217 basic_block
*region_copy
,
6218 bool update_dominance
)
6221 bool free_region_copy
= false, copying_header
= false;
6222 struct loop
*loop
= entry
->dest
->loop_father
;
6224 vec
<basic_block
> doms
;
6226 int total_freq
= 0, entry_freq
= 0;
6227 profile_count total_count
= profile_count::uninitialized ();
6228 profile_count entry_count
= profile_count::uninitialized ();
6230 if (!can_copy_bbs_p (region
, n_region
))
6233 /* Some sanity checking. Note that we do not check for all possible
6234 missuses of the functions. I.e. if you ask to copy something weird,
6235 it will work, but the state of structures probably will not be
6237 for (i
= 0; i
< n_region
; i
++)
6239 /* We do not handle subloops, i.e. all the blocks must belong to the
6241 if (region
[i
]->loop_father
!= loop
)
6244 if (region
[i
] != entry
->dest
6245 && region
[i
] == loop
->header
)
6249 /* In case the function is used for loop header copying (which is the primary
6250 use), ensure that EXIT and its copy will be new latch and entry edges. */
6251 if (loop
->header
== entry
->dest
)
6253 copying_header
= true;
6255 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, exit
->src
))
6258 for (i
= 0; i
< n_region
; i
++)
6259 if (region
[i
] != exit
->src
6260 && dominated_by_p (CDI_DOMINATORS
, region
[i
], exit
->src
))
6264 initialize_original_copy_tables ();
6267 set_loop_copy (loop
, loop_outer (loop
));
6269 set_loop_copy (loop
, loop
);
6273 region_copy
= XNEWVEC (basic_block
, n_region
);
6274 free_region_copy
= true;
6277 /* Record blocks outside the region that are dominated by something
6279 if (update_dominance
)
6282 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
6285 if (entry
->dest
->count
.initialized_p ())
6287 total_count
= entry
->dest
->count
;
6288 entry_count
= entry
->count
;
6289 /* Fix up corner cases, to avoid division by zero or creation of negative
6291 if (entry_count
> total_count
)
6292 entry_count
= total_count
;
6294 if (!(total_count
> 0) || !(entry_count
> 0))
6296 total_freq
= entry
->dest
->frequency
;
6297 entry_freq
= EDGE_FREQUENCY (entry
);
6298 /* Fix up corner cases, to avoid division by zero or creation of negative
6300 if (total_freq
== 0)
6302 else if (entry_freq
> total_freq
)
6303 entry_freq
= total_freq
;
6306 copy_bbs (region
, n_region
, region_copy
, &exit
, 1, &exit_copy
, loop
,
6307 split_edge_bb_loc (entry
), update_dominance
);
6308 if (total_count
> 0 && entry_count
> 0)
6310 scale_bbs_frequencies_profile_count (region
, n_region
,
6311 total_count
- entry_count
,
6313 scale_bbs_frequencies_profile_count (region_copy
, n_region
, entry_count
,
6318 scale_bbs_frequencies_int (region
, n_region
, total_freq
- entry_freq
,
6320 scale_bbs_frequencies_int (region_copy
, n_region
, entry_freq
, total_freq
);
6325 loop
->header
= exit
->dest
;
6326 loop
->latch
= exit
->src
;
6329 /* Redirect the entry and add the phi node arguments. */
6330 redirected
= redirect_edge_and_branch (entry
, get_bb_copy (entry
->dest
));
6331 gcc_assert (redirected
!= NULL
);
6332 flush_pending_stmts (entry
);
6334 /* Concerning updating of dominators: We must recount dominators
6335 for entry block and its copy. Anything that is outside of the
6336 region, but was dominated by something inside needs recounting as
6338 if (update_dominance
)
6340 set_immediate_dominator (CDI_DOMINATORS
, entry
->dest
, entry
->src
);
6341 doms
.safe_push (get_bb_original (entry
->dest
));
6342 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6346 /* Add the other PHI node arguments. */
6347 add_phi_args_after_copy (region_copy
, n_region
, NULL
);
6349 if (free_region_copy
)
6352 free_original_copy_tables ();
6356 /* Checks if BB is part of the region defined by N_REGION BBS. */
6358 bb_part_of_region_p (basic_block bb
, basic_block
* bbs
, unsigned n_region
)
6362 for (n
= 0; n
< n_region
; n
++)
6370 /* Duplicates REGION consisting of N_REGION blocks. The new blocks
6371 are stored to REGION_COPY in the same order in that they appear
6372 in REGION, if REGION_COPY is not NULL. ENTRY is the entry to
6373 the region, EXIT an exit from it. The condition guarding EXIT
6374 is moved to ENTRY. Returns true if duplication succeeds, false
6400 gimple_duplicate_sese_tail (edge entry
, edge exit
,
6401 basic_block
*region
, unsigned n_region
,
6402 basic_block
*region_copy
)
6405 bool free_region_copy
= false;
6406 struct loop
*loop
= exit
->dest
->loop_father
;
6407 struct loop
*orig_loop
= entry
->dest
->loop_father
;
6408 basic_block switch_bb
, entry_bb
, nentry_bb
;
6409 vec
<basic_block
> doms
;
6410 int total_freq
= 0, exit_freq
= 0;
6411 profile_count total_count
= profile_count::uninitialized (),
6412 exit_count
= profile_count::uninitialized ();
6413 edge exits
[2], nexits
[2], e
;
6414 gimple_stmt_iterator gsi
;
6417 basic_block exit_bb
;
6421 struct loop
*target
, *aloop
, *cloop
;
6423 gcc_assert (EDGE_COUNT (exit
->src
->succs
) == 2);
6425 exits
[1] = EDGE_SUCC (exit
->src
, EDGE_SUCC (exit
->src
, 0) == exit
);
6427 if (!can_copy_bbs_p (region
, n_region
))
6430 initialize_original_copy_tables ();
6431 set_loop_copy (orig_loop
, loop
);
6434 for (aloop
= orig_loop
->inner
; aloop
; aloop
= aloop
->next
)
6436 if (bb_part_of_region_p (aloop
->header
, region
, n_region
))
6438 cloop
= duplicate_loop (aloop
, target
);
6439 duplicate_subloops (aloop
, cloop
);
6445 region_copy
= XNEWVEC (basic_block
, n_region
);
6446 free_region_copy
= true;
6449 gcc_assert (!need_ssa_update_p (cfun
));
6451 /* Record blocks outside the region that are dominated by something
6453 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
6455 if (exit
->src
->count
> 0)
6457 total_count
= exit
->src
->count
;
6458 exit_count
= exit
->count
;
6459 /* Fix up corner cases, to avoid division by zero or creation of negative
6461 if (exit_count
> total_count
)
6462 exit_count
= total_count
;
6466 total_freq
= exit
->src
->frequency
;
6467 exit_freq
= EDGE_FREQUENCY (exit
);
6468 /* Fix up corner cases, to avoid division by zero or creation of negative
6470 if (total_freq
== 0)
6472 if (exit_freq
> total_freq
)
6473 exit_freq
= total_freq
;
6476 copy_bbs (region
, n_region
, region_copy
, exits
, 2, nexits
, orig_loop
,
6477 split_edge_bb_loc (exit
), true);
6478 if (total_count
.initialized_p ())
6480 scale_bbs_frequencies_profile_count (region
, n_region
,
6481 total_count
- exit_count
,
6483 scale_bbs_frequencies_profile_count (region_copy
, n_region
, exit_count
,
6488 scale_bbs_frequencies_int (region
, n_region
, total_freq
- exit_freq
,
6490 scale_bbs_frequencies_int (region_copy
, n_region
, exit_freq
, total_freq
);
6493 /* Create the switch block, and put the exit condition to it. */
6494 entry_bb
= entry
->dest
;
6495 nentry_bb
= get_bb_copy (entry_bb
);
6496 if (!last_stmt (entry
->src
)
6497 || !stmt_ends_bb_p (last_stmt (entry
->src
)))
6498 switch_bb
= entry
->src
;
6500 switch_bb
= split_edge (entry
);
6501 set_immediate_dominator (CDI_DOMINATORS
, nentry_bb
, switch_bb
);
6503 gsi
= gsi_last_bb (switch_bb
);
6504 cond_stmt
= last_stmt (exit
->src
);
6505 gcc_assert (gimple_code (cond_stmt
) == GIMPLE_COND
);
6506 cond_stmt
= gimple_copy (cond_stmt
);
6508 gsi_insert_after (&gsi
, cond_stmt
, GSI_NEW_STMT
);
6510 sorig
= single_succ_edge (switch_bb
);
6511 sorig
->flags
= exits
[1]->flags
;
6512 sorig
->probability
= exits
[1]->probability
;
6513 sorig
->count
= exits
[1]->count
;
6514 snew
= make_edge (switch_bb
, nentry_bb
, exits
[0]->flags
);
6515 snew
->probability
= exits
[0]->probability
;
6516 snew
->count
= exits
[1]->count
;
6519 /* Register the new edge from SWITCH_BB in loop exit lists. */
6520 rescan_loop_exit (snew
, true, false);
6522 /* Add the PHI node arguments. */
6523 add_phi_args_after_copy (region_copy
, n_region
, snew
);
6525 /* Get rid of now superfluous conditions and associated edges (and phi node
6527 exit_bb
= exit
->dest
;
6529 e
= redirect_edge_and_branch (exits
[0], exits
[1]->dest
);
6530 PENDING_STMT (e
) = NULL
;
6532 /* The latch of ORIG_LOOP was copied, and so was the backedge
6533 to the original header. We redirect this backedge to EXIT_BB. */
6534 for (i
= 0; i
< n_region
; i
++)
6535 if (get_bb_original (region_copy
[i
]) == orig_loop
->latch
)
6537 gcc_assert (single_succ_edge (region_copy
[i
]));
6538 e
= redirect_edge_and_branch (single_succ_edge (region_copy
[i
]), exit_bb
);
6539 PENDING_STMT (e
) = NULL
;
6540 for (psi
= gsi_start_phis (exit_bb
);
6545 def
= PHI_ARG_DEF (phi
, nexits
[0]->dest_idx
);
6546 add_phi_arg (phi
, def
, e
, gimple_phi_arg_location_from_edge (phi
, e
));
6549 e
= redirect_edge_and_branch (nexits
[1], nexits
[0]->dest
);
6550 PENDING_STMT (e
) = NULL
;
6552 /* Anything that is outside of the region, but was dominated by something
6553 inside needs to update dominance info. */
6554 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6556 /* Update the SSA web. */
6557 update_ssa (TODO_update_ssa
);
6559 if (free_region_copy
)
6562 free_original_copy_tables ();
6566 /* Add all the blocks dominated by ENTRY to the array BBS_P. Stop
6567 adding blocks when the dominator traversal reaches EXIT. This
6568 function silently assumes that ENTRY strictly dominates EXIT. */
6571 gather_blocks_in_sese_region (basic_block entry
, basic_block exit
,
6572 vec
<basic_block
> *bbs_p
)
6576 for (son
= first_dom_son (CDI_DOMINATORS
, entry
);
6578 son
= next_dom_son (CDI_DOMINATORS
, son
))
6580 bbs_p
->safe_push (son
);
6582 gather_blocks_in_sese_region (son
, exit
, bbs_p
);
6586 /* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
6587 The duplicates are recorded in VARS_MAP. */
6590 replace_by_duplicate_decl (tree
*tp
, hash_map
<tree
, tree
> *vars_map
,
6593 tree t
= *tp
, new_t
;
6594 struct function
*f
= DECL_STRUCT_FUNCTION (to_context
);
6596 if (DECL_CONTEXT (t
) == to_context
)
6600 tree
&loc
= vars_map
->get_or_insert (t
, &existed
);
6606 new_t
= copy_var_decl (t
, DECL_NAME (t
), TREE_TYPE (t
));
6607 add_local_decl (f
, new_t
);
6611 gcc_assert (TREE_CODE (t
) == CONST_DECL
);
6612 new_t
= copy_node (t
);
6614 DECL_CONTEXT (new_t
) = to_context
;
6625 /* Creates an ssa name in TO_CONTEXT equivalent to NAME.
6626 VARS_MAP maps old ssa names and var_decls to the new ones. */
6629 replace_ssa_name (tree name
, hash_map
<tree
, tree
> *vars_map
,
6634 gcc_assert (!virtual_operand_p (name
));
6636 tree
*loc
= vars_map
->get (name
);
6640 tree decl
= SSA_NAME_VAR (name
);
6643 gcc_assert (!SSA_NAME_IS_DEFAULT_DEF (name
));
6644 replace_by_duplicate_decl (&decl
, vars_map
, to_context
);
6645 new_name
= make_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6646 decl
, SSA_NAME_DEF_STMT (name
));
6649 new_name
= copy_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6650 name
, SSA_NAME_DEF_STMT (name
));
6652 /* Now that we've used the def stmt to define new_name, make sure it
6653 doesn't define name anymore. */
6654 SSA_NAME_DEF_STMT (name
) = NULL
;
6656 vars_map
->put (name
, new_name
);
6670 hash_map
<tree
, tree
> *vars_map
;
6671 htab_t new_label_map
;
6672 hash_map
<void *, void *> *eh_map
;
6676 /* Helper for move_block_to_fn. Set TREE_BLOCK in every expression
6677 contained in *TP if it has been ORIG_BLOCK previously and change the
6678 DECL_CONTEXT of every local variable referenced in *TP. */
6681 move_stmt_op (tree
*tp
, int *walk_subtrees
, void *data
)
6683 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
6684 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6689 tree block
= TREE_BLOCK (t
);
6690 if (block
== NULL_TREE
)
6692 else if (block
== p
->orig_block
6693 || p
->orig_block
== NULL_TREE
)
6694 TREE_SET_BLOCK (t
, p
->new_block
);
6695 else if (flag_checking
)
6697 while (block
&& TREE_CODE (block
) == BLOCK
&& block
!= p
->orig_block
)
6698 block
= BLOCK_SUPERCONTEXT (block
);
6699 gcc_assert (block
== p
->orig_block
);
6702 else if (DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
)
6704 if (TREE_CODE (t
) == SSA_NAME
)
6705 *tp
= replace_ssa_name (t
, p
->vars_map
, p
->to_context
);
6706 else if (TREE_CODE (t
) == PARM_DECL
6707 && gimple_in_ssa_p (cfun
))
6708 *tp
= *(p
->vars_map
->get (t
));
6709 else if (TREE_CODE (t
) == LABEL_DECL
)
6711 if (p
->new_label_map
)
6713 struct tree_map in
, *out
;
6715 out
= (struct tree_map
*)
6716 htab_find_with_hash (p
->new_label_map
, &in
, DECL_UID (t
));
6721 /* For FORCED_LABELs we can end up with references from other
6722 functions if some SESE regions are outlined. It is UB to
6723 jump in between them, but they could be used just for printing
6724 addresses etc. In that case, DECL_CONTEXT on the label should
6725 be the function containing the glabel stmt with that LABEL_DECL,
6726 rather than whatever function a reference to the label was seen
6728 if (!FORCED_LABEL (t
) && !DECL_NONLOCAL (t
))
6729 DECL_CONTEXT (t
) = p
->to_context
;
6731 else if (p
->remap_decls_p
)
6733 /* Replace T with its duplicate. T should no longer appear in the
6734 parent function, so this looks wasteful; however, it may appear
6735 in referenced_vars, and more importantly, as virtual operands of
6736 statements, and in alias lists of other variables. It would be
6737 quite difficult to expunge it from all those places. ??? It might
6738 suffice to do this for addressable variables. */
6739 if ((VAR_P (t
) && !is_global_var (t
))
6740 || TREE_CODE (t
) == CONST_DECL
)
6741 replace_by_duplicate_decl (tp
, p
->vars_map
, p
->to_context
);
6745 else if (TYPE_P (t
))
6751 /* Helper for move_stmt_r. Given an EH region number for the source
6752 function, map that to the duplicate EH regio number in the dest. */
6755 move_stmt_eh_region_nr (int old_nr
, struct move_stmt_d
*p
)
6757 eh_region old_r
, new_r
;
6759 old_r
= get_eh_region_from_number (old_nr
);
6760 new_r
= static_cast<eh_region
> (*p
->eh_map
->get (old_r
));
6762 return new_r
->index
;
6765 /* Similar, but operate on INTEGER_CSTs. */
6768 move_stmt_eh_region_tree_nr (tree old_t_nr
, struct move_stmt_d
*p
)
6772 old_nr
= tree_to_shwi (old_t_nr
);
6773 new_nr
= move_stmt_eh_region_nr (old_nr
, p
);
6775 return build_int_cst (integer_type_node
, new_nr
);
6778 /* Like move_stmt_op, but for gimple statements.
6780 Helper for move_block_to_fn. Set GIMPLE_BLOCK in every expression
6781 contained in the current statement in *GSI_P and change the
6782 DECL_CONTEXT of every local variable referenced in the current
6786 move_stmt_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
6787 struct walk_stmt_info
*wi
)
6789 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6790 gimple
*stmt
= gsi_stmt (*gsi_p
);
6791 tree block
= gimple_block (stmt
);
6793 if (block
== p
->orig_block
6794 || (p
->orig_block
== NULL_TREE
6795 && block
!= NULL_TREE
))
6796 gimple_set_block (stmt
, p
->new_block
);
6798 switch (gimple_code (stmt
))
6801 /* Remap the region numbers for __builtin_eh_{pointer,filter}. */
6803 tree r
, fndecl
= gimple_call_fndecl (stmt
);
6804 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
6805 switch (DECL_FUNCTION_CODE (fndecl
))
6807 case BUILT_IN_EH_COPY_VALUES
:
6808 r
= gimple_call_arg (stmt
, 1);
6809 r
= move_stmt_eh_region_tree_nr (r
, p
);
6810 gimple_call_set_arg (stmt
, 1, r
);
6813 case BUILT_IN_EH_POINTER
:
6814 case BUILT_IN_EH_FILTER
:
6815 r
= gimple_call_arg (stmt
, 0);
6816 r
= move_stmt_eh_region_tree_nr (r
, p
);
6817 gimple_call_set_arg (stmt
, 0, r
);
6828 gresx
*resx_stmt
= as_a
<gresx
*> (stmt
);
6829 int r
= gimple_resx_region (resx_stmt
);
6830 r
= move_stmt_eh_region_nr (r
, p
);
6831 gimple_resx_set_region (resx_stmt
, r
);
6835 case GIMPLE_EH_DISPATCH
:
6837 geh_dispatch
*eh_dispatch_stmt
= as_a
<geh_dispatch
*> (stmt
);
6838 int r
= gimple_eh_dispatch_region (eh_dispatch_stmt
);
6839 r
= move_stmt_eh_region_nr (r
, p
);
6840 gimple_eh_dispatch_set_region (eh_dispatch_stmt
, r
);
6844 case GIMPLE_OMP_RETURN
:
6845 case GIMPLE_OMP_CONTINUE
:
6850 /* For FORCED_LABEL, move_stmt_op doesn't adjust DECL_CONTEXT,
6851 so that such labels can be referenced from other regions.
6852 Make sure to update it when seeing a GIMPLE_LABEL though,
6853 that is the owner of the label. */
6854 walk_gimple_op (stmt
, move_stmt_op
, wi
);
6855 *handled_ops_p
= true;
6856 tree label
= gimple_label_label (as_a
<glabel
*> (stmt
));
6857 if (FORCED_LABEL (label
) || DECL_NONLOCAL (label
))
6858 DECL_CONTEXT (label
) = p
->to_context
;
6863 if (is_gimple_omp (stmt
))
6865 /* Do not remap variables inside OMP directives. Variables
6866 referenced in clauses and directive header belong to the
6867 parent function and should not be moved into the child
6869 bool save_remap_decls_p
= p
->remap_decls_p
;
6870 p
->remap_decls_p
= false;
6871 *handled_ops_p
= true;
6873 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt
), move_stmt_r
,
6876 p
->remap_decls_p
= save_remap_decls_p
;
6884 /* Move basic block BB from function CFUN to function DEST_FN. The
6885 block is moved out of the original linked list and placed after
6886 block AFTER in the new list. Also, the block is removed from the
6887 original array of blocks and placed in DEST_FN's array of blocks.
6888 If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
6889 updated to reflect the moved edges.
6891 The local variables are remapped to new instances, VARS_MAP is used
6892 to record the mapping. */
6895 move_block_to_fn (struct function
*dest_cfun
, basic_block bb
,
6896 basic_block after
, bool update_edge_count_p
,
6897 struct move_stmt_d
*d
)
6899 struct control_flow_graph
*cfg
;
6902 gimple_stmt_iterator si
;
6903 unsigned old_len
, new_len
;
6905 /* Remove BB from dominance structures. */
6906 delete_from_dominance_info (CDI_DOMINATORS
, bb
);
6908 /* Move BB from its current loop to the copy in the new function. */
6911 struct loop
*new_loop
= (struct loop
*)bb
->loop_father
->aux
;
6913 bb
->loop_father
= new_loop
;
6916 /* Link BB to the new linked list. */
6917 move_block_after (bb
, after
);
6919 /* Update the edge count in the corresponding flowgraphs. */
6920 if (update_edge_count_p
)
6921 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6923 cfun
->cfg
->x_n_edges
--;
6924 dest_cfun
->cfg
->x_n_edges
++;
6927 /* Remove BB from the original basic block array. */
6928 (*cfun
->cfg
->x_basic_block_info
)[bb
->index
] = NULL
;
6929 cfun
->cfg
->x_n_basic_blocks
--;
6931 /* Grow DEST_CFUN's basic block array if needed. */
6932 cfg
= dest_cfun
->cfg
;
6933 cfg
->x_n_basic_blocks
++;
6934 if (bb
->index
>= cfg
->x_last_basic_block
)
6935 cfg
->x_last_basic_block
= bb
->index
+ 1;
6937 old_len
= vec_safe_length (cfg
->x_basic_block_info
);
6938 if ((unsigned) cfg
->x_last_basic_block
>= old_len
)
6940 new_len
= cfg
->x_last_basic_block
+ (cfg
->x_last_basic_block
+ 3) / 4;
6941 vec_safe_grow_cleared (cfg
->x_basic_block_info
, new_len
);
6944 (*cfg
->x_basic_block_info
)[bb
->index
] = bb
;
6946 /* Remap the variables in phi nodes. */
6947 for (gphi_iterator psi
= gsi_start_phis (bb
);
6950 gphi
*phi
= psi
.phi ();
6952 tree op
= PHI_RESULT (phi
);
6956 if (virtual_operand_p (op
))
6958 /* Remove the phi nodes for virtual operands (alias analysis will be
6959 run for the new function, anyway). */
6960 remove_phi_node (&psi
, true);
6964 SET_PHI_RESULT (phi
,
6965 replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
6966 FOR_EACH_PHI_ARG (use
, phi
, oi
, SSA_OP_USE
)
6968 op
= USE_FROM_PTR (use
);
6969 if (TREE_CODE (op
) == SSA_NAME
)
6970 SET_USE (use
, replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
6973 for (i
= 0; i
< EDGE_COUNT (bb
->preds
); i
++)
6975 location_t locus
= gimple_phi_arg_location (phi
, i
);
6976 tree block
= LOCATION_BLOCK (locus
);
6978 if (locus
== UNKNOWN_LOCATION
)
6980 if (d
->orig_block
== NULL_TREE
|| block
== d
->orig_block
)
6982 locus
= set_block (locus
, d
->new_block
);
6983 gimple_phi_arg_set_location (phi
, i
, locus
);
6990 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6992 gimple
*stmt
= gsi_stmt (si
);
6993 struct walk_stmt_info wi
;
6995 memset (&wi
, 0, sizeof (wi
));
6997 walk_gimple_stmt (&si
, move_stmt_r
, move_stmt_op
, &wi
);
6999 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
7001 tree label
= gimple_label_label (label_stmt
);
7002 int uid
= LABEL_DECL_UID (label
);
7004 gcc_assert (uid
> -1);
7006 old_len
= vec_safe_length (cfg
->x_label_to_block_map
);
7007 if (old_len
<= (unsigned) uid
)
7009 new_len
= 3 * uid
/ 2 + 1;
7010 vec_safe_grow_cleared (cfg
->x_label_to_block_map
, new_len
);
7013 (*cfg
->x_label_to_block_map
)[uid
] = bb
;
7014 (*cfun
->cfg
->x_label_to_block_map
)[uid
] = NULL
;
7016 gcc_assert (DECL_CONTEXT (label
) == dest_cfun
->decl
);
7018 if (uid
>= dest_cfun
->cfg
->last_label_uid
)
7019 dest_cfun
->cfg
->last_label_uid
= uid
+ 1;
7022 maybe_duplicate_eh_stmt_fn (dest_cfun
, stmt
, cfun
, stmt
, d
->eh_map
, 0);
7023 remove_stmt_from_eh_lp_fn (cfun
, stmt
);
7025 gimple_duplicate_stmt_histograms (dest_cfun
, stmt
, cfun
, stmt
);
7026 gimple_remove_stmt_histograms (cfun
, stmt
);
7028 /* We cannot leave any operands allocated from the operand caches of
7029 the current function. */
7030 free_stmt_operands (cfun
, stmt
);
7031 push_cfun (dest_cfun
);
7036 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7037 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
7039 tree block
= LOCATION_BLOCK (e
->goto_locus
);
7040 if (d
->orig_block
== NULL_TREE
7041 || block
== d
->orig_block
)
7042 e
->goto_locus
= set_block (e
->goto_locus
, d
->new_block
);
7046 /* Examine the statements in BB (which is in SRC_CFUN); find and return
7047 the outermost EH region. Use REGION as the incoming base EH region. */
7050 find_outermost_region_in_block (struct function
*src_cfun
,
7051 basic_block bb
, eh_region region
)
7053 gimple_stmt_iterator si
;
7055 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
7057 gimple
*stmt
= gsi_stmt (si
);
7058 eh_region stmt_region
;
7061 lp_nr
= lookup_stmt_eh_lp_fn (src_cfun
, stmt
);
7062 stmt_region
= get_eh_region_from_lp_number_fn (src_cfun
, lp_nr
);
7066 region
= stmt_region
;
7067 else if (stmt_region
!= region
)
7069 region
= eh_region_outermost (src_cfun
, stmt_region
, region
);
7070 gcc_assert (region
!= NULL
);
7079 new_label_mapper (tree decl
, void *data
)
7081 htab_t hash
= (htab_t
) data
;
7085 gcc_assert (TREE_CODE (decl
) == LABEL_DECL
);
7087 m
= XNEW (struct tree_map
);
7088 m
->hash
= DECL_UID (decl
);
7089 m
->base
.from
= decl
;
7090 m
->to
= create_artificial_label (UNKNOWN_LOCATION
);
7091 LABEL_DECL_UID (m
->to
) = LABEL_DECL_UID (decl
);
7092 if (LABEL_DECL_UID (m
->to
) >= cfun
->cfg
->last_label_uid
)
7093 cfun
->cfg
->last_label_uid
= LABEL_DECL_UID (m
->to
) + 1;
7095 slot
= htab_find_slot_with_hash (hash
, m
, m
->hash
, INSERT
);
7096 gcc_assert (*slot
== NULL
);
7103 /* Tree walker to replace the decls used inside value expressions by
7107 replace_block_vars_by_duplicates_1 (tree
*tp
, int *walk_subtrees
, void *data
)
7109 struct replace_decls_d
*rd
= (struct replace_decls_d
*)data
;
7111 switch (TREE_CODE (*tp
))
7116 replace_by_duplicate_decl (tp
, rd
->vars_map
, rd
->to_context
);
7122 if (IS_TYPE_OR_DECL_P (*tp
))
7123 *walk_subtrees
= false;
7128 /* Change DECL_CONTEXT of all BLOCK_VARS in block, including
7132 replace_block_vars_by_duplicates (tree block
, hash_map
<tree
, tree
> *vars_map
,
7137 for (tp
= &BLOCK_VARS (block
); *tp
; tp
= &DECL_CHAIN (*tp
))
7140 if (!VAR_P (t
) && TREE_CODE (t
) != CONST_DECL
)
7142 replace_by_duplicate_decl (&t
, vars_map
, to_context
);
7145 if (VAR_P (*tp
) && DECL_HAS_VALUE_EXPR_P (*tp
))
7147 tree x
= DECL_VALUE_EXPR (*tp
);
7148 struct replace_decls_d rd
= { vars_map
, to_context
};
7150 walk_tree (&x
, replace_block_vars_by_duplicates_1
, &rd
, NULL
);
7151 SET_DECL_VALUE_EXPR (t
, x
);
7152 DECL_HAS_VALUE_EXPR_P (t
) = 1;
7154 DECL_CHAIN (t
) = DECL_CHAIN (*tp
);
7159 for (block
= BLOCK_SUBBLOCKS (block
); block
; block
= BLOCK_CHAIN (block
))
7160 replace_block_vars_by_duplicates (block
, vars_map
, to_context
);
7163 /* Fixup the loop arrays and numbers after moving LOOP and its subloops
7167 fixup_loop_arrays_after_move (struct function
*fn1
, struct function
*fn2
,
7170 /* Discard it from the old loop array. */
7171 (*get_loops (fn1
))[loop
->num
] = NULL
;
7173 /* Place it in the new loop array, assigning it a new number. */
7174 loop
->num
= number_of_loops (fn2
);
7175 vec_safe_push (loops_for_fn (fn2
)->larray
, loop
);
7177 /* Recurse to children. */
7178 for (loop
= loop
->inner
; loop
; loop
= loop
->next
)
7179 fixup_loop_arrays_after_move (fn1
, fn2
, loop
);
7182 /* Verify that the blocks in BBS_P are a single-entry, single-exit region
7183 delimited by ENTRY_BB and EXIT_BB, possibly containing noreturn blocks. */
7186 verify_sese (basic_block entry
, basic_block exit
, vec
<basic_block
> *bbs_p
)
7191 bitmap bbs
= BITMAP_ALLOC (NULL
);
7194 gcc_assert (entry
!= NULL
);
7195 gcc_assert (entry
!= exit
);
7196 gcc_assert (bbs_p
!= NULL
);
7198 gcc_assert (bbs_p
->length () > 0);
7200 FOR_EACH_VEC_ELT (*bbs_p
, i
, bb
)
7201 bitmap_set_bit (bbs
, bb
->index
);
7203 gcc_assert (bitmap_bit_p (bbs
, entry
->index
));
7204 gcc_assert (exit
== NULL
|| bitmap_bit_p (bbs
, exit
->index
));
7206 FOR_EACH_VEC_ELT (*bbs_p
, i
, bb
)
7210 gcc_assert (single_pred_p (entry
));
7211 gcc_assert (!bitmap_bit_p (bbs
, single_pred (entry
)->index
));
7214 for (ei
= ei_start (bb
->preds
); !ei_end_p (ei
); ei_next (&ei
))
7217 gcc_assert (bitmap_bit_p (bbs
, e
->src
->index
));
7222 gcc_assert (single_succ_p (exit
));
7223 gcc_assert (!bitmap_bit_p (bbs
, single_succ (exit
)->index
));
7226 for (ei
= ei_start (bb
->succs
); !ei_end_p (ei
); ei_next (&ei
))
7229 gcc_assert (bitmap_bit_p (bbs
, e
->dest
->index
));
7236 /* If FROM is an SSA_NAME, mark the version in bitmap DATA. */
7239 gather_ssa_name_hash_map_from (tree
const &from
, tree
const &, void *data
)
7241 bitmap release_names
= (bitmap
)data
;
7243 if (TREE_CODE (from
) != SSA_NAME
)
7246 bitmap_set_bit (release_names
, SSA_NAME_VERSION (from
));
7250 /* Move a single-entry, single-exit region delimited by ENTRY_BB and
7251 EXIT_BB to function DEST_CFUN. The whole region is replaced by a
7252 single basic block in the original CFG and the new basic block is
7253 returned. DEST_CFUN must not have a CFG yet.
7255 Note that the region need not be a pure SESE region. Blocks inside
7256 the region may contain calls to abort/exit. The only restriction
7257 is that ENTRY_BB should be the only entry point and it must
7260 Change TREE_BLOCK of all statements in ORIG_BLOCK to the new
7261 functions outermost BLOCK, move all subblocks of ORIG_BLOCK
7262 to the new function.
7264 All local variables referenced in the region are assumed to be in
7265 the corresponding BLOCK_VARS and unexpanded variable lists
7266 associated with DEST_CFUN.
7268 TODO: investigate whether we can reuse gimple_duplicate_sese_region to
7269 reimplement move_sese_region_to_fn by duplicating the region rather than
7273 move_sese_region_to_fn (struct function
*dest_cfun
, basic_block entry_bb
,
7274 basic_block exit_bb
, tree orig_block
)
7276 vec
<basic_block
> bbs
, dom_bbs
;
7277 basic_block dom_entry
= get_immediate_dominator (CDI_DOMINATORS
, entry_bb
);
7278 basic_block after
, bb
, *entry_pred
, *exit_succ
, abb
;
7279 struct function
*saved_cfun
= cfun
;
7280 int *entry_flag
, *exit_flag
;
7281 profile_probability
*entry_prob
, *exit_prob
;
7282 unsigned i
, num_entry_edges
, num_exit_edges
, num_nodes
;
7285 htab_t new_label_map
;
7286 hash_map
<void *, void *> *eh_map
;
7287 struct loop
*loop
= entry_bb
->loop_father
;
7288 struct loop
*loop0
= get_loop (saved_cfun
, 0);
7289 struct move_stmt_d d
;
7291 /* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
7293 gcc_assert (entry_bb
!= exit_bb
7295 || dominated_by_p (CDI_DOMINATORS
, exit_bb
, entry_bb
)));
7297 /* Collect all the blocks in the region. Manually add ENTRY_BB
7298 because it won't be added by dfs_enumerate_from. */
7300 bbs
.safe_push (entry_bb
);
7301 gather_blocks_in_sese_region (entry_bb
, exit_bb
, &bbs
);
7304 verify_sese (entry_bb
, exit_bb
, &bbs
);
7306 /* The blocks that used to be dominated by something in BBS will now be
7307 dominated by the new block. */
7308 dom_bbs
= get_dominated_by_region (CDI_DOMINATORS
,
7312 /* Detach ENTRY_BB and EXIT_BB from CFUN->CFG. We need to remember
7313 the predecessor edges to ENTRY_BB and the successor edges to
7314 EXIT_BB so that we can re-attach them to the new basic block that
7315 will replace the region. */
7316 num_entry_edges
= EDGE_COUNT (entry_bb
->preds
);
7317 entry_pred
= XNEWVEC (basic_block
, num_entry_edges
);
7318 entry_flag
= XNEWVEC (int, num_entry_edges
);
7319 entry_prob
= XNEWVEC (profile_probability
, num_entry_edges
);
7321 for (ei
= ei_start (entry_bb
->preds
); (e
= ei_safe_edge (ei
)) != NULL
;)
7323 entry_prob
[i
] = e
->probability
;
7324 entry_flag
[i
] = e
->flags
;
7325 entry_pred
[i
++] = e
->src
;
7331 num_exit_edges
= EDGE_COUNT (exit_bb
->succs
);
7332 exit_succ
= XNEWVEC (basic_block
, num_exit_edges
);
7333 exit_flag
= XNEWVEC (int, num_exit_edges
);
7334 exit_prob
= XNEWVEC (profile_probability
, num_exit_edges
);
7336 for (ei
= ei_start (exit_bb
->succs
); (e
= ei_safe_edge (ei
)) != NULL
;)
7338 exit_prob
[i
] = e
->probability
;
7339 exit_flag
[i
] = e
->flags
;
7340 exit_succ
[i
++] = e
->dest
;
7352 /* Switch context to the child function to initialize DEST_FN's CFG. */
7353 gcc_assert (dest_cfun
->cfg
== NULL
);
7354 push_cfun (dest_cfun
);
7356 init_empty_tree_cfg ();
7358 /* Initialize EH information for the new function. */
7360 new_label_map
= NULL
;
7363 eh_region region
= NULL
;
7365 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7366 region
= find_outermost_region_in_block (saved_cfun
, bb
, region
);
7368 init_eh_for_function ();
7371 new_label_map
= htab_create (17, tree_map_hash
, tree_map_eq
, free
);
7372 eh_map
= duplicate_eh_regions (saved_cfun
, region
, 0,
7373 new_label_mapper
, new_label_map
);
7377 /* Initialize an empty loop tree. */
7378 struct loops
*loops
= ggc_cleared_alloc
<struct loops
> ();
7379 init_loops_structure (dest_cfun
, loops
, 1);
7380 loops
->state
= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
7381 set_loops_for_fn (dest_cfun
, loops
);
7383 /* Move the outlined loop tree part. */
7384 num_nodes
= bbs
.length ();
7385 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7387 if (bb
->loop_father
->header
== bb
)
7389 struct loop
*this_loop
= bb
->loop_father
;
7390 struct loop
*outer
= loop_outer (this_loop
);
7392 /* If the SESE region contains some bbs ending with
7393 a noreturn call, those are considered to belong
7394 to the outermost loop in saved_cfun, rather than
7395 the entry_bb's loop_father. */
7399 num_nodes
-= this_loop
->num_nodes
;
7400 flow_loop_tree_node_remove (bb
->loop_father
);
7401 flow_loop_tree_node_add (get_loop (dest_cfun
, 0), this_loop
);
7402 fixup_loop_arrays_after_move (saved_cfun
, cfun
, this_loop
);
7405 else if (bb
->loop_father
== loop0
&& loop0
!= loop
)
7408 /* Remove loop exits from the outlined region. */
7409 if (loops_for_fn (saved_cfun
)->exits
)
7410 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7412 struct loops
*l
= loops_for_fn (saved_cfun
);
7414 = l
->exits
->find_slot_with_hash (e
, htab_hash_pointer (e
),
7417 l
->exits
->clear_slot (slot
);
7422 /* Adjust the number of blocks in the tree root of the outlined part. */
7423 get_loop (dest_cfun
, 0)->num_nodes
= bbs
.length () + 2;
7425 /* Setup a mapping to be used by move_block_to_fn. */
7426 loop
->aux
= current_loops
->tree_root
;
7427 loop0
->aux
= current_loops
->tree_root
;
7431 /* Move blocks from BBS into DEST_CFUN. */
7432 gcc_assert (bbs
.length () >= 2);
7433 after
= dest_cfun
->cfg
->x_entry_block_ptr
;
7434 hash_map
<tree
, tree
> vars_map
;
7436 memset (&d
, 0, sizeof (d
));
7437 d
.orig_block
= orig_block
;
7438 d
.new_block
= DECL_INITIAL (dest_cfun
->decl
);
7439 d
.from_context
= cfun
->decl
;
7440 d
.to_context
= dest_cfun
->decl
;
7441 d
.vars_map
= &vars_map
;
7442 d
.new_label_map
= new_label_map
;
7444 d
.remap_decls_p
= true;
7446 if (gimple_in_ssa_p (cfun
))
7447 for (tree arg
= DECL_ARGUMENTS (d
.to_context
); arg
; arg
= DECL_CHAIN (arg
))
7449 tree narg
= make_ssa_name_fn (dest_cfun
, arg
, gimple_build_nop ());
7450 set_ssa_default_def (dest_cfun
, arg
, narg
);
7451 vars_map
.put (arg
, narg
);
7454 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7456 /* No need to update edge counts on the last block. It has
7457 already been updated earlier when we detached the region from
7458 the original CFG. */
7459 move_block_to_fn (dest_cfun
, bb
, after
, bb
!= exit_bb
, &d
);
7465 /* Loop sizes are no longer correct, fix them up. */
7466 loop
->num_nodes
-= num_nodes
;
7467 for (struct loop
*outer
= loop_outer (loop
);
7468 outer
; outer
= loop_outer (outer
))
7469 outer
->num_nodes
-= num_nodes
;
7470 loop0
->num_nodes
-= bbs
.length () - num_nodes
;
7472 if (saved_cfun
->has_simduid_loops
|| saved_cfun
->has_force_vectorize_loops
)
7475 for (i
= 0; vec_safe_iterate (loops
->larray
, i
, &aloop
); i
++)
7480 replace_by_duplicate_decl (&aloop
->simduid
, d
.vars_map
,
7482 dest_cfun
->has_simduid_loops
= true;
7484 if (aloop
->force_vectorize
)
7485 dest_cfun
->has_force_vectorize_loops
= true;
7489 /* Rewire BLOCK_SUBBLOCKS of orig_block. */
7493 gcc_assert (BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
7495 BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
7496 = BLOCK_SUBBLOCKS (orig_block
);
7497 for (block
= BLOCK_SUBBLOCKS (orig_block
);
7498 block
; block
= BLOCK_CHAIN (block
))
7499 BLOCK_SUPERCONTEXT (block
) = DECL_INITIAL (dest_cfun
->decl
);
7500 BLOCK_SUBBLOCKS (orig_block
) = NULL_TREE
;
7503 replace_block_vars_by_duplicates (DECL_INITIAL (dest_cfun
->decl
),
7504 &vars_map
, dest_cfun
->decl
);
7507 htab_delete (new_label_map
);
7511 if (gimple_in_ssa_p (cfun
))
7513 /* We need to release ssa-names in a defined order, so first find them,
7514 and then iterate in ascending version order. */
7515 bitmap release_names
= BITMAP_ALLOC (NULL
);
7516 vars_map
.traverse
<void *, gather_ssa_name_hash_map_from
> (release_names
);
7519 EXECUTE_IF_SET_IN_BITMAP (release_names
, 0, i
, bi
)
7520 release_ssa_name (ssa_name (i
));
7521 BITMAP_FREE (release_names
);
7524 /* Rewire the entry and exit blocks. The successor to the entry
7525 block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
7526 the child function. Similarly, the predecessor of DEST_FN's
7527 EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR. We
7528 need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
7529 various CFG manipulation function get to the right CFG.
7531 FIXME, this is silly. The CFG ought to become a parameter to
7533 push_cfun (dest_cfun
);
7534 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
), entry_bb
, EDGE_FALLTHRU
);
7536 make_edge (exit_bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
7539 /* Back in the original function, the SESE region has disappeared,
7540 create a new basic block in its place. */
7541 bb
= create_empty_bb (entry_pred
[0]);
7543 add_bb_to_loop (bb
, loop
);
7544 for (i
= 0; i
< num_entry_edges
; i
++)
7546 e
= make_edge (entry_pred
[i
], bb
, entry_flag
[i
]);
7547 e
->probability
= entry_prob
[i
];
7550 for (i
= 0; i
< num_exit_edges
; i
++)
7552 e
= make_edge (bb
, exit_succ
[i
], exit_flag
[i
]);
7553 e
->probability
= exit_prob
[i
];
7556 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom_entry
);
7557 FOR_EACH_VEC_ELT (dom_bbs
, i
, abb
)
7558 set_immediate_dominator (CDI_DOMINATORS
, abb
, bb
);
7575 /* Dump default def DEF to file FILE using FLAGS and indentation
7579 dump_default_def (FILE *file
, tree def
, int spc
, dump_flags_t flags
)
7581 for (int i
= 0; i
< spc
; ++i
)
7582 fprintf (file
, " ");
7583 dump_ssaname_info_to_file (file
, def
, spc
);
7585 print_generic_expr (file
, TREE_TYPE (def
), flags
);
7586 fprintf (file
, " ");
7587 print_generic_expr (file
, def
, flags
);
7588 fprintf (file
, " = ");
7589 print_generic_expr (file
, SSA_NAME_VAR (def
), flags
);
7590 fprintf (file
, ";\n");
7593 /* Print no_sanitize attribute to FILE for a given attribute VALUE. */
7596 print_no_sanitize_attr_value (FILE *file
, tree value
)
7598 unsigned int flags
= tree_to_uhwi (value
);
7600 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
7602 if ((sanitizer_opts
[i
].flag
& flags
) == sanitizer_opts
[i
].flag
)
7605 fprintf (file
, " | ");
7606 fprintf (file
, "%s", sanitizer_opts
[i
].name
);
7612 /* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in dumpfile.h)
7616 dump_function_to_file (tree fndecl
, FILE *file
, dump_flags_t flags
)
7618 tree arg
, var
, old_current_fndecl
= current_function_decl
;
7619 struct function
*dsf
;
7620 bool ignore_topmost_bind
= false, any_var
= false;
7623 bool tmclone
= (TREE_CODE (fndecl
) == FUNCTION_DECL
7624 && decl_is_tm_clone (fndecl
));
7625 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
7627 if (DECL_ATTRIBUTES (fndecl
) != NULL_TREE
)
7629 fprintf (file
, "__attribute__((");
7633 for (chain
= DECL_ATTRIBUTES (fndecl
); chain
;
7634 first
= false, chain
= TREE_CHAIN (chain
))
7637 fprintf (file
, ", ");
7639 tree name
= get_attribute_name (chain
);
7640 print_generic_expr (file
, name
, dump_flags
);
7641 if (TREE_VALUE (chain
) != NULL_TREE
)
7643 fprintf (file
, " (");
7645 if (strstr (IDENTIFIER_POINTER (name
), "no_sanitize"))
7646 print_no_sanitize_attr_value (file
, TREE_VALUE (chain
));
7648 print_generic_expr (file
, TREE_VALUE (chain
), dump_flags
);
7649 fprintf (file
, ")");
7653 fprintf (file
, "))\n");
7656 current_function_decl
= fndecl
;
7657 if (flags
& TDF_GIMPLE
)
7659 print_generic_expr (file
, TREE_TYPE (TREE_TYPE (fndecl
)),
7660 dump_flags
| TDF_SLIM
);
7661 fprintf (file
, " __GIMPLE ()\n%s (", function_name (fun
));
7664 fprintf (file
, "%s %s(", function_name (fun
), tmclone
? "[tm-clone] " : "");
7666 arg
= DECL_ARGUMENTS (fndecl
);
7669 print_generic_expr (file
, TREE_TYPE (arg
), dump_flags
);
7670 fprintf (file
, " ");
7671 print_generic_expr (file
, arg
, dump_flags
);
7672 if (DECL_CHAIN (arg
))
7673 fprintf (file
, ", ");
7674 arg
= DECL_CHAIN (arg
);
7676 fprintf (file
, ")\n");
7678 dsf
= DECL_STRUCT_FUNCTION (fndecl
);
7679 if (dsf
&& (flags
& TDF_EH
))
7680 dump_eh_tree (file
, dsf
);
7682 if (flags
& TDF_RAW
&& !gimple_has_body_p (fndecl
))
7684 dump_node (fndecl
, TDF_SLIM
| flags
, file
);
7685 current_function_decl
= old_current_fndecl
;
7689 /* When GIMPLE is lowered, the variables are no longer available in
7690 BIND_EXPRs, so display them separately. */
7691 if (fun
&& fun
->decl
== fndecl
&& (fun
->curr_properties
& PROP_gimple_lcf
))
7694 ignore_topmost_bind
= true;
7696 fprintf (file
, "{\n");
7697 if (gimple_in_ssa_p (fun
)
7698 && (flags
& TDF_ALIAS
))
7700 for (arg
= DECL_ARGUMENTS (fndecl
); arg
!= NULL
;
7701 arg
= DECL_CHAIN (arg
))
7703 tree def
= ssa_default_def (fun
, arg
);
7705 dump_default_def (file
, def
, 2, flags
);
7708 tree res
= DECL_RESULT (fun
->decl
);
7709 if (res
!= NULL_TREE
7710 && DECL_BY_REFERENCE (res
))
7712 tree def
= ssa_default_def (fun
, res
);
7714 dump_default_def (file
, def
, 2, flags
);
7717 tree static_chain
= fun
->static_chain_decl
;
7718 if (static_chain
!= NULL_TREE
)
7720 tree def
= ssa_default_def (fun
, static_chain
);
7722 dump_default_def (file
, def
, 2, flags
);
7726 if (!vec_safe_is_empty (fun
->local_decls
))
7727 FOR_EACH_LOCAL_DECL (fun
, ix
, var
)
7729 print_generic_decl (file
, var
, flags
);
7730 fprintf (file
, "\n");
7737 if (gimple_in_ssa_p (cfun
))
7738 FOR_EACH_SSA_NAME (ix
, name
, cfun
)
7740 if (!SSA_NAME_VAR (name
))
7742 fprintf (file
, " ");
7743 print_generic_expr (file
, TREE_TYPE (name
), flags
);
7744 fprintf (file
, " ");
7745 print_generic_expr (file
, name
, flags
);
7746 fprintf (file
, ";\n");
7753 if (fun
&& fun
->decl
== fndecl
7755 && basic_block_info_for_fn (fun
))
7757 /* If the CFG has been built, emit a CFG-based dump. */
7758 if (!ignore_topmost_bind
)
7759 fprintf (file
, "{\n");
7761 if (any_var
&& n_basic_blocks_for_fn (fun
))
7762 fprintf (file
, "\n");
7764 FOR_EACH_BB_FN (bb
, fun
)
7765 dump_bb (file
, bb
, 2, flags
);
7767 fprintf (file
, "}\n");
7769 else if (fun
->curr_properties
& PROP_gimple_any
)
7771 /* The function is now in GIMPLE form but the CFG has not been
7772 built yet. Emit the single sequence of GIMPLE statements
7773 that make up its body. */
7774 gimple_seq body
= gimple_body (fndecl
);
7776 if (gimple_seq_first_stmt (body
)
7777 && gimple_seq_first_stmt (body
) == gimple_seq_last_stmt (body
)
7778 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
)
7779 print_gimple_seq (file
, body
, 0, flags
);
7782 if (!ignore_topmost_bind
)
7783 fprintf (file
, "{\n");
7786 fprintf (file
, "\n");
7788 print_gimple_seq (file
, body
, 2, flags
);
7789 fprintf (file
, "}\n");
7796 /* Make a tree based dump. */
7797 chain
= DECL_SAVED_TREE (fndecl
);
7798 if (chain
&& TREE_CODE (chain
) == BIND_EXPR
)
7800 if (ignore_topmost_bind
)
7802 chain
= BIND_EXPR_BODY (chain
);
7810 if (!ignore_topmost_bind
)
7812 fprintf (file
, "{\n");
7813 /* No topmost bind, pretend it's ignored for later. */
7814 ignore_topmost_bind
= true;
7820 fprintf (file
, "\n");
7822 print_generic_stmt_indented (file
, chain
, flags
, indent
);
7823 if (ignore_topmost_bind
)
7824 fprintf (file
, "}\n");
7827 if (flags
& TDF_ENUMERATE_LOCALS
)
7828 dump_enumerated_decls (file
, flags
);
7829 fprintf (file
, "\n\n");
7831 current_function_decl
= old_current_fndecl
;
7834 /* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h) */
7837 debug_function (tree fn
, dump_flags_t flags
)
7839 dump_function_to_file (fn
, stderr
, flags
);
7843 /* Print on FILE the indexes for the predecessors of basic_block BB. */
7846 print_pred_bbs (FILE *file
, basic_block bb
)
7851 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7852 fprintf (file
, "bb_%d ", e
->src
->index
);
7856 /* Print on FILE the indexes for the successors of basic_block BB. */
7859 print_succ_bbs (FILE *file
, basic_block bb
)
7864 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7865 fprintf (file
, "bb_%d ", e
->dest
->index
);
7868 /* Print to FILE the basic block BB following the VERBOSITY level. */
7871 print_loops_bb (FILE *file
, basic_block bb
, int indent
, int verbosity
)
7873 char *s_indent
= (char *) alloca ((size_t) indent
+ 1);
7874 memset ((void *) s_indent
, ' ', (size_t) indent
);
7875 s_indent
[indent
] = '\0';
7877 /* Print basic_block's header. */
7880 fprintf (file
, "%s bb_%d (preds = {", s_indent
, bb
->index
);
7881 print_pred_bbs (file
, bb
);
7882 fprintf (file
, "}, succs = {");
7883 print_succ_bbs (file
, bb
);
7884 fprintf (file
, "})\n");
7887 /* Print basic_block's body. */
7890 fprintf (file
, "%s {\n", s_indent
);
7891 dump_bb (file
, bb
, indent
+ 4, TDF_VOPS
|TDF_MEMSYMS
);
7892 fprintf (file
, "%s }\n", s_indent
);
7896 static void print_loop_and_siblings (FILE *, struct loop
*, int, int);
7898 /* Pretty print LOOP on FILE, indented INDENT spaces. Following
7899 VERBOSITY level this outputs the contents of the loop, or just its
7903 print_loop (FILE *file
, struct loop
*loop
, int indent
, int verbosity
)
7911 s_indent
= (char *) alloca ((size_t) indent
+ 1);
7912 memset ((void *) s_indent
, ' ', (size_t) indent
);
7913 s_indent
[indent
] = '\0';
7915 /* Print loop's header. */
7916 fprintf (file
, "%sloop_%d (", s_indent
, loop
->num
);
7918 fprintf (file
, "header = %d", loop
->header
->index
);
7921 fprintf (file
, "deleted)\n");
7925 fprintf (file
, ", latch = %d", loop
->latch
->index
);
7927 fprintf (file
, ", multiple latches");
7928 fprintf (file
, ", niter = ");
7929 print_generic_expr (file
, loop
->nb_iterations
);
7931 if (loop
->any_upper_bound
)
7933 fprintf (file
, ", upper_bound = ");
7934 print_decu (loop
->nb_iterations_upper_bound
, file
);
7936 if (loop
->any_likely_upper_bound
)
7938 fprintf (file
, ", likely_upper_bound = ");
7939 print_decu (loop
->nb_iterations_likely_upper_bound
, file
);
7942 if (loop
->any_estimate
)
7944 fprintf (file
, ", estimate = ");
7945 print_decu (loop
->nb_iterations_estimate
, file
);
7947 fprintf (file
, ")\n");
7949 /* Print loop's body. */
7952 fprintf (file
, "%s{\n", s_indent
);
7953 FOR_EACH_BB_FN (bb
, cfun
)
7954 if (bb
->loop_father
== loop
)
7955 print_loops_bb (file
, bb
, indent
, verbosity
);
7957 print_loop_and_siblings (file
, loop
->inner
, indent
+ 2, verbosity
);
7958 fprintf (file
, "%s}\n", s_indent
);
7962 /* Print the LOOP and its sibling loops on FILE, indented INDENT
7963 spaces. Following VERBOSITY level this outputs the contents of the
7964 loop, or just its structure. */
7967 print_loop_and_siblings (FILE *file
, struct loop
*loop
, int indent
,
7973 print_loop (file
, loop
, indent
, verbosity
);
7974 print_loop_and_siblings (file
, loop
->next
, indent
, verbosity
);
7977 /* Follow a CFG edge from the entry point of the program, and on entry
7978 of a loop, pretty print the loop structure on FILE. */
7981 print_loops (FILE *file
, int verbosity
)
7985 bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
7986 fprintf (file
, "\nLoops in function: %s\n", current_function_name ());
7987 if (bb
&& bb
->loop_father
)
7988 print_loop_and_siblings (file
, bb
->loop_father
, 0, verbosity
);
7994 debug (struct loop
&ref
)
7996 print_loop (stderr
, &ref
, 0, /*verbosity*/0);
8000 debug (struct loop
*ptr
)
8005 fprintf (stderr
, "<nil>\n");
8008 /* Dump a loop verbosely. */
8011 debug_verbose (struct loop
&ref
)
8013 print_loop (stderr
, &ref
, 0, /*verbosity*/3);
8017 debug_verbose (struct loop
*ptr
)
8022 fprintf (stderr
, "<nil>\n");
8026 /* Debugging loops structure at tree level, at some VERBOSITY level. */
8029 debug_loops (int verbosity
)
8031 print_loops (stderr
, verbosity
);
8034 /* Print on stderr the code of LOOP, at some VERBOSITY level. */
8037 debug_loop (struct loop
*loop
, int verbosity
)
8039 print_loop (stderr
, loop
, 0, verbosity
);
8042 /* Print on stderr the code of loop number NUM, at some VERBOSITY
8046 debug_loop_num (unsigned num
, int verbosity
)
8048 debug_loop (get_loop (cfun
, num
), verbosity
);
8051 /* Return true if BB ends with a call, possibly followed by some
8052 instructions that must stay with the call. Return false,
8056 gimple_block_ends_with_call_p (basic_block bb
)
8058 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
8059 return !gsi_end_p (gsi
) && is_gimple_call (gsi_stmt (gsi
));
8063 /* Return true if BB ends with a conditional branch. Return false,
8067 gimple_block_ends_with_condjump_p (const_basic_block bb
)
8069 gimple
*stmt
= last_stmt (CONST_CAST_BB (bb
));
8070 return (stmt
&& gimple_code (stmt
) == GIMPLE_COND
);
8074 /* Return true if statement T may terminate execution of BB in ways not
8075 explicitly represtented in the CFG. */
8078 stmt_can_terminate_bb_p (gimple
*t
)
8080 tree fndecl
= NULL_TREE
;
8083 /* Eh exception not handled internally terminates execution of the whole
8085 if (stmt_can_throw_external (t
))
8088 /* NORETURN and LONGJMP calls already have an edge to exit.
8089 CONST and PURE calls do not need one.
8090 We don't currently check for CONST and PURE here, although
8091 it would be a good idea, because those attributes are
8092 figured out from the RTL in mark_constant_function, and
8093 the counter incrementation code from -fprofile-arcs
8094 leads to different results from -fbranch-probabilities. */
8095 if (is_gimple_call (t
))
8097 fndecl
= gimple_call_fndecl (t
);
8098 call_flags
= gimple_call_flags (t
);
8101 if (is_gimple_call (t
)
8103 && DECL_BUILT_IN (fndecl
)
8104 && (call_flags
& ECF_NOTHROW
)
8105 && !(call_flags
& ECF_RETURNS_TWICE
)
8106 /* fork() doesn't really return twice, but the effect of
8107 wrapping it in __gcov_fork() which calls __gcov_flush()
8108 and clears the counters before forking has the same
8109 effect as returning twice. Force a fake edge. */
8110 && !(DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
8111 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FORK
))
8114 if (is_gimple_call (t
))
8120 if (call_flags
& (ECF_PURE
| ECF_CONST
)
8121 && !(call_flags
& ECF_LOOPING_CONST_OR_PURE
))
8124 /* Function call may do longjmp, terminate program or do other things.
8125 Special case noreturn that have non-abnormal edges out as in this case
8126 the fact is sufficiently represented by lack of edges out of T. */
8127 if (!(call_flags
& ECF_NORETURN
))
8131 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8132 if ((e
->flags
& EDGE_FAKE
) == 0)
8136 if (gasm
*asm_stmt
= dyn_cast
<gasm
*> (t
))
8137 if (gimple_asm_volatile_p (asm_stmt
) || gimple_asm_input_p (asm_stmt
))
8144 /* Add fake edges to the function exit for any non constant and non
8145 noreturn calls (or noreturn calls with EH/abnormal edges),
8146 volatile inline assembly in the bitmap of blocks specified by BLOCKS
8147 or to the whole CFG if BLOCKS is zero. Return the number of blocks
8150 The goal is to expose cases in which entering a basic block does
8151 not imply that all subsequent instructions must be executed. */
8154 gimple_flow_call_edges_add (sbitmap blocks
)
8157 int blocks_split
= 0;
8158 int last_bb
= last_basic_block_for_fn (cfun
);
8159 bool check_last_block
= false;
8161 if (n_basic_blocks_for_fn (cfun
) == NUM_FIXED_BLOCKS
)
8165 check_last_block
= true;
8167 check_last_block
= bitmap_bit_p (blocks
,
8168 EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
->index
);
8170 /* In the last basic block, before epilogue generation, there will be
8171 a fallthru edge to EXIT. Special care is required if the last insn
8172 of the last basic block is a call because make_edge folds duplicate
8173 edges, which would result in the fallthru edge also being marked
8174 fake, which would result in the fallthru edge being removed by
8175 remove_fake_edges, which would result in an invalid CFG.
8177 Moreover, we can't elide the outgoing fake edge, since the block
8178 profiler needs to take this into account in order to solve the minimal
8179 spanning tree in the case that the call doesn't return.
8181 Handle this by adding a dummy instruction in a new last basic block. */
8182 if (check_last_block
)
8184 basic_block bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
8185 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
8188 if (!gsi_end_p (gsi
))
8191 if (t
&& stmt_can_terminate_bb_p (t
))
8195 e
= find_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
8198 gsi_insert_on_edge (e
, gimple_build_nop ());
8199 gsi_commit_edge_inserts ();
8204 /* Now add fake edges to the function exit for any non constant
8205 calls since there is no way that we can determine if they will
8207 for (i
= 0; i
< last_bb
; i
++)
8209 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8210 gimple_stmt_iterator gsi
;
8211 gimple
*stmt
, *last_stmt
;
8216 if (blocks
&& !bitmap_bit_p (blocks
, i
))
8219 gsi
= gsi_last_nondebug_bb (bb
);
8220 if (!gsi_end_p (gsi
))
8222 last_stmt
= gsi_stmt (gsi
);
8225 stmt
= gsi_stmt (gsi
);
8226 if (stmt_can_terminate_bb_p (stmt
))
8230 /* The handling above of the final block before the
8231 epilogue should be enough to verify that there is
8232 no edge to the exit block in CFG already.
8233 Calling make_edge in such case would cause us to
8234 mark that edge as fake and remove it later. */
8235 if (flag_checking
&& stmt
== last_stmt
)
8237 e
= find_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
8238 gcc_assert (e
== NULL
);
8241 /* Note that the following may create a new basic block
8242 and renumber the existing basic blocks. */
8243 if (stmt
!= last_stmt
)
8245 e
= split_block (bb
, stmt
);
8249 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FAKE
);
8250 e
->probability
= profile_probability::guessed_never ();
8251 e
->count
= profile_count::guessed_zero ();
8255 while (!gsi_end_p (gsi
));
8260 checking_verify_flow_info ();
8262 return blocks_split
;
8265 /* Removes edge E and all the blocks dominated by it, and updates dominance
8266 information. The IL in E->src needs to be updated separately.
8267 If dominance info is not available, only the edge E is removed.*/
8270 remove_edge_and_dominated_blocks (edge e
)
8272 vec
<basic_block
> bbs_to_remove
= vNULL
;
8273 vec
<basic_block
> bbs_to_fix_dom
= vNULL
;
8276 bool none_removed
= false;
8278 basic_block bb
, dbb
;
8281 /* If we are removing a path inside a non-root loop that may change
8282 loop ownership of blocks or remove loops. Mark loops for fixup. */
8284 && loop_outer (e
->src
->loop_father
) != NULL
8285 && e
->src
->loop_father
== e
->dest
->loop_father
)
8286 loops_state_set (LOOPS_NEED_FIXUP
);
8288 if (!dom_info_available_p (CDI_DOMINATORS
))
8294 /* No updating is needed for edges to exit. */
8295 if (e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
8297 if (cfgcleanup_altered_bbs
)
8298 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
8303 /* First, we find the basic blocks to remove. If E->dest has a predecessor
8304 that is not dominated by E->dest, then this set is empty. Otherwise,
8305 all the basic blocks dominated by E->dest are removed.
8307 Also, to DF_IDOM we store the immediate dominators of the blocks in
8308 the dominance frontier of E (i.e., of the successors of the
8309 removed blocks, if there are any, and of E->dest otherwise). */
8310 FOR_EACH_EDGE (f
, ei
, e
->dest
->preds
)
8315 if (!dominated_by_p (CDI_DOMINATORS
, f
->src
, e
->dest
))
8317 none_removed
= true;
8322 auto_bitmap df
, df_idom
;
8324 bitmap_set_bit (df_idom
,
8325 get_immediate_dominator (CDI_DOMINATORS
, e
->dest
)->index
);
8328 bbs_to_remove
= get_all_dominated_blocks (CDI_DOMINATORS
, e
->dest
);
8329 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
8331 FOR_EACH_EDGE (f
, ei
, bb
->succs
)
8333 if (f
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
8334 bitmap_set_bit (df
, f
->dest
->index
);
8337 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
8338 bitmap_clear_bit (df
, bb
->index
);
8340 EXECUTE_IF_SET_IN_BITMAP (df
, 0, i
, bi
)
8342 bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8343 bitmap_set_bit (df_idom
,
8344 get_immediate_dominator (CDI_DOMINATORS
, bb
)->index
);
8348 if (cfgcleanup_altered_bbs
)
8350 /* Record the set of the altered basic blocks. */
8351 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
8352 bitmap_ior_into (cfgcleanup_altered_bbs
, df
);
8355 /* Remove E and the cancelled blocks. */
8360 /* Walk backwards so as to get a chance to substitute all
8361 released DEFs into debug stmts. See
8362 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
8364 for (i
= bbs_to_remove
.length (); i
-- > 0; )
8365 delete_basic_block (bbs_to_remove
[i
]);
8368 /* Update the dominance information. The immediate dominator may change only
8369 for blocks whose immediate dominator belongs to DF_IDOM:
8371 Suppose that idom(X) = Y before removal of E and idom(X) != Y after the
8372 removal. Let Z the arbitrary block such that idom(Z) = Y and
8373 Z dominates X after the removal. Before removal, there exists a path P
8374 from Y to X that avoids Z. Let F be the last edge on P that is
8375 removed, and let W = F->dest. Before removal, idom(W) = Y (since Y
8376 dominates W, and because of P, Z does not dominate W), and W belongs to
8377 the dominance frontier of E. Therefore, Y belongs to DF_IDOM. */
8378 EXECUTE_IF_SET_IN_BITMAP (df_idom
, 0, i
, bi
)
8380 bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8381 for (dbb
= first_dom_son (CDI_DOMINATORS
, bb
);
8383 dbb
= next_dom_son (CDI_DOMINATORS
, dbb
))
8384 bbs_to_fix_dom
.safe_push (dbb
);
8387 iterate_fix_dominators (CDI_DOMINATORS
, bbs_to_fix_dom
, true);
8389 bbs_to_remove
.release ();
8390 bbs_to_fix_dom
.release ();
8393 /* Purge dead EH edges from basic block BB. */
8396 gimple_purge_dead_eh_edges (basic_block bb
)
8398 bool changed
= false;
8401 gimple
*stmt
= last_stmt (bb
);
8403 if (stmt
&& stmt_can_throw_internal (stmt
))
8406 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
8408 if (e
->flags
& EDGE_EH
)
8410 remove_edge_and_dominated_blocks (e
);
8420 /* Purge dead EH edges from basic block listed in BLOCKS. */
8423 gimple_purge_all_dead_eh_edges (const_bitmap blocks
)
8425 bool changed
= false;
8429 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
8431 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8433 /* Earlier gimple_purge_dead_eh_edges could have removed
8434 this basic block already. */
8435 gcc_assert (bb
|| changed
);
8437 changed
|= gimple_purge_dead_eh_edges (bb
);
8443 /* Purge dead abnormal call edges from basic block BB. */
8446 gimple_purge_dead_abnormal_call_edges (basic_block bb
)
8448 bool changed
= false;
8451 gimple
*stmt
= last_stmt (bb
);
8453 if (!cfun
->has_nonlocal_label
8454 && !cfun
->calls_setjmp
)
8457 if (stmt
&& stmt_can_make_abnormal_goto (stmt
))
8460 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
8462 if (e
->flags
& EDGE_ABNORMAL
)
8464 if (e
->flags
& EDGE_FALLTHRU
)
8465 e
->flags
&= ~EDGE_ABNORMAL
;
8467 remove_edge_and_dominated_blocks (e
);
8477 /* Purge dead abnormal call edges from basic block listed in BLOCKS. */
8480 gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks
)
8482 bool changed
= false;
8486 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
8488 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8490 /* Earlier gimple_purge_dead_abnormal_call_edges could have removed
8491 this basic block already. */
8492 gcc_assert (bb
|| changed
);
8494 changed
|= gimple_purge_dead_abnormal_call_edges (bb
);
8500 /* This function is called whenever a new edge is created or
8504 gimple_execute_on_growing_pred (edge e
)
8506 basic_block bb
= e
->dest
;
8508 if (!gimple_seq_empty_p (phi_nodes (bb
)))
8509 reserve_phi_args_for_new_edge (bb
);
8512 /* This function is called immediately before edge E is removed from
8513 the edge vector E->dest->preds. */
8516 gimple_execute_on_shrinking_pred (edge e
)
8518 if (!gimple_seq_empty_p (phi_nodes (e
->dest
)))
8519 remove_phi_args (e
);
8522 /*---------------------------------------------------------------------------
8523 Helper functions for Loop versioning
8524 ---------------------------------------------------------------------------*/
8526 /* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy
8527 of 'first'. Both of them are dominated by 'new_head' basic block. When
8528 'new_head' was created by 'second's incoming edge it received phi arguments
8529 on the edge by split_edge(). Later, additional edge 'e' was created to
8530 connect 'new_head' and 'first'. Now this routine adds phi args on this
8531 additional edge 'e' that new_head to second edge received as part of edge
8535 gimple_lv_adjust_loop_header_phi (basic_block first
, basic_block second
,
8536 basic_block new_head
, edge e
)
8539 gphi_iterator psi1
, psi2
;
8541 edge e2
= find_edge (new_head
, second
);
8543 /* Because NEW_HEAD has been created by splitting SECOND's incoming
8544 edge, we should always have an edge from NEW_HEAD to SECOND. */
8545 gcc_assert (e2
!= NULL
);
8547 /* Browse all 'second' basic block phi nodes and add phi args to
8548 edge 'e' for 'first' head. PHI args are always in correct order. */
8550 for (psi2
= gsi_start_phis (second
),
8551 psi1
= gsi_start_phis (first
);
8552 !gsi_end_p (psi2
) && !gsi_end_p (psi1
);
8553 gsi_next (&psi2
), gsi_next (&psi1
))
8557 def
= PHI_ARG_DEF (phi2
, e2
->dest_idx
);
8558 add_phi_arg (phi1
, def
, e
, gimple_phi_arg_location_from_edge (phi2
, e2
));
8563 /* Adds a if else statement to COND_BB with condition COND_EXPR.
8564 SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
8565 the destination of the ELSE part. */
8568 gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED
,
8569 basic_block second_head ATTRIBUTE_UNUSED
,
8570 basic_block cond_bb
, void *cond_e
)
8572 gimple_stmt_iterator gsi
;
8573 gimple
*new_cond_expr
;
8574 tree cond_expr
= (tree
) cond_e
;
8577 /* Build new conditional expr */
8578 new_cond_expr
= gimple_build_cond_from_tree (cond_expr
,
8579 NULL_TREE
, NULL_TREE
);
8581 /* Add new cond in cond_bb. */
8582 gsi
= gsi_last_bb (cond_bb
);
8583 gsi_insert_after (&gsi
, new_cond_expr
, GSI_NEW_STMT
);
8585 /* Adjust edges appropriately to connect new head with first head
8586 as well as second head. */
8587 e0
= single_succ_edge (cond_bb
);
8588 e0
->flags
&= ~EDGE_FALLTHRU
;
8589 e0
->flags
|= EDGE_FALSE_VALUE
;
8593 /* Do book-keeping of basic block BB for the profile consistency checker.
8594 If AFTER_PASS is 0, do pre-pass accounting, or if AFTER_PASS is 1
8595 then do post-pass accounting. Store the counting in RECORD. */
8597 gimple_account_profile_record (basic_block bb
, int after_pass
,
8598 struct profile_record
*record
)
8600 gimple_stmt_iterator i
;
8601 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
8603 record
->size
[after_pass
]
8604 += estimate_num_insns (gsi_stmt (i
), &eni_size_weights
);
8605 if (bb
->count
.initialized_p ())
8606 record
->time
[after_pass
]
8607 += estimate_num_insns (gsi_stmt (i
),
8608 &eni_time_weights
) * bb
->count
.to_gcov_type ();
8609 else if (profile_status_for_fn (cfun
) == PROFILE_GUESSED
)
8610 record
->time
[after_pass
]
8611 += estimate_num_insns (gsi_stmt (i
),
8612 &eni_time_weights
) * bb
->frequency
;
8616 struct cfg_hooks gimple_cfg_hooks
= {
8618 gimple_verify_flow_info
,
8619 gimple_dump_bb
, /* dump_bb */
8620 gimple_dump_bb_for_graph
, /* dump_bb_for_graph */
8621 create_bb
, /* create_basic_block */
8622 gimple_redirect_edge_and_branch
, /* redirect_edge_and_branch */
8623 gimple_redirect_edge_and_branch_force
, /* redirect_edge_and_branch_force */
8624 gimple_can_remove_branch_p
, /* can_remove_branch_p */
8625 remove_bb
, /* delete_basic_block */
8626 gimple_split_block
, /* split_block */
8627 gimple_move_block_after
, /* move_block_after */
8628 gimple_can_merge_blocks_p
, /* can_merge_blocks_p */
8629 gimple_merge_blocks
, /* merge_blocks */
8630 gimple_predict_edge
, /* predict_edge */
8631 gimple_predicted_by_p
, /* predicted_by_p */
8632 gimple_can_duplicate_bb_p
, /* can_duplicate_block_p */
8633 gimple_duplicate_bb
, /* duplicate_block */
8634 gimple_split_edge
, /* split_edge */
8635 gimple_make_forwarder_block
, /* make_forward_block */
8636 NULL
, /* tidy_fallthru_edge */
8637 NULL
, /* force_nonfallthru */
8638 gimple_block_ends_with_call_p
,/* block_ends_with_call_p */
8639 gimple_block_ends_with_condjump_p
, /* block_ends_with_condjump_p */
8640 gimple_flow_call_edges_add
, /* flow_call_edges_add */
8641 gimple_execute_on_growing_pred
, /* execute_on_growing_pred */
8642 gimple_execute_on_shrinking_pred
, /* execute_on_shrinking_pred */
8643 gimple_duplicate_loop_to_header_edge
, /* duplicate loop for trees */
8644 gimple_lv_add_condition_to_bb
, /* lv_add_condition_to_bb */
8645 gimple_lv_adjust_loop_header_phi
, /* lv_adjust_loop_header_phi*/
8646 extract_true_false_edges_from_block
, /* extract_cond_bb_edges */
8647 flush_pending_stmts
, /* flush_pending_stmts */
8648 gimple_empty_block_p
, /* block_empty_p */
8649 gimple_split_block_before_cond_jump
, /* split_block_before_cond_jump */
8650 gimple_account_profile_record
,
8654 /* Split all critical edges. */
8657 split_critical_edges (void)
8663 /* split_edge can redirect edges out of SWITCH_EXPRs, which can get
8664 expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
8665 mappings around the calls to split_edge. */
8666 start_recording_case_labels ();
8667 FOR_ALL_BB_FN (bb
, cfun
)
8669 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8671 if (EDGE_CRITICAL_P (e
) && !(e
->flags
& EDGE_ABNORMAL
))
8673 /* PRE inserts statements to edges and expects that
8674 since split_critical_edges was done beforehand, committing edge
8675 insertions will not split more edges. In addition to critical
8676 edges we must split edges that have multiple successors and
8677 end by control flow statements, such as RESX.
8678 Go ahead and split them too. This matches the logic in
8679 gimple_find_edge_insert_loc. */
8680 else if ((!single_pred_p (e
->dest
)
8681 || !gimple_seq_empty_p (phi_nodes (e
->dest
))
8682 || e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
8683 && e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)
8684 && !(e
->flags
& EDGE_ABNORMAL
))
8686 gimple_stmt_iterator gsi
;
8688 gsi
= gsi_last_bb (e
->src
);
8689 if (!gsi_end_p (gsi
)
8690 && stmt_ends_bb_p (gsi_stmt (gsi
))
8691 && (gimple_code (gsi_stmt (gsi
)) != GIMPLE_RETURN
8692 && !gimple_call_builtin_p (gsi_stmt (gsi
),
8698 end_recording_case_labels ();
8704 const pass_data pass_data_split_crit_edges
=
8706 GIMPLE_PASS
, /* type */
8707 "crited", /* name */
8708 OPTGROUP_NONE
, /* optinfo_flags */
8709 TV_TREE_SPLIT_EDGES
, /* tv_id */
8710 PROP_cfg
, /* properties_required */
8711 PROP_no_crit_edges
, /* properties_provided */
8712 0, /* properties_destroyed */
8713 0, /* todo_flags_start */
8714 0, /* todo_flags_finish */
8717 class pass_split_crit_edges
: public gimple_opt_pass
8720 pass_split_crit_edges (gcc::context
*ctxt
)
8721 : gimple_opt_pass (pass_data_split_crit_edges
, ctxt
)
8724 /* opt_pass methods: */
8725 virtual unsigned int execute (function
*) { return split_critical_edges (); }
8727 opt_pass
* clone () { return new pass_split_crit_edges (m_ctxt
); }
8728 }; // class pass_split_crit_edges
8733 make_pass_split_crit_edges (gcc::context
*ctxt
)
8735 return new pass_split_crit_edges (ctxt
);
8739 /* Insert COND expression which is GIMPLE_COND after STMT
8740 in basic block BB with appropriate basic block split
8741 and creation of a new conditionally executed basic block.
8742 Update profile so the new bb is visited with probability PROB.
8743 Return created basic block. */
8745 insert_cond_bb (basic_block bb
, gimple
*stmt
, gimple
*cond
,
8746 profile_probability prob
)
8748 edge fall
= split_block (bb
, stmt
);
8749 gimple_stmt_iterator iter
= gsi_last_bb (bb
);
8752 /* Insert cond statement. */
8753 gcc_assert (gimple_code (cond
) == GIMPLE_COND
);
8754 if (gsi_end_p (iter
))
8755 gsi_insert_before (&iter
, cond
, GSI_CONTINUE_LINKING
);
8757 gsi_insert_after (&iter
, cond
, GSI_CONTINUE_LINKING
);
8759 /* Create conditionally executed block. */
8760 new_bb
= create_empty_bb (bb
);
8761 edge e
= make_edge (bb
, new_bb
, EDGE_TRUE_VALUE
);
8762 e
->probability
= prob
;
8763 e
->count
= bb
->count
.apply_probability (prob
);
8764 new_bb
->count
= e
->count
;
8765 new_bb
->frequency
= prob
.apply (bb
->frequency
);
8766 make_single_succ_edge (new_bb
, fall
->dest
, EDGE_FALLTHRU
);
8768 /* Fix edge for split bb. */
8769 fall
->flags
= EDGE_FALSE_VALUE
;
8770 fall
->count
-= e
->count
;
8771 fall
->probability
-= e
->probability
;
8773 /* Update dominance info. */
8774 if (dom_info_available_p (CDI_DOMINATORS
))
8776 set_immediate_dominator (CDI_DOMINATORS
, new_bb
, bb
);
8777 set_immediate_dominator (CDI_DOMINATORS
, fall
->dest
, bb
);
8780 /* Update loop info. */
8782 add_bb_to_loop (new_bb
, bb
->loop_father
);
8787 /* Build a ternary operation and gimplify it. Emit code before GSI.
8788 Return the gimple_val holding the result. */
8791 gimplify_build3 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
8792 tree type
, tree a
, tree b
, tree c
)
8795 location_t loc
= gimple_location (gsi_stmt (*gsi
));
8797 ret
= fold_build3_loc (loc
, code
, type
, a
, b
, c
);
8800 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
8804 /* Build a binary operation and gimplify it. Emit code before GSI.
8805 Return the gimple_val holding the result. */
8808 gimplify_build2 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
8809 tree type
, tree a
, tree b
)
8813 ret
= fold_build2_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
, b
);
8816 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
8820 /* Build a unary operation and gimplify it. Emit code before GSI.
8821 Return the gimple_val holding the result. */
8824 gimplify_build1 (gimple_stmt_iterator
*gsi
, enum tree_code code
, tree type
,
8829 ret
= fold_build1_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
);
8832 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
8838 /* Given a basic block B which ends with a conditional and has
8839 precisely two successors, determine which of the edges is taken if
8840 the conditional is true and which is taken if the conditional is
8841 false. Set TRUE_EDGE and FALSE_EDGE appropriately. */
8844 extract_true_false_edges_from_block (basic_block b
,
8848 edge e
= EDGE_SUCC (b
, 0);
8850 if (e
->flags
& EDGE_TRUE_VALUE
)
8853 *false_edge
= EDGE_SUCC (b
, 1);
8858 *true_edge
= EDGE_SUCC (b
, 1);
8863 /* From a controlling predicate in the immediate dominator DOM of
8864 PHIBLOCK determine the edges into PHIBLOCK that are chosen if the
8865 predicate evaluates to true and false and store them to
8866 *TRUE_CONTROLLED_EDGE and *FALSE_CONTROLLED_EDGE if
8867 they are non-NULL. Returns true if the edges can be determined,
8868 else return false. */
8871 extract_true_false_controlled_edges (basic_block dom
, basic_block phiblock
,
8872 edge
*true_controlled_edge
,
8873 edge
*false_controlled_edge
)
8875 basic_block bb
= phiblock
;
8876 edge true_edge
, false_edge
, tem
;
8877 edge e0
= NULL
, e1
= NULL
;
8879 /* We have to verify that one edge into the PHI node is dominated
8880 by the true edge of the predicate block and the other edge
8881 dominated by the false edge. This ensures that the PHI argument
8882 we are going to take is completely determined by the path we
8883 take from the predicate block.
8884 We can only use BB dominance checks below if the destination of
8885 the true/false edges are dominated by their edge, thus only
8886 have a single predecessor. */
8887 extract_true_false_edges_from_block (dom
, &true_edge
, &false_edge
);
8888 tem
= EDGE_PRED (bb
, 0);
8889 if (tem
== true_edge
8890 || (single_pred_p (true_edge
->dest
)
8891 && (tem
->src
== true_edge
->dest
8892 || dominated_by_p (CDI_DOMINATORS
,
8893 tem
->src
, true_edge
->dest
))))
8895 else if (tem
== false_edge
8896 || (single_pred_p (false_edge
->dest
)
8897 && (tem
->src
== false_edge
->dest
8898 || dominated_by_p (CDI_DOMINATORS
,
8899 tem
->src
, false_edge
->dest
))))
8903 tem
= EDGE_PRED (bb
, 1);
8904 if (tem
== true_edge
8905 || (single_pred_p (true_edge
->dest
)
8906 && (tem
->src
== true_edge
->dest
8907 || dominated_by_p (CDI_DOMINATORS
,
8908 tem
->src
, true_edge
->dest
))))
8910 else if (tem
== false_edge
8911 || (single_pred_p (false_edge
->dest
)
8912 && (tem
->src
== false_edge
->dest
8913 || dominated_by_p (CDI_DOMINATORS
,
8914 tem
->src
, false_edge
->dest
))))
8921 if (true_controlled_edge
)
8922 *true_controlled_edge
= e0
;
8923 if (false_controlled_edge
)
8924 *false_controlled_edge
= e1
;
8931 /* Emit return warnings. */
8935 const pass_data pass_data_warn_function_return
=
8937 GIMPLE_PASS
, /* type */
8938 "*warn_function_return", /* name */
8939 OPTGROUP_NONE
, /* optinfo_flags */
8940 TV_NONE
, /* tv_id */
8941 PROP_cfg
, /* properties_required */
8942 0, /* properties_provided */
8943 0, /* properties_destroyed */
8944 0, /* todo_flags_start */
8945 0, /* todo_flags_finish */
8948 class pass_warn_function_return
: public gimple_opt_pass
8951 pass_warn_function_return (gcc::context
*ctxt
)
8952 : gimple_opt_pass (pass_data_warn_function_return
, ctxt
)
8955 /* opt_pass methods: */
8956 virtual unsigned int execute (function
*);
8958 }; // class pass_warn_function_return
8961 pass_warn_function_return::execute (function
*fun
)
8963 source_location location
;
8968 if (!targetm
.warn_func_return (fun
->decl
))
8971 /* If we have a path to EXIT, then we do return. */
8972 if (TREE_THIS_VOLATILE (fun
->decl
)
8973 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) > 0)
8975 location
= UNKNOWN_LOCATION
;
8976 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
)
8978 last
= last_stmt (e
->src
);
8979 if ((gimple_code (last
) == GIMPLE_RETURN
8980 || gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
8981 && (location
= gimple_location (last
)) != UNKNOWN_LOCATION
)
8984 if (location
== UNKNOWN_LOCATION
)
8985 location
= cfun
->function_end_locus
;
8986 warning_at (location
, 0, "%<noreturn%> function does return");
8989 /* If we see "return;" in some basic block, then we do reach the end
8990 without returning a value. */
8991 else if (warn_return_type
8992 && !TREE_NO_WARNING (fun
->decl
)
8993 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) > 0
8994 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fun
->decl
))))
8996 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
)
8998 gimple
*last
= last_stmt (e
->src
);
8999 greturn
*return_stmt
= dyn_cast
<greturn
*> (last
);
9001 && gimple_return_retval (return_stmt
) == NULL
9002 && !gimple_no_warning_p (last
))
9004 location
= gimple_location (last
);
9005 if (location
== UNKNOWN_LOCATION
)
9006 location
= fun
->function_end_locus
;
9007 warning_at (location
, OPT_Wreturn_type
, "control reaches end of non-void function");
9008 TREE_NO_WARNING (fun
->decl
) = 1;
9019 make_pass_warn_function_return (gcc::context
*ctxt
)
9021 return new pass_warn_function_return (ctxt
);
9024 /* Walk a gimplified function and warn for functions whose return value is
9025 ignored and attribute((warn_unused_result)) is set. This is done before
9026 inlining, so we don't have to worry about that. */
9029 do_warn_unused_result (gimple_seq seq
)
9032 gimple_stmt_iterator i
;
9034 for (i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
9036 gimple
*g
= gsi_stmt (i
);
9038 switch (gimple_code (g
))
9041 do_warn_unused_result (gimple_bind_body (as_a
<gbind
*>(g
)));
9044 do_warn_unused_result (gimple_try_eval (g
));
9045 do_warn_unused_result (gimple_try_cleanup (g
));
9048 do_warn_unused_result (gimple_catch_handler (
9049 as_a
<gcatch
*> (g
)));
9051 case GIMPLE_EH_FILTER
:
9052 do_warn_unused_result (gimple_eh_filter_failure (g
));
9056 if (gimple_call_lhs (g
))
9058 if (gimple_call_internal_p (g
))
9061 /* This is a naked call, as opposed to a GIMPLE_CALL with an
9062 LHS. All calls whose value is ignored should be
9063 represented like this. Look for the attribute. */
9064 fdecl
= gimple_call_fndecl (g
);
9065 ftype
= gimple_call_fntype (g
);
9067 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
9069 location_t loc
= gimple_location (g
);
9072 warning_at (loc
, OPT_Wunused_result
,
9073 "ignoring return value of %qD, "
9074 "declared with attribute warn_unused_result",
9077 warning_at (loc
, OPT_Wunused_result
,
9078 "ignoring return value of function "
9079 "declared with attribute warn_unused_result");
9084 /* Not a container, not a call, or a call whose value is used. */
9092 const pass_data pass_data_warn_unused_result
=
9094 GIMPLE_PASS
, /* type */
9095 "*warn_unused_result", /* name */
9096 OPTGROUP_NONE
, /* optinfo_flags */
9097 TV_NONE
, /* tv_id */
9098 PROP_gimple_any
, /* properties_required */
9099 0, /* properties_provided */
9100 0, /* properties_destroyed */
9101 0, /* todo_flags_start */
9102 0, /* todo_flags_finish */
9105 class pass_warn_unused_result
: public gimple_opt_pass
9108 pass_warn_unused_result (gcc::context
*ctxt
)
9109 : gimple_opt_pass (pass_data_warn_unused_result
, ctxt
)
9112 /* opt_pass methods: */
9113 virtual bool gate (function
*) { return flag_warn_unused_result
; }
9114 virtual unsigned int execute (function
*)
9116 do_warn_unused_result (gimple_body (current_function_decl
));
9120 }; // class pass_warn_unused_result
9125 make_pass_warn_unused_result (gcc::context
*ctxt
)
9127 return new pass_warn_unused_result (ctxt
);
9130 /* IPA passes, compilation of earlier functions or inlining
9131 might have changed some properties, such as marked functions nothrow,
9132 pure, const or noreturn.
9133 Remove redundant edges and basic blocks, and create new ones if necessary.
9135 This pass can't be executed as stand alone pass from pass manager, because
9136 in between inlining and this fixup the verify_flow_info would fail. */
9139 execute_fixup_cfg (void)
9142 gimple_stmt_iterator gsi
;
9146 cgraph_node
*node
= cgraph_node::get (current_function_decl
);
9147 profile_count num
= node
->count
;
9148 profile_count den
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
9149 bool scale
= num
.initialized_p ()
9150 && (den
> 0 || num
== profile_count::zero ())
9155 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= node
->count
;
9156 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
9157 = EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
.apply_scale (num
, den
);
9159 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
)
9160 e
->count
= e
->count
.apply_scale (num
, den
);
9163 FOR_EACH_BB_FN (bb
, cfun
)
9166 bb
->count
= bb
->count
.apply_scale (num
, den
);
9167 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
9169 gimple
*stmt
= gsi_stmt (gsi
);
9170 tree decl
= is_gimple_call (stmt
)
9171 ? gimple_call_fndecl (stmt
)
9175 int flags
= gimple_call_flags (stmt
);
9176 if (flags
& (ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
))
9178 if (gimple_purge_dead_abnormal_call_edges (bb
))
9179 todo
|= TODO_cleanup_cfg
;
9181 if (gimple_in_ssa_p (cfun
))
9183 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
9188 if (flags
& ECF_NORETURN
9189 && fixup_noreturn_call (stmt
))
9190 todo
|= TODO_cleanup_cfg
;
9193 /* Remove stores to variables we marked write-only.
9194 Keep access when store has side effect, i.e. in case when source
9196 if (gimple_store_p (stmt
)
9197 && !gimple_has_side_effects (stmt
))
9199 tree lhs
= get_base_address (gimple_get_lhs (stmt
));
9202 && (TREE_STATIC (lhs
) || DECL_EXTERNAL (lhs
))
9203 && varpool_node::get (lhs
)->writeonly
)
9205 unlink_stmt_vdef (stmt
);
9206 gsi_remove (&gsi
, true);
9207 release_defs (stmt
);
9208 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
9212 /* For calls we can simply remove LHS when it is known
9213 to be write-only. */
9214 if (is_gimple_call (stmt
)
9215 && gimple_get_lhs (stmt
))
9217 tree lhs
= get_base_address (gimple_get_lhs (stmt
));
9220 && (TREE_STATIC (lhs
) || DECL_EXTERNAL (lhs
))
9221 && varpool_node::get (lhs
)->writeonly
)
9223 gimple_call_set_lhs (stmt
, NULL
);
9225 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
9229 if (maybe_clean_eh_stmt (stmt
)
9230 && gimple_purge_dead_eh_edges (bb
))
9231 todo
|= TODO_cleanup_cfg
;
9236 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
9237 e
->count
= e
->count
.apply_scale (num
, den
);
9239 /* If we have a basic block with no successors that does not
9240 end with a control statement or a noreturn call end it with
9241 a call to __builtin_unreachable. This situation can occur
9242 when inlining a noreturn call that does in fact return. */
9243 if (EDGE_COUNT (bb
->succs
) == 0)
9245 gimple
*stmt
= last_stmt (bb
);
9247 || (!is_ctrl_stmt (stmt
)
9248 && (!is_gimple_call (stmt
)
9249 || !gimple_call_noreturn_p (stmt
))))
9251 if (stmt
&& is_gimple_call (stmt
))
9252 gimple_call_set_ctrl_altering (stmt
, false);
9253 tree fndecl
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
9254 stmt
= gimple_build_call (fndecl
, 0);
9255 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
9256 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
9257 if (!cfun
->after_inlining
)
9259 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
9261 = compute_call_stmt_bb_frequency (current_function_decl
,
9263 node
->create_edge (cgraph_node::get_create (fndecl
),
9264 call_stmt
, bb
->count
, freq
);
9270 compute_function_frequency ();
9273 && (todo
& TODO_cleanup_cfg
))
9274 loops_state_set (LOOPS_NEED_FIXUP
);
9281 const pass_data pass_data_fixup_cfg
=
9283 GIMPLE_PASS
, /* type */
9284 "fixup_cfg", /* name */
9285 OPTGROUP_NONE
, /* optinfo_flags */
9286 TV_NONE
, /* tv_id */
9287 PROP_cfg
, /* properties_required */
9288 0, /* properties_provided */
9289 0, /* properties_destroyed */
9290 0, /* todo_flags_start */
9291 0, /* todo_flags_finish */
9294 class pass_fixup_cfg
: public gimple_opt_pass
9297 pass_fixup_cfg (gcc::context
*ctxt
)
9298 : gimple_opt_pass (pass_data_fixup_cfg
, ctxt
)
9301 /* opt_pass methods: */
9302 opt_pass
* clone () { return new pass_fixup_cfg (m_ctxt
); }
9303 virtual unsigned int execute (function
*) { return execute_fixup_cfg (); }
9305 }; // class pass_fixup_cfg
9310 make_pass_fixup_cfg (gcc::context
*ctxt
)
9312 return new pass_fixup_cfg (ctxt
);
9315 /* Garbage collection support for edge_def. */
9317 extern void gt_ggc_mx (tree
&);
9318 extern void gt_ggc_mx (gimple
*&);
9319 extern void gt_ggc_mx (rtx
&);
9320 extern void gt_ggc_mx (basic_block
&);
9323 gt_ggc_mx (rtx_insn
*& x
)
9326 gt_ggc_mx_rtx_def ((void *) x
);
9330 gt_ggc_mx (edge_def
*e
)
9332 tree block
= LOCATION_BLOCK (e
->goto_locus
);
9334 gt_ggc_mx (e
->dest
);
9335 if (current_ir_type () == IR_GIMPLE
)
9336 gt_ggc_mx (e
->insns
.g
);
9338 gt_ggc_mx (e
->insns
.r
);
9342 /* PCH support for edge_def. */
9344 extern void gt_pch_nx (tree
&);
9345 extern void gt_pch_nx (gimple
*&);
9346 extern void gt_pch_nx (rtx
&);
9347 extern void gt_pch_nx (basic_block
&);
9350 gt_pch_nx (rtx_insn
*& x
)
9353 gt_pch_nx_rtx_def ((void *) x
);
9357 gt_pch_nx (edge_def
*e
)
9359 tree block
= LOCATION_BLOCK (e
->goto_locus
);
9361 gt_pch_nx (e
->dest
);
9362 if (current_ir_type () == IR_GIMPLE
)
9363 gt_pch_nx (e
->insns
.g
);
9365 gt_pch_nx (e
->insns
.r
);
9370 gt_pch_nx (edge_def
*e
, gt_pointer_operator op
, void *cookie
)
9372 tree block
= LOCATION_BLOCK (e
->goto_locus
);
9373 op (&(e
->src
), cookie
);
9374 op (&(e
->dest
), cookie
);
9375 if (current_ir_type () == IR_GIMPLE
)
9376 op (&(e
->insns
.g
), cookie
);
9378 op (&(e
->insns
.r
), cookie
);
9379 op (&(block
), cookie
);
9384 namespace selftest
{
9386 /* Helper function for CFG selftests: create a dummy function decl
9387 and push it as cfun. */
9390 push_fndecl (const char *name
)
9392 tree fn_type
= build_function_type_array (integer_type_node
, 0, NULL
);
9393 /* FIXME: this uses input_location: */
9394 tree fndecl
= build_fn_decl (name
, fn_type
);
9395 tree retval
= build_decl (UNKNOWN_LOCATION
, RESULT_DECL
,
9396 NULL_TREE
, integer_type_node
);
9397 DECL_RESULT (fndecl
) = retval
;
9398 push_struct_function (fndecl
);
9399 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
9400 ASSERT_TRUE (fun
!= NULL
);
9401 init_empty_tree_cfg_for_function (fun
);
9402 ASSERT_EQ (2, n_basic_blocks_for_fn (fun
));
9403 ASSERT_EQ (0, n_edges_for_fn (fun
));
9407 /* These tests directly create CFGs.
9408 Compare with the static fns within tree-cfg.c:
9410 - make_blocks: calls create_basic_block (seq, bb);
9413 /* Verify a simple cfg of the form:
9414 ENTRY -> A -> B -> C -> EXIT. */
9417 test_linear_chain ()
9419 gimple_register_cfg_hooks ();
9421 tree fndecl
= push_fndecl ("cfg_test_linear_chain");
9422 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
9424 /* Create some empty blocks. */
9425 basic_block bb_a
= create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
9426 basic_block bb_b
= create_empty_bb (bb_a
);
9427 basic_block bb_c
= create_empty_bb (bb_b
);
9429 ASSERT_EQ (5, n_basic_blocks_for_fn (fun
));
9430 ASSERT_EQ (0, n_edges_for_fn (fun
));
9432 /* Create some edges: a simple linear chain of BBs. */
9433 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
), bb_a
, EDGE_FALLTHRU
);
9434 make_edge (bb_a
, bb_b
, 0);
9435 make_edge (bb_b
, bb_c
, 0);
9436 make_edge (bb_c
, EXIT_BLOCK_PTR_FOR_FN (fun
), 0);
9438 /* Verify the edges. */
9439 ASSERT_EQ (4, n_edges_for_fn (fun
));
9440 ASSERT_EQ (NULL
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->preds
);
9441 ASSERT_EQ (1, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
->length ());
9442 ASSERT_EQ (1, bb_a
->preds
->length ());
9443 ASSERT_EQ (1, bb_a
->succs
->length ());
9444 ASSERT_EQ (1, bb_b
->preds
->length ());
9445 ASSERT_EQ (1, bb_b
->succs
->length ());
9446 ASSERT_EQ (1, bb_c
->preds
->length ());
9447 ASSERT_EQ (1, bb_c
->succs
->length ());
9448 ASSERT_EQ (1, EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
->length ());
9449 ASSERT_EQ (NULL
, EXIT_BLOCK_PTR_FOR_FN (fun
)->succs
);
9451 /* Verify the dominance information
9452 Each BB in our simple chain should be dominated by the one before
9454 calculate_dominance_info (CDI_DOMINATORS
);
9455 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_b
));
9456 ASSERT_EQ (bb_b
, get_immediate_dominator (CDI_DOMINATORS
, bb_c
));
9457 vec
<basic_block
> dom_by_b
= get_dominated_by (CDI_DOMINATORS
, bb_b
);
9458 ASSERT_EQ (1, dom_by_b
.length ());
9459 ASSERT_EQ (bb_c
, dom_by_b
[0]);
9460 free_dominance_info (CDI_DOMINATORS
);
9461 dom_by_b
.release ();
9463 /* Similarly for post-dominance: each BB in our chain is post-dominated
9464 by the one after it. */
9465 calculate_dominance_info (CDI_POST_DOMINATORS
);
9466 ASSERT_EQ (bb_b
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_a
));
9467 ASSERT_EQ (bb_c
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_b
));
9468 vec
<basic_block
> postdom_by_b
= get_dominated_by (CDI_POST_DOMINATORS
, bb_b
);
9469 ASSERT_EQ (1, postdom_by_b
.length ());
9470 ASSERT_EQ (bb_a
, postdom_by_b
[0]);
9471 free_dominance_info (CDI_POST_DOMINATORS
);
9472 postdom_by_b
.release ();
9477 /* Verify a simple CFG of the form:
9493 gimple_register_cfg_hooks ();
9495 tree fndecl
= push_fndecl ("cfg_test_diamond");
9496 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
9498 /* Create some empty blocks. */
9499 basic_block bb_a
= create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
9500 basic_block bb_b
= create_empty_bb (bb_a
);
9501 basic_block bb_c
= create_empty_bb (bb_a
);
9502 basic_block bb_d
= create_empty_bb (bb_b
);
9504 ASSERT_EQ (6, n_basic_blocks_for_fn (fun
));
9505 ASSERT_EQ (0, n_edges_for_fn (fun
));
9507 /* Create the edges. */
9508 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
), bb_a
, EDGE_FALLTHRU
);
9509 make_edge (bb_a
, bb_b
, EDGE_TRUE_VALUE
);
9510 make_edge (bb_a
, bb_c
, EDGE_FALSE_VALUE
);
9511 make_edge (bb_b
, bb_d
, 0);
9512 make_edge (bb_c
, bb_d
, 0);
9513 make_edge (bb_d
, EXIT_BLOCK_PTR_FOR_FN (fun
), 0);
9515 /* Verify the edges. */
9516 ASSERT_EQ (6, n_edges_for_fn (fun
));
9517 ASSERT_EQ (1, bb_a
->preds
->length ());
9518 ASSERT_EQ (2, bb_a
->succs
->length ());
9519 ASSERT_EQ (1, bb_b
->preds
->length ());
9520 ASSERT_EQ (1, bb_b
->succs
->length ());
9521 ASSERT_EQ (1, bb_c
->preds
->length ());
9522 ASSERT_EQ (1, bb_c
->succs
->length ());
9523 ASSERT_EQ (2, bb_d
->preds
->length ());
9524 ASSERT_EQ (1, bb_d
->succs
->length ());
9526 /* Verify the dominance information. */
9527 calculate_dominance_info (CDI_DOMINATORS
);
9528 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_b
));
9529 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_c
));
9530 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_d
));
9531 vec
<basic_block
> dom_by_a
= get_dominated_by (CDI_DOMINATORS
, bb_a
);
9532 ASSERT_EQ (3, dom_by_a
.length ()); /* B, C, D, in some order. */
9533 dom_by_a
.release ();
9534 vec
<basic_block
> dom_by_b
= get_dominated_by (CDI_DOMINATORS
, bb_b
);
9535 ASSERT_EQ (0, dom_by_b
.length ());
9536 dom_by_b
.release ();
9537 free_dominance_info (CDI_DOMINATORS
);
9539 /* Similarly for post-dominance. */
9540 calculate_dominance_info (CDI_POST_DOMINATORS
);
9541 ASSERT_EQ (bb_d
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_a
));
9542 ASSERT_EQ (bb_d
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_b
));
9543 ASSERT_EQ (bb_d
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_c
));
9544 vec
<basic_block
> postdom_by_d
= get_dominated_by (CDI_POST_DOMINATORS
, bb_d
);
9545 ASSERT_EQ (3, postdom_by_d
.length ()); /* A, B, C in some order. */
9546 postdom_by_d
.release ();
9547 vec
<basic_block
> postdom_by_b
= get_dominated_by (CDI_POST_DOMINATORS
, bb_b
);
9548 ASSERT_EQ (0, postdom_by_b
.length ());
9549 postdom_by_b
.release ();
9550 free_dominance_info (CDI_POST_DOMINATORS
);
9555 /* Verify that we can handle a CFG containing a "complete" aka
9556 fully-connected subgraph (where A B C D below all have edges
9557 pointing to each other node, also to themselves).
9575 test_fully_connected ()
9577 gimple_register_cfg_hooks ();
9579 tree fndecl
= push_fndecl ("cfg_fully_connected");
9580 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
9584 /* Create some empty blocks. */
9585 auto_vec
<basic_block
> subgraph_nodes
;
9586 for (int i
= 0; i
< n
; i
++)
9587 subgraph_nodes
.safe_push (create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
)));
9589 ASSERT_EQ (n
+ 2, n_basic_blocks_for_fn (fun
));
9590 ASSERT_EQ (0, n_edges_for_fn (fun
));
9592 /* Create the edges. */
9593 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
), subgraph_nodes
[0], EDGE_FALLTHRU
);
9594 make_edge (subgraph_nodes
[0], EXIT_BLOCK_PTR_FOR_FN (fun
), 0);
9595 for (int i
= 0; i
< n
; i
++)
9596 for (int j
= 0; j
< n
; j
++)
9597 make_edge (subgraph_nodes
[i
], subgraph_nodes
[j
], 0);
9599 /* Verify the edges. */
9600 ASSERT_EQ (2 + (n
* n
), n_edges_for_fn (fun
));
9601 /* The first one is linked to ENTRY/EXIT as well as itself and
9603 ASSERT_EQ (n
+ 1, subgraph_nodes
[0]->preds
->length ());
9604 ASSERT_EQ (n
+ 1, subgraph_nodes
[0]->succs
->length ());
9605 /* The other ones in the subgraph are linked to everything in
9606 the subgraph (including themselves). */
9607 for (int i
= 1; i
< n
; i
++)
9609 ASSERT_EQ (n
, subgraph_nodes
[i
]->preds
->length ());
9610 ASSERT_EQ (n
, subgraph_nodes
[i
]->succs
->length ());
9613 /* Verify the dominance information. */
9614 calculate_dominance_info (CDI_DOMINATORS
);
9615 /* The initial block in the subgraph should be dominated by ENTRY. */
9616 ASSERT_EQ (ENTRY_BLOCK_PTR_FOR_FN (fun
),
9617 get_immediate_dominator (CDI_DOMINATORS
,
9618 subgraph_nodes
[0]));
9619 /* Every other block in the subgraph should be dominated by the
9621 for (int i
= 1; i
< n
; i
++)
9622 ASSERT_EQ (subgraph_nodes
[0],
9623 get_immediate_dominator (CDI_DOMINATORS
,
9624 subgraph_nodes
[i
]));
9625 free_dominance_info (CDI_DOMINATORS
);
9627 /* Similarly for post-dominance. */
9628 calculate_dominance_info (CDI_POST_DOMINATORS
);
9629 /* The initial block in the subgraph should be postdominated by EXIT. */
9630 ASSERT_EQ (EXIT_BLOCK_PTR_FOR_FN (fun
),
9631 get_immediate_dominator (CDI_POST_DOMINATORS
,
9632 subgraph_nodes
[0]));
9633 /* Every other block in the subgraph should be postdominated by the
9634 initial block, since that leads to EXIT. */
9635 for (int i
= 1; i
< n
; i
++)
9636 ASSERT_EQ (subgraph_nodes
[0],
9637 get_immediate_dominator (CDI_POST_DOMINATORS
,
9638 subgraph_nodes
[i
]));
9639 free_dominance_info (CDI_POST_DOMINATORS
);
9644 /* Run all of the selftests within this file. */
9649 test_linear_chain ();
9651 test_fully_connected ();
9654 } // namespace selftest
9656 /* TODO: test the dominator/postdominator logic with various graphs/nodes:
9659 - switch statement (a block with many out-edges)
9660 - something that jumps to itself
9663 #endif /* CHECKING_P */