1 /* Control flow functions for trees.
2 Copyright (C) 2001-2019 Free Software Foundation, Inc.
3 Contributed by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
30 #include "tree-pass.h"
33 #include "gimple-pretty-print.h"
34 #include "diagnostic-core.h"
35 #include "fold-const.h"
36 #include "trans-mem.h"
37 #include "stor-layout.h"
38 #include "print-tree.h"
40 #include "gimple-fold.h"
42 #include "gimple-iterator.h"
43 #include "gimplify-me.h"
44 #include "gimple-walk.h"
46 #include "tree-ssa-loop-manip.h"
47 #include "tree-ssa-loop-niter.h"
48 #include "tree-into-ssa.h"
53 #include "tree-ssa-propagate.h"
54 #include "value-prof.h"
55 #include "tree-inline.h"
56 #include "tree-ssa-live.h"
57 #include "omp-general.h"
58 #include "omp-expand.h"
59 #include "tree-cfgcleanup.h"
67 /* This file contains functions for building the Control Flow Graph (CFG)
68 for a function tree. */
70 /* Local declarations. */
72 /* Initial capacity for the basic block array. */
73 static const int initial_cfg_capacity
= 20;
75 /* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
76 which use a particular edge. The CASE_LABEL_EXPRs are chained together
77 via their CASE_CHAIN field, which we clear after we're done with the
78 hash table to prevent problems with duplication of GIMPLE_SWITCHes.
80 Access to this list of CASE_LABEL_EXPRs allows us to efficiently
81 update the case vector in response to edge redirections.
83 Right now this table is set up and torn down at key points in the
84 compilation process. It would be nice if we could make the table
85 more persistent. The key is getting notification of changes to
86 the CFG (particularly edge removal, creation and redirection). */
88 static hash_map
<edge
, tree
> *edge_to_cases
;
90 /* If we record edge_to_cases, this bitmap will hold indexes
91 of basic blocks that end in a GIMPLE_SWITCH which we touched
92 due to edge manipulations. */
94 static bitmap touched_switch_bbs
;
99 long num_merged_labels
;
102 static struct cfg_stats_d cfg_stats
;
104 /* Data to pass to replace_block_vars_by_duplicates_1. */
105 struct replace_decls_d
107 hash_map
<tree
, tree
> *vars_map
;
111 /* Hash table to store last discriminator assigned for each locus. */
112 struct locus_discrim_map
118 /* Hashtable helpers. */
120 struct locus_discrim_hasher
: free_ptr_hash
<locus_discrim_map
>
122 static inline hashval_t
hash (const locus_discrim_map
*);
123 static inline bool equal (const locus_discrim_map
*,
124 const locus_discrim_map
*);
127 /* Trivial hash function for a location_t. ITEM is a pointer to
128 a hash table entry that maps a location_t to a discriminator. */
131 locus_discrim_hasher::hash (const locus_discrim_map
*item
)
133 return item
->location_line
;
136 /* Equality function for the locus-to-discriminator map. A and B
137 point to the two hash table entries to compare. */
140 locus_discrim_hasher::equal (const locus_discrim_map
*a
,
141 const locus_discrim_map
*b
)
143 return a
->location_line
== b
->location_line
;
146 static hash_table
<locus_discrim_hasher
> *discriminator_per_locus
;
148 /* Basic blocks and flowgraphs. */
149 static void make_blocks (gimple_seq
);
152 static void make_edges (void);
153 static void assign_discriminators (void);
154 static void make_cond_expr_edges (basic_block
);
155 static void make_gimple_switch_edges (gswitch
*, basic_block
);
156 static bool make_goto_expr_edges (basic_block
);
157 static void make_gimple_asm_edges (basic_block
);
158 static edge
gimple_redirect_edge_and_branch (edge
, basic_block
);
159 static edge
gimple_try_redirect_by_replacing_jump (edge
, basic_block
);
161 /* Various helpers. */
162 static inline bool stmt_starts_bb_p (gimple
*, gimple
*);
163 static int gimple_verify_flow_info (void);
164 static void gimple_make_forwarder_block (edge
);
165 static gimple
*first_non_label_stmt (basic_block
);
166 static bool verify_gimple_transaction (gtransaction
*);
167 static bool call_can_make_abnormal_goto (gimple
*);
169 /* Flowgraph optimization and cleanup. */
170 static void gimple_merge_blocks (basic_block
, basic_block
);
171 static bool gimple_can_merge_blocks_p (basic_block
, basic_block
);
172 static void remove_bb (basic_block
);
173 static edge
find_taken_edge_computed_goto (basic_block
, tree
);
174 static edge
find_taken_edge_cond_expr (const gcond
*, tree
);
177 init_empty_tree_cfg_for_function (struct function
*fn
)
179 /* Initialize the basic block array. */
181 profile_status_for_fn (fn
) = PROFILE_ABSENT
;
182 n_basic_blocks_for_fn (fn
) = NUM_FIXED_BLOCKS
;
183 last_basic_block_for_fn (fn
) = NUM_FIXED_BLOCKS
;
184 vec_alloc (basic_block_info_for_fn (fn
), initial_cfg_capacity
);
185 vec_safe_grow_cleared (basic_block_info_for_fn (fn
),
186 initial_cfg_capacity
);
188 /* Build a mapping of labels to their associated blocks. */
189 vec_alloc (label_to_block_map_for_fn (fn
), initial_cfg_capacity
);
190 vec_safe_grow_cleared (label_to_block_map_for_fn (fn
),
191 initial_cfg_capacity
);
193 SET_BASIC_BLOCK_FOR_FN (fn
, ENTRY_BLOCK
, ENTRY_BLOCK_PTR_FOR_FN (fn
));
194 SET_BASIC_BLOCK_FOR_FN (fn
, EXIT_BLOCK
, EXIT_BLOCK_PTR_FOR_FN (fn
));
196 ENTRY_BLOCK_PTR_FOR_FN (fn
)->next_bb
197 = EXIT_BLOCK_PTR_FOR_FN (fn
);
198 EXIT_BLOCK_PTR_FOR_FN (fn
)->prev_bb
199 = ENTRY_BLOCK_PTR_FOR_FN (fn
);
203 init_empty_tree_cfg (void)
205 init_empty_tree_cfg_for_function (cfun
);
208 /*---------------------------------------------------------------------------
210 ---------------------------------------------------------------------------*/
212 /* Entry point to the CFG builder for trees. SEQ is the sequence of
213 statements to be added to the flowgraph. */
216 build_gimple_cfg (gimple_seq seq
)
218 /* Register specific gimple functions. */
219 gimple_register_cfg_hooks ();
221 memset ((void *) &cfg_stats
, 0, sizeof (cfg_stats
));
223 init_empty_tree_cfg ();
227 /* Make sure there is always at least one block, even if it's empty. */
228 if (n_basic_blocks_for_fn (cfun
) == NUM_FIXED_BLOCKS
)
229 create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
231 /* Adjust the size of the array. */
232 if (basic_block_info_for_fn (cfun
)->length ()
233 < (size_t) n_basic_blocks_for_fn (cfun
))
234 vec_safe_grow_cleared (basic_block_info_for_fn (cfun
),
235 n_basic_blocks_for_fn (cfun
));
237 /* To speed up statement iterator walks, we first purge dead labels. */
238 cleanup_dead_labels ();
240 /* Group case nodes to reduce the number of edges.
241 We do this after cleaning up dead labels because otherwise we miss
242 a lot of obvious case merging opportunities. */
243 group_case_labels ();
245 /* Create the edges of the flowgraph. */
246 discriminator_per_locus
= new hash_table
<locus_discrim_hasher
> (13);
248 assign_discriminators ();
249 cleanup_dead_labels ();
250 delete discriminator_per_locus
;
251 discriminator_per_locus
= NULL
;
254 /* Look for ANNOTATE calls with loop annotation kind in BB; if found, remove
255 them and propagate the information to LOOP. We assume that the annotations
256 come immediately before the condition in BB, if any. */
259 replace_loop_annotate_in_block (basic_block bb
, class loop
*loop
)
261 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
262 gimple
*stmt
= gsi_stmt (gsi
);
264 if (!(stmt
&& gimple_code (stmt
) == GIMPLE_COND
))
267 for (gsi_prev_nondebug (&gsi
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
269 stmt
= gsi_stmt (gsi
);
270 if (gimple_code (stmt
) != GIMPLE_CALL
)
272 if (!gimple_call_internal_p (stmt
)
273 || gimple_call_internal_fn (stmt
) != IFN_ANNOTATE
)
276 switch ((annot_expr_kind
) tree_to_shwi (gimple_call_arg (stmt
, 1)))
278 case annot_expr_ivdep_kind
:
279 loop
->safelen
= INT_MAX
;
281 case annot_expr_unroll_kind
:
283 = (unsigned short) tree_to_shwi (gimple_call_arg (stmt
, 2));
284 cfun
->has_unroll
= true;
286 case annot_expr_no_vector_kind
:
287 loop
->dont_vectorize
= true;
289 case annot_expr_vector_kind
:
290 loop
->force_vectorize
= true;
291 cfun
->has_force_vectorize_loops
= true;
293 case annot_expr_parallel_kind
:
294 loop
->can_be_parallel
= true;
295 loop
->safelen
= INT_MAX
;
301 stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
302 gimple_call_arg (stmt
, 0));
303 gsi_replace (&gsi
, stmt
, true);
307 /* Look for ANNOTATE calls with loop annotation kind; if found, remove
308 them and propagate the information to the loop. We assume that the
309 annotations come immediately before the condition of the loop. */
312 replace_loop_annotate (void)
316 gimple_stmt_iterator gsi
;
319 FOR_EACH_LOOP (loop
, 0)
321 /* First look into the header. */
322 replace_loop_annotate_in_block (loop
->header
, loop
);
324 /* Then look into the latch, if any. */
326 replace_loop_annotate_in_block (loop
->latch
, loop
);
329 /* Remove IFN_ANNOTATE. Safeguard for the case loop->latch == NULL. */
330 FOR_EACH_BB_FN (bb
, cfun
)
332 for (gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
334 stmt
= gsi_stmt (gsi
);
335 if (gimple_code (stmt
) != GIMPLE_CALL
)
337 if (!gimple_call_internal_p (stmt
)
338 || gimple_call_internal_fn (stmt
) != IFN_ANNOTATE
)
341 switch ((annot_expr_kind
) tree_to_shwi (gimple_call_arg (stmt
, 1)))
343 case annot_expr_ivdep_kind
:
344 case annot_expr_unroll_kind
:
345 case annot_expr_no_vector_kind
:
346 case annot_expr_vector_kind
:
347 case annot_expr_parallel_kind
:
353 warning_at (gimple_location (stmt
), 0, "ignoring loop annotation");
354 stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
355 gimple_call_arg (stmt
, 0));
356 gsi_replace (&gsi
, stmt
, true);
362 execute_build_cfg (void)
364 gimple_seq body
= gimple_body (current_function_decl
);
366 build_gimple_cfg (body
);
367 gimple_set_body (current_function_decl
, NULL
);
368 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
370 fprintf (dump_file
, "Scope blocks:\n");
371 dump_scope_blocks (dump_file
, dump_flags
);
374 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
375 replace_loop_annotate ();
381 const pass_data pass_data_build_cfg
=
383 GIMPLE_PASS
, /* type */
385 OPTGROUP_NONE
, /* optinfo_flags */
386 TV_TREE_CFG
, /* tv_id */
387 PROP_gimple_leh
, /* properties_required */
388 ( PROP_cfg
| PROP_loops
), /* properties_provided */
389 0, /* properties_destroyed */
390 0, /* todo_flags_start */
391 0, /* todo_flags_finish */
394 class pass_build_cfg
: public gimple_opt_pass
397 pass_build_cfg (gcc::context
*ctxt
)
398 : gimple_opt_pass (pass_data_build_cfg
, ctxt
)
401 /* opt_pass methods: */
402 virtual unsigned int execute (function
*) { return execute_build_cfg (); }
404 }; // class pass_build_cfg
409 make_pass_build_cfg (gcc::context
*ctxt
)
411 return new pass_build_cfg (ctxt
);
415 /* Return true if T is a computed goto. */
418 computed_goto_p (gimple
*t
)
420 return (gimple_code (t
) == GIMPLE_GOTO
421 && TREE_CODE (gimple_goto_dest (t
)) != LABEL_DECL
);
424 /* Returns true if the sequence of statements STMTS only contains
425 a call to __builtin_unreachable (). */
428 gimple_seq_unreachable_p (gimple_seq stmts
)
431 /* Return false if -fsanitize=unreachable, we don't want to
432 optimize away those calls, but rather turn them into
433 __ubsan_handle_builtin_unreachable () or __builtin_trap ()
435 || sanitize_flags_p (SANITIZE_UNREACHABLE
))
438 gimple_stmt_iterator gsi
= gsi_last (stmts
);
440 if (!gimple_call_builtin_p (gsi_stmt (gsi
), BUILT_IN_UNREACHABLE
))
443 for (gsi_prev (&gsi
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
445 gimple
*stmt
= gsi_stmt (gsi
);
446 if (gimple_code (stmt
) != GIMPLE_LABEL
447 && !is_gimple_debug (stmt
)
448 && !gimple_clobber_p (stmt
))
454 /* Returns true for edge E where e->src ends with a GIMPLE_COND and
455 the other edge points to a bb with just __builtin_unreachable ().
456 I.e. return true for C->M edge in:
464 __builtin_unreachable ();
468 assert_unreachable_fallthru_edge_p (edge e
)
470 basic_block pred_bb
= e
->src
;
471 gimple
*last
= last_stmt (pred_bb
);
472 if (last
&& gimple_code (last
) == GIMPLE_COND
)
474 basic_block other_bb
= EDGE_SUCC (pred_bb
, 0)->dest
;
475 if (other_bb
== e
->dest
)
476 other_bb
= EDGE_SUCC (pred_bb
, 1)->dest
;
477 if (EDGE_COUNT (other_bb
->succs
) == 0)
478 return gimple_seq_unreachable_p (bb_seq (other_bb
));
484 /* Initialize GF_CALL_CTRL_ALTERING flag, which indicates the call
485 could alter control flow except via eh. We initialize the flag at
486 CFG build time and only ever clear it later. */
489 gimple_call_initialize_ctrl_altering (gimple
*stmt
)
491 int flags
= gimple_call_flags (stmt
);
493 /* A call alters control flow if it can make an abnormal goto. */
494 if (call_can_make_abnormal_goto (stmt
)
495 /* A call also alters control flow if it does not return. */
496 || flags
& ECF_NORETURN
497 /* TM ending statements have backedges out of the transaction.
498 Return true so we split the basic block containing them.
499 Note that the TM_BUILTIN test is merely an optimization. */
500 || ((flags
& ECF_TM_BUILTIN
)
501 && is_tm_ending_fndecl (gimple_call_fndecl (stmt
)))
502 /* BUILT_IN_RETURN call is same as return statement. */
503 || gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
)
504 /* IFN_UNIQUE should be the last insn, to make checking for it
505 as cheap as possible. */
506 || (gimple_call_internal_p (stmt
)
507 && gimple_call_internal_unique_p (stmt
)))
508 gimple_call_set_ctrl_altering (stmt
, true);
510 gimple_call_set_ctrl_altering (stmt
, false);
514 /* Insert SEQ after BB and build a flowgraph. */
517 make_blocks_1 (gimple_seq seq
, basic_block bb
)
519 gimple_stmt_iterator i
= gsi_start (seq
);
521 gimple
*prev_stmt
= NULL
;
522 bool start_new_block
= true;
523 bool first_stmt_of_seq
= true;
525 while (!gsi_end_p (i
))
527 /* PREV_STMT should only be set to a debug stmt if the debug
528 stmt is before nondebug stmts. Once stmt reaches a nondebug
529 nonlabel, prev_stmt will be set to it, so that
530 stmt_starts_bb_p will know to start a new block if a label is
531 found. However, if stmt was a label after debug stmts only,
532 keep the label in prev_stmt even if we find further debug
533 stmts, for there may be other labels after them, and they
534 should land in the same block. */
535 if (!prev_stmt
|| !stmt
|| !is_gimple_debug (stmt
))
539 if (stmt
&& is_gimple_call (stmt
))
540 gimple_call_initialize_ctrl_altering (stmt
);
542 /* If the statement starts a new basic block or if we have determined
543 in a previous pass that we need to create a new block for STMT, do
545 if (start_new_block
|| stmt_starts_bb_p (stmt
, prev_stmt
))
547 if (!first_stmt_of_seq
)
548 gsi_split_seq_before (&i
, &seq
);
549 bb
= create_basic_block (seq
, bb
);
550 start_new_block
= false;
554 /* Now add STMT to BB and create the subgraphs for special statement
556 gimple_set_bb (stmt
, bb
);
558 /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
560 if (stmt_ends_bb_p (stmt
))
562 /* If the stmt can make abnormal goto use a new temporary
563 for the assignment to the LHS. This makes sure the old value
564 of the LHS is available on the abnormal edge. Otherwise
565 we will end up with overlapping life-ranges for abnormal
567 if (gimple_has_lhs (stmt
)
568 && stmt_can_make_abnormal_goto (stmt
)
569 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt
))))
571 tree lhs
= gimple_get_lhs (stmt
);
572 tree tmp
= create_tmp_var (TREE_TYPE (lhs
));
573 gimple
*s
= gimple_build_assign (lhs
, tmp
);
574 gimple_set_location (s
, gimple_location (stmt
));
575 gimple_set_block (s
, gimple_block (stmt
));
576 gimple_set_lhs (stmt
, tmp
);
577 if (TREE_CODE (TREE_TYPE (tmp
)) == COMPLEX_TYPE
578 || TREE_CODE (TREE_TYPE (tmp
)) == VECTOR_TYPE
)
579 DECL_GIMPLE_REG_P (tmp
) = 1;
580 gsi_insert_after (&i
, s
, GSI_SAME_STMT
);
582 start_new_block
= true;
586 first_stmt_of_seq
= false;
591 /* Build a flowgraph for the sequence of stmts SEQ. */
594 make_blocks (gimple_seq seq
)
596 /* Look for debug markers right before labels, and move the debug
597 stmts after the labels. Accepting labels among debug markers
598 adds no value, just complexity; if we wanted to annotate labels
599 with view numbers (so sequencing among markers would matter) or
600 somesuch, we're probably better off still moving the labels, but
601 adding other debug annotations in their original positions or
602 emitting nonbind or bind markers associated with the labels in
603 the original position of the labels.
605 Moving labels would probably be simpler, but we can't do that:
606 moving labels assigns label ids to them, and doing so because of
607 debug markers makes for -fcompare-debug and possibly even codegen
608 differences. So, we have to move the debug stmts instead. To
609 that end, we scan SEQ backwards, marking the position of the
610 latest (earliest we find) label, and moving debug stmts that are
611 not separated from it by nondebug nonlabel stmts after the
613 if (MAY_HAVE_DEBUG_MARKER_STMTS
)
615 gimple_stmt_iterator label
= gsi_none ();
617 for (gimple_stmt_iterator i
= gsi_last (seq
); !gsi_end_p (i
); gsi_prev (&i
))
619 gimple
*stmt
= gsi_stmt (i
);
621 /* If this is the first label we encounter (latest in SEQ)
622 before nondebug stmts, record its position. */
623 if (is_a
<glabel
*> (stmt
))
625 if (gsi_end_p (label
))
630 /* Without a recorded label position to move debug stmts to,
631 there's nothing to do. */
632 if (gsi_end_p (label
))
635 /* Move the debug stmt at I after LABEL. */
636 if (is_gimple_debug (stmt
))
638 gcc_assert (gimple_debug_nonbind_marker_p (stmt
));
639 /* As STMT is removed, I advances to the stmt after
640 STMT, so the gsi_prev in the for "increment"
641 expression gets us to the stmt we're to visit after
642 STMT. LABEL, however, would advance to the moved
643 stmt if we passed it to gsi_move_after, so pass it a
644 copy instead, so as to keep LABEL pointing to the
646 gimple_stmt_iterator copy
= label
;
647 gsi_move_after (&i
, ©
);
651 /* There aren't any (more?) debug stmts before label, so
652 there isn't anything else to move after it. */
657 make_blocks_1 (seq
, ENTRY_BLOCK_PTR_FOR_FN (cfun
));
660 /* Create and return a new empty basic block after bb AFTER. */
663 create_bb (void *h
, void *e
, basic_block after
)
669 /* Create and initialize a new basic block. Since alloc_block uses
670 GC allocation that clears memory to allocate a basic block, we do
671 not have to clear the newly allocated basic block here. */
674 bb
->index
= last_basic_block_for_fn (cfun
);
676 set_bb_seq (bb
, h
? (gimple_seq
) h
: NULL
);
678 /* Add the new block to the linked list of blocks. */
679 link_block (bb
, after
);
681 /* Grow the basic block array if needed. */
682 if ((size_t) last_basic_block_for_fn (cfun
)
683 == basic_block_info_for_fn (cfun
)->length ())
686 (last_basic_block_for_fn (cfun
)
687 + (last_basic_block_for_fn (cfun
) + 3) / 4);
688 vec_safe_grow_cleared (basic_block_info_for_fn (cfun
), new_size
);
691 /* Add the newly created block to the array. */
692 SET_BASIC_BLOCK_FOR_FN (cfun
, last_basic_block_for_fn (cfun
), bb
);
694 n_basic_blocks_for_fn (cfun
)++;
695 last_basic_block_for_fn (cfun
)++;
701 /*---------------------------------------------------------------------------
703 ---------------------------------------------------------------------------*/
705 /* If basic block BB has an abnormal edge to a basic block
706 containing IFN_ABNORMAL_DISPATCHER internal call, return
707 that the dispatcher's basic block, otherwise return NULL. */
710 get_abnormal_succ_dispatcher (basic_block bb
)
715 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
716 if ((e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)) == EDGE_ABNORMAL
)
718 gimple_stmt_iterator gsi
719 = gsi_start_nondebug_after_labels_bb (e
->dest
);
720 gimple
*g
= gsi_stmt (gsi
);
721 if (g
&& gimple_call_internal_p (g
, IFN_ABNORMAL_DISPATCHER
))
727 /* Helper function for make_edges. Create a basic block with
728 with ABNORMAL_DISPATCHER internal call in it if needed, and
729 create abnormal edges from BBS to it and from it to FOR_BB
730 if COMPUTED_GOTO is false, otherwise factor the computed gotos. */
733 handle_abnormal_edges (basic_block
*dispatcher_bbs
,
734 basic_block for_bb
, int *bb_to_omp_idx
,
735 auto_vec
<basic_block
> *bbs
, bool computed_goto
)
737 basic_block
*dispatcher
= dispatcher_bbs
+ (computed_goto
? 1 : 0);
738 unsigned int idx
= 0;
744 dispatcher
= dispatcher_bbs
+ 2 * bb_to_omp_idx
[for_bb
->index
];
745 if (bb_to_omp_idx
[for_bb
->index
] != 0)
749 /* If the dispatcher has been created already, then there are basic
750 blocks with abnormal edges to it, so just make a new edge to
752 if (*dispatcher
== NULL
)
754 /* Check if there are any basic blocks that need to have
755 abnormal edges to this dispatcher. If there are none, return
757 if (bb_to_omp_idx
== NULL
)
759 if (bbs
->is_empty ())
764 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
765 if (bb_to_omp_idx
[bb
->index
] == bb_to_omp_idx
[for_bb
->index
])
771 /* Create the dispatcher bb. */
772 *dispatcher
= create_basic_block (NULL
, for_bb
);
775 /* Factor computed gotos into a common computed goto site. Also
776 record the location of that site so that we can un-factor the
777 gotos after we have converted back to normal form. */
778 gimple_stmt_iterator gsi
= gsi_start_bb (*dispatcher
);
780 /* Create the destination of the factored goto. Each original
781 computed goto will put its desired destination into this
782 variable and jump to the label we create immediately below. */
783 tree var
= create_tmp_var (ptr_type_node
, "gotovar");
785 /* Build a label for the new block which will contain the
786 factored computed goto. */
787 tree factored_label_decl
788 = create_artificial_label (UNKNOWN_LOCATION
);
789 gimple
*factored_computed_goto_label
790 = gimple_build_label (factored_label_decl
);
791 gsi_insert_after (&gsi
, factored_computed_goto_label
, GSI_NEW_STMT
);
793 /* Build our new computed goto. */
794 gimple
*factored_computed_goto
= gimple_build_goto (var
);
795 gsi_insert_after (&gsi
, factored_computed_goto
, GSI_NEW_STMT
);
797 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
800 && bb_to_omp_idx
[bb
->index
] != bb_to_omp_idx
[for_bb
->index
])
803 gsi
= gsi_last_bb (bb
);
804 gimple
*last
= gsi_stmt (gsi
);
806 gcc_assert (computed_goto_p (last
));
808 /* Copy the original computed goto's destination into VAR. */
810 = gimple_build_assign (var
, gimple_goto_dest (last
));
811 gsi_insert_before (&gsi
, assignment
, GSI_SAME_STMT
);
813 edge e
= make_edge (bb
, *dispatcher
, EDGE_FALLTHRU
);
814 e
->goto_locus
= gimple_location (last
);
815 gsi_remove (&gsi
, true);
820 tree arg
= inner
? boolean_true_node
: boolean_false_node
;
821 gimple
*g
= gimple_build_call_internal (IFN_ABNORMAL_DISPATCHER
,
823 gimple_stmt_iterator gsi
= gsi_after_labels (*dispatcher
);
824 gsi_insert_after (&gsi
, g
, GSI_NEW_STMT
);
826 /* Create predecessor edges of the dispatcher. */
827 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
830 && bb_to_omp_idx
[bb
->index
] != bb_to_omp_idx
[for_bb
->index
])
832 make_edge (bb
, *dispatcher
, EDGE_ABNORMAL
);
837 make_edge (*dispatcher
, for_bb
, EDGE_ABNORMAL
);
840 /* Creates outgoing edges for BB. Returns 1 when it ends with an
841 computed goto, returns 2 when it ends with a statement that
842 might return to this function via an nonlocal goto, otherwise
843 return 0. Updates *PCUR_REGION with the OMP region this BB is in. */
846 make_edges_bb (basic_block bb
, struct omp_region
**pcur_region
, int *pomp_index
)
848 gimple
*last
= last_stmt (bb
);
849 bool fallthru
= false;
855 switch (gimple_code (last
))
858 if (make_goto_expr_edges (bb
))
864 edge e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
865 e
->goto_locus
= gimple_location (last
);
870 make_cond_expr_edges (bb
);
874 make_gimple_switch_edges (as_a
<gswitch
*> (last
), bb
);
878 make_eh_edges (last
);
881 case GIMPLE_EH_DISPATCH
:
882 fallthru
= make_eh_dispatch_edges (as_a
<geh_dispatch
*> (last
));
886 /* If this function receives a nonlocal goto, then we need to
887 make edges from this call site to all the nonlocal goto
889 if (stmt_can_make_abnormal_goto (last
))
892 /* If this statement has reachable exception handlers, then
893 create abnormal edges to them. */
894 make_eh_edges (last
);
896 /* BUILTIN_RETURN is really a return statement. */
897 if (gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
899 make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
902 /* Some calls are known not to return. */
904 fallthru
= !gimple_call_noreturn_p (last
);
908 /* A GIMPLE_ASSIGN may throw internally and thus be considered
910 if (is_ctrl_altering_stmt (last
))
911 make_eh_edges (last
);
916 make_gimple_asm_edges (bb
);
921 fallthru
= omp_make_gimple_edges (bb
, pcur_region
, pomp_index
);
924 case GIMPLE_TRANSACTION
:
926 gtransaction
*txn
= as_a
<gtransaction
*> (last
);
927 tree label1
= gimple_transaction_label_norm (txn
);
928 tree label2
= gimple_transaction_label_uninst (txn
);
931 make_edge (bb
, label_to_block (cfun
, label1
), EDGE_FALLTHRU
);
933 make_edge (bb
, label_to_block (cfun
, label2
),
934 EDGE_TM_UNINSTRUMENTED
| (label1
? 0 : EDGE_FALLTHRU
));
936 tree label3
= gimple_transaction_label_over (txn
);
937 if (gimple_transaction_subcode (txn
)
938 & (GTMA_HAVE_ABORT
| GTMA_IS_OUTER
))
939 make_edge (bb
, label_to_block (cfun
, label3
), EDGE_TM_ABORT
);
946 gcc_assert (!stmt_ends_bb_p (last
));
952 make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
957 /* Join all the blocks in the flowgraph. */
963 struct omp_region
*cur_region
= NULL
;
964 auto_vec
<basic_block
> ab_edge_goto
;
965 auto_vec
<basic_block
> ab_edge_call
;
966 int *bb_to_omp_idx
= NULL
;
967 int cur_omp_region_idx
= 0;
969 /* Create an edge from entry to the first block with executable
971 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
972 BASIC_BLOCK_FOR_FN (cfun
, NUM_FIXED_BLOCKS
),
975 /* Traverse the basic block array placing edges. */
976 FOR_EACH_BB_FN (bb
, cfun
)
981 bb_to_omp_idx
[bb
->index
] = cur_omp_region_idx
;
983 mer
= make_edges_bb (bb
, &cur_region
, &cur_omp_region_idx
);
985 ab_edge_goto
.safe_push (bb
);
987 ab_edge_call
.safe_push (bb
);
989 if (cur_region
&& bb_to_omp_idx
== NULL
)
990 bb_to_omp_idx
= XCNEWVEC (int, n_basic_blocks_for_fn (cfun
));
993 /* Computed gotos are hell to deal with, especially if there are
994 lots of them with a large number of destinations. So we factor
995 them to a common computed goto location before we build the
996 edge list. After we convert back to normal form, we will un-factor
997 the computed gotos since factoring introduces an unwanted jump.
998 For non-local gotos and abnormal edges from calls to calls that return
999 twice or forced labels, factor the abnormal edges too, by having all
1000 abnormal edges from the calls go to a common artificial basic block
1001 with ABNORMAL_DISPATCHER internal call and abnormal edges from that
1002 basic block to all forced labels and calls returning twice.
1003 We do this per-OpenMP structured block, because those regions
1004 are guaranteed to be single entry single exit by the standard,
1005 so it is not allowed to enter or exit such regions abnormally this way,
1006 thus all computed gotos, non-local gotos and setjmp/longjmp calls
1007 must not transfer control across SESE region boundaries. */
1008 if (!ab_edge_goto
.is_empty () || !ab_edge_call
.is_empty ())
1010 gimple_stmt_iterator gsi
;
1011 basic_block dispatcher_bb_array
[2] = { NULL
, NULL
};
1012 basic_block
*dispatcher_bbs
= dispatcher_bb_array
;
1013 int count
= n_basic_blocks_for_fn (cfun
);
1016 dispatcher_bbs
= XCNEWVEC (basic_block
, 2 * count
);
1018 FOR_EACH_BB_FN (bb
, cfun
)
1020 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1022 glabel
*label_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
1028 target
= gimple_label_label (label_stmt
);
1030 /* Make an edge to every label block that has been marked as a
1031 potential target for a computed goto or a non-local goto. */
1032 if (FORCED_LABEL (target
))
1033 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
1034 &ab_edge_goto
, true);
1035 if (DECL_NONLOCAL (target
))
1037 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
1038 &ab_edge_call
, false);
1043 if (!gsi_end_p (gsi
) && is_gimple_debug (gsi_stmt (gsi
)))
1044 gsi_next_nondebug (&gsi
);
1045 if (!gsi_end_p (gsi
))
1047 /* Make an edge to every setjmp-like call. */
1048 gimple
*call_stmt
= gsi_stmt (gsi
);
1049 if (is_gimple_call (call_stmt
)
1050 && ((gimple_call_flags (call_stmt
) & ECF_RETURNS_TWICE
)
1051 || gimple_call_builtin_p (call_stmt
,
1052 BUILT_IN_SETJMP_RECEIVER
)))
1053 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
1054 &ab_edge_call
, false);
1059 XDELETE (dispatcher_bbs
);
1062 XDELETE (bb_to_omp_idx
);
1064 omp_free_regions ();
1067 /* Add SEQ after GSI. Start new bb after GSI, and created further bbs as
1068 needed. Returns true if new bbs were created.
1069 Note: This is transitional code, and should not be used for new code. We
1070 should be able to get rid of this by rewriting all target va-arg
1071 gimplification hooks to use an interface gimple_build_cond_value as described
1072 in https://gcc.gnu.org/ml/gcc-patches/2015-02/msg01194.html. */
1075 gimple_find_sub_bbs (gimple_seq seq
, gimple_stmt_iterator
*gsi
)
1077 gimple
*stmt
= gsi_stmt (*gsi
);
1078 basic_block bb
= gimple_bb (stmt
);
1079 basic_block lastbb
, afterbb
;
1080 int old_num_bbs
= n_basic_blocks_for_fn (cfun
);
1082 lastbb
= make_blocks_1 (seq
, bb
);
1083 if (old_num_bbs
== n_basic_blocks_for_fn (cfun
))
1085 e
= split_block (bb
, stmt
);
1086 /* Move e->dest to come after the new basic blocks. */
1088 unlink_block (afterbb
);
1089 link_block (afterbb
, lastbb
);
1090 redirect_edge_succ (e
, bb
->next_bb
);
1092 while (bb
!= afterbb
)
1094 struct omp_region
*cur_region
= NULL
;
1095 profile_count cnt
= profile_count::zero ();
1098 int cur_omp_region_idx
= 0;
1099 int mer
= make_edges_bb (bb
, &cur_region
, &cur_omp_region_idx
);
1100 gcc_assert (!mer
&& !cur_region
);
1101 add_bb_to_loop (bb
, afterbb
->loop_father
);
1105 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
1107 if (e
->count ().initialized_p ())
1112 tree_guess_outgoing_edge_probabilities (bb
);
1113 if (all
|| profile_status_for_fn (cfun
) == PROFILE_READ
)
1121 /* Find the next available discriminator value for LOCUS. The
1122 discriminator distinguishes among several basic blocks that
1123 share a common locus, allowing for more accurate sample-based
1127 next_discriminator_for_locus (int line
)
1129 struct locus_discrim_map item
;
1130 struct locus_discrim_map
**slot
;
1132 item
.location_line
= line
;
1133 item
.discriminator
= 0;
1134 slot
= discriminator_per_locus
->find_slot_with_hash (&item
, line
, INSERT
);
1136 if (*slot
== HTAB_EMPTY_ENTRY
)
1138 *slot
= XNEW (struct locus_discrim_map
);
1140 (*slot
)->location_line
= line
;
1141 (*slot
)->discriminator
= 0;
1143 (*slot
)->discriminator
++;
1144 return (*slot
)->discriminator
;
1147 /* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line. */
1150 same_line_p (location_t locus1
, expanded_location
*from
, location_t locus2
)
1152 expanded_location to
;
1154 if (locus1
== locus2
)
1157 to
= expand_location (locus2
);
1159 if (from
->line
!= to
.line
)
1161 if (from
->file
== to
.file
)
1163 return (from
->file
!= NULL
1165 && filename_cmp (from
->file
, to
.file
) == 0);
1168 /* Assign discriminators to each basic block. */
1171 assign_discriminators (void)
1175 FOR_EACH_BB_FN (bb
, cfun
)
1179 gimple
*last
= last_stmt (bb
);
1180 location_t locus
= last
? gimple_location (last
) : UNKNOWN_LOCATION
;
1182 if (locus
== UNKNOWN_LOCATION
)
1185 expanded_location locus_e
= expand_location (locus
);
1187 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1189 gimple
*first
= first_non_label_stmt (e
->dest
);
1190 gimple
*last
= last_stmt (e
->dest
);
1191 if ((first
&& same_line_p (locus
, &locus_e
,
1192 gimple_location (first
)))
1193 || (last
&& same_line_p (locus
, &locus_e
,
1194 gimple_location (last
))))
1196 if (e
->dest
->discriminator
!= 0 && bb
->discriminator
== 0)
1198 = next_discriminator_for_locus (locus_e
.line
);
1200 e
->dest
->discriminator
1201 = next_discriminator_for_locus (locus_e
.line
);
1207 /* Create the edges for a GIMPLE_COND starting at block BB. */
1210 make_cond_expr_edges (basic_block bb
)
1212 gcond
*entry
= as_a
<gcond
*> (last_stmt (bb
));
1213 gimple
*then_stmt
, *else_stmt
;
1214 basic_block then_bb
, else_bb
;
1215 tree then_label
, else_label
;
1219 gcc_assert (gimple_code (entry
) == GIMPLE_COND
);
1221 /* Entry basic blocks for each component. */
1222 then_label
= gimple_cond_true_label (entry
);
1223 else_label
= gimple_cond_false_label (entry
);
1224 then_bb
= label_to_block (cfun
, then_label
);
1225 else_bb
= label_to_block (cfun
, else_label
);
1226 then_stmt
= first_stmt (then_bb
);
1227 else_stmt
= first_stmt (else_bb
);
1229 e
= make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1230 e
->goto_locus
= gimple_location (then_stmt
);
1231 e
= make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1233 e
->goto_locus
= gimple_location (else_stmt
);
1235 /* We do not need the labels anymore. */
1236 gimple_cond_set_true_label (entry
, NULL_TREE
);
1237 gimple_cond_set_false_label (entry
, NULL_TREE
);
1241 /* Called for each element in the hash table (P) as we delete the
1242 edge to cases hash table.
1244 Clear all the CASE_CHAINs to prevent problems with copying of
1245 SWITCH_EXPRs and structure sharing rules, then free the hash table
1249 edge_to_cases_cleanup (edge
const &, tree
const &value
, void *)
1253 for (t
= value
; t
; t
= next
)
1255 next
= CASE_CHAIN (t
);
1256 CASE_CHAIN (t
) = NULL
;
1262 /* Start recording information mapping edges to case labels. */
1265 start_recording_case_labels (void)
1267 gcc_assert (edge_to_cases
== NULL
);
1268 edge_to_cases
= new hash_map
<edge
, tree
>;
1269 touched_switch_bbs
= BITMAP_ALLOC (NULL
);
1272 /* Return nonzero if we are recording information for case labels. */
1275 recording_case_labels_p (void)
1277 return (edge_to_cases
!= NULL
);
1280 /* Stop recording information mapping edges to case labels and
1281 remove any information we have recorded. */
1283 end_recording_case_labels (void)
1287 edge_to_cases
->traverse
<void *, edge_to_cases_cleanup
> (NULL
);
1288 delete edge_to_cases
;
1289 edge_to_cases
= NULL
;
1290 EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs
, 0, i
, bi
)
1292 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
1295 gimple
*stmt
= last_stmt (bb
);
1296 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1297 group_case_labels_stmt (as_a
<gswitch
*> (stmt
));
1300 BITMAP_FREE (touched_switch_bbs
);
1303 /* If we are inside a {start,end}_recording_cases block, then return
1304 a chain of CASE_LABEL_EXPRs from T which reference E.
1306 Otherwise return NULL. */
1309 get_cases_for_edge (edge e
, gswitch
*t
)
1314 /* If we are not recording cases, then we do not have CASE_LABEL_EXPR
1315 chains available. Return NULL so the caller can detect this case. */
1316 if (!recording_case_labels_p ())
1319 slot
= edge_to_cases
->get (e
);
1323 /* If we did not find E in the hash table, then this must be the first
1324 time we have been queried for information about E & T. Add all the
1325 elements from T to the hash table then perform the query again. */
1327 n
= gimple_switch_num_labels (t
);
1328 for (i
= 0; i
< n
; i
++)
1330 tree elt
= gimple_switch_label (t
, i
);
1331 tree lab
= CASE_LABEL (elt
);
1332 basic_block label_bb
= label_to_block (cfun
, lab
);
1333 edge this_edge
= find_edge (e
->src
, label_bb
);
1335 /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
1337 tree
&s
= edge_to_cases
->get_or_insert (this_edge
);
1338 CASE_CHAIN (elt
) = s
;
1342 return *edge_to_cases
->get (e
);
1345 /* Create the edges for a GIMPLE_SWITCH starting at block BB. */
1348 make_gimple_switch_edges (gswitch
*entry
, basic_block bb
)
1352 n
= gimple_switch_num_labels (entry
);
1354 for (i
= 0; i
< n
; ++i
)
1356 basic_block label_bb
= gimple_switch_label_bb (cfun
, entry
, i
);
1357 make_edge (bb
, label_bb
, 0);
1362 /* Return the basic block holding label DEST. */
1365 label_to_block (struct function
*ifun
, tree dest
)
1367 int uid
= LABEL_DECL_UID (dest
);
1369 /* We would die hard when faced by an undefined label. Emit a label to
1370 the very first basic block. This will hopefully make even the dataflow
1371 and undefined variable warnings quite right. */
1372 if (seen_error () && uid
< 0)
1374 gimple_stmt_iterator gsi
=
1375 gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, NUM_FIXED_BLOCKS
));
1378 stmt
= gimple_build_label (dest
);
1379 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
1380 uid
= LABEL_DECL_UID (dest
);
1382 if (vec_safe_length (ifun
->cfg
->x_label_to_block_map
) <= (unsigned int) uid
)
1384 return (*ifun
->cfg
->x_label_to_block_map
)[uid
];
1387 /* Create edges for a goto statement at block BB. Returns true
1388 if abnormal edges should be created. */
1391 make_goto_expr_edges (basic_block bb
)
1393 gimple_stmt_iterator last
= gsi_last_bb (bb
);
1394 gimple
*goto_t
= gsi_stmt (last
);
1396 /* A simple GOTO creates normal edges. */
1397 if (simple_goto_p (goto_t
))
1399 tree dest
= gimple_goto_dest (goto_t
);
1400 basic_block label_bb
= label_to_block (cfun
, dest
);
1401 edge e
= make_edge (bb
, label_bb
, EDGE_FALLTHRU
);
1402 e
->goto_locus
= gimple_location (goto_t
);
1403 gsi_remove (&last
, true);
1407 /* A computed GOTO creates abnormal edges. */
1411 /* Create edges for an asm statement with labels at block BB. */
1414 make_gimple_asm_edges (basic_block bb
)
1416 gasm
*stmt
= as_a
<gasm
*> (last_stmt (bb
));
1417 int i
, n
= gimple_asm_nlabels (stmt
);
1419 for (i
= 0; i
< n
; ++i
)
1421 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
1422 basic_block label_bb
= label_to_block (cfun
, label
);
1423 make_edge (bb
, label_bb
, 0);
1427 /*---------------------------------------------------------------------------
1429 ---------------------------------------------------------------------------*/
1431 /* Cleanup useless labels in basic blocks. This is something we wish
1432 to do early because it allows us to group case labels before creating
1433 the edges for the CFG, and it speeds up block statement iterators in
1434 all passes later on.
1435 We rerun this pass after CFG is created, to get rid of the labels that
1436 are no longer referenced. After then we do not run it any more, since
1437 (almost) no new labels should be created. */
1439 /* A map from basic block index to the leading label of that block. */
1445 /* True if the label is referenced from somewhere. */
1449 /* Given LABEL return the first label in the same basic block. */
1452 main_block_label (tree label
, label_record
*label_for_bb
)
1454 basic_block bb
= label_to_block (cfun
, label
);
1455 tree main_label
= label_for_bb
[bb
->index
].label
;
1457 /* label_to_block possibly inserted undefined label into the chain. */
1460 label_for_bb
[bb
->index
].label
= label
;
1464 label_for_bb
[bb
->index
].used
= true;
1468 /* Clean up redundant labels within the exception tree. */
1471 cleanup_dead_labels_eh (label_record
*label_for_bb
)
1478 if (cfun
->eh
== NULL
)
1481 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1482 if (lp
&& lp
->post_landing_pad
)
1484 lab
= main_block_label (lp
->post_landing_pad
, label_for_bb
);
1485 if (lab
!= lp
->post_landing_pad
)
1487 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1488 EH_LANDING_PAD_NR (lab
) = lp
->index
;
1492 FOR_ALL_EH_REGION (r
)
1496 case ERT_MUST_NOT_THROW
:
1502 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
1506 c
->label
= main_block_label (lab
, label_for_bb
);
1511 case ERT_ALLOWED_EXCEPTIONS
:
1512 lab
= r
->u
.allowed
.label
;
1514 r
->u
.allowed
.label
= main_block_label (lab
, label_for_bb
);
1520 /* Cleanup redundant labels. This is a three-step process:
1521 1) Find the leading label for each block.
1522 2) Redirect all references to labels to the leading labels.
1523 3) Cleanup all useless labels. */
1526 cleanup_dead_labels (void)
1529 label_record
*label_for_bb
= XCNEWVEC (struct label_record
,
1530 last_basic_block_for_fn (cfun
));
1532 /* Find a suitable label for each block. We use the first user-defined
1533 label if there is one, or otherwise just the first label we see. */
1534 FOR_EACH_BB_FN (bb
, cfun
)
1536 gimple_stmt_iterator i
;
1538 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
1541 glabel
*label_stmt
= dyn_cast
<glabel
*> (gsi_stmt (i
));
1546 label
= gimple_label_label (label_stmt
);
1548 /* If we have not yet seen a label for the current block,
1549 remember this one and see if there are more labels. */
1550 if (!label_for_bb
[bb
->index
].label
)
1552 label_for_bb
[bb
->index
].label
= label
;
1556 /* If we did see a label for the current block already, but it
1557 is an artificially created label, replace it if the current
1558 label is a user defined label. */
1559 if (!DECL_ARTIFICIAL (label
)
1560 && DECL_ARTIFICIAL (label_for_bb
[bb
->index
].label
))
1562 label_for_bb
[bb
->index
].label
= label
;
1568 /* Now redirect all jumps/branches to the selected label.
1569 First do so for each block ending in a control statement. */
1570 FOR_EACH_BB_FN (bb
, cfun
)
1572 gimple
*stmt
= last_stmt (bb
);
1573 tree label
, new_label
;
1578 switch (gimple_code (stmt
))
1582 gcond
*cond_stmt
= as_a
<gcond
*> (stmt
);
1583 label
= gimple_cond_true_label (cond_stmt
);
1586 new_label
= main_block_label (label
, label_for_bb
);
1587 if (new_label
!= label
)
1588 gimple_cond_set_true_label (cond_stmt
, new_label
);
1591 label
= gimple_cond_false_label (cond_stmt
);
1594 new_label
= main_block_label (label
, label_for_bb
);
1595 if (new_label
!= label
)
1596 gimple_cond_set_false_label (cond_stmt
, new_label
);
1603 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
1604 size_t i
, n
= gimple_switch_num_labels (switch_stmt
);
1606 /* Replace all destination labels. */
1607 for (i
= 0; i
< n
; ++i
)
1609 tree case_label
= gimple_switch_label (switch_stmt
, i
);
1610 label
= CASE_LABEL (case_label
);
1611 new_label
= main_block_label (label
, label_for_bb
);
1612 if (new_label
!= label
)
1613 CASE_LABEL (case_label
) = new_label
;
1620 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
1621 int i
, n
= gimple_asm_nlabels (asm_stmt
);
1623 for (i
= 0; i
< n
; ++i
)
1625 tree cons
= gimple_asm_label_op (asm_stmt
, i
);
1626 tree label
= main_block_label (TREE_VALUE (cons
), label_for_bb
);
1627 TREE_VALUE (cons
) = label
;
1632 /* We have to handle gotos until they're removed, and we don't
1633 remove them until after we've created the CFG edges. */
1635 if (!computed_goto_p (stmt
))
1637 ggoto
*goto_stmt
= as_a
<ggoto
*> (stmt
);
1638 label
= gimple_goto_dest (goto_stmt
);
1639 new_label
= main_block_label (label
, label_for_bb
);
1640 if (new_label
!= label
)
1641 gimple_goto_set_dest (goto_stmt
, new_label
);
1645 case GIMPLE_TRANSACTION
:
1647 gtransaction
*txn
= as_a
<gtransaction
*> (stmt
);
1649 label
= gimple_transaction_label_norm (txn
);
1652 new_label
= main_block_label (label
, label_for_bb
);
1653 if (new_label
!= label
)
1654 gimple_transaction_set_label_norm (txn
, new_label
);
1657 label
= gimple_transaction_label_uninst (txn
);
1660 new_label
= main_block_label (label
, label_for_bb
);
1661 if (new_label
!= label
)
1662 gimple_transaction_set_label_uninst (txn
, new_label
);
1665 label
= gimple_transaction_label_over (txn
);
1668 new_label
= main_block_label (label
, label_for_bb
);
1669 if (new_label
!= label
)
1670 gimple_transaction_set_label_over (txn
, new_label
);
1680 /* Do the same for the exception region tree labels. */
1681 cleanup_dead_labels_eh (label_for_bb
);
1683 /* Finally, purge dead labels. All user-defined labels and labels that
1684 can be the target of non-local gotos and labels which have their
1685 address taken are preserved. */
1686 FOR_EACH_BB_FN (bb
, cfun
)
1688 gimple_stmt_iterator i
;
1689 tree label_for_this_bb
= label_for_bb
[bb
->index
].label
;
1691 if (!label_for_this_bb
)
1694 /* If the main label of the block is unused, we may still remove it. */
1695 if (!label_for_bb
[bb
->index
].used
)
1696 label_for_this_bb
= NULL
;
1698 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); )
1701 glabel
*label_stmt
= dyn_cast
<glabel
*> (gsi_stmt (i
));
1706 label
= gimple_label_label (label_stmt
);
1708 if (label
== label_for_this_bb
1709 || !DECL_ARTIFICIAL (label
)
1710 || DECL_NONLOCAL (label
)
1711 || FORCED_LABEL (label
))
1714 gsi_remove (&i
, true);
1718 free (label_for_bb
);
1721 /* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
1722 the ones jumping to the same label.
1723 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
1726 group_case_labels_stmt (gswitch
*stmt
)
1728 int old_size
= gimple_switch_num_labels (stmt
);
1729 int i
, next_index
, new_size
;
1730 basic_block default_bb
= NULL
;
1732 default_bb
= gimple_switch_default_bb (cfun
, stmt
);
1734 /* Look for possible opportunities to merge cases. */
1736 while (i
< old_size
)
1738 tree base_case
, base_high
;
1739 basic_block base_bb
;
1741 base_case
= gimple_switch_label (stmt
, i
);
1743 gcc_assert (base_case
);
1744 base_bb
= label_to_block (cfun
, CASE_LABEL (base_case
));
1746 /* Discard cases that have the same destination as the default case or
1747 whose destiniation blocks have already been removed as unreachable. */
1748 if (base_bb
== NULL
|| base_bb
== default_bb
)
1754 base_high
= CASE_HIGH (base_case
)
1755 ? CASE_HIGH (base_case
)
1756 : CASE_LOW (base_case
);
1759 /* Try to merge case labels. Break out when we reach the end
1760 of the label vector or when we cannot merge the next case
1761 label with the current one. */
1762 while (next_index
< old_size
)
1764 tree merge_case
= gimple_switch_label (stmt
, next_index
);
1765 basic_block merge_bb
= label_to_block (cfun
, CASE_LABEL (merge_case
));
1766 wide_int bhp1
= wi::to_wide (base_high
) + 1;
1768 /* Merge the cases if they jump to the same place,
1769 and their ranges are consecutive. */
1770 if (merge_bb
== base_bb
1771 && wi::to_wide (CASE_LOW (merge_case
)) == bhp1
)
1773 base_high
= CASE_HIGH (merge_case
) ?
1774 CASE_HIGH (merge_case
) : CASE_LOW (merge_case
);
1775 CASE_HIGH (base_case
) = base_high
;
1782 /* Discard cases that have an unreachable destination block. */
1783 if (EDGE_COUNT (base_bb
->succs
) == 0
1784 && gimple_seq_unreachable_p (bb_seq (base_bb
))
1785 /* Don't optimize this if __builtin_unreachable () is the
1786 implicitly added one by the C++ FE too early, before
1787 -Wreturn-type can be diagnosed. We'll optimize it later
1788 during switchconv pass or any other cfg cleanup. */
1789 && (gimple_in_ssa_p (cfun
)
1790 || (LOCATION_LOCUS (gimple_location (last_stmt (base_bb
)))
1791 != BUILTINS_LOCATION
)))
1793 edge base_edge
= find_edge (gimple_bb (stmt
), base_bb
);
1794 if (base_edge
!= NULL
)
1795 remove_edge_and_dominated_blocks (base_edge
);
1801 gimple_switch_set_label (stmt
, new_size
,
1802 gimple_switch_label (stmt
, i
));
1807 gcc_assert (new_size
<= old_size
);
1809 if (new_size
< old_size
)
1810 gimple_switch_set_num_labels (stmt
, new_size
);
1812 return new_size
< old_size
;
1815 /* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
1816 and scan the sorted vector of cases. Combine the ones jumping to the
1820 group_case_labels (void)
1823 bool changed
= false;
1825 FOR_EACH_BB_FN (bb
, cfun
)
1827 gimple
*stmt
= last_stmt (bb
);
1828 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1829 changed
|= group_case_labels_stmt (as_a
<gswitch
*> (stmt
));
1835 /* Checks whether we can merge block B into block A. */
1838 gimple_can_merge_blocks_p (basic_block a
, basic_block b
)
1842 if (!single_succ_p (a
))
1845 if (single_succ_edge (a
)->flags
& EDGE_COMPLEX
)
1848 if (single_succ (a
) != b
)
1851 if (!single_pred_p (b
))
1854 if (a
== ENTRY_BLOCK_PTR_FOR_FN (cfun
)
1855 || b
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
1858 /* If A ends by a statement causing exceptions or something similar, we
1859 cannot merge the blocks. */
1860 stmt
= last_stmt (a
);
1861 if (stmt
&& stmt_ends_bb_p (stmt
))
1864 /* Do not allow a block with only a non-local label to be merged. */
1866 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
1867 if (DECL_NONLOCAL (gimple_label_label (label_stmt
)))
1870 /* Examine the labels at the beginning of B. */
1871 for (gimple_stmt_iterator gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
);
1875 glabel
*label_stmt
= dyn_cast
<glabel
*> (gsi_stmt (gsi
));
1878 lab
= gimple_label_label (label_stmt
);
1880 /* Do not remove user forced labels or for -O0 any user labels. */
1881 if (!DECL_ARTIFICIAL (lab
) && (!optimize
|| FORCED_LABEL (lab
)))
1885 /* Protect simple loop latches. We only want to avoid merging
1886 the latch with the loop header or with a block in another
1887 loop in this case. */
1889 && b
->loop_father
->latch
== b
1890 && loops_state_satisfies_p (LOOPS_HAVE_SIMPLE_LATCHES
)
1891 && (b
->loop_father
->header
== a
1892 || b
->loop_father
!= a
->loop_father
))
1895 /* It must be possible to eliminate all phi nodes in B. If ssa form
1896 is not up-to-date and a name-mapping is registered, we cannot eliminate
1897 any phis. Symbols marked for renaming are never a problem though. */
1898 for (gphi_iterator gsi
= gsi_start_phis (b
); !gsi_end_p (gsi
);
1901 gphi
*phi
= gsi
.phi ();
1902 /* Technically only new names matter. */
1903 if (name_registered_for_update_p (PHI_RESULT (phi
)))
1907 /* When not optimizing, don't merge if we'd lose goto_locus. */
1909 && single_succ_edge (a
)->goto_locus
!= UNKNOWN_LOCATION
)
1911 location_t goto_locus
= single_succ_edge (a
)->goto_locus
;
1912 gimple_stmt_iterator prev
, next
;
1913 prev
= gsi_last_nondebug_bb (a
);
1914 next
= gsi_after_labels (b
);
1915 if (!gsi_end_p (next
) && is_gimple_debug (gsi_stmt (next
)))
1916 gsi_next_nondebug (&next
);
1917 if ((gsi_end_p (prev
)
1918 || gimple_location (gsi_stmt (prev
)) != goto_locus
)
1919 && (gsi_end_p (next
)
1920 || gimple_location (gsi_stmt (next
)) != goto_locus
))
1927 /* Replaces all uses of NAME by VAL. */
1930 replace_uses_by (tree name
, tree val
)
1932 imm_use_iterator imm_iter
;
1937 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, name
)
1939 /* Mark the block if we change the last stmt in it. */
1940 if (cfgcleanup_altered_bbs
1941 && stmt_ends_bb_p (stmt
))
1942 bitmap_set_bit (cfgcleanup_altered_bbs
, gimple_bb (stmt
)->index
);
1944 FOR_EACH_IMM_USE_ON_STMT (use
, imm_iter
)
1946 replace_exp (use
, val
);
1948 if (gimple_code (stmt
) == GIMPLE_PHI
)
1950 e
= gimple_phi_arg_edge (as_a
<gphi
*> (stmt
),
1951 PHI_ARG_INDEX_FROM_USE (use
));
1952 if (e
->flags
& EDGE_ABNORMAL
1953 && !SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val
))
1955 /* This can only occur for virtual operands, since
1956 for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
1957 would prevent replacement. */
1958 gcc_checking_assert (virtual_operand_p (name
));
1959 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val
) = 1;
1964 if (gimple_code (stmt
) != GIMPLE_PHI
)
1966 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
1967 gimple
*orig_stmt
= stmt
;
1970 /* FIXME. It shouldn't be required to keep TREE_CONSTANT
1971 on ADDR_EXPRs up-to-date on GIMPLE. Propagation will
1972 only change sth from non-invariant to invariant, and only
1973 when propagating constants. */
1974 if (is_gimple_min_invariant (val
))
1975 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1977 tree op
= gimple_op (stmt
, i
);
1978 /* Operands may be empty here. For example, the labels
1979 of a GIMPLE_COND are nulled out following the creation
1980 of the corresponding CFG edges. */
1981 if (op
&& TREE_CODE (op
) == ADDR_EXPR
)
1982 recompute_tree_invariant_for_addr_expr (op
);
1985 if (fold_stmt (&gsi
))
1986 stmt
= gsi_stmt (gsi
);
1988 if (maybe_clean_or_replace_eh_stmt (orig_stmt
, stmt
))
1989 gimple_purge_dead_eh_edges (gimple_bb (stmt
));
1995 gcc_checking_assert (has_zero_uses (name
));
1997 /* Also update the trees stored in loop structures. */
2002 FOR_EACH_LOOP (loop
, 0)
2004 substitute_in_loop_info (loop
, name
, val
);
2009 /* Merge block B into block A. */
2012 gimple_merge_blocks (basic_block a
, basic_block b
)
2014 gimple_stmt_iterator last
, gsi
;
2018 fprintf (dump_file
, "Merging blocks %d and %d\n", a
->index
, b
->index
);
2020 /* Remove all single-valued PHI nodes from block B of the form
2021 V_i = PHI <V_j> by propagating V_j to all the uses of V_i. */
2022 gsi
= gsi_last_bb (a
);
2023 for (psi
= gsi_start_phis (b
); !gsi_end_p (psi
); )
2025 gimple
*phi
= gsi_stmt (psi
);
2026 tree def
= gimple_phi_result (phi
), use
= gimple_phi_arg_def (phi
, 0);
2028 bool may_replace_uses
= (virtual_operand_p (def
)
2029 || may_propagate_copy (def
, use
));
2031 /* In case we maintain loop closed ssa form, do not propagate arguments
2032 of loop exit phi nodes. */
2034 && loops_state_satisfies_p (LOOP_CLOSED_SSA
)
2035 && !virtual_operand_p (def
)
2036 && TREE_CODE (use
) == SSA_NAME
2037 && a
->loop_father
!= b
->loop_father
)
2038 may_replace_uses
= false;
2040 if (!may_replace_uses
)
2042 gcc_assert (!virtual_operand_p (def
));
2044 /* Note that just emitting the copies is fine -- there is no problem
2045 with ordering of phi nodes. This is because A is the single
2046 predecessor of B, therefore results of the phi nodes cannot
2047 appear as arguments of the phi nodes. */
2048 copy
= gimple_build_assign (def
, use
);
2049 gsi_insert_after (&gsi
, copy
, GSI_NEW_STMT
);
2050 remove_phi_node (&psi
, false);
2054 /* If we deal with a PHI for virtual operands, we can simply
2055 propagate these without fussing with folding or updating
2057 if (virtual_operand_p (def
))
2059 imm_use_iterator iter
;
2060 use_operand_p use_p
;
2063 FOR_EACH_IMM_USE_STMT (stmt
, iter
, def
)
2064 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
2065 SET_USE (use_p
, use
);
2067 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
2068 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use
) = 1;
2071 replace_uses_by (def
, use
);
2073 remove_phi_node (&psi
, true);
2077 /* Ensure that B follows A. */
2078 move_block_after (b
, a
);
2080 gcc_assert (single_succ_edge (a
)->flags
& EDGE_FALLTHRU
);
2081 gcc_assert (!last_stmt (a
) || !stmt_ends_bb_p (last_stmt (a
)));
2083 /* Remove labels from B and set gimple_bb to A for other statements. */
2084 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
);)
2086 gimple
*stmt
= gsi_stmt (gsi
);
2087 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
2089 tree label
= gimple_label_label (label_stmt
);
2092 gsi_remove (&gsi
, false);
2094 /* Now that we can thread computed gotos, we might have
2095 a situation where we have a forced label in block B
2096 However, the label at the start of block B might still be
2097 used in other ways (think about the runtime checking for
2098 Fortran assigned gotos). So we cannot just delete the
2099 label. Instead we move the label to the start of block A. */
2100 if (FORCED_LABEL (label
))
2102 gimple_stmt_iterator dest_gsi
= gsi_start_bb (a
);
2103 gsi_insert_before (&dest_gsi
, stmt
, GSI_NEW_STMT
);
2105 /* Other user labels keep around in a form of a debug stmt. */
2106 else if (!DECL_ARTIFICIAL (label
) && MAY_HAVE_DEBUG_BIND_STMTS
)
2108 gimple
*dbg
= gimple_build_debug_bind (label
,
2111 gimple_debug_bind_reset_value (dbg
);
2112 gsi_insert_before (&gsi
, dbg
, GSI_SAME_STMT
);
2115 lp_nr
= EH_LANDING_PAD_NR (label
);
2118 eh_landing_pad lp
= get_eh_landing_pad_from_number (lp_nr
);
2119 lp
->post_landing_pad
= NULL
;
2124 gimple_set_bb (stmt
, a
);
2129 /* When merging two BBs, if their counts are different, the larger count
2130 is selected as the new bb count. This is to handle inconsistent
2132 if (a
->loop_father
== b
->loop_father
)
2134 a
->count
= a
->count
.merge (b
->count
);
2137 /* Merge the sequences. */
2138 last
= gsi_last_bb (a
);
2139 gsi_insert_seq_after (&last
, bb_seq (b
), GSI_NEW_STMT
);
2140 set_bb_seq (b
, NULL
);
2142 if (cfgcleanup_altered_bbs
)
2143 bitmap_set_bit (cfgcleanup_altered_bbs
, a
->index
);
2147 /* Return the one of two successors of BB that is not reachable by a
2148 complex edge, if there is one. Else, return BB. We use
2149 this in optimizations that use post-dominators for their heuristics,
2150 to catch the cases in C++ where function calls are involved. */
2153 single_noncomplex_succ (basic_block bb
)
2156 if (EDGE_COUNT (bb
->succs
) != 2)
2159 e0
= EDGE_SUCC (bb
, 0);
2160 e1
= EDGE_SUCC (bb
, 1);
2161 if (e0
->flags
& EDGE_COMPLEX
)
2163 if (e1
->flags
& EDGE_COMPLEX
)
2169 /* T is CALL_EXPR. Set current_function_calls_* flags. */
2172 notice_special_calls (gcall
*call
)
2174 int flags
= gimple_call_flags (call
);
2176 if (flags
& ECF_MAY_BE_ALLOCA
)
2177 cfun
->calls_alloca
= true;
2178 if (flags
& ECF_RETURNS_TWICE
)
2179 cfun
->calls_setjmp
= true;
2183 /* Clear flags set by notice_special_calls. Used by dead code removal
2184 to update the flags. */
2187 clear_special_calls (void)
2189 cfun
->calls_alloca
= false;
2190 cfun
->calls_setjmp
= false;
2193 /* Remove PHI nodes associated with basic block BB and all edges out of BB. */
2196 remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb
)
2198 /* Since this block is no longer reachable, we can just delete all
2199 of its PHI nodes. */
2200 remove_phi_nodes (bb
);
2202 /* Remove edges to BB's successors. */
2203 while (EDGE_COUNT (bb
->succs
) > 0)
2204 remove_edge (EDGE_SUCC (bb
, 0));
2208 /* Remove statements of basic block BB. */
2211 remove_bb (basic_block bb
)
2213 gimple_stmt_iterator i
;
2217 fprintf (dump_file
, "Removing basic block %d\n", bb
->index
);
2218 if (dump_flags
& TDF_DETAILS
)
2220 dump_bb (dump_file
, bb
, 0, TDF_BLOCKS
);
2221 fprintf (dump_file
, "\n");
2227 class loop
*loop
= bb
->loop_father
;
2229 /* If a loop gets removed, clean up the information associated
2231 if (loop
->latch
== bb
2232 || loop
->header
== bb
)
2233 free_numbers_of_iterations_estimates (loop
);
2236 /* Remove all the instructions in the block. */
2237 if (bb_seq (bb
) != NULL
)
2239 /* Walk backwards so as to get a chance to substitute all
2240 released DEFs into debug stmts. See
2241 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
2243 for (i
= gsi_last_bb (bb
); !gsi_end_p (i
);)
2245 gimple
*stmt
= gsi_stmt (i
);
2246 glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
);
2248 && (FORCED_LABEL (gimple_label_label (label_stmt
))
2249 || DECL_NONLOCAL (gimple_label_label (label_stmt
))))
2252 gimple_stmt_iterator new_gsi
;
2254 /* A non-reachable non-local label may still be referenced.
2255 But it no longer needs to carry the extra semantics of
2257 if (DECL_NONLOCAL (gimple_label_label (label_stmt
)))
2259 DECL_NONLOCAL (gimple_label_label (label_stmt
)) = 0;
2260 FORCED_LABEL (gimple_label_label (label_stmt
)) = 1;
2263 new_bb
= bb
->prev_bb
;
2264 /* Don't move any labels into ENTRY block. */
2265 if (new_bb
== ENTRY_BLOCK_PTR_FOR_FN (cfun
))
2267 new_bb
= single_succ (new_bb
);
2268 gcc_assert (new_bb
!= bb
);
2270 new_gsi
= gsi_after_labels (new_bb
);
2271 gsi_remove (&i
, false);
2272 gsi_insert_before (&new_gsi
, stmt
, GSI_NEW_STMT
);
2276 /* Release SSA definitions. */
2277 release_defs (stmt
);
2278 gsi_remove (&i
, true);
2282 i
= gsi_last_bb (bb
);
2288 remove_phi_nodes_and_edges_for_unreachable_block (bb
);
2289 bb
->il
.gimple
.seq
= NULL
;
2290 bb
->il
.gimple
.phi_nodes
= NULL
;
2294 /* Given a basic block BB and a value VAL for use in the final statement
2295 of the block (if a GIMPLE_COND, GIMPLE_SWITCH, or computed goto), return
2296 the edge that will be taken out of the block.
2297 If VAL is NULL_TREE, then the current value of the final statement's
2298 predicate or index is used.
2299 If the value does not match a unique edge, NULL is returned. */
2302 find_taken_edge (basic_block bb
, tree val
)
2306 stmt
= last_stmt (bb
);
2308 /* Handle ENTRY and EXIT. */
2312 if (gimple_code (stmt
) == GIMPLE_COND
)
2313 return find_taken_edge_cond_expr (as_a
<gcond
*> (stmt
), val
);
2315 if (gimple_code (stmt
) == GIMPLE_SWITCH
)
2316 return find_taken_edge_switch_expr (as_a
<gswitch
*> (stmt
), val
);
2318 if (computed_goto_p (stmt
))
2320 /* Only optimize if the argument is a label, if the argument is
2321 not a label then we cannot construct a proper CFG.
2323 It may be the case that we only need to allow the LABEL_REF to
2324 appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
2325 appear inside a LABEL_EXPR just to be safe. */
2327 && (TREE_CODE (val
) == ADDR_EXPR
|| TREE_CODE (val
) == LABEL_EXPR
)
2328 && TREE_CODE (TREE_OPERAND (val
, 0)) == LABEL_DECL
)
2329 return find_taken_edge_computed_goto (bb
, TREE_OPERAND (val
, 0));
2332 /* Otherwise we only know the taken successor edge if it's unique. */
2333 return single_succ_p (bb
) ? single_succ_edge (bb
) : NULL
;
2336 /* Given a constant value VAL and the entry block BB to a GOTO_EXPR
2337 statement, determine which of the outgoing edges will be taken out of the
2338 block. Return NULL if either edge may be taken. */
2341 find_taken_edge_computed_goto (basic_block bb
, tree val
)
2346 dest
= label_to_block (cfun
, val
);
2348 e
= find_edge (bb
, dest
);
2350 /* It's possible for find_edge to return NULL here on invalid code
2351 that abuses the labels-as-values extension (e.g. code that attempts to
2352 jump *between* functions via stored labels-as-values; PR 84136).
2353 If so, then we simply return that NULL for the edge.
2354 We don't currently have a way of detecting such invalid code, so we
2355 can't assert that it was the case when a NULL edge occurs here. */
2360 /* Given COND_STMT and a constant value VAL for use as the predicate,
2361 determine which of the two edges will be taken out of
2362 the statement's block. Return NULL if either edge may be taken.
2363 If VAL is NULL_TREE, then the current value of COND_STMT's predicate
2367 find_taken_edge_cond_expr (const gcond
*cond_stmt
, tree val
)
2369 edge true_edge
, false_edge
;
2371 if (val
== NULL_TREE
)
2373 /* Use the current value of the predicate. */
2374 if (gimple_cond_true_p (cond_stmt
))
2375 val
= integer_one_node
;
2376 else if (gimple_cond_false_p (cond_stmt
))
2377 val
= integer_zero_node
;
2381 else if (TREE_CODE (val
) != INTEGER_CST
)
2384 extract_true_false_edges_from_block (gimple_bb (cond_stmt
),
2385 &true_edge
, &false_edge
);
2387 return (integer_zerop (val
) ? false_edge
: true_edge
);
2390 /* Given SWITCH_STMT and an INTEGER_CST VAL for use as the index, determine
2391 which edge will be taken out of the statement's block. Return NULL if any
2393 If VAL is NULL_TREE, then the current value of SWITCH_STMT's index
2397 find_taken_edge_switch_expr (const gswitch
*switch_stmt
, tree val
)
2399 basic_block dest_bb
;
2403 if (gimple_switch_num_labels (switch_stmt
) == 1)
2404 taken_case
= gimple_switch_default_label (switch_stmt
);
2407 if (val
== NULL_TREE
)
2408 val
= gimple_switch_index (switch_stmt
);
2409 if (TREE_CODE (val
) != INTEGER_CST
)
2412 taken_case
= find_case_label_for_value (switch_stmt
, val
);
2414 dest_bb
= label_to_block (cfun
, CASE_LABEL (taken_case
));
2416 e
= find_edge (gimple_bb (switch_stmt
), dest_bb
);
2422 /* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
2423 We can make optimal use here of the fact that the case labels are
2424 sorted: We can do a binary search for a case matching VAL. */
2427 find_case_label_for_value (const gswitch
*switch_stmt
, tree val
)
2429 size_t low
, high
, n
= gimple_switch_num_labels (switch_stmt
);
2430 tree default_case
= gimple_switch_default_label (switch_stmt
);
2432 for (low
= 0, high
= n
; high
- low
> 1; )
2434 size_t i
= (high
+ low
) / 2;
2435 tree t
= gimple_switch_label (switch_stmt
, i
);
2438 /* Cache the result of comparing CASE_LOW and val. */
2439 cmp
= tree_int_cst_compare (CASE_LOW (t
), val
);
2446 if (CASE_HIGH (t
) == NULL
)
2448 /* A singe-valued case label. */
2454 /* A case range. We can only handle integer ranges. */
2455 if (cmp
<= 0 && tree_int_cst_compare (CASE_HIGH (t
), val
) >= 0)
2460 return default_case
;
2464 /* Dump a basic block on stderr. */
2467 gimple_debug_bb (basic_block bb
)
2469 dump_bb (stderr
, bb
, 0, TDF_VOPS
|TDF_MEMSYMS
|TDF_BLOCKS
);
2473 /* Dump basic block with index N on stderr. */
2476 gimple_debug_bb_n (int n
)
2478 gimple_debug_bb (BASIC_BLOCK_FOR_FN (cfun
, n
));
2479 return BASIC_BLOCK_FOR_FN (cfun
, n
);
2483 /* Dump the CFG on stderr.
2485 FLAGS are the same used by the tree dumping functions
2486 (see TDF_* in dumpfile.h). */
2489 gimple_debug_cfg (dump_flags_t flags
)
2491 gimple_dump_cfg (stderr
, flags
);
2495 /* Dump the program showing basic block boundaries on the given FILE.
2497 FLAGS are the same used by the tree dumping functions (see TDF_* in
2501 gimple_dump_cfg (FILE *file
, dump_flags_t flags
)
2503 if (flags
& TDF_DETAILS
)
2505 dump_function_header (file
, current_function_decl
, flags
);
2506 fprintf (file
, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
2507 n_basic_blocks_for_fn (cfun
), n_edges_for_fn (cfun
),
2508 last_basic_block_for_fn (cfun
));
2510 brief_dump_cfg (file
, flags
);
2511 fprintf (file
, "\n");
2514 if (flags
& TDF_STATS
)
2515 dump_cfg_stats (file
);
2517 dump_function_to_file (current_function_decl
, file
, flags
| TDF_BLOCKS
);
2521 /* Dump CFG statistics on FILE. */
2524 dump_cfg_stats (FILE *file
)
2526 static long max_num_merged_labels
= 0;
2527 unsigned long size
, total
= 0;
2530 const char * const fmt_str
= "%-30s%-13s%12s\n";
2531 const char * const fmt_str_1
= "%-30s%13d" PRsa (11) "\n";
2532 const char * const fmt_str_2
= "%-30s%13ld" PRsa (11) "\n";
2533 const char * const fmt_str_3
= "%-43s" PRsa (11) "\n";
2534 const char *funcname
= current_function_name ();
2536 fprintf (file
, "\nCFG Statistics for %s\n\n", funcname
);
2538 fprintf (file
, "---------------------------------------------------------\n");
2539 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
2540 fprintf (file
, fmt_str
, "", " instances ", "used ");
2541 fprintf (file
, "---------------------------------------------------------\n");
2543 size
= n_basic_blocks_for_fn (cfun
) * sizeof (struct basic_block_def
);
2545 fprintf (file
, fmt_str_1
, "Basic blocks", n_basic_blocks_for_fn (cfun
),
2546 SIZE_AMOUNT (size
));
2549 FOR_EACH_BB_FN (bb
, cfun
)
2550 num_edges
+= EDGE_COUNT (bb
->succs
);
2551 size
= num_edges
* sizeof (class edge_def
);
2553 fprintf (file
, fmt_str_2
, "Edges", num_edges
, SIZE_AMOUNT (size
));
2555 fprintf (file
, "---------------------------------------------------------\n");
2556 fprintf (file
, fmt_str_3
, "Total memory used by CFG data",
2557 SIZE_AMOUNT (total
));
2558 fprintf (file
, "---------------------------------------------------------\n");
2559 fprintf (file
, "\n");
2561 if (cfg_stats
.num_merged_labels
> max_num_merged_labels
)
2562 max_num_merged_labels
= cfg_stats
.num_merged_labels
;
2564 fprintf (file
, "Coalesced label blocks: %ld (Max so far: %ld)\n",
2565 cfg_stats
.num_merged_labels
, max_num_merged_labels
);
2567 fprintf (file
, "\n");
2571 /* Dump CFG statistics on stderr. Keep extern so that it's always
2572 linked in the final executable. */
2575 debug_cfg_stats (void)
2577 dump_cfg_stats (stderr
);
2580 /*---------------------------------------------------------------------------
2581 Miscellaneous helpers
2582 ---------------------------------------------------------------------------*/
2584 /* Return true if T, a GIMPLE_CALL, can make an abnormal transfer of control
2585 flow. Transfers of control flow associated with EH are excluded. */
2588 call_can_make_abnormal_goto (gimple
*t
)
2590 /* If the function has no non-local labels, then a call cannot make an
2591 abnormal transfer of control. */
2592 if (!cfun
->has_nonlocal_label
2593 && !cfun
->calls_setjmp
)
2596 /* Likewise if the call has no side effects. */
2597 if (!gimple_has_side_effects (t
))
2600 /* Likewise if the called function is leaf. */
2601 if (gimple_call_flags (t
) & ECF_LEAF
)
2608 /* Return true if T can make an abnormal transfer of control flow.
2609 Transfers of control flow associated with EH are excluded. */
2612 stmt_can_make_abnormal_goto (gimple
*t
)
2614 if (computed_goto_p (t
))
2616 if (is_gimple_call (t
))
2617 return call_can_make_abnormal_goto (t
);
2622 /* Return true if T represents a stmt that always transfers control. */
2625 is_ctrl_stmt (gimple
*t
)
2627 switch (gimple_code (t
))
2641 /* Return true if T is a statement that may alter the flow of control
2642 (e.g., a call to a non-returning function). */
2645 is_ctrl_altering_stmt (gimple
*t
)
2649 switch (gimple_code (t
))
2652 /* Per stmt call flag indicates whether the call could alter
2654 if (gimple_call_ctrl_altering_p (t
))
2658 case GIMPLE_EH_DISPATCH
:
2659 /* EH_DISPATCH branches to the individual catch handlers at
2660 this level of a try or allowed-exceptions region. It can
2661 fallthru to the next statement as well. */
2665 if (gimple_asm_nlabels (as_a
<gasm
*> (t
)) > 0)
2670 /* OpenMP directives alter control flow. */
2673 case GIMPLE_TRANSACTION
:
2674 /* A transaction start alters control flow. */
2681 /* If a statement can throw, it alters control flow. */
2682 return stmt_can_throw_internal (cfun
, t
);
2686 /* Return true if T is a simple local goto. */
2689 simple_goto_p (gimple
*t
)
2691 return (gimple_code (t
) == GIMPLE_GOTO
2692 && TREE_CODE (gimple_goto_dest (t
)) == LABEL_DECL
);
2696 /* Return true if STMT should start a new basic block. PREV_STMT is
2697 the statement preceding STMT. It is used when STMT is a label or a
2698 case label. Labels should only start a new basic block if their
2699 previous statement wasn't a label. Otherwise, sequence of labels
2700 would generate unnecessary basic blocks that only contain a single
2704 stmt_starts_bb_p (gimple
*stmt
, gimple
*prev_stmt
)
2709 /* PREV_STMT is only set to a debug stmt if the debug stmt is before
2710 any nondebug stmts in the block. We don't want to start another
2711 block in this case: the debug stmt will already have started the
2712 one STMT would start if we weren't outputting debug stmts. */
2713 if (prev_stmt
&& is_gimple_debug (prev_stmt
))
2716 /* Labels start a new basic block only if the preceding statement
2717 wasn't a label of the same type. This prevents the creation of
2718 consecutive blocks that have nothing but a single label. */
2719 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
2721 /* Nonlocal and computed GOTO targets always start a new block. */
2722 if (DECL_NONLOCAL (gimple_label_label (label_stmt
))
2723 || FORCED_LABEL (gimple_label_label (label_stmt
)))
2726 if (glabel
*plabel
= safe_dyn_cast
<glabel
*> (prev_stmt
))
2728 if (DECL_NONLOCAL (gimple_label_label (plabel
))
2729 || !DECL_ARTIFICIAL (gimple_label_label (plabel
)))
2732 cfg_stats
.num_merged_labels
++;
2738 else if (gimple_code (stmt
) == GIMPLE_CALL
)
2740 if (gimple_call_flags (stmt
) & ECF_RETURNS_TWICE
)
2741 /* setjmp acts similar to a nonlocal GOTO target and thus should
2742 start a new block. */
2744 if (gimple_call_internal_p (stmt
, IFN_PHI
)
2746 && gimple_code (prev_stmt
) != GIMPLE_LABEL
2747 && (gimple_code (prev_stmt
) != GIMPLE_CALL
2748 || ! gimple_call_internal_p (prev_stmt
, IFN_PHI
)))
2749 /* PHI nodes start a new block unless preceeded by a label
2758 /* Return true if T should end a basic block. */
2761 stmt_ends_bb_p (gimple
*t
)
2763 return is_ctrl_stmt (t
) || is_ctrl_altering_stmt (t
);
2766 /* Remove block annotations and other data structures. */
2769 delete_tree_cfg_annotations (struct function
*fn
)
2771 vec_free (label_to_block_map_for_fn (fn
));
2774 /* Return the virtual phi in BB. */
2777 get_virtual_phi (basic_block bb
)
2779 for (gphi_iterator gsi
= gsi_start_phis (bb
);
2783 gphi
*phi
= gsi
.phi ();
2785 if (virtual_operand_p (PHI_RESULT (phi
)))
2792 /* Return the first statement in basic block BB. */
2795 first_stmt (basic_block bb
)
2797 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2798 gimple
*stmt
= NULL
;
2800 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2808 /* Return the first non-label statement in basic block BB. */
2811 first_non_label_stmt (basic_block bb
)
2813 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2814 while (!gsi_end_p (i
) && gimple_code (gsi_stmt (i
)) == GIMPLE_LABEL
)
2816 return !gsi_end_p (i
) ? gsi_stmt (i
) : NULL
;
2819 /* Return the last statement in basic block BB. */
2822 last_stmt (basic_block bb
)
2824 gimple_stmt_iterator i
= gsi_last_bb (bb
);
2825 gimple
*stmt
= NULL
;
2827 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2835 /* Return the last statement of an otherwise empty block. Return NULL
2836 if the block is totally empty, or if it contains more than one
2840 last_and_only_stmt (basic_block bb
)
2842 gimple_stmt_iterator i
= gsi_last_nondebug_bb (bb
);
2843 gimple
*last
, *prev
;
2848 last
= gsi_stmt (i
);
2849 gsi_prev_nondebug (&i
);
2853 /* Empty statements should no longer appear in the instruction stream.
2854 Everything that might have appeared before should be deleted by
2855 remove_useless_stmts, and the optimizers should just gsi_remove
2856 instead of smashing with build_empty_stmt.
2858 Thus the only thing that should appear here in a block containing
2859 one executable statement is a label. */
2860 prev
= gsi_stmt (i
);
2861 if (gimple_code (prev
) == GIMPLE_LABEL
)
2867 /* Reinstall those PHI arguments queued in OLD_EDGE to NEW_EDGE. */
2870 reinstall_phi_args (edge new_edge
, edge old_edge
)
2876 vec
<edge_var_map
> *v
= redirect_edge_var_map_vector (old_edge
);
2880 for (i
= 0, phis
= gsi_start_phis (new_edge
->dest
);
2881 v
->iterate (i
, &vm
) && !gsi_end_p (phis
);
2882 i
++, gsi_next (&phis
))
2884 gphi
*phi
= phis
.phi ();
2885 tree result
= redirect_edge_var_map_result (vm
);
2886 tree arg
= redirect_edge_var_map_def (vm
);
2888 gcc_assert (result
== gimple_phi_result (phi
));
2890 add_phi_arg (phi
, arg
, new_edge
, redirect_edge_var_map_location (vm
));
2893 redirect_edge_var_map_clear (old_edge
);
2896 /* Returns the basic block after which the new basic block created
2897 by splitting edge EDGE_IN should be placed. Tries to keep the new block
2898 near its "logical" location. This is of most help to humans looking
2899 at debugging dumps. */
2902 split_edge_bb_loc (edge edge_in
)
2904 basic_block dest
= edge_in
->dest
;
2905 basic_block dest_prev
= dest
->prev_bb
;
2909 edge e
= find_edge (dest_prev
, dest
);
2910 if (e
&& !(e
->flags
& EDGE_COMPLEX
))
2911 return edge_in
->src
;
2916 /* Split a (typically critical) edge EDGE_IN. Return the new block.
2917 Abort on abnormal edges. */
2920 gimple_split_edge (edge edge_in
)
2922 basic_block new_bb
, after_bb
, dest
;
2925 /* Abnormal edges cannot be split. */
2926 gcc_assert (!(edge_in
->flags
& EDGE_ABNORMAL
));
2928 dest
= edge_in
->dest
;
2930 after_bb
= split_edge_bb_loc (edge_in
);
2932 new_bb
= create_empty_bb (after_bb
);
2933 new_bb
->count
= edge_in
->count ();
2935 e
= redirect_edge_and_branch (edge_in
, new_bb
);
2936 gcc_assert (e
== edge_in
);
2938 new_edge
= make_single_succ_edge (new_bb
, dest
, EDGE_FALLTHRU
);
2939 reinstall_phi_args (new_edge
, e
);
2945 /* Verify properties of the address expression T whose base should be
2946 TREE_ADDRESSABLE if VERIFY_ADDRESSABLE is true. */
2949 verify_address (tree t
, bool verify_addressable
)
2952 bool old_side_effects
;
2954 bool new_side_effects
;
2956 old_constant
= TREE_CONSTANT (t
);
2957 old_side_effects
= TREE_SIDE_EFFECTS (t
);
2959 recompute_tree_invariant_for_addr_expr (t
);
2960 new_side_effects
= TREE_SIDE_EFFECTS (t
);
2961 new_constant
= TREE_CONSTANT (t
);
2963 if (old_constant
!= new_constant
)
2965 error ("constant not recomputed when %<ADDR_EXPR%> changed");
2968 if (old_side_effects
!= new_side_effects
)
2970 error ("side effects not recomputed when %<ADDR_EXPR%> changed");
2974 tree base
= TREE_OPERAND (t
, 0);
2975 while (handled_component_p (base
))
2976 base
= TREE_OPERAND (base
, 0);
2979 || TREE_CODE (base
) == PARM_DECL
2980 || TREE_CODE (base
) == RESULT_DECL
))
2983 if (DECL_GIMPLE_REG_P (base
))
2985 error ("%<DECL_GIMPLE_REG_P%> set on a variable with address taken");
2989 if (verify_addressable
&& !TREE_ADDRESSABLE (base
))
2991 error ("address taken but %<TREE_ADDRESSABLE%> bit not set");
2999 /* Verify if EXPR is either a GIMPLE ID or a GIMPLE indirect reference.
3000 Returns true if there is an error, otherwise false. */
3003 verify_types_in_gimple_min_lval (tree expr
)
3007 if (is_gimple_id (expr
))
3010 if (TREE_CODE (expr
) != TARGET_MEM_REF
3011 && TREE_CODE (expr
) != MEM_REF
)
3013 error ("invalid expression for min lvalue");
3017 /* TARGET_MEM_REFs are strange beasts. */
3018 if (TREE_CODE (expr
) == TARGET_MEM_REF
)
3021 op
= TREE_OPERAND (expr
, 0);
3022 if (!is_gimple_val (op
))
3024 error ("invalid operand in indirect reference");
3025 debug_generic_stmt (op
);
3028 /* Memory references now generally can involve a value conversion. */
3033 /* Verify if EXPR is a valid GIMPLE reference expression. If
3034 REQUIRE_LVALUE is true verifies it is an lvalue. Returns true
3035 if there is an error, otherwise false. */
3038 verify_types_in_gimple_reference (tree expr
, bool require_lvalue
)
3040 const char *code_name
= get_tree_code_name (TREE_CODE (expr
));
3042 if (TREE_CODE (expr
) == REALPART_EXPR
3043 || TREE_CODE (expr
) == IMAGPART_EXPR
3044 || TREE_CODE (expr
) == BIT_FIELD_REF
)
3046 tree op
= TREE_OPERAND (expr
, 0);
3047 if (!is_gimple_reg_type (TREE_TYPE (expr
)))
3049 error ("non-scalar %qs", code_name
);
3053 if (TREE_CODE (expr
) == BIT_FIELD_REF
)
3055 tree t1
= TREE_OPERAND (expr
, 1);
3056 tree t2
= TREE_OPERAND (expr
, 2);
3057 poly_uint64 size
, bitpos
;
3058 if (!poly_int_tree_p (t1
, &size
)
3059 || !poly_int_tree_p (t2
, &bitpos
)
3060 || !types_compatible_p (bitsizetype
, TREE_TYPE (t1
))
3061 || !types_compatible_p (bitsizetype
, TREE_TYPE (t2
)))
3063 error ("invalid position or size operand to %qs", code_name
);
3066 if (INTEGRAL_TYPE_P (TREE_TYPE (expr
))
3067 && maybe_ne (TYPE_PRECISION (TREE_TYPE (expr
)), size
))
3069 error ("integral result type precision does not match "
3070 "field size of %qs", code_name
);
3073 else if (!INTEGRAL_TYPE_P (TREE_TYPE (expr
))
3074 && TYPE_MODE (TREE_TYPE (expr
)) != BLKmode
3075 && maybe_ne (GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr
))),
3078 error ("mode size of non-integral result does not "
3079 "match field size of %qs",
3083 if (INTEGRAL_TYPE_P (TREE_TYPE (op
))
3084 && !type_has_mode_precision_p (TREE_TYPE (op
)))
3086 error ("%qs of non-mode-precision operand", code_name
);
3089 if (!AGGREGATE_TYPE_P (TREE_TYPE (op
))
3090 && maybe_gt (size
+ bitpos
,
3091 tree_to_poly_uint64 (TYPE_SIZE (TREE_TYPE (op
)))))
3093 error ("position plus size exceeds size of referenced object in "
3099 if ((TREE_CODE (expr
) == REALPART_EXPR
3100 || TREE_CODE (expr
) == IMAGPART_EXPR
)
3101 && !useless_type_conversion_p (TREE_TYPE (expr
),
3102 TREE_TYPE (TREE_TYPE (op
))))
3104 error ("type mismatch in %qs reference", code_name
);
3105 debug_generic_stmt (TREE_TYPE (expr
));
3106 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3112 while (handled_component_p (expr
))
3114 code_name
= get_tree_code_name (TREE_CODE (expr
));
3116 if (TREE_CODE (expr
) == REALPART_EXPR
3117 || TREE_CODE (expr
) == IMAGPART_EXPR
3118 || TREE_CODE (expr
) == BIT_FIELD_REF
)
3120 error ("non-top-level %qs", code_name
);
3124 tree op
= TREE_OPERAND (expr
, 0);
3126 if (TREE_CODE (expr
) == ARRAY_REF
3127 || TREE_CODE (expr
) == ARRAY_RANGE_REF
)
3129 if (!is_gimple_val (TREE_OPERAND (expr
, 1))
3130 || (TREE_OPERAND (expr
, 2)
3131 && !is_gimple_val (TREE_OPERAND (expr
, 2)))
3132 || (TREE_OPERAND (expr
, 3)
3133 && !is_gimple_val (TREE_OPERAND (expr
, 3))))
3135 error ("invalid operands to %qs", code_name
);
3136 debug_generic_stmt (expr
);
3141 /* Verify if the reference array element types are compatible. */
3142 if (TREE_CODE (expr
) == ARRAY_REF
3143 && !useless_type_conversion_p (TREE_TYPE (expr
),
3144 TREE_TYPE (TREE_TYPE (op
))))
3146 error ("type mismatch in %qs", code_name
);
3147 debug_generic_stmt (TREE_TYPE (expr
));
3148 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3151 if (TREE_CODE (expr
) == ARRAY_RANGE_REF
3152 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr
)),
3153 TREE_TYPE (TREE_TYPE (op
))))
3155 error ("type mismatch in %qs", code_name
);
3156 debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr
)));
3157 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3161 if (TREE_CODE (expr
) == COMPONENT_REF
)
3163 if (TREE_OPERAND (expr
, 2)
3164 && !is_gimple_val (TREE_OPERAND (expr
, 2)))
3166 error ("invalid %qs offset operator", code_name
);
3169 if (!useless_type_conversion_p (TREE_TYPE (expr
),
3170 TREE_TYPE (TREE_OPERAND (expr
, 1))))
3172 error ("type mismatch in %qs", code_name
);
3173 debug_generic_stmt (TREE_TYPE (expr
));
3174 debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr
, 1)));
3179 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
)
3181 /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
3182 that their operand is not an SSA name or an invariant when
3183 requiring an lvalue (this usually means there is a SRA or IPA-SRA
3184 bug). Otherwise there is nothing to verify, gross mismatches at
3185 most invoke undefined behavior. */
3187 && (TREE_CODE (op
) == SSA_NAME
3188 || is_gimple_min_invariant (op
)))
3190 error ("conversion of %qs on the left hand side of %qs",
3191 get_tree_code_name (TREE_CODE (op
)), code_name
);
3192 debug_generic_stmt (expr
);
3195 else if (TREE_CODE (op
) == SSA_NAME
3196 && TYPE_SIZE (TREE_TYPE (expr
)) != TYPE_SIZE (TREE_TYPE (op
)))
3198 error ("conversion of register to a different size in %qs",
3200 debug_generic_stmt (expr
);
3203 else if (!handled_component_p (op
))
3210 code_name
= get_tree_code_name (TREE_CODE (expr
));
3212 if (TREE_CODE (expr
) == MEM_REF
)
3214 if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr
, 0))
3215 || (TREE_CODE (TREE_OPERAND (expr
, 0)) == ADDR_EXPR
3216 && verify_address (TREE_OPERAND (expr
, 0), false)))
3218 error ("invalid address operand in %qs", code_name
);
3219 debug_generic_stmt (expr
);
3222 if (!poly_int_tree_p (TREE_OPERAND (expr
, 1))
3223 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr
, 1))))
3225 error ("invalid offset operand in %qs", code_name
);
3226 debug_generic_stmt (expr
);
3230 else if (TREE_CODE (expr
) == TARGET_MEM_REF
)
3232 if (!TMR_BASE (expr
)
3233 || !is_gimple_mem_ref_addr (TMR_BASE (expr
))
3234 || (TREE_CODE (TMR_BASE (expr
)) == ADDR_EXPR
3235 && verify_address (TMR_BASE (expr
), false)))
3237 error ("invalid address operand in %qs", code_name
);
3240 if (!TMR_OFFSET (expr
)
3241 || !poly_int_tree_p (TMR_OFFSET (expr
))
3242 || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr
))))
3244 error ("invalid offset operand in %qs", code_name
);
3245 debug_generic_stmt (expr
);
3249 else if (TREE_CODE (expr
) == INDIRECT_REF
)
3251 error ("%qs in gimple IL", code_name
);
3252 debug_generic_stmt (expr
);
3256 return ((require_lvalue
|| !is_gimple_min_invariant (expr
))
3257 && verify_types_in_gimple_min_lval (expr
));
3260 /* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
3261 list of pointer-to types that is trivially convertible to DEST. */
3264 one_pointer_to_useless_type_conversion_p (tree dest
, tree src_obj
)
3268 if (!TYPE_POINTER_TO (src_obj
))
3271 for (src
= TYPE_POINTER_TO (src_obj
); src
; src
= TYPE_NEXT_PTR_TO (src
))
3272 if (useless_type_conversion_p (dest
, src
))
3278 /* Return true if TYPE1 is a fixed-point type and if conversions to and
3279 from TYPE2 can be handled by FIXED_CONVERT_EXPR. */
3282 valid_fixed_convert_types_p (tree type1
, tree type2
)
3284 return (FIXED_POINT_TYPE_P (type1
)
3285 && (INTEGRAL_TYPE_P (type2
)
3286 || SCALAR_FLOAT_TYPE_P (type2
)
3287 || FIXED_POINT_TYPE_P (type2
)));
3290 /* Verify the contents of a GIMPLE_CALL STMT. Returns true when there
3291 is a problem, otherwise false. */
3294 verify_gimple_call (gcall
*stmt
)
3296 tree fn
= gimple_call_fn (stmt
);
3297 tree fntype
, fndecl
;
3300 if (gimple_call_internal_p (stmt
))
3304 error ("gimple call has two targets");
3305 debug_generic_stmt (fn
);
3313 error ("gimple call has no target");
3318 if (fn
&& !is_gimple_call_addr (fn
))
3320 error ("invalid function in gimple call");
3321 debug_generic_stmt (fn
);
3326 && (!POINTER_TYPE_P (TREE_TYPE (fn
))
3327 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != FUNCTION_TYPE
3328 && TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != METHOD_TYPE
)))
3330 error ("non-function in gimple call");
3334 fndecl
= gimple_call_fndecl (stmt
);
3336 && TREE_CODE (fndecl
) == FUNCTION_DECL
3337 && DECL_LOOPING_CONST_OR_PURE_P (fndecl
)
3338 && !DECL_PURE_P (fndecl
)
3339 && !TREE_READONLY (fndecl
))
3341 error ("invalid pure const state for function");
3345 tree lhs
= gimple_call_lhs (stmt
);
3347 && (!is_gimple_lvalue (lhs
)
3348 || verify_types_in_gimple_reference (lhs
, true)))
3350 error ("invalid LHS in gimple call");
3354 if (gimple_call_ctrl_altering_p (stmt
)
3355 && gimple_call_noreturn_p (stmt
)
3356 && should_remove_lhs_p (lhs
))
3358 error ("LHS in %<noreturn%> call");
3362 fntype
= gimple_call_fntype (stmt
);
3365 && !useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (fntype
))
3366 /* ??? At least C++ misses conversions at assignments from
3367 void * call results.
3368 For now simply allow arbitrary pointer type conversions. */
3369 && !(POINTER_TYPE_P (TREE_TYPE (lhs
))
3370 && POINTER_TYPE_P (TREE_TYPE (fntype
))))
3372 error ("invalid conversion in gimple call");
3373 debug_generic_stmt (TREE_TYPE (lhs
));
3374 debug_generic_stmt (TREE_TYPE (fntype
));
3378 if (gimple_call_chain (stmt
)
3379 && !is_gimple_val (gimple_call_chain (stmt
)))
3381 error ("invalid static chain in gimple call");
3382 debug_generic_stmt (gimple_call_chain (stmt
));
3386 /* If there is a static chain argument, the call should either be
3387 indirect, or the decl should have DECL_STATIC_CHAIN set. */
3388 if (gimple_call_chain (stmt
)
3390 && !DECL_STATIC_CHAIN (fndecl
))
3392 error ("static chain with function that doesn%'t use one");
3396 if (fndecl
&& fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
))
3398 switch (DECL_FUNCTION_CODE (fndecl
))
3400 case BUILT_IN_UNREACHABLE
:
3402 if (gimple_call_num_args (stmt
) > 0)
3404 /* Built-in unreachable with parameters might not be caught by
3405 undefined behavior sanitizer. Front-ends do check users do not
3406 call them that way but we also produce calls to
3407 __builtin_unreachable internally, for example when IPA figures
3408 out a call cannot happen in a legal program. In such cases,
3409 we must make sure arguments are stripped off. */
3410 error ("%<__builtin_unreachable%> or %<__builtin_trap%> call "
3420 /* ??? The C frontend passes unpromoted arguments in case it
3421 didn't see a function declaration before the call. So for now
3422 leave the call arguments mostly unverified. Once we gimplify
3423 unit-at-a-time we have a chance to fix this. */
3425 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
3427 tree arg
= gimple_call_arg (stmt
, i
);
3428 if ((is_gimple_reg_type (TREE_TYPE (arg
))
3429 && !is_gimple_val (arg
))
3430 || (!is_gimple_reg_type (TREE_TYPE (arg
))
3431 && !is_gimple_lvalue (arg
)))
3433 error ("invalid argument to gimple call");
3434 debug_generic_expr (arg
);
3442 /* Verifies the gimple comparison with the result type TYPE and
3443 the operands OP0 and OP1, comparison code is CODE. */
3446 verify_gimple_comparison (tree type
, tree op0
, tree op1
, enum tree_code code
)
3448 tree op0_type
= TREE_TYPE (op0
);
3449 tree op1_type
= TREE_TYPE (op1
);
3451 if (!is_gimple_val (op0
) || !is_gimple_val (op1
))
3453 error ("invalid operands in gimple comparison");
3457 /* For comparisons we do not have the operations type as the
3458 effective type the comparison is carried out in. Instead
3459 we require that either the first operand is trivially
3460 convertible into the second, or the other way around.
3461 Because we special-case pointers to void we allow
3462 comparisons of pointers with the same mode as well. */
3463 if (!useless_type_conversion_p (op0_type
, op1_type
)
3464 && !useless_type_conversion_p (op1_type
, op0_type
)
3465 && (!POINTER_TYPE_P (op0_type
)
3466 || !POINTER_TYPE_P (op1_type
)
3467 || TYPE_MODE (op0_type
) != TYPE_MODE (op1_type
)))
3469 error ("mismatching comparison operand types");
3470 debug_generic_expr (op0_type
);
3471 debug_generic_expr (op1_type
);
3475 /* The resulting type of a comparison may be an effective boolean type. */
3476 if (INTEGRAL_TYPE_P (type
)
3477 && (TREE_CODE (type
) == BOOLEAN_TYPE
3478 || TYPE_PRECISION (type
) == 1))
3480 if ((TREE_CODE (op0_type
) == VECTOR_TYPE
3481 || TREE_CODE (op1_type
) == VECTOR_TYPE
)
3482 && code
!= EQ_EXPR
&& code
!= NE_EXPR
3483 && !VECTOR_BOOLEAN_TYPE_P (op0_type
)
3484 && !VECTOR_INTEGER_TYPE_P (op0_type
))
3486 error ("unsupported operation or type for vector comparison"
3487 " returning a boolean");
3488 debug_generic_expr (op0_type
);
3489 debug_generic_expr (op1_type
);
3493 /* Or a boolean vector type with the same element count
3494 as the comparison operand types. */
3495 else if (TREE_CODE (type
) == VECTOR_TYPE
3496 && TREE_CODE (TREE_TYPE (type
)) == BOOLEAN_TYPE
)
3498 if (TREE_CODE (op0_type
) != VECTOR_TYPE
3499 || TREE_CODE (op1_type
) != VECTOR_TYPE
)
3501 error ("non-vector operands in vector comparison");
3502 debug_generic_expr (op0_type
);
3503 debug_generic_expr (op1_type
);
3507 if (maybe_ne (TYPE_VECTOR_SUBPARTS (type
),
3508 TYPE_VECTOR_SUBPARTS (op0_type
)))
3510 error ("invalid vector comparison resulting type");
3511 debug_generic_expr (type
);
3517 error ("bogus comparison result type");
3518 debug_generic_expr (type
);
3525 /* Verify a gimple assignment statement STMT with an unary rhs.
3526 Returns true if anything is wrong. */
3529 verify_gimple_assign_unary (gassign
*stmt
)
3531 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3532 tree lhs
= gimple_assign_lhs (stmt
);
3533 tree lhs_type
= TREE_TYPE (lhs
);
3534 tree rhs1
= gimple_assign_rhs1 (stmt
);
3535 tree rhs1_type
= TREE_TYPE (rhs1
);
3537 if (!is_gimple_reg (lhs
))
3539 error ("non-register as LHS of unary operation");
3543 if (!is_gimple_val (rhs1
))
3545 error ("invalid operand in unary operation");
3549 const char* const code_name
= get_tree_code_name (rhs_code
);
3551 /* First handle conversions. */
3556 /* Allow conversions from pointer type to integral type only if
3557 there is no sign or zero extension involved.
3558 For targets were the precision of ptrofftype doesn't match that
3559 of pointers we need to allow arbitrary conversions to ptrofftype. */
3560 if ((POINTER_TYPE_P (lhs_type
)
3561 && INTEGRAL_TYPE_P (rhs1_type
))
3562 || (POINTER_TYPE_P (rhs1_type
)
3563 && INTEGRAL_TYPE_P (lhs_type
)
3564 && (TYPE_PRECISION (rhs1_type
) >= TYPE_PRECISION (lhs_type
)
3565 || ptrofftype_p (lhs_type
))))
3568 /* Allow conversion from integral to offset type and vice versa. */
3569 if ((TREE_CODE (lhs_type
) == OFFSET_TYPE
3570 && INTEGRAL_TYPE_P (rhs1_type
))
3571 || (INTEGRAL_TYPE_P (lhs_type
)
3572 && TREE_CODE (rhs1_type
) == OFFSET_TYPE
))
3575 /* Otherwise assert we are converting between types of the
3577 if (INTEGRAL_TYPE_P (lhs_type
) != INTEGRAL_TYPE_P (rhs1_type
))
3579 error ("invalid types in nop conversion");
3580 debug_generic_expr (lhs_type
);
3581 debug_generic_expr (rhs1_type
);
3588 case ADDR_SPACE_CONVERT_EXPR
:
3590 if (!POINTER_TYPE_P (rhs1_type
) || !POINTER_TYPE_P (lhs_type
)
3591 || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type
))
3592 == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type
))))
3594 error ("invalid types in address space conversion");
3595 debug_generic_expr (lhs_type
);
3596 debug_generic_expr (rhs1_type
);
3603 case FIXED_CONVERT_EXPR
:
3605 if (!valid_fixed_convert_types_p (lhs_type
, rhs1_type
)
3606 && !valid_fixed_convert_types_p (rhs1_type
, lhs_type
))
3608 error ("invalid types in fixed-point conversion");
3609 debug_generic_expr (lhs_type
);
3610 debug_generic_expr (rhs1_type
);
3619 if ((!INTEGRAL_TYPE_P (rhs1_type
) || !SCALAR_FLOAT_TYPE_P (lhs_type
))
3620 && (!VECTOR_INTEGER_TYPE_P (rhs1_type
)
3621 || !VECTOR_FLOAT_TYPE_P (lhs_type
)))
3623 error ("invalid types in conversion to floating-point");
3624 debug_generic_expr (lhs_type
);
3625 debug_generic_expr (rhs1_type
);
3632 case FIX_TRUNC_EXPR
:
3634 if ((!INTEGRAL_TYPE_P (lhs_type
) || !SCALAR_FLOAT_TYPE_P (rhs1_type
))
3635 && (!VECTOR_INTEGER_TYPE_P (lhs_type
)
3636 || !VECTOR_FLOAT_TYPE_P (rhs1_type
)))
3638 error ("invalid types in conversion to integer");
3639 debug_generic_expr (lhs_type
);
3640 debug_generic_expr (rhs1_type
);
3647 case VEC_UNPACK_HI_EXPR
:
3648 case VEC_UNPACK_LO_EXPR
:
3649 case VEC_UNPACK_FLOAT_HI_EXPR
:
3650 case VEC_UNPACK_FLOAT_LO_EXPR
:
3651 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3652 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3653 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3654 || TREE_CODE (lhs_type
) != VECTOR_TYPE
3655 || (!INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3656 && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type
)))
3657 || (!INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3658 && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
)))
3659 || ((rhs_code
== VEC_UNPACK_HI_EXPR
3660 || rhs_code
== VEC_UNPACK_LO_EXPR
)
3661 && (INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3662 != INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))))
3663 || ((rhs_code
== VEC_UNPACK_FLOAT_HI_EXPR
3664 || rhs_code
== VEC_UNPACK_FLOAT_LO_EXPR
)
3665 && (INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3666 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
))))
3667 || ((rhs_code
== VEC_UNPACK_FIX_TRUNC_HI_EXPR
3668 || rhs_code
== VEC_UNPACK_FIX_TRUNC_LO_EXPR
)
3669 && (INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3670 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type
))))
3671 || (maybe_ne (GET_MODE_SIZE (element_mode (lhs_type
)),
3672 2 * GET_MODE_SIZE (element_mode (rhs1_type
)))
3673 && (!VECTOR_BOOLEAN_TYPE_P (lhs_type
)
3674 || !VECTOR_BOOLEAN_TYPE_P (rhs1_type
)))
3675 || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (lhs_type
),
3676 TYPE_VECTOR_SUBPARTS (rhs1_type
)))
3678 error ("type mismatch in %qs expression", code_name
);
3679 debug_generic_expr (lhs_type
);
3680 debug_generic_expr (rhs1_type
);
3694 if (!ANY_INTEGRAL_TYPE_P (lhs_type
)
3695 || !TYPE_UNSIGNED (lhs_type
)
3696 || !ANY_INTEGRAL_TYPE_P (rhs1_type
)
3697 || TYPE_UNSIGNED (rhs1_type
)
3698 || element_precision (lhs_type
) != element_precision (rhs1_type
))
3700 error ("invalid types for %qs", code_name
);
3701 debug_generic_expr (lhs_type
);
3702 debug_generic_expr (rhs1_type
);
3707 case VEC_DUPLICATE_EXPR
:
3708 if (TREE_CODE (lhs_type
) != VECTOR_TYPE
3709 || !useless_type_conversion_p (TREE_TYPE (lhs_type
), rhs1_type
))
3711 error ("%qs should be from a scalar to a like vector", code_name
);
3712 debug_generic_expr (lhs_type
);
3713 debug_generic_expr (rhs1_type
);
3722 /* For the remaining codes assert there is no conversion involved. */
3723 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3725 error ("non-trivial conversion in unary operation");
3726 debug_generic_expr (lhs_type
);
3727 debug_generic_expr (rhs1_type
);
3734 /* Verify a gimple assignment statement STMT with a binary rhs.
3735 Returns true if anything is wrong. */
3738 verify_gimple_assign_binary (gassign
*stmt
)
3740 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3741 tree lhs
= gimple_assign_lhs (stmt
);
3742 tree lhs_type
= TREE_TYPE (lhs
);
3743 tree rhs1
= gimple_assign_rhs1 (stmt
);
3744 tree rhs1_type
= TREE_TYPE (rhs1
);
3745 tree rhs2
= gimple_assign_rhs2 (stmt
);
3746 tree rhs2_type
= TREE_TYPE (rhs2
);
3748 if (!is_gimple_reg (lhs
))
3750 error ("non-register as LHS of binary operation");
3754 if (!is_gimple_val (rhs1
)
3755 || !is_gimple_val (rhs2
))
3757 error ("invalid operands in binary operation");
3761 const char* const code_name
= get_tree_code_name (rhs_code
);
3763 /* First handle operations that involve different types. */
3768 if (TREE_CODE (lhs_type
) != COMPLEX_TYPE
3769 || !(INTEGRAL_TYPE_P (rhs1_type
)
3770 || SCALAR_FLOAT_TYPE_P (rhs1_type
))
3771 || !(INTEGRAL_TYPE_P (rhs2_type
)
3772 || SCALAR_FLOAT_TYPE_P (rhs2_type
)))
3774 error ("type mismatch in %qs", code_name
);
3775 debug_generic_expr (lhs_type
);
3776 debug_generic_expr (rhs1_type
);
3777 debug_generic_expr (rhs2_type
);
3789 /* Shifts and rotates are ok on integral types, fixed point
3790 types and integer vector types. */
3791 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3792 && !FIXED_POINT_TYPE_P (rhs1_type
)
3793 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3794 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))))
3795 || (!INTEGRAL_TYPE_P (rhs2_type
)
3796 /* Vector shifts of vectors are also ok. */
3797 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3798 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3799 && TREE_CODE (rhs2_type
) == VECTOR_TYPE
3800 && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3801 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3803 error ("type mismatch in %qs", code_name
);
3804 debug_generic_expr (lhs_type
);
3805 debug_generic_expr (rhs1_type
);
3806 debug_generic_expr (rhs2_type
);
3813 case WIDEN_LSHIFT_EXPR
:
3815 if (!INTEGRAL_TYPE_P (lhs_type
)
3816 || !INTEGRAL_TYPE_P (rhs1_type
)
3817 || TREE_CODE (rhs2
) != INTEGER_CST
3818 || (2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)))
3820 error ("type mismatch in %qs", code_name
);
3821 debug_generic_expr (lhs_type
);
3822 debug_generic_expr (rhs1_type
);
3823 debug_generic_expr (rhs2_type
);
3830 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3831 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3833 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3834 || TREE_CODE (lhs_type
) != VECTOR_TYPE
3835 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3836 || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3837 || TREE_CODE (rhs2
) != INTEGER_CST
3838 || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type
))
3839 > TYPE_PRECISION (TREE_TYPE (lhs_type
))))
3841 error ("type mismatch in %qs", code_name
);
3842 debug_generic_expr (lhs_type
);
3843 debug_generic_expr (rhs1_type
);
3844 debug_generic_expr (rhs2_type
);
3854 tree lhs_etype
= lhs_type
;
3855 tree rhs1_etype
= rhs1_type
;
3856 tree rhs2_etype
= rhs2_type
;
3857 if (TREE_CODE (lhs_type
) == VECTOR_TYPE
)
3859 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3860 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
)
3862 error ("invalid non-vector operands to %qs", code_name
);
3865 lhs_etype
= TREE_TYPE (lhs_type
);
3866 rhs1_etype
= TREE_TYPE (rhs1_type
);
3867 rhs2_etype
= TREE_TYPE (rhs2_type
);
3869 if (POINTER_TYPE_P (lhs_etype
)
3870 || POINTER_TYPE_P (rhs1_etype
)
3871 || POINTER_TYPE_P (rhs2_etype
))
3873 error ("invalid (pointer) operands %qs", code_name
);
3877 /* Continue with generic binary expression handling. */
3881 case POINTER_PLUS_EXPR
:
3883 if (!POINTER_TYPE_P (rhs1_type
)
3884 || !useless_type_conversion_p (lhs_type
, rhs1_type
)
3885 || !ptrofftype_p (rhs2_type
))
3887 error ("type mismatch in %qs", code_name
);
3888 debug_generic_stmt (lhs_type
);
3889 debug_generic_stmt (rhs1_type
);
3890 debug_generic_stmt (rhs2_type
);
3897 case POINTER_DIFF_EXPR
:
3899 if (!POINTER_TYPE_P (rhs1_type
)
3900 || !POINTER_TYPE_P (rhs2_type
)
3901 /* Because we special-case pointers to void we allow difference
3902 of arbitrary pointers with the same mode. */
3903 || TYPE_MODE (rhs1_type
) != TYPE_MODE (rhs2_type
)
3904 || TREE_CODE (lhs_type
) != INTEGER_TYPE
3905 || TYPE_UNSIGNED (lhs_type
)
3906 || TYPE_PRECISION (lhs_type
) != TYPE_PRECISION (rhs1_type
))
3908 error ("type mismatch in %qs", code_name
);
3909 debug_generic_stmt (lhs_type
);
3910 debug_generic_stmt (rhs1_type
);
3911 debug_generic_stmt (rhs2_type
);
3918 case TRUTH_ANDIF_EXPR
:
3919 case TRUTH_ORIF_EXPR
:
3920 case TRUTH_AND_EXPR
:
3922 case TRUTH_XOR_EXPR
:
3932 case UNORDERED_EXPR
:
3940 /* Comparisons are also binary, but the result type is not
3941 connected to the operand types. */
3942 return verify_gimple_comparison (lhs_type
, rhs1
, rhs2
, rhs_code
);
3944 case WIDEN_MULT_EXPR
:
3945 if (TREE_CODE (lhs_type
) != INTEGER_TYPE
)
3947 return ((2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
))
3948 || (TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
)));
3950 case WIDEN_SUM_EXPR
:
3952 if (((TREE_CODE (rhs1_type
) != VECTOR_TYPE
3953 || TREE_CODE (lhs_type
) != VECTOR_TYPE
)
3954 && ((!INTEGRAL_TYPE_P (rhs1_type
)
3955 && !SCALAR_FLOAT_TYPE_P (rhs1_type
))
3956 || (!INTEGRAL_TYPE_P (lhs_type
)
3957 && !SCALAR_FLOAT_TYPE_P (lhs_type
))))
3958 || !useless_type_conversion_p (lhs_type
, rhs2_type
)
3959 || maybe_lt (GET_MODE_SIZE (element_mode (rhs2_type
)),
3960 2 * GET_MODE_SIZE (element_mode (rhs1_type
))))
3962 error ("type mismatch in %qs", code_name
);
3963 debug_generic_expr (lhs_type
);
3964 debug_generic_expr (rhs1_type
);
3965 debug_generic_expr (rhs2_type
);
3971 case VEC_WIDEN_MULT_HI_EXPR
:
3972 case VEC_WIDEN_MULT_LO_EXPR
:
3973 case VEC_WIDEN_MULT_EVEN_EXPR
:
3974 case VEC_WIDEN_MULT_ODD_EXPR
:
3976 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3977 || TREE_CODE (lhs_type
) != VECTOR_TYPE
3978 || !types_compatible_p (rhs1_type
, rhs2_type
)
3979 || maybe_ne (GET_MODE_SIZE (element_mode (lhs_type
)),
3980 2 * GET_MODE_SIZE (element_mode (rhs1_type
))))
3982 error ("type mismatch in %qs", code_name
);
3983 debug_generic_expr (lhs_type
);
3984 debug_generic_expr (rhs1_type
);
3985 debug_generic_expr (rhs2_type
);
3991 case VEC_PACK_TRUNC_EXPR
:
3992 /* ??? We currently use VEC_PACK_TRUNC_EXPR to simply concat
3993 vector boolean types. */
3994 if (VECTOR_BOOLEAN_TYPE_P (lhs_type
)
3995 && VECTOR_BOOLEAN_TYPE_P (rhs1_type
)
3996 && types_compatible_p (rhs1_type
, rhs2_type
)
3997 && known_eq (TYPE_VECTOR_SUBPARTS (lhs_type
),
3998 2 * TYPE_VECTOR_SUBPARTS (rhs1_type
)))
4002 case VEC_PACK_SAT_EXPR
:
4003 case VEC_PACK_FIX_TRUNC_EXPR
:
4005 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4006 || TREE_CODE (lhs_type
) != VECTOR_TYPE
4007 || !((rhs_code
== VEC_PACK_FIX_TRUNC_EXPR
4008 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
))
4009 && INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
)))
4010 || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
4011 == INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))))
4012 || !types_compatible_p (rhs1_type
, rhs2_type
)
4013 || maybe_ne (GET_MODE_SIZE (element_mode (rhs1_type
)),
4014 2 * GET_MODE_SIZE (element_mode (lhs_type
)))
4015 || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (rhs1_type
),
4016 TYPE_VECTOR_SUBPARTS (lhs_type
)))
4018 error ("type mismatch in %qs", code_name
);
4019 debug_generic_expr (lhs_type
);
4020 debug_generic_expr (rhs1_type
);
4021 debug_generic_expr (rhs2_type
);
4028 case VEC_PACK_FLOAT_EXPR
:
4029 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4030 || TREE_CODE (lhs_type
) != VECTOR_TYPE
4031 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
4032 || !SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type
))
4033 || !types_compatible_p (rhs1_type
, rhs2_type
)
4034 || maybe_ne (GET_MODE_SIZE (element_mode (rhs1_type
)),
4035 2 * GET_MODE_SIZE (element_mode (lhs_type
)))
4036 || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (rhs1_type
),
4037 TYPE_VECTOR_SUBPARTS (lhs_type
)))
4039 error ("type mismatch in %qs", code_name
);
4040 debug_generic_expr (lhs_type
);
4041 debug_generic_expr (rhs1_type
);
4042 debug_generic_expr (rhs2_type
);
4049 case MULT_HIGHPART_EXPR
:
4050 case TRUNC_DIV_EXPR
:
4052 case FLOOR_DIV_EXPR
:
4053 case ROUND_DIV_EXPR
:
4054 case TRUNC_MOD_EXPR
:
4056 case FLOOR_MOD_EXPR
:
4057 case ROUND_MOD_EXPR
:
4059 case EXACT_DIV_EXPR
:
4065 /* Continue with generic binary expression handling. */
4068 case VEC_SERIES_EXPR
:
4069 if (!useless_type_conversion_p (rhs1_type
, rhs2_type
))
4071 error ("type mismatch in %qs", code_name
);
4072 debug_generic_expr (rhs1_type
);
4073 debug_generic_expr (rhs2_type
);
4076 if (TREE_CODE (lhs_type
) != VECTOR_TYPE
4077 || !useless_type_conversion_p (TREE_TYPE (lhs_type
), rhs1_type
))
4079 error ("vector type expected in %qs", code_name
);
4080 debug_generic_expr (lhs_type
);
4089 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
4090 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
4092 error ("type mismatch in binary expression");
4093 debug_generic_stmt (lhs_type
);
4094 debug_generic_stmt (rhs1_type
);
4095 debug_generic_stmt (rhs2_type
);
4102 /* Verify a gimple assignment statement STMT with a ternary rhs.
4103 Returns true if anything is wrong. */
4106 verify_gimple_assign_ternary (gassign
*stmt
)
4108 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
4109 tree lhs
= gimple_assign_lhs (stmt
);
4110 tree lhs_type
= TREE_TYPE (lhs
);
4111 tree rhs1
= gimple_assign_rhs1 (stmt
);
4112 tree rhs1_type
= TREE_TYPE (rhs1
);
4113 tree rhs2
= gimple_assign_rhs2 (stmt
);
4114 tree rhs2_type
= TREE_TYPE (rhs2
);
4115 tree rhs3
= gimple_assign_rhs3 (stmt
);
4116 tree rhs3_type
= TREE_TYPE (rhs3
);
4118 if (!is_gimple_reg (lhs
))
4120 error ("non-register as LHS of ternary operation");
4124 if (((rhs_code
== VEC_COND_EXPR
|| rhs_code
== COND_EXPR
)
4125 ? !is_gimple_condexpr (rhs1
) : !is_gimple_val (rhs1
))
4126 || !is_gimple_val (rhs2
)
4127 || !is_gimple_val (rhs3
))
4129 error ("invalid operands in ternary operation");
4133 const char* const code_name
= get_tree_code_name (rhs_code
);
4135 /* First handle operations that involve different types. */
4138 case WIDEN_MULT_PLUS_EXPR
:
4139 case WIDEN_MULT_MINUS_EXPR
:
4140 if ((!INTEGRAL_TYPE_P (rhs1_type
)
4141 && !FIXED_POINT_TYPE_P (rhs1_type
))
4142 || !useless_type_conversion_p (rhs1_type
, rhs2_type
)
4143 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
4144 || 2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)
4145 || TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
))
4147 error ("type mismatch in %qs", code_name
);
4148 debug_generic_expr (lhs_type
);
4149 debug_generic_expr (rhs1_type
);
4150 debug_generic_expr (rhs2_type
);
4151 debug_generic_expr (rhs3_type
);
4157 if (!VECTOR_BOOLEAN_TYPE_P (rhs1_type
)
4158 || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs1_type
),
4159 TYPE_VECTOR_SUBPARTS (lhs_type
)))
4161 error ("the first argument of a %qs must be of a "
4162 "boolean vector type of the same number of elements "
4163 "as the result", code_name
);
4164 debug_generic_expr (lhs_type
);
4165 debug_generic_expr (rhs1_type
);
4170 if (!is_gimple_val (rhs1
)
4171 && verify_gimple_comparison (TREE_TYPE (rhs1
),
4172 TREE_OPERAND (rhs1
, 0),
4173 TREE_OPERAND (rhs1
, 1),
4176 if (!useless_type_conversion_p (lhs_type
, rhs2_type
)
4177 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
4179 error ("type mismatch in %qs", code_name
);
4180 debug_generic_expr (lhs_type
);
4181 debug_generic_expr (rhs2_type
);
4182 debug_generic_expr (rhs3_type
);
4188 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
4189 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
4191 error ("type mismatch in %qs", code_name
);
4192 debug_generic_expr (lhs_type
);
4193 debug_generic_expr (rhs1_type
);
4194 debug_generic_expr (rhs2_type
);
4195 debug_generic_expr (rhs3_type
);
4199 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4200 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
4201 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
4203 error ("vector types expected in %qs", code_name
);
4204 debug_generic_expr (lhs_type
);
4205 debug_generic_expr (rhs1_type
);
4206 debug_generic_expr (rhs2_type
);
4207 debug_generic_expr (rhs3_type
);
4211 if (maybe_ne (TYPE_VECTOR_SUBPARTS (rhs1_type
),
4212 TYPE_VECTOR_SUBPARTS (rhs2_type
))
4213 || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs2_type
),
4214 TYPE_VECTOR_SUBPARTS (rhs3_type
))
4215 || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs3_type
),
4216 TYPE_VECTOR_SUBPARTS (lhs_type
)))
4218 error ("vectors with different element number found in %qs",
4220 debug_generic_expr (lhs_type
);
4221 debug_generic_expr (rhs1_type
);
4222 debug_generic_expr (rhs2_type
);
4223 debug_generic_expr (rhs3_type
);
4227 if (TREE_CODE (TREE_TYPE (rhs3_type
)) != INTEGER_TYPE
4228 || (TREE_CODE (rhs3
) != VECTOR_CST
4229 && (GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE
4230 (TREE_TYPE (rhs3_type
)))
4231 != GET_MODE_BITSIZE (SCALAR_TYPE_MODE
4232 (TREE_TYPE (rhs1_type
))))))
4234 error ("invalid mask type in %qs", code_name
);
4235 debug_generic_expr (lhs_type
);
4236 debug_generic_expr (rhs1_type
);
4237 debug_generic_expr (rhs2_type
);
4238 debug_generic_expr (rhs3_type
);
4245 if (!useless_type_conversion_p (rhs1_type
, rhs2_type
)
4246 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
4247 || 2 * GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type
)))
4248 > GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (lhs_type
))))
4250 error ("type mismatch in %qs", code_name
);
4251 debug_generic_expr (lhs_type
);
4252 debug_generic_expr (rhs1_type
);
4253 debug_generic_expr (rhs2_type
);
4254 debug_generic_expr (rhs3_type
);
4258 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4259 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
4260 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
4262 error ("vector types expected in %qs", code_name
);
4263 debug_generic_expr (lhs_type
);
4264 debug_generic_expr (rhs1_type
);
4265 debug_generic_expr (rhs2_type
);
4266 debug_generic_expr (rhs3_type
);
4272 case BIT_INSERT_EXPR
:
4273 if (! useless_type_conversion_p (lhs_type
, rhs1_type
))
4275 error ("type mismatch in %qs", code_name
);
4276 debug_generic_expr (lhs_type
);
4277 debug_generic_expr (rhs1_type
);
4280 if (! ((INTEGRAL_TYPE_P (rhs1_type
)
4281 && INTEGRAL_TYPE_P (rhs2_type
))
4282 /* Vector element insert. */
4283 || (VECTOR_TYPE_P (rhs1_type
)
4284 && types_compatible_p (TREE_TYPE (rhs1_type
), rhs2_type
))
4285 /* Aligned sub-vector insert. */
4286 || (VECTOR_TYPE_P (rhs1_type
)
4287 && VECTOR_TYPE_P (rhs2_type
)
4288 && types_compatible_p (TREE_TYPE (rhs1_type
),
4289 TREE_TYPE (rhs2_type
))
4290 && multiple_p (TYPE_VECTOR_SUBPARTS (rhs1_type
),
4291 TYPE_VECTOR_SUBPARTS (rhs2_type
))
4292 && multiple_of_p (bitsizetype
, rhs3
, TYPE_SIZE (rhs2_type
)))))
4294 error ("not allowed type combination in %qs", code_name
);
4295 debug_generic_expr (rhs1_type
);
4296 debug_generic_expr (rhs2_type
);
4299 if (! tree_fits_uhwi_p (rhs3
)
4300 || ! types_compatible_p (bitsizetype
, TREE_TYPE (rhs3
))
4301 || ! tree_fits_uhwi_p (TYPE_SIZE (rhs2_type
)))
4303 error ("invalid position or size in %qs", code_name
);
4306 if (INTEGRAL_TYPE_P (rhs1_type
)
4307 && !type_has_mode_precision_p (rhs1_type
))
4309 error ("%qs into non-mode-precision operand", code_name
);
4312 if (INTEGRAL_TYPE_P (rhs1_type
))
4314 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (rhs3
);
4315 if (bitpos
>= TYPE_PRECISION (rhs1_type
)
4316 || (bitpos
+ TYPE_PRECISION (rhs2_type
)
4317 > TYPE_PRECISION (rhs1_type
)))
4319 error ("insertion out of range in %qs", code_name
);
4323 else if (VECTOR_TYPE_P (rhs1_type
))
4325 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (rhs3
);
4326 unsigned HOST_WIDE_INT bitsize
= tree_to_uhwi (TYPE_SIZE (rhs2_type
));
4327 if (bitpos
% bitsize
!= 0)
4329 error ("%qs not at element boundary", code_name
);
4337 if (((TREE_CODE (rhs1_type
) != VECTOR_TYPE
4338 || TREE_CODE (lhs_type
) != VECTOR_TYPE
)
4339 && ((!INTEGRAL_TYPE_P (rhs1_type
)
4340 && !SCALAR_FLOAT_TYPE_P (rhs1_type
))
4341 || (!INTEGRAL_TYPE_P (lhs_type
)
4342 && !SCALAR_FLOAT_TYPE_P (lhs_type
))))
4343 || !types_compatible_p (rhs1_type
, rhs2_type
)
4344 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
4345 || maybe_lt (GET_MODE_SIZE (element_mode (rhs3_type
)),
4346 2 * GET_MODE_SIZE (element_mode (rhs1_type
))))
4348 error ("type mismatch in %qs", code_name
);
4349 debug_generic_expr (lhs_type
);
4350 debug_generic_expr (rhs1_type
);
4351 debug_generic_expr (rhs2_type
);
4357 case REALIGN_LOAD_EXPR
:
4367 /* Verify a gimple assignment statement STMT with a single rhs.
4368 Returns true if anything is wrong. */
4371 verify_gimple_assign_single (gassign
*stmt
)
4373 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
4374 tree lhs
= gimple_assign_lhs (stmt
);
4375 tree lhs_type
= TREE_TYPE (lhs
);
4376 tree rhs1
= gimple_assign_rhs1 (stmt
);
4377 tree rhs1_type
= TREE_TYPE (rhs1
);
4380 const char* const code_name
= get_tree_code_name (rhs_code
);
4382 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
4384 error ("non-trivial conversion in %qs", code_name
);
4385 debug_generic_expr (lhs_type
);
4386 debug_generic_expr (rhs1_type
);
4390 if (gimple_clobber_p (stmt
)
4391 && !(DECL_P (lhs
) || TREE_CODE (lhs
) == MEM_REF
))
4393 error ("%qs LHS in clobber statement",
4394 get_tree_code_name (TREE_CODE (lhs
)));
4395 debug_generic_expr (lhs
);
4399 if (handled_component_p (lhs
)
4400 || TREE_CODE (lhs
) == MEM_REF
4401 || TREE_CODE (lhs
) == TARGET_MEM_REF
)
4402 res
|= verify_types_in_gimple_reference (lhs
, true);
4404 /* Special codes we cannot handle via their class. */
4409 tree op
= TREE_OPERAND (rhs1
, 0);
4410 if (!is_gimple_addressable (op
))
4412 error ("invalid operand in %qs", code_name
);
4416 /* Technically there is no longer a need for matching types, but
4417 gimple hygiene asks for this check. In LTO we can end up
4418 combining incompatible units and thus end up with addresses
4419 of globals that change their type to a common one. */
4421 && !types_compatible_p (TREE_TYPE (op
),
4422 TREE_TYPE (TREE_TYPE (rhs1
)))
4423 && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1
),
4426 error ("type mismatch in %qs", code_name
);
4427 debug_generic_stmt (TREE_TYPE (rhs1
));
4428 debug_generic_stmt (TREE_TYPE (op
));
4432 return (verify_address (rhs1
, true)
4433 || verify_types_in_gimple_reference (op
, true));
4438 error ("%qs in gimple IL", code_name
);
4444 case ARRAY_RANGE_REF
:
4445 case VIEW_CONVERT_EXPR
:
4448 case TARGET_MEM_REF
:
4450 if (!is_gimple_reg (lhs
)
4451 && is_gimple_reg_type (TREE_TYPE (lhs
)))
4453 error ("invalid RHS for gimple memory store: %qs", code_name
);
4454 debug_generic_stmt (lhs
);
4455 debug_generic_stmt (rhs1
);
4458 return res
|| verify_types_in_gimple_reference (rhs1
, false);
4470 /* tcc_declaration */
4475 if (!is_gimple_reg (lhs
)
4476 && !is_gimple_reg (rhs1
)
4477 && is_gimple_reg_type (TREE_TYPE (lhs
)))
4479 error ("invalid RHS for gimple memory store: %qs", code_name
);
4480 debug_generic_stmt (lhs
);
4481 debug_generic_stmt (rhs1
);
4487 if (TREE_CODE (rhs1_type
) == VECTOR_TYPE
)
4490 tree elt_i
, elt_v
, elt_t
= NULL_TREE
;
4492 if (CONSTRUCTOR_NELTS (rhs1
) == 0)
4494 /* For vector CONSTRUCTORs we require that either it is empty
4495 CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
4496 (then the element count must be correct to cover the whole
4497 outer vector and index must be NULL on all elements, or it is
4498 a CONSTRUCTOR of scalar elements, where we as an exception allow
4499 smaller number of elements (assuming zero filling) and
4500 consecutive indexes as compared to NULL indexes (such
4501 CONSTRUCTORs can appear in the IL from FEs). */
4502 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1
), i
, elt_i
, elt_v
)
4504 if (elt_t
== NULL_TREE
)
4506 elt_t
= TREE_TYPE (elt_v
);
4507 if (TREE_CODE (elt_t
) == VECTOR_TYPE
)
4509 tree elt_t
= TREE_TYPE (elt_v
);
4510 if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
4513 error ("incorrect type of vector %qs elements",
4515 debug_generic_stmt (rhs1
);
4518 else if (maybe_ne (CONSTRUCTOR_NELTS (rhs1
)
4519 * TYPE_VECTOR_SUBPARTS (elt_t
),
4520 TYPE_VECTOR_SUBPARTS (rhs1_type
)))
4522 error ("incorrect number of vector %qs elements",
4524 debug_generic_stmt (rhs1
);
4528 else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
4531 error ("incorrect type of vector %qs elements",
4533 debug_generic_stmt (rhs1
);
4536 else if (maybe_gt (CONSTRUCTOR_NELTS (rhs1
),
4537 TYPE_VECTOR_SUBPARTS (rhs1_type
)))
4539 error ("incorrect number of vector %qs elements",
4541 debug_generic_stmt (rhs1
);
4545 else if (!useless_type_conversion_p (elt_t
, TREE_TYPE (elt_v
)))
4547 error ("incorrect type of vector CONSTRUCTOR elements");
4548 debug_generic_stmt (rhs1
);
4551 if (elt_i
!= NULL_TREE
4552 && (TREE_CODE (elt_t
) == VECTOR_TYPE
4553 || TREE_CODE (elt_i
) != INTEGER_CST
4554 || compare_tree_int (elt_i
, i
) != 0))
4556 error ("vector %qs with non-NULL element index",
4558 debug_generic_stmt (rhs1
);
4561 if (!is_gimple_val (elt_v
))
4563 error ("vector %qs element is not a GIMPLE value",
4565 debug_generic_stmt (rhs1
);
4570 else if (CONSTRUCTOR_NELTS (rhs1
) != 0)
4572 error ("non-vector %qs with elements", code_name
);
4573 debug_generic_stmt (rhs1
);
4580 rhs1
= fold (ASSERT_EXPR_COND (rhs1
));
4581 if (rhs1
== boolean_false_node
)
4583 error ("%qs with an always-false condition", code_name
);
4584 debug_generic_stmt (rhs1
);
4590 case WITH_SIZE_EXPR
:
4600 /* Verify the contents of a GIMPLE_ASSIGN STMT. Returns true when there
4601 is a problem, otherwise false. */
4604 verify_gimple_assign (gassign
*stmt
)
4606 switch (gimple_assign_rhs_class (stmt
))
4608 case GIMPLE_SINGLE_RHS
:
4609 return verify_gimple_assign_single (stmt
);
4611 case GIMPLE_UNARY_RHS
:
4612 return verify_gimple_assign_unary (stmt
);
4614 case GIMPLE_BINARY_RHS
:
4615 return verify_gimple_assign_binary (stmt
);
4617 case GIMPLE_TERNARY_RHS
:
4618 return verify_gimple_assign_ternary (stmt
);
4625 /* Verify the contents of a GIMPLE_RETURN STMT. Returns true when there
4626 is a problem, otherwise false. */
4629 verify_gimple_return (greturn
*stmt
)
4631 tree op
= gimple_return_retval (stmt
);
4632 tree restype
= TREE_TYPE (TREE_TYPE (cfun
->decl
));
4634 /* We cannot test for present return values as we do not fix up missing
4635 return values from the original source. */
4639 if (!is_gimple_val (op
)
4640 && TREE_CODE (op
) != RESULT_DECL
)
4642 error ("invalid operand in return statement");
4643 debug_generic_stmt (op
);
4647 if ((TREE_CODE (op
) == RESULT_DECL
4648 && DECL_BY_REFERENCE (op
))
4649 || (TREE_CODE (op
) == SSA_NAME
4650 && SSA_NAME_VAR (op
)
4651 && TREE_CODE (SSA_NAME_VAR (op
)) == RESULT_DECL
4652 && DECL_BY_REFERENCE (SSA_NAME_VAR (op
))))
4653 op
= TREE_TYPE (op
);
4655 if (!useless_type_conversion_p (restype
, TREE_TYPE (op
)))
4657 error ("invalid conversion in return statement");
4658 debug_generic_stmt (restype
);
4659 debug_generic_stmt (TREE_TYPE (op
));
4667 /* Verify the contents of a GIMPLE_GOTO STMT. Returns true when there
4668 is a problem, otherwise false. */
4671 verify_gimple_goto (ggoto
*stmt
)
4673 tree dest
= gimple_goto_dest (stmt
);
4675 /* ??? We have two canonical forms of direct goto destinations, a
4676 bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
4677 if (TREE_CODE (dest
) != LABEL_DECL
4678 && (!is_gimple_val (dest
)
4679 || !POINTER_TYPE_P (TREE_TYPE (dest
))))
4681 error ("goto destination is neither a label nor a pointer");
4688 /* Verify the contents of a GIMPLE_SWITCH STMT. Returns true when there
4689 is a problem, otherwise false. */
4692 verify_gimple_switch (gswitch
*stmt
)
4695 tree elt
, prev_upper_bound
= NULL_TREE
;
4696 tree index_type
, elt_type
= NULL_TREE
;
4698 if (!is_gimple_val (gimple_switch_index (stmt
)))
4700 error ("invalid operand to switch statement");
4701 debug_generic_stmt (gimple_switch_index (stmt
));
4705 index_type
= TREE_TYPE (gimple_switch_index (stmt
));
4706 if (! INTEGRAL_TYPE_P (index_type
))
4708 error ("non-integral type switch statement");
4709 debug_generic_expr (index_type
);
4713 elt
= gimple_switch_label (stmt
, 0);
4714 if (CASE_LOW (elt
) != NULL_TREE
4715 || CASE_HIGH (elt
) != NULL_TREE
4716 || CASE_CHAIN (elt
) != NULL_TREE
)
4718 error ("invalid default case label in switch statement");
4719 debug_generic_expr (elt
);
4723 n
= gimple_switch_num_labels (stmt
);
4724 for (i
= 1; i
< n
; i
++)
4726 elt
= gimple_switch_label (stmt
, i
);
4728 if (CASE_CHAIN (elt
))
4730 error ("invalid %<CASE_CHAIN%>");
4731 debug_generic_expr (elt
);
4734 if (! CASE_LOW (elt
))
4736 error ("invalid case label in switch statement");
4737 debug_generic_expr (elt
);
4741 && ! tree_int_cst_lt (CASE_LOW (elt
), CASE_HIGH (elt
)))
4743 error ("invalid case range in switch statement");
4744 debug_generic_expr (elt
);
4750 if (TREE_TYPE (CASE_LOW (elt
)) != elt_type
4751 || (CASE_HIGH (elt
) && TREE_TYPE (CASE_HIGH (elt
)) != elt_type
))
4753 error ("type mismatch for case label in switch statement");
4754 debug_generic_expr (elt
);
4760 elt_type
= TREE_TYPE (CASE_LOW (elt
));
4761 if (TYPE_PRECISION (index_type
) < TYPE_PRECISION (elt_type
))
4763 error ("type precision mismatch in switch statement");
4768 if (prev_upper_bound
)
4770 if (! tree_int_cst_lt (prev_upper_bound
, CASE_LOW (elt
)))
4772 error ("case labels not sorted in switch statement");
4777 prev_upper_bound
= CASE_HIGH (elt
);
4778 if (! prev_upper_bound
)
4779 prev_upper_bound
= CASE_LOW (elt
);
4785 /* Verify a gimple debug statement STMT.
4786 Returns true if anything is wrong. */
4789 verify_gimple_debug (gimple
*stmt ATTRIBUTE_UNUSED
)
4791 /* There isn't much that could be wrong in a gimple debug stmt. A
4792 gimple debug bind stmt, for example, maps a tree, that's usually
4793 a VAR_DECL or a PARM_DECL, but that could also be some scalarized
4794 component or member of an aggregate type, to another tree, that
4795 can be an arbitrary expression. These stmts expand into debug
4796 insns, and are converted to debug notes by var-tracking.c. */
4800 /* Verify a gimple label statement STMT.
4801 Returns true if anything is wrong. */
4804 verify_gimple_label (glabel
*stmt
)
4806 tree decl
= gimple_label_label (stmt
);
4810 if (TREE_CODE (decl
) != LABEL_DECL
)
4812 if (!DECL_NONLOCAL (decl
) && !FORCED_LABEL (decl
)
4813 && DECL_CONTEXT (decl
) != current_function_decl
)
4815 error ("label context is not the current function declaration");
4819 uid
= LABEL_DECL_UID (decl
);
4822 || (*label_to_block_map_for_fn (cfun
))[uid
] != gimple_bb (stmt
)))
4824 error ("incorrect entry in %<label_to_block_map%>");
4828 uid
= EH_LANDING_PAD_NR (decl
);
4831 eh_landing_pad lp
= get_eh_landing_pad_from_number (uid
);
4832 if (decl
!= lp
->post_landing_pad
)
4834 error ("incorrect setting of landing pad number");
4842 /* Verify a gimple cond statement STMT.
4843 Returns true if anything is wrong. */
4846 verify_gimple_cond (gcond
*stmt
)
4848 if (TREE_CODE_CLASS (gimple_cond_code (stmt
)) != tcc_comparison
)
4850 error ("invalid comparison code in gimple cond");
4853 if (!(!gimple_cond_true_label (stmt
)
4854 || TREE_CODE (gimple_cond_true_label (stmt
)) == LABEL_DECL
)
4855 || !(!gimple_cond_false_label (stmt
)
4856 || TREE_CODE (gimple_cond_false_label (stmt
)) == LABEL_DECL
))
4858 error ("invalid labels in gimple cond");
4862 return verify_gimple_comparison (boolean_type_node
,
4863 gimple_cond_lhs (stmt
),
4864 gimple_cond_rhs (stmt
),
4865 gimple_cond_code (stmt
));
4868 /* Verify the GIMPLE statement STMT. Returns true if there is an
4869 error, otherwise false. */
4872 verify_gimple_stmt (gimple
*stmt
)
4874 switch (gimple_code (stmt
))
4877 return verify_gimple_assign (as_a
<gassign
*> (stmt
));
4880 return verify_gimple_label (as_a
<glabel
*> (stmt
));
4883 return verify_gimple_call (as_a
<gcall
*> (stmt
));
4886 return verify_gimple_cond (as_a
<gcond
*> (stmt
));
4889 return verify_gimple_goto (as_a
<ggoto
*> (stmt
));
4892 return verify_gimple_switch (as_a
<gswitch
*> (stmt
));
4895 return verify_gimple_return (as_a
<greturn
*> (stmt
));
4900 case GIMPLE_TRANSACTION
:
4901 return verify_gimple_transaction (as_a
<gtransaction
*> (stmt
));
4903 /* Tuples that do not have tree operands. */
4905 case GIMPLE_PREDICT
:
4907 case GIMPLE_EH_DISPATCH
:
4908 case GIMPLE_EH_MUST_NOT_THROW
:
4912 /* OpenMP directives are validated by the FE and never operated
4913 on by the optimizers. Furthermore, GIMPLE_OMP_FOR may contain
4914 non-gimple expressions when the main index variable has had
4915 its address taken. This does not affect the loop itself
4916 because the header of an GIMPLE_OMP_FOR is merely used to determine
4917 how to setup the parallel iteration. */
4921 return verify_gimple_debug (stmt
);
4928 /* Verify the contents of a GIMPLE_PHI. Returns true if there is a problem,
4929 and false otherwise. */
4932 verify_gimple_phi (gphi
*phi
)
4936 tree phi_result
= gimple_phi_result (phi
);
4941 error ("invalid %<PHI%> result");
4945 virtual_p
= virtual_operand_p (phi_result
);
4946 if (TREE_CODE (phi_result
) != SSA_NAME
4948 && SSA_NAME_VAR (phi_result
) != gimple_vop (cfun
)))
4950 error ("invalid %<PHI%> result");
4954 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4956 tree t
= gimple_phi_arg_def (phi
, i
);
4960 error ("missing %<PHI%> def");
4964 /* Addressable variables do have SSA_NAMEs but they
4965 are not considered gimple values. */
4966 else if ((TREE_CODE (t
) == SSA_NAME
4967 && virtual_p
!= virtual_operand_p (t
))
4969 && (TREE_CODE (t
) != SSA_NAME
4970 || SSA_NAME_VAR (t
) != gimple_vop (cfun
)))
4972 && !is_gimple_val (t
)))
4974 error ("invalid %<PHI%> argument");
4975 debug_generic_expr (t
);
4978 #ifdef ENABLE_TYPES_CHECKING
4979 if (!useless_type_conversion_p (TREE_TYPE (phi_result
), TREE_TYPE (t
)))
4981 error ("incompatible types in %<PHI%> argument %u", i
);
4982 debug_generic_stmt (TREE_TYPE (phi_result
));
4983 debug_generic_stmt (TREE_TYPE (t
));
4992 /* Verify the GIMPLE statements inside the sequence STMTS. */
4995 verify_gimple_in_seq_2 (gimple_seq stmts
)
4997 gimple_stmt_iterator ittr
;
5000 for (ittr
= gsi_start (stmts
); !gsi_end_p (ittr
); gsi_next (&ittr
))
5002 gimple
*stmt
= gsi_stmt (ittr
);
5004 switch (gimple_code (stmt
))
5007 err
|= verify_gimple_in_seq_2 (
5008 gimple_bind_body (as_a
<gbind
*> (stmt
)));
5012 err
|= verify_gimple_in_seq_2 (gimple_try_eval (stmt
));
5013 err
|= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt
));
5016 case GIMPLE_EH_FILTER
:
5017 err
|= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt
));
5020 case GIMPLE_EH_ELSE
:
5022 geh_else
*eh_else
= as_a
<geh_else
*> (stmt
);
5023 err
|= verify_gimple_in_seq_2 (gimple_eh_else_n_body (eh_else
));
5024 err
|= verify_gimple_in_seq_2 (gimple_eh_else_e_body (eh_else
));
5029 err
|= verify_gimple_in_seq_2 (gimple_catch_handler (
5030 as_a
<gcatch
*> (stmt
)));
5033 case GIMPLE_TRANSACTION
:
5034 err
|= verify_gimple_transaction (as_a
<gtransaction
*> (stmt
));
5039 bool err2
= verify_gimple_stmt (stmt
);
5041 debug_gimple_stmt (stmt
);
5050 /* Verify the contents of a GIMPLE_TRANSACTION. Returns true if there
5051 is a problem, otherwise false. */
5054 verify_gimple_transaction (gtransaction
*stmt
)
5058 lab
= gimple_transaction_label_norm (stmt
);
5059 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
5061 lab
= gimple_transaction_label_uninst (stmt
);
5062 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
5064 lab
= gimple_transaction_label_over (stmt
);
5065 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
5068 return verify_gimple_in_seq_2 (gimple_transaction_body (stmt
));
5072 /* Verify the GIMPLE statements inside the statement list STMTS. */
5075 verify_gimple_in_seq (gimple_seq stmts
)
5077 timevar_push (TV_TREE_STMT_VERIFY
);
5078 if (verify_gimple_in_seq_2 (stmts
))
5079 internal_error ("%<verify_gimple%> failed");
5080 timevar_pop (TV_TREE_STMT_VERIFY
);
5083 /* Return true when the T can be shared. */
5086 tree_node_can_be_shared (tree t
)
5088 if (IS_TYPE_OR_DECL_P (t
)
5089 || TREE_CODE (t
) == SSA_NAME
5090 || TREE_CODE (t
) == IDENTIFIER_NODE
5091 || TREE_CODE (t
) == CASE_LABEL_EXPR
5092 || is_gimple_min_invariant (t
))
5095 if (t
== error_mark_node
)
5101 /* Called via walk_tree. Verify tree sharing. */
5104 verify_node_sharing_1 (tree
*tp
, int *walk_subtrees
, void *data
)
5106 hash_set
<void *> *visited
= (hash_set
<void *> *) data
;
5108 if (tree_node_can_be_shared (*tp
))
5110 *walk_subtrees
= false;
5114 if (visited
->add (*tp
))
5120 /* Called via walk_gimple_stmt. Verify tree sharing. */
5123 verify_node_sharing (tree
*tp
, int *walk_subtrees
, void *data
)
5125 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
5126 return verify_node_sharing_1 (tp
, walk_subtrees
, wi
->info
);
5129 static bool eh_error_found
;
5131 verify_eh_throw_stmt_node (gimple
*const &stmt
, const int &,
5132 hash_set
<gimple
*> *visited
)
5134 if (!visited
->contains (stmt
))
5136 error ("dead statement in EH table");
5137 debug_gimple_stmt (stmt
);
5138 eh_error_found
= true;
5143 /* Verify if the location LOCs block is in BLOCKS. */
5146 verify_location (hash_set
<tree
> *blocks
, location_t loc
)
5148 tree block
= LOCATION_BLOCK (loc
);
5149 if (block
!= NULL_TREE
5150 && !blocks
->contains (block
))
5152 error ("location references block not in block tree");
5155 if (block
!= NULL_TREE
)
5156 return verify_location (blocks
, BLOCK_SOURCE_LOCATION (block
));
5160 /* Called via walk_tree. Verify that expressions have no blocks. */
5163 verify_expr_no_block (tree
*tp
, int *walk_subtrees
, void *)
5167 *walk_subtrees
= false;
5171 location_t loc
= EXPR_LOCATION (*tp
);
5172 if (LOCATION_BLOCK (loc
) != NULL
)
5178 /* Called via walk_tree. Verify locations of expressions. */
5181 verify_expr_location_1 (tree
*tp
, int *walk_subtrees
, void *data
)
5183 hash_set
<tree
> *blocks
= (hash_set
<tree
> *) data
;
5186 /* ??? This doesn't really belong here but there's no good place to
5187 stick this remainder of old verify_expr. */
5188 /* ??? This barfs on debug stmts which contain binds to vars with
5189 different function context. */
5192 || TREE_CODE (t
) == PARM_DECL
5193 || TREE_CODE (t
) == RESULT_DECL
)
5195 tree context
= decl_function_context (t
);
5196 if (context
!= cfun
->decl
5197 && !SCOPE_FILE_SCOPE_P (context
)
5199 && !DECL_EXTERNAL (t
))
5201 error ("local declaration from a different function");
5207 if (VAR_P (t
) && DECL_HAS_DEBUG_EXPR_P (t
))
5209 tree x
= DECL_DEBUG_EXPR (t
);
5210 tree addr
= walk_tree (&x
, verify_expr_no_block
, NULL
, NULL
);
5215 || TREE_CODE (t
) == PARM_DECL
5216 || TREE_CODE (t
) == RESULT_DECL
)
5217 && DECL_HAS_VALUE_EXPR_P (t
))
5219 tree x
= DECL_VALUE_EXPR (t
);
5220 tree addr
= walk_tree (&x
, verify_expr_no_block
, NULL
, NULL
);
5227 *walk_subtrees
= false;
5231 location_t loc
= EXPR_LOCATION (t
);
5232 if (verify_location (blocks
, loc
))
5238 /* Called via walk_gimple_op. Verify locations of expressions. */
5241 verify_expr_location (tree
*tp
, int *walk_subtrees
, void *data
)
5243 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
5244 return verify_expr_location_1 (tp
, walk_subtrees
, wi
->info
);
5247 /* Insert all subblocks of BLOCK into BLOCKS and recurse. */
5250 collect_subblocks (hash_set
<tree
> *blocks
, tree block
)
5253 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
5256 collect_subblocks (blocks
, t
);
5260 /* Disable warnings about missing quoting in GCC diagnostics for
5261 the verification errors. Their format strings don't follow
5262 GCC diagnostic conventions and trigger an ICE in the end. */
5264 # pragma GCC diagnostic push
5265 # pragma GCC diagnostic ignored "-Wformat-diag"
5268 /* Verify the GIMPLE statements in the CFG of FN. */
5271 verify_gimple_in_cfg (struct function
*fn
, bool verify_nothrow
)
5276 timevar_push (TV_TREE_STMT_VERIFY
);
5277 hash_set
<void *> visited
;
5278 hash_set
<gimple
*> visited_throwing_stmts
;
5280 /* Collect all BLOCKs referenced by the BLOCK tree of FN. */
5281 hash_set
<tree
> blocks
;
5282 if (DECL_INITIAL (fn
->decl
))
5284 blocks
.add (DECL_INITIAL (fn
->decl
));
5285 collect_subblocks (&blocks
, DECL_INITIAL (fn
->decl
));
5288 FOR_EACH_BB_FN (bb
, fn
)
5290 gimple_stmt_iterator gsi
;
5294 for (gphi_iterator gpi
= gsi_start_phis (bb
);
5298 gphi
*phi
= gpi
.phi ();
5302 if (gimple_bb (phi
) != bb
)
5304 error ("gimple_bb (phi) is set to a wrong basic block");
5308 err2
|= verify_gimple_phi (phi
);
5310 /* Only PHI arguments have locations. */
5311 if (gimple_location (phi
) != UNKNOWN_LOCATION
)
5313 error ("PHI node with location");
5317 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
5319 tree arg
= gimple_phi_arg_def (phi
, i
);
5320 tree addr
= walk_tree (&arg
, verify_node_sharing_1
,
5324 error ("incorrect sharing of tree nodes");
5325 debug_generic_expr (addr
);
5328 location_t loc
= gimple_phi_arg_location (phi
, i
);
5329 if (virtual_operand_p (gimple_phi_result (phi
))
5330 && loc
!= UNKNOWN_LOCATION
)
5332 error ("virtual PHI with argument locations");
5335 addr
= walk_tree (&arg
, verify_expr_location_1
, &blocks
, NULL
);
5338 debug_generic_expr (addr
);
5341 err2
|= verify_location (&blocks
, loc
);
5345 debug_gimple_stmt (phi
);
5349 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5351 gimple
*stmt
= gsi_stmt (gsi
);
5353 struct walk_stmt_info wi
;
5357 if (gimple_bb (stmt
) != bb
)
5359 error ("gimple_bb (stmt) is set to a wrong basic block");
5363 err2
|= verify_gimple_stmt (stmt
);
5364 err2
|= verify_location (&blocks
, gimple_location (stmt
));
5366 memset (&wi
, 0, sizeof (wi
));
5367 wi
.info
= (void *) &visited
;
5368 addr
= walk_gimple_op (stmt
, verify_node_sharing
, &wi
);
5371 error ("incorrect sharing of tree nodes");
5372 debug_generic_expr (addr
);
5376 memset (&wi
, 0, sizeof (wi
));
5377 wi
.info
= (void *) &blocks
;
5378 addr
= walk_gimple_op (stmt
, verify_expr_location
, &wi
);
5381 debug_generic_expr (addr
);
5385 /* If the statement is marked as part of an EH region, then it is
5386 expected that the statement could throw. Verify that when we
5387 have optimizations that simplify statements such that we prove
5388 that they cannot throw, that we update other data structures
5390 lp_nr
= lookup_stmt_eh_lp (stmt
);
5392 visited_throwing_stmts
.add (stmt
);
5395 if (!stmt_could_throw_p (cfun
, stmt
))
5399 error ("statement marked for throw, but doesn%'t");
5403 else if (!gsi_one_before_end_p (gsi
))
5405 error ("statement marked for throw in middle of block");
5411 debug_gimple_stmt (stmt
);
5415 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5416 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
5417 err
|= verify_location (&blocks
, e
->goto_locus
);
5420 hash_map
<gimple
*, int> *eh_table
= get_eh_throw_stmt_table (cfun
);
5421 eh_error_found
= false;
5423 eh_table
->traverse
<hash_set
<gimple
*> *, verify_eh_throw_stmt_node
>
5424 (&visited_throwing_stmts
);
5426 if (err
|| eh_error_found
)
5427 internal_error ("verify_gimple failed");
5429 verify_histograms ();
5430 timevar_pop (TV_TREE_STMT_VERIFY
);
5434 /* Verifies that the flow information is OK. */
5437 gimple_verify_flow_info (void)
5441 gimple_stmt_iterator gsi
;
5446 if (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.seq
5447 || ENTRY_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.phi_nodes
)
5449 error ("ENTRY_BLOCK has IL associated with it");
5453 if (EXIT_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.seq
5454 || EXIT_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.phi_nodes
)
5456 error ("EXIT_BLOCK has IL associated with it");
5460 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5461 if (e
->flags
& EDGE_FALLTHRU
)
5463 error ("fallthru to exit from bb %d", e
->src
->index
);
5467 FOR_EACH_BB_FN (bb
, cfun
)
5469 bool found_ctrl_stmt
= false;
5473 /* Skip labels on the start of basic block. */
5474 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5477 gimple
*prev_stmt
= stmt
;
5479 stmt
= gsi_stmt (gsi
);
5481 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5484 label
= gimple_label_label (as_a
<glabel
*> (stmt
));
5485 if (prev_stmt
&& DECL_NONLOCAL (label
))
5487 error ("nonlocal label ");
5488 print_generic_expr (stderr
, label
);
5489 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
5494 if (prev_stmt
&& EH_LANDING_PAD_NR (label
) != 0)
5496 error ("EH landing pad label ");
5497 print_generic_expr (stderr
, label
);
5498 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
5503 if (label_to_block (cfun
, label
) != bb
)
5506 print_generic_expr (stderr
, label
);
5507 fprintf (stderr
, " to block does not match in bb %d",
5512 if (decl_function_context (label
) != current_function_decl
)
5515 print_generic_expr (stderr
, label
);
5516 fprintf (stderr
, " has incorrect context in bb %d",
5522 /* Verify that body of basic block BB is free of control flow. */
5523 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5525 gimple
*stmt
= gsi_stmt (gsi
);
5527 if (found_ctrl_stmt
)
5529 error ("control flow in the middle of basic block %d",
5534 if (stmt_ends_bb_p (stmt
))
5535 found_ctrl_stmt
= true;
5537 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
5540 print_generic_expr (stderr
, gimple_label_label (label_stmt
));
5541 fprintf (stderr
, " in the middle of basic block %d", bb
->index
);
5546 gsi
= gsi_last_nondebug_bb (bb
);
5547 if (gsi_end_p (gsi
))
5550 stmt
= gsi_stmt (gsi
);
5552 if (gimple_code (stmt
) == GIMPLE_LABEL
)
5555 err
|= verify_eh_edges (stmt
);
5557 if (is_ctrl_stmt (stmt
))
5559 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5560 if (e
->flags
& EDGE_FALLTHRU
)
5562 error ("fallthru edge after a control statement in bb %d",
5568 if (gimple_code (stmt
) != GIMPLE_COND
)
5570 /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
5571 after anything else but if statement. */
5572 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5573 if (e
->flags
& (EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
))
5575 error ("true/false edge after a non-GIMPLE_COND in bb %d",
5581 switch (gimple_code (stmt
))
5588 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
5592 || !(true_edge
->flags
& EDGE_TRUE_VALUE
)
5593 || !(false_edge
->flags
& EDGE_FALSE_VALUE
)
5594 || (true_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
5595 || (false_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
5596 || EDGE_COUNT (bb
->succs
) >= 3)
5598 error ("wrong outgoing edge flags at end of bb %d",
5606 if (simple_goto_p (stmt
))
5608 error ("explicit goto at end of bb %d", bb
->index
);
5613 /* FIXME. We should double check that the labels in the
5614 destination blocks have their address taken. */
5615 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5616 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_TRUE_VALUE
5617 | EDGE_FALSE_VALUE
))
5618 || !(e
->flags
& EDGE_ABNORMAL
))
5620 error ("wrong outgoing edge flags at end of bb %d",
5628 if (!gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
))
5632 if (!single_succ_p (bb
)
5633 || (single_succ_edge (bb
)->flags
5634 & (EDGE_FALLTHRU
| EDGE_ABNORMAL
5635 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5637 error ("wrong outgoing edge flags at end of bb %d", bb
->index
);
5640 if (single_succ (bb
) != EXIT_BLOCK_PTR_FOR_FN (cfun
))
5642 error ("return edge does not point to exit in bb %d",
5650 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
5655 n
= gimple_switch_num_labels (switch_stmt
);
5657 /* Mark all the destination basic blocks. */
5658 for (i
= 0; i
< n
; ++i
)
5660 basic_block label_bb
= gimple_switch_label_bb (cfun
, switch_stmt
, i
);
5661 gcc_assert (!label_bb
->aux
|| label_bb
->aux
== (void *)1);
5662 label_bb
->aux
= (void *)1;
5665 /* Verify that the case labels are sorted. */
5666 prev
= gimple_switch_label (switch_stmt
, 0);
5667 for (i
= 1; i
< n
; ++i
)
5669 tree c
= gimple_switch_label (switch_stmt
, i
);
5672 error ("found default case not at the start of "
5678 && !tree_int_cst_lt (CASE_LOW (prev
), CASE_LOW (c
)))
5680 error ("case labels not sorted: ");
5681 print_generic_expr (stderr
, prev
);
5682 fprintf (stderr
," is greater than ");
5683 print_generic_expr (stderr
, c
);
5684 fprintf (stderr
," but comes before it.\n");
5689 /* VRP will remove the default case if it can prove it will
5690 never be executed. So do not verify there always exists
5691 a default case here. */
5693 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5697 error ("extra outgoing edge %d->%d",
5698 bb
->index
, e
->dest
->index
);
5702 e
->dest
->aux
= (void *)2;
5703 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
5704 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5706 error ("wrong outgoing edge flags at end of bb %d",
5712 /* Check that we have all of them. */
5713 for (i
= 0; i
< n
; ++i
)
5715 basic_block label_bb
= gimple_switch_label_bb (cfun
,
5718 if (label_bb
->aux
!= (void *)2)
5720 error ("missing edge %i->%i", bb
->index
, label_bb
->index
);
5725 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5726 e
->dest
->aux
= (void *)0;
5730 case GIMPLE_EH_DISPATCH
:
5731 err
|= verify_eh_dispatch_edge (as_a
<geh_dispatch
*> (stmt
));
5739 if (dom_info_state (CDI_DOMINATORS
) >= DOM_NO_FAST_QUERY
)
5740 verify_dominators (CDI_DOMINATORS
);
5746 # pragma GCC diagnostic pop
5749 /* Updates phi nodes after creating a forwarder block joined
5750 by edge FALLTHRU. */
5753 gimple_make_forwarder_block (edge fallthru
)
5757 basic_block dummy
, bb
;
5760 bool forward_location_p
;
5762 dummy
= fallthru
->src
;
5763 bb
= fallthru
->dest
;
5765 if (single_pred_p (bb
))
5768 /* We can forward location info if we have only one predecessor. */
5769 forward_location_p
= single_pred_p (dummy
);
5771 /* If we redirected a branch we must create new PHI nodes at the
5773 for (gsi
= gsi_start_phis (dummy
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5775 gphi
*phi
, *new_phi
;
5778 var
= gimple_phi_result (phi
);
5779 new_phi
= create_phi_node (var
, bb
);
5780 gimple_phi_set_result (phi
, copy_ssa_name (var
, phi
));
5781 add_phi_arg (new_phi
, gimple_phi_result (phi
), fallthru
,
5783 ? gimple_phi_arg_location (phi
, 0) : UNKNOWN_LOCATION
);
5786 /* Add the arguments we have stored on edges. */
5787 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
5792 flush_pending_stmts (e
);
5797 /* Return a non-special label in the head of basic block BLOCK.
5798 Create one if it doesn't exist. */
5801 gimple_block_label (basic_block bb
)
5803 gimple_stmt_iterator i
, s
= gsi_start_bb (bb
);
5808 for (i
= s
; !gsi_end_p (i
); first
= false, gsi_next (&i
))
5810 stmt
= dyn_cast
<glabel
*> (gsi_stmt (i
));
5813 label
= gimple_label_label (stmt
);
5814 if (!DECL_NONLOCAL (label
))
5817 gsi_move_before (&i
, &s
);
5822 label
= create_artificial_label (UNKNOWN_LOCATION
);
5823 stmt
= gimple_build_label (label
);
5824 gsi_insert_before (&s
, stmt
, GSI_NEW_STMT
);
5829 /* Attempt to perform edge redirection by replacing a possibly complex
5830 jump instruction by a goto or by removing the jump completely.
5831 This can apply only if all edges now point to the same block. The
5832 parameters and return values are equivalent to
5833 redirect_edge_and_branch. */
5836 gimple_try_redirect_by_replacing_jump (edge e
, basic_block target
)
5838 basic_block src
= e
->src
;
5839 gimple_stmt_iterator i
;
5842 /* We can replace or remove a complex jump only when we have exactly
5844 if (EDGE_COUNT (src
->succs
) != 2
5845 /* Verify that all targets will be TARGET. Specifically, the
5846 edge that is not E must also go to TARGET. */
5847 || EDGE_SUCC (src
, EDGE_SUCC (src
, 0) == e
)->dest
!= target
)
5850 i
= gsi_last_bb (src
);
5854 stmt
= gsi_stmt (i
);
5856 if (gimple_code (stmt
) == GIMPLE_COND
|| gimple_code (stmt
) == GIMPLE_SWITCH
)
5858 gsi_remove (&i
, true);
5859 e
= ssa_redirect_edge (e
, target
);
5860 e
->flags
= EDGE_FALLTHRU
;
5868 /* Redirect E to DEST. Return NULL on failure. Otherwise, return the
5869 edge representing the redirected branch. */
5872 gimple_redirect_edge_and_branch (edge e
, basic_block dest
)
5874 basic_block bb
= e
->src
;
5875 gimple_stmt_iterator gsi
;
5879 if (e
->flags
& EDGE_ABNORMAL
)
5882 if (e
->dest
== dest
)
5885 if (e
->flags
& EDGE_EH
)
5886 return redirect_eh_edge (e
, dest
);
5888 if (e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
))
5890 ret
= gimple_try_redirect_by_replacing_jump (e
, dest
);
5895 gsi
= gsi_last_nondebug_bb (bb
);
5896 stmt
= gsi_end_p (gsi
) ? NULL
: gsi_stmt (gsi
);
5898 switch (stmt
? gimple_code (stmt
) : GIMPLE_ERROR_MARK
)
5901 /* For COND_EXPR, we only need to redirect the edge. */
5905 /* No non-abnormal edges should lead from a non-simple goto, and
5906 simple ones should be represented implicitly. */
5911 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
5912 tree label
= gimple_block_label (dest
);
5913 tree cases
= get_cases_for_edge (e
, switch_stmt
);
5915 /* If we have a list of cases associated with E, then use it
5916 as it's a lot faster than walking the entire case vector. */
5919 edge e2
= find_edge (e
->src
, dest
);
5926 CASE_LABEL (cases
) = label
;
5927 cases
= CASE_CHAIN (cases
);
5930 /* If there was already an edge in the CFG, then we need
5931 to move all the cases associated with E to E2. */
5934 tree cases2
= get_cases_for_edge (e2
, switch_stmt
);
5936 CASE_CHAIN (last
) = CASE_CHAIN (cases2
);
5937 CASE_CHAIN (cases2
) = first
;
5939 bitmap_set_bit (touched_switch_bbs
, gimple_bb (stmt
)->index
);
5943 size_t i
, n
= gimple_switch_num_labels (switch_stmt
);
5945 for (i
= 0; i
< n
; i
++)
5947 tree elt
= gimple_switch_label (switch_stmt
, i
);
5948 if (label_to_block (cfun
, CASE_LABEL (elt
)) == e
->dest
)
5949 CASE_LABEL (elt
) = label
;
5957 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
5958 int i
, n
= gimple_asm_nlabels (asm_stmt
);
5961 for (i
= 0; i
< n
; ++i
)
5963 tree cons
= gimple_asm_label_op (asm_stmt
, i
);
5964 if (label_to_block (cfun
, TREE_VALUE (cons
)) == e
->dest
)
5967 label
= gimple_block_label (dest
);
5968 TREE_VALUE (cons
) = label
;
5972 /* If we didn't find any label matching the former edge in the
5973 asm labels, we must be redirecting the fallthrough
5975 gcc_assert (label
|| (e
->flags
& EDGE_FALLTHRU
));
5980 gsi_remove (&gsi
, true);
5981 e
->flags
|= EDGE_FALLTHRU
;
5984 case GIMPLE_OMP_RETURN
:
5985 case GIMPLE_OMP_CONTINUE
:
5986 case GIMPLE_OMP_SECTIONS_SWITCH
:
5987 case GIMPLE_OMP_FOR
:
5988 /* The edges from OMP constructs can be simply redirected. */
5991 case GIMPLE_EH_DISPATCH
:
5992 if (!(e
->flags
& EDGE_FALLTHRU
))
5993 redirect_eh_dispatch_edge (as_a
<geh_dispatch
*> (stmt
), e
, dest
);
5996 case GIMPLE_TRANSACTION
:
5997 if (e
->flags
& EDGE_TM_ABORT
)
5998 gimple_transaction_set_label_over (as_a
<gtransaction
*> (stmt
),
5999 gimple_block_label (dest
));
6000 else if (e
->flags
& EDGE_TM_UNINSTRUMENTED
)
6001 gimple_transaction_set_label_uninst (as_a
<gtransaction
*> (stmt
),
6002 gimple_block_label (dest
));
6004 gimple_transaction_set_label_norm (as_a
<gtransaction
*> (stmt
),
6005 gimple_block_label (dest
));
6009 /* Otherwise it must be a fallthru edge, and we don't need to
6010 do anything besides redirecting it. */
6011 gcc_assert (e
->flags
& EDGE_FALLTHRU
);
6015 /* Update/insert PHI nodes as necessary. */
6017 /* Now update the edges in the CFG. */
6018 e
= ssa_redirect_edge (e
, dest
);
6023 /* Returns true if it is possible to remove edge E by redirecting
6024 it to the destination of the other edge from E->src. */
6027 gimple_can_remove_branch_p (const_edge e
)
6029 if (e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
))
6035 /* Simple wrapper, as we can always redirect fallthru edges. */
6038 gimple_redirect_edge_and_branch_force (edge e
, basic_block dest
)
6040 e
= gimple_redirect_edge_and_branch (e
, dest
);
6047 /* Splits basic block BB after statement STMT (but at least after the
6048 labels). If STMT is NULL, BB is split just after the labels. */
6051 gimple_split_block (basic_block bb
, void *stmt
)
6053 gimple_stmt_iterator gsi
;
6054 gimple_stmt_iterator gsi_tgt
;
6060 new_bb
= create_empty_bb (bb
);
6062 /* Redirect the outgoing edges. */
6063 new_bb
->succs
= bb
->succs
;
6065 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
6068 /* Get a stmt iterator pointing to the first stmt to move. */
6069 if (!stmt
|| gimple_code ((gimple
*) stmt
) == GIMPLE_LABEL
)
6070 gsi
= gsi_after_labels (bb
);
6073 gsi
= gsi_for_stmt ((gimple
*) stmt
);
6077 /* Move everything from GSI to the new basic block. */
6078 if (gsi_end_p (gsi
))
6081 /* Split the statement list - avoid re-creating new containers as this
6082 brings ugly quadratic memory consumption in the inliner.
6083 (We are still quadratic since we need to update stmt BB pointers,
6085 gsi_split_seq_before (&gsi
, &list
);
6086 set_bb_seq (new_bb
, list
);
6087 for (gsi_tgt
= gsi_start (list
);
6088 !gsi_end_p (gsi_tgt
); gsi_next (&gsi_tgt
))
6089 gimple_set_bb (gsi_stmt (gsi_tgt
), new_bb
);
6095 /* Moves basic block BB after block AFTER. */
6098 gimple_move_block_after (basic_block bb
, basic_block after
)
6100 if (bb
->prev_bb
== after
)
6104 link_block (bb
, after
);
6110 /* Return TRUE if block BB has no executable statements, otherwise return
6114 gimple_empty_block_p (basic_block bb
)
6116 /* BB must have no executable statements. */
6117 gimple_stmt_iterator gsi
= gsi_after_labels (bb
);
6120 while (!gsi_end_p (gsi
))
6122 gimple
*stmt
= gsi_stmt (gsi
);
6123 if (is_gimple_debug (stmt
))
6125 else if (gimple_code (stmt
) == GIMPLE_NOP
6126 || gimple_code (stmt
) == GIMPLE_PREDICT
)
6136 /* Split a basic block if it ends with a conditional branch and if the
6137 other part of the block is not empty. */
6140 gimple_split_block_before_cond_jump (basic_block bb
)
6142 gimple
*last
, *split_point
;
6143 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
6144 if (gsi_end_p (gsi
))
6146 last
= gsi_stmt (gsi
);
6147 if (gimple_code (last
) != GIMPLE_COND
6148 && gimple_code (last
) != GIMPLE_SWITCH
)
6151 split_point
= gsi_stmt (gsi
);
6152 return split_block (bb
, split_point
)->dest
;
6156 /* Return true if basic_block can be duplicated. */
6159 gimple_can_duplicate_bb_p (const_basic_block bb ATTRIBUTE_UNUSED
)
6164 /* Create a duplicate of the basic block BB. NOTE: This does not
6165 preserve SSA form. */
6168 gimple_duplicate_bb (basic_block bb
, copy_bb_data
*id
)
6171 gimple_stmt_iterator gsi_tgt
;
6173 new_bb
= create_empty_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
);
6175 /* Copy the PHI nodes. We ignore PHI node arguments here because
6176 the incoming edges have not been setup yet. */
6177 for (gphi_iterator gpi
= gsi_start_phis (bb
);
6183 copy
= create_phi_node (NULL_TREE
, new_bb
);
6184 create_new_def_for (gimple_phi_result (phi
), copy
,
6185 gimple_phi_result_ptr (copy
));
6186 gimple_set_uid (copy
, gimple_uid (phi
));
6189 gsi_tgt
= gsi_start_bb (new_bb
);
6190 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
6194 def_operand_p def_p
;
6195 ssa_op_iter op_iter
;
6197 gimple
*stmt
, *copy
;
6199 stmt
= gsi_stmt (gsi
);
6200 if (gimple_code (stmt
) == GIMPLE_LABEL
)
6203 /* Don't duplicate label debug stmts. */
6204 if (gimple_debug_bind_p (stmt
)
6205 && TREE_CODE (gimple_debug_bind_get_var (stmt
))
6209 /* Create a new copy of STMT and duplicate STMT's virtual
6211 copy
= gimple_copy (stmt
);
6212 gsi_insert_after (&gsi_tgt
, copy
, GSI_NEW_STMT
);
6214 maybe_duplicate_eh_stmt (copy
, stmt
);
6215 gimple_duplicate_stmt_histograms (cfun
, copy
, cfun
, stmt
);
6217 /* When copying around a stmt writing into a local non-user
6218 aggregate, make sure it won't share stack slot with other
6220 lhs
= gimple_get_lhs (stmt
);
6221 if (lhs
&& TREE_CODE (lhs
) != SSA_NAME
)
6223 tree base
= get_base_address (lhs
);
6225 && (VAR_P (base
) || TREE_CODE (base
) == RESULT_DECL
)
6226 && DECL_IGNORED_P (base
)
6227 && !TREE_STATIC (base
)
6228 && !DECL_EXTERNAL (base
)
6229 && (!VAR_P (base
) || !DECL_HAS_VALUE_EXPR_P (base
)))
6230 DECL_NONSHAREABLE (base
) = 1;
6233 /* If requested remap dependence info of cliques brought in
6236 for (unsigned i
= 0; i
< gimple_num_ops (copy
); ++i
)
6238 tree op
= gimple_op (copy
, i
);
6241 if (TREE_CODE (op
) == ADDR_EXPR
6242 || TREE_CODE (op
) == WITH_SIZE_EXPR
)
6243 op
= TREE_OPERAND (op
, 0);
6244 while (handled_component_p (op
))
6245 op
= TREE_OPERAND (op
, 0);
6246 if ((TREE_CODE (op
) == MEM_REF
6247 || TREE_CODE (op
) == TARGET_MEM_REF
)
6248 && MR_DEPENDENCE_CLIQUE (op
) > 1
6249 && MR_DEPENDENCE_CLIQUE (op
) != bb
->loop_father
->owned_clique
)
6251 if (!id
->dependence_map
)
6252 id
->dependence_map
= new hash_map
<dependence_hash
,
6255 unsigned short &newc
= id
->dependence_map
->get_or_insert
6256 (MR_DEPENDENCE_CLIQUE (op
), &existed
);
6259 gcc_assert (MR_DEPENDENCE_CLIQUE (op
) <= cfun
->last_clique
);
6260 newc
= ++cfun
->last_clique
;
6262 MR_DEPENDENCE_CLIQUE (op
) = newc
;
6266 /* Create new names for all the definitions created by COPY and
6267 add replacement mappings for each new name. */
6268 FOR_EACH_SSA_DEF_OPERAND (def_p
, copy
, op_iter
, SSA_OP_ALL_DEFS
)
6269 create_new_def_for (DEF_FROM_PTR (def_p
), copy
, def_p
);
6275 /* Adds phi node arguments for edge E_COPY after basic block duplication. */
6278 add_phi_args_after_copy_edge (edge e_copy
)
6280 basic_block bb
, bb_copy
= e_copy
->src
, dest
;
6283 gphi
*phi
, *phi_copy
;
6285 gphi_iterator psi
, psi_copy
;
6287 if (gimple_seq_empty_p (phi_nodes (e_copy
->dest
)))
6290 bb
= bb_copy
->flags
& BB_DUPLICATED
? get_bb_original (bb_copy
) : bb_copy
;
6292 if (e_copy
->dest
->flags
& BB_DUPLICATED
)
6293 dest
= get_bb_original (e_copy
->dest
);
6295 dest
= e_copy
->dest
;
6297 e
= find_edge (bb
, dest
);
6300 /* During loop unrolling the target of the latch edge is copied.
6301 In this case we are not looking for edge to dest, but to
6302 duplicated block whose original was dest. */
6303 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6305 if ((e
->dest
->flags
& BB_DUPLICATED
)
6306 && get_bb_original (e
->dest
) == dest
)
6310 gcc_assert (e
!= NULL
);
6313 for (psi
= gsi_start_phis (e
->dest
),
6314 psi_copy
= gsi_start_phis (e_copy
->dest
);
6316 gsi_next (&psi
), gsi_next (&psi_copy
))
6319 phi_copy
= psi_copy
.phi ();
6320 def
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
6321 add_phi_arg (phi_copy
, def
, e_copy
,
6322 gimple_phi_arg_location_from_edge (phi
, e
));
6327 /* Basic block BB_COPY was created by code duplication. Add phi node
6328 arguments for edges going out of BB_COPY. The blocks that were
6329 duplicated have BB_DUPLICATED set. */
6332 add_phi_args_after_copy_bb (basic_block bb_copy
)
6337 FOR_EACH_EDGE (e_copy
, ei
, bb_copy
->succs
)
6339 add_phi_args_after_copy_edge (e_copy
);
6343 /* Blocks in REGION_COPY array of length N_REGION were created by
6344 duplication of basic blocks. Add phi node arguments for edges
6345 going from these blocks. If E_COPY is not NULL, also add
6346 phi node arguments for its destination.*/
6349 add_phi_args_after_copy (basic_block
*region_copy
, unsigned n_region
,
6354 for (i
= 0; i
< n_region
; i
++)
6355 region_copy
[i
]->flags
|= BB_DUPLICATED
;
6357 for (i
= 0; i
< n_region
; i
++)
6358 add_phi_args_after_copy_bb (region_copy
[i
]);
6360 add_phi_args_after_copy_edge (e_copy
);
6362 for (i
= 0; i
< n_region
; i
++)
6363 region_copy
[i
]->flags
&= ~BB_DUPLICATED
;
6366 /* Duplicates a REGION (set of N_REGION basic blocks) with just a single
6367 important exit edge EXIT. By important we mean that no SSA name defined
6368 inside region is live over the other exit edges of the region. All entry
6369 edges to the region must go to ENTRY->dest. The edge ENTRY is redirected
6370 to the duplicate of the region. Dominance and loop information is
6371 updated if UPDATE_DOMINANCE is true, but not the SSA web. If
6372 UPDATE_DOMINANCE is false then we assume that the caller will update the
6373 dominance information after calling this function. The new basic
6374 blocks are stored to REGION_COPY in the same order as they had in REGION,
6375 provided that REGION_COPY is not NULL.
6376 The function returns false if it is unable to copy the region,
6380 gimple_duplicate_sese_region (edge entry
, edge exit
,
6381 basic_block
*region
, unsigned n_region
,
6382 basic_block
*region_copy
,
6383 bool update_dominance
)
6386 bool free_region_copy
= false, copying_header
= false;
6387 class loop
*loop
= entry
->dest
->loop_father
;
6389 vec
<basic_block
> doms
= vNULL
;
6391 profile_count total_count
= profile_count::uninitialized ();
6392 profile_count entry_count
= profile_count::uninitialized ();
6394 if (!can_copy_bbs_p (region
, n_region
))
6397 /* Some sanity checking. Note that we do not check for all possible
6398 missuses of the functions. I.e. if you ask to copy something weird,
6399 it will work, but the state of structures probably will not be
6401 for (i
= 0; i
< n_region
; i
++)
6403 /* We do not handle subloops, i.e. all the blocks must belong to the
6405 if (region
[i
]->loop_father
!= loop
)
6408 if (region
[i
] != entry
->dest
6409 && region
[i
] == loop
->header
)
6413 /* In case the function is used for loop header copying (which is the primary
6414 use), ensure that EXIT and its copy will be new latch and entry edges. */
6415 if (loop
->header
== entry
->dest
)
6417 copying_header
= true;
6419 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, exit
->src
))
6422 for (i
= 0; i
< n_region
; i
++)
6423 if (region
[i
] != exit
->src
6424 && dominated_by_p (CDI_DOMINATORS
, region
[i
], exit
->src
))
6428 initialize_original_copy_tables ();
6431 set_loop_copy (loop
, loop_outer (loop
));
6433 set_loop_copy (loop
, loop
);
6437 region_copy
= XNEWVEC (basic_block
, n_region
);
6438 free_region_copy
= true;
6441 /* Record blocks outside the region that are dominated by something
6443 if (update_dominance
)
6446 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
6449 if (entry
->dest
->count
.initialized_p ())
6451 total_count
= entry
->dest
->count
;
6452 entry_count
= entry
->count ();
6453 /* Fix up corner cases, to avoid division by zero or creation of negative
6455 if (entry_count
> total_count
)
6456 entry_count
= total_count
;
6459 copy_bbs (region
, n_region
, region_copy
, &exit
, 1, &exit_copy
, loop
,
6460 split_edge_bb_loc (entry
), update_dominance
);
6461 if (total_count
.initialized_p () && entry_count
.initialized_p ())
6463 scale_bbs_frequencies_profile_count (region
, n_region
,
6464 total_count
- entry_count
,
6466 scale_bbs_frequencies_profile_count (region_copy
, n_region
, entry_count
,
6472 loop
->header
= exit
->dest
;
6473 loop
->latch
= exit
->src
;
6476 /* Redirect the entry and add the phi node arguments. */
6477 redirected
= redirect_edge_and_branch (entry
, get_bb_copy (entry
->dest
));
6478 gcc_assert (redirected
!= NULL
);
6479 flush_pending_stmts (entry
);
6481 /* Concerning updating of dominators: We must recount dominators
6482 for entry block and its copy. Anything that is outside of the
6483 region, but was dominated by something inside needs recounting as
6485 if (update_dominance
)
6487 set_immediate_dominator (CDI_DOMINATORS
, entry
->dest
, entry
->src
);
6488 doms
.safe_push (get_bb_original (entry
->dest
));
6489 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6493 /* Add the other PHI node arguments. */
6494 add_phi_args_after_copy (region_copy
, n_region
, NULL
);
6496 if (free_region_copy
)
6499 free_original_copy_tables ();
6503 /* Checks if BB is part of the region defined by N_REGION BBS. */
6505 bb_part_of_region_p (basic_block bb
, basic_block
* bbs
, unsigned n_region
)
6509 for (n
= 0; n
< n_region
; n
++)
6517 /* Duplicates REGION consisting of N_REGION blocks. The new blocks
6518 are stored to REGION_COPY in the same order in that they appear
6519 in REGION, if REGION_COPY is not NULL. ENTRY is the entry to
6520 the region, EXIT an exit from it. The condition guarding EXIT
6521 is moved to ENTRY. Returns true if duplication succeeds, false
6547 gimple_duplicate_sese_tail (edge entry
, edge exit
,
6548 basic_block
*region
, unsigned n_region
,
6549 basic_block
*region_copy
)
6552 bool free_region_copy
= false;
6553 class loop
*loop
= exit
->dest
->loop_father
;
6554 class loop
*orig_loop
= entry
->dest
->loop_father
;
6555 basic_block switch_bb
, entry_bb
, nentry_bb
;
6556 vec
<basic_block
> doms
;
6557 profile_count total_count
= profile_count::uninitialized (),
6558 exit_count
= profile_count::uninitialized ();
6559 edge exits
[2], nexits
[2], e
;
6560 gimple_stmt_iterator gsi
;
6563 basic_block exit_bb
;
6567 class loop
*target
, *aloop
, *cloop
;
6569 gcc_assert (EDGE_COUNT (exit
->src
->succs
) == 2);
6571 exits
[1] = EDGE_SUCC (exit
->src
, EDGE_SUCC (exit
->src
, 0) == exit
);
6573 if (!can_copy_bbs_p (region
, n_region
))
6576 initialize_original_copy_tables ();
6577 set_loop_copy (orig_loop
, loop
);
6580 for (aloop
= orig_loop
->inner
; aloop
; aloop
= aloop
->next
)
6582 if (bb_part_of_region_p (aloop
->header
, region
, n_region
))
6584 cloop
= duplicate_loop (aloop
, target
);
6585 duplicate_subloops (aloop
, cloop
);
6591 region_copy
= XNEWVEC (basic_block
, n_region
);
6592 free_region_copy
= true;
6595 gcc_assert (!need_ssa_update_p (cfun
));
6597 /* Record blocks outside the region that are dominated by something
6599 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
6601 total_count
= exit
->src
->count
;
6602 exit_count
= exit
->count ();
6603 /* Fix up corner cases, to avoid division by zero or creation of negative
6605 if (exit_count
> total_count
)
6606 exit_count
= total_count
;
6608 copy_bbs (region
, n_region
, region_copy
, exits
, 2, nexits
, orig_loop
,
6609 split_edge_bb_loc (exit
), true);
6610 if (total_count
.initialized_p () && exit_count
.initialized_p ())
6612 scale_bbs_frequencies_profile_count (region
, n_region
,
6613 total_count
- exit_count
,
6615 scale_bbs_frequencies_profile_count (region_copy
, n_region
, exit_count
,
6619 /* Create the switch block, and put the exit condition to it. */
6620 entry_bb
= entry
->dest
;
6621 nentry_bb
= get_bb_copy (entry_bb
);
6622 if (!last_stmt (entry
->src
)
6623 || !stmt_ends_bb_p (last_stmt (entry
->src
)))
6624 switch_bb
= entry
->src
;
6626 switch_bb
= split_edge (entry
);
6627 set_immediate_dominator (CDI_DOMINATORS
, nentry_bb
, switch_bb
);
6629 gsi
= gsi_last_bb (switch_bb
);
6630 cond_stmt
= last_stmt (exit
->src
);
6631 gcc_assert (gimple_code (cond_stmt
) == GIMPLE_COND
);
6632 cond_stmt
= gimple_copy (cond_stmt
);
6634 gsi_insert_after (&gsi
, cond_stmt
, GSI_NEW_STMT
);
6636 sorig
= single_succ_edge (switch_bb
);
6637 sorig
->flags
= exits
[1]->flags
;
6638 sorig
->probability
= exits
[1]->probability
;
6639 snew
= make_edge (switch_bb
, nentry_bb
, exits
[0]->flags
);
6640 snew
->probability
= exits
[0]->probability
;
6643 /* Register the new edge from SWITCH_BB in loop exit lists. */
6644 rescan_loop_exit (snew
, true, false);
6646 /* Add the PHI node arguments. */
6647 add_phi_args_after_copy (region_copy
, n_region
, snew
);
6649 /* Get rid of now superfluous conditions and associated edges (and phi node
6651 exit_bb
= exit
->dest
;
6653 e
= redirect_edge_and_branch (exits
[0], exits
[1]->dest
);
6654 PENDING_STMT (e
) = NULL
;
6656 /* The latch of ORIG_LOOP was copied, and so was the backedge
6657 to the original header. We redirect this backedge to EXIT_BB. */
6658 for (i
= 0; i
< n_region
; i
++)
6659 if (get_bb_original (region_copy
[i
]) == orig_loop
->latch
)
6661 gcc_assert (single_succ_edge (region_copy
[i
]));
6662 e
= redirect_edge_and_branch (single_succ_edge (region_copy
[i
]), exit_bb
);
6663 PENDING_STMT (e
) = NULL
;
6664 for (psi
= gsi_start_phis (exit_bb
);
6669 def
= PHI_ARG_DEF (phi
, nexits
[0]->dest_idx
);
6670 add_phi_arg (phi
, def
, e
, gimple_phi_arg_location_from_edge (phi
, e
));
6673 e
= redirect_edge_and_branch (nexits
[1], nexits
[0]->dest
);
6674 PENDING_STMT (e
) = NULL
;
6676 /* Anything that is outside of the region, but was dominated by something
6677 inside needs to update dominance info. */
6678 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6680 /* Update the SSA web. */
6681 update_ssa (TODO_update_ssa
);
6683 if (free_region_copy
)
6686 free_original_copy_tables ();
6690 /* Add all the blocks dominated by ENTRY to the array BBS_P. Stop
6691 adding blocks when the dominator traversal reaches EXIT. This
6692 function silently assumes that ENTRY strictly dominates EXIT. */
6695 gather_blocks_in_sese_region (basic_block entry
, basic_block exit
,
6696 vec
<basic_block
> *bbs_p
)
6700 for (son
= first_dom_son (CDI_DOMINATORS
, entry
);
6702 son
= next_dom_son (CDI_DOMINATORS
, son
))
6704 bbs_p
->safe_push (son
);
6706 gather_blocks_in_sese_region (son
, exit
, bbs_p
);
6710 /* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
6711 The duplicates are recorded in VARS_MAP. */
6714 replace_by_duplicate_decl (tree
*tp
, hash_map
<tree
, tree
> *vars_map
,
6717 tree t
= *tp
, new_t
;
6718 struct function
*f
= DECL_STRUCT_FUNCTION (to_context
);
6720 if (DECL_CONTEXT (t
) == to_context
)
6724 tree
&loc
= vars_map
->get_or_insert (t
, &existed
);
6730 new_t
= copy_var_decl (t
, DECL_NAME (t
), TREE_TYPE (t
));
6731 add_local_decl (f
, new_t
);
6735 gcc_assert (TREE_CODE (t
) == CONST_DECL
);
6736 new_t
= copy_node (t
);
6738 DECL_CONTEXT (new_t
) = to_context
;
6749 /* Creates an ssa name in TO_CONTEXT equivalent to NAME.
6750 VARS_MAP maps old ssa names and var_decls to the new ones. */
6753 replace_ssa_name (tree name
, hash_map
<tree
, tree
> *vars_map
,
6758 gcc_assert (!virtual_operand_p (name
));
6760 tree
*loc
= vars_map
->get (name
);
6764 tree decl
= SSA_NAME_VAR (name
);
6767 gcc_assert (!SSA_NAME_IS_DEFAULT_DEF (name
));
6768 replace_by_duplicate_decl (&decl
, vars_map
, to_context
);
6769 new_name
= make_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6770 decl
, SSA_NAME_DEF_STMT (name
));
6773 new_name
= copy_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6774 name
, SSA_NAME_DEF_STMT (name
));
6776 /* Now that we've used the def stmt to define new_name, make sure it
6777 doesn't define name anymore. */
6778 SSA_NAME_DEF_STMT (name
) = NULL
;
6780 vars_map
->put (name
, new_name
);
6794 hash_map
<tree
, tree
> *vars_map
;
6795 htab_t new_label_map
;
6796 hash_map
<void *, void *> *eh_map
;
6800 /* Helper for move_block_to_fn. Set TREE_BLOCK in every expression
6801 contained in *TP if it has been ORIG_BLOCK previously and change the
6802 DECL_CONTEXT of every local variable referenced in *TP. */
6805 move_stmt_op (tree
*tp
, int *walk_subtrees
, void *data
)
6807 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
6808 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6813 tree block
= TREE_BLOCK (t
);
6814 if (block
== NULL_TREE
)
6816 else if (block
== p
->orig_block
6817 || p
->orig_block
== NULL_TREE
)
6819 /* tree_node_can_be_shared says we can share invariant
6820 addresses but unshare_expr copies them anyways. Make sure
6821 to unshare before adjusting the block in place - we do not
6822 always see a copy here. */
6823 if (TREE_CODE (t
) == ADDR_EXPR
6824 && is_gimple_min_invariant (t
))
6825 *tp
= t
= unshare_expr (t
);
6826 TREE_SET_BLOCK (t
, p
->new_block
);
6828 else if (flag_checking
)
6830 while (block
&& TREE_CODE (block
) == BLOCK
&& block
!= p
->orig_block
)
6831 block
= BLOCK_SUPERCONTEXT (block
);
6832 gcc_assert (block
== p
->orig_block
);
6835 else if (DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
)
6837 if (TREE_CODE (t
) == SSA_NAME
)
6838 *tp
= replace_ssa_name (t
, p
->vars_map
, p
->to_context
);
6839 else if (TREE_CODE (t
) == PARM_DECL
6840 && gimple_in_ssa_p (cfun
))
6841 *tp
= *(p
->vars_map
->get (t
));
6842 else if (TREE_CODE (t
) == LABEL_DECL
)
6844 if (p
->new_label_map
)
6846 struct tree_map in
, *out
;
6848 out
= (struct tree_map
*)
6849 htab_find_with_hash (p
->new_label_map
, &in
, DECL_UID (t
));
6854 /* For FORCED_LABELs we can end up with references from other
6855 functions if some SESE regions are outlined. It is UB to
6856 jump in between them, but they could be used just for printing
6857 addresses etc. In that case, DECL_CONTEXT on the label should
6858 be the function containing the glabel stmt with that LABEL_DECL,
6859 rather than whatever function a reference to the label was seen
6861 if (!FORCED_LABEL (t
) && !DECL_NONLOCAL (t
))
6862 DECL_CONTEXT (t
) = p
->to_context
;
6864 else if (p
->remap_decls_p
)
6866 /* Replace T with its duplicate. T should no longer appear in the
6867 parent function, so this looks wasteful; however, it may appear
6868 in referenced_vars, and more importantly, as virtual operands of
6869 statements, and in alias lists of other variables. It would be
6870 quite difficult to expunge it from all those places. ??? It might
6871 suffice to do this for addressable variables. */
6872 if ((VAR_P (t
) && !is_global_var (t
))
6873 || TREE_CODE (t
) == CONST_DECL
)
6874 replace_by_duplicate_decl (tp
, p
->vars_map
, p
->to_context
);
6878 else if (TYPE_P (t
))
6884 /* Helper for move_stmt_r. Given an EH region number for the source
6885 function, map that to the duplicate EH regio number in the dest. */
6888 move_stmt_eh_region_nr (int old_nr
, struct move_stmt_d
*p
)
6890 eh_region old_r
, new_r
;
6892 old_r
= get_eh_region_from_number (old_nr
);
6893 new_r
= static_cast<eh_region
> (*p
->eh_map
->get (old_r
));
6895 return new_r
->index
;
6898 /* Similar, but operate on INTEGER_CSTs. */
6901 move_stmt_eh_region_tree_nr (tree old_t_nr
, struct move_stmt_d
*p
)
6905 old_nr
= tree_to_shwi (old_t_nr
);
6906 new_nr
= move_stmt_eh_region_nr (old_nr
, p
);
6908 return build_int_cst (integer_type_node
, new_nr
);
6911 /* Like move_stmt_op, but for gimple statements.
6913 Helper for move_block_to_fn. Set GIMPLE_BLOCK in every expression
6914 contained in the current statement in *GSI_P and change the
6915 DECL_CONTEXT of every local variable referenced in the current
6919 move_stmt_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
6920 struct walk_stmt_info
*wi
)
6922 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6923 gimple
*stmt
= gsi_stmt (*gsi_p
);
6924 tree block
= gimple_block (stmt
);
6926 if (block
== p
->orig_block
6927 || (p
->orig_block
== NULL_TREE
6928 && block
!= NULL_TREE
))
6929 gimple_set_block (stmt
, p
->new_block
);
6931 switch (gimple_code (stmt
))
6934 /* Remap the region numbers for __builtin_eh_{pointer,filter}. */
6936 tree r
, fndecl
= gimple_call_fndecl (stmt
);
6937 if (fndecl
&& fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
))
6938 switch (DECL_FUNCTION_CODE (fndecl
))
6940 case BUILT_IN_EH_COPY_VALUES
:
6941 r
= gimple_call_arg (stmt
, 1);
6942 r
= move_stmt_eh_region_tree_nr (r
, p
);
6943 gimple_call_set_arg (stmt
, 1, r
);
6946 case BUILT_IN_EH_POINTER
:
6947 case BUILT_IN_EH_FILTER
:
6948 r
= gimple_call_arg (stmt
, 0);
6949 r
= move_stmt_eh_region_tree_nr (r
, p
);
6950 gimple_call_set_arg (stmt
, 0, r
);
6961 gresx
*resx_stmt
= as_a
<gresx
*> (stmt
);
6962 int r
= gimple_resx_region (resx_stmt
);
6963 r
= move_stmt_eh_region_nr (r
, p
);
6964 gimple_resx_set_region (resx_stmt
, r
);
6968 case GIMPLE_EH_DISPATCH
:
6970 geh_dispatch
*eh_dispatch_stmt
= as_a
<geh_dispatch
*> (stmt
);
6971 int r
= gimple_eh_dispatch_region (eh_dispatch_stmt
);
6972 r
= move_stmt_eh_region_nr (r
, p
);
6973 gimple_eh_dispatch_set_region (eh_dispatch_stmt
, r
);
6977 case GIMPLE_OMP_RETURN
:
6978 case GIMPLE_OMP_CONTINUE
:
6983 /* For FORCED_LABEL, move_stmt_op doesn't adjust DECL_CONTEXT,
6984 so that such labels can be referenced from other regions.
6985 Make sure to update it when seeing a GIMPLE_LABEL though,
6986 that is the owner of the label. */
6987 walk_gimple_op (stmt
, move_stmt_op
, wi
);
6988 *handled_ops_p
= true;
6989 tree label
= gimple_label_label (as_a
<glabel
*> (stmt
));
6990 if (FORCED_LABEL (label
) || DECL_NONLOCAL (label
))
6991 DECL_CONTEXT (label
) = p
->to_context
;
6996 if (is_gimple_omp (stmt
))
6998 /* Do not remap variables inside OMP directives. Variables
6999 referenced in clauses and directive header belong to the
7000 parent function and should not be moved into the child
7002 bool save_remap_decls_p
= p
->remap_decls_p
;
7003 p
->remap_decls_p
= false;
7004 *handled_ops_p
= true;
7006 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt
), move_stmt_r
,
7009 p
->remap_decls_p
= save_remap_decls_p
;
7017 /* Move basic block BB from function CFUN to function DEST_FN. The
7018 block is moved out of the original linked list and placed after
7019 block AFTER in the new list. Also, the block is removed from the
7020 original array of blocks and placed in DEST_FN's array of blocks.
7021 If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
7022 updated to reflect the moved edges.
7024 The local variables are remapped to new instances, VARS_MAP is used
7025 to record the mapping. */
7028 move_block_to_fn (struct function
*dest_cfun
, basic_block bb
,
7029 basic_block after
, bool update_edge_count_p
,
7030 struct move_stmt_d
*d
)
7032 struct control_flow_graph
*cfg
;
7035 gimple_stmt_iterator si
;
7036 unsigned old_len
, new_len
;
7038 /* Remove BB from dominance structures. */
7039 delete_from_dominance_info (CDI_DOMINATORS
, bb
);
7041 /* Move BB from its current loop to the copy in the new function. */
7044 class loop
*new_loop
= (class loop
*)bb
->loop_father
->aux
;
7046 bb
->loop_father
= new_loop
;
7049 /* Link BB to the new linked list. */
7050 move_block_after (bb
, after
);
7052 /* Update the edge count in the corresponding flowgraphs. */
7053 if (update_edge_count_p
)
7054 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7056 cfun
->cfg
->x_n_edges
--;
7057 dest_cfun
->cfg
->x_n_edges
++;
7060 /* Remove BB from the original basic block array. */
7061 (*cfun
->cfg
->x_basic_block_info
)[bb
->index
] = NULL
;
7062 cfun
->cfg
->x_n_basic_blocks
--;
7064 /* Grow DEST_CFUN's basic block array if needed. */
7065 cfg
= dest_cfun
->cfg
;
7066 cfg
->x_n_basic_blocks
++;
7067 if (bb
->index
>= cfg
->x_last_basic_block
)
7068 cfg
->x_last_basic_block
= bb
->index
+ 1;
7070 old_len
= vec_safe_length (cfg
->x_basic_block_info
);
7071 if ((unsigned) cfg
->x_last_basic_block
>= old_len
)
7073 new_len
= cfg
->x_last_basic_block
+ (cfg
->x_last_basic_block
+ 3) / 4;
7074 vec_safe_grow_cleared (cfg
->x_basic_block_info
, new_len
);
7077 (*cfg
->x_basic_block_info
)[bb
->index
] = bb
;
7079 /* Remap the variables in phi nodes. */
7080 for (gphi_iterator psi
= gsi_start_phis (bb
);
7083 gphi
*phi
= psi
.phi ();
7085 tree op
= PHI_RESULT (phi
);
7089 if (virtual_operand_p (op
))
7091 /* Remove the phi nodes for virtual operands (alias analysis will be
7092 run for the new function, anyway). But replace all uses that
7093 might be outside of the region we move. */
7094 use_operand_p use_p
;
7095 imm_use_iterator iter
;
7097 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, op
)
7098 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
7099 SET_USE (use_p
, SSA_NAME_VAR (op
));
7100 remove_phi_node (&psi
, true);
7104 SET_PHI_RESULT (phi
,
7105 replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
7106 FOR_EACH_PHI_ARG (use
, phi
, oi
, SSA_OP_USE
)
7108 op
= USE_FROM_PTR (use
);
7109 if (TREE_CODE (op
) == SSA_NAME
)
7110 SET_USE (use
, replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
7113 for (i
= 0; i
< EDGE_COUNT (bb
->preds
); i
++)
7115 location_t locus
= gimple_phi_arg_location (phi
, i
);
7116 tree block
= LOCATION_BLOCK (locus
);
7118 if (locus
== UNKNOWN_LOCATION
)
7120 if (d
->orig_block
== NULL_TREE
|| block
== d
->orig_block
)
7122 locus
= set_block (locus
, d
->new_block
);
7123 gimple_phi_arg_set_location (phi
, i
, locus
);
7130 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
7132 gimple
*stmt
= gsi_stmt (si
);
7133 struct walk_stmt_info wi
;
7135 memset (&wi
, 0, sizeof (wi
));
7137 walk_gimple_stmt (&si
, move_stmt_r
, move_stmt_op
, &wi
);
7139 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
7141 tree label
= gimple_label_label (label_stmt
);
7142 int uid
= LABEL_DECL_UID (label
);
7144 gcc_assert (uid
> -1);
7146 old_len
= vec_safe_length (cfg
->x_label_to_block_map
);
7147 if (old_len
<= (unsigned) uid
)
7149 new_len
= 3 * uid
/ 2 + 1;
7150 vec_safe_grow_cleared (cfg
->x_label_to_block_map
, new_len
);
7153 (*cfg
->x_label_to_block_map
)[uid
] = bb
;
7154 (*cfun
->cfg
->x_label_to_block_map
)[uid
] = NULL
;
7156 gcc_assert (DECL_CONTEXT (label
) == dest_cfun
->decl
);
7158 if (uid
>= dest_cfun
->cfg
->last_label_uid
)
7159 dest_cfun
->cfg
->last_label_uid
= uid
+ 1;
7162 maybe_duplicate_eh_stmt_fn (dest_cfun
, stmt
, cfun
, stmt
, d
->eh_map
, 0);
7163 remove_stmt_from_eh_lp_fn (cfun
, stmt
);
7165 gimple_duplicate_stmt_histograms (dest_cfun
, stmt
, cfun
, stmt
);
7166 gimple_remove_stmt_histograms (cfun
, stmt
);
7168 /* We cannot leave any operands allocated from the operand caches of
7169 the current function. */
7170 free_stmt_operands (cfun
, stmt
);
7171 push_cfun (dest_cfun
);
7176 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7177 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
7179 tree block
= LOCATION_BLOCK (e
->goto_locus
);
7180 if (d
->orig_block
== NULL_TREE
7181 || block
== d
->orig_block
)
7182 e
->goto_locus
= set_block (e
->goto_locus
, d
->new_block
);
7186 /* Examine the statements in BB (which is in SRC_CFUN); find and return
7187 the outermost EH region. Use REGION as the incoming base EH region.
7188 If there is no single outermost region, return NULL and set *ALL to
7192 find_outermost_region_in_block (struct function
*src_cfun
,
7193 basic_block bb
, eh_region region
,
7196 gimple_stmt_iterator si
;
7198 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
7200 gimple
*stmt
= gsi_stmt (si
);
7201 eh_region stmt_region
;
7204 lp_nr
= lookup_stmt_eh_lp_fn (src_cfun
, stmt
);
7205 stmt_region
= get_eh_region_from_lp_number_fn (src_cfun
, lp_nr
);
7209 region
= stmt_region
;
7210 else if (stmt_region
!= region
)
7212 region
= eh_region_outermost (src_cfun
, stmt_region
, region
);
7226 new_label_mapper (tree decl
, void *data
)
7228 htab_t hash
= (htab_t
) data
;
7232 gcc_assert (TREE_CODE (decl
) == LABEL_DECL
);
7234 m
= XNEW (struct tree_map
);
7235 m
->hash
= DECL_UID (decl
);
7236 m
->base
.from
= decl
;
7237 m
->to
= create_artificial_label (UNKNOWN_LOCATION
);
7238 LABEL_DECL_UID (m
->to
) = LABEL_DECL_UID (decl
);
7239 if (LABEL_DECL_UID (m
->to
) >= cfun
->cfg
->last_label_uid
)
7240 cfun
->cfg
->last_label_uid
= LABEL_DECL_UID (m
->to
) + 1;
7242 slot
= htab_find_slot_with_hash (hash
, m
, m
->hash
, INSERT
);
7243 gcc_assert (*slot
== NULL
);
7250 /* Tree walker to replace the decls used inside value expressions by
7254 replace_block_vars_by_duplicates_1 (tree
*tp
, int *walk_subtrees
, void *data
)
7256 struct replace_decls_d
*rd
= (struct replace_decls_d
*)data
;
7258 switch (TREE_CODE (*tp
))
7263 replace_by_duplicate_decl (tp
, rd
->vars_map
, rd
->to_context
);
7269 if (IS_TYPE_OR_DECL_P (*tp
))
7270 *walk_subtrees
= false;
7275 /* Change DECL_CONTEXT of all BLOCK_VARS in block, including
7279 replace_block_vars_by_duplicates (tree block
, hash_map
<tree
, tree
> *vars_map
,
7284 for (tp
= &BLOCK_VARS (block
); *tp
; tp
= &DECL_CHAIN (*tp
))
7287 if (!VAR_P (t
) && TREE_CODE (t
) != CONST_DECL
)
7289 replace_by_duplicate_decl (&t
, vars_map
, to_context
);
7292 if (VAR_P (*tp
) && DECL_HAS_VALUE_EXPR_P (*tp
))
7294 tree x
= DECL_VALUE_EXPR (*tp
);
7295 struct replace_decls_d rd
= { vars_map
, to_context
};
7297 walk_tree (&x
, replace_block_vars_by_duplicates_1
, &rd
, NULL
);
7298 SET_DECL_VALUE_EXPR (t
, x
);
7299 DECL_HAS_VALUE_EXPR_P (t
) = 1;
7301 DECL_CHAIN (t
) = DECL_CHAIN (*tp
);
7306 for (block
= BLOCK_SUBBLOCKS (block
); block
; block
= BLOCK_CHAIN (block
))
7307 replace_block_vars_by_duplicates (block
, vars_map
, to_context
);
7310 /* Fixup the loop arrays and numbers after moving LOOP and its subloops
7314 fixup_loop_arrays_after_move (struct function
*fn1
, struct function
*fn2
,
7317 /* Discard it from the old loop array. */
7318 (*get_loops (fn1
))[loop
->num
] = NULL
;
7320 /* Place it in the new loop array, assigning it a new number. */
7321 loop
->num
= number_of_loops (fn2
);
7322 vec_safe_push (loops_for_fn (fn2
)->larray
, loop
);
7324 /* Recurse to children. */
7325 for (loop
= loop
->inner
; loop
; loop
= loop
->next
)
7326 fixup_loop_arrays_after_move (fn1
, fn2
, loop
);
7329 /* Verify that the blocks in BBS_P are a single-entry, single-exit region
7330 delimited by ENTRY_BB and EXIT_BB, possibly containing noreturn blocks. */
7333 verify_sese (basic_block entry
, basic_block exit
, vec
<basic_block
> *bbs_p
)
7338 bitmap bbs
= BITMAP_ALLOC (NULL
);
7341 gcc_assert (entry
!= NULL
);
7342 gcc_assert (entry
!= exit
);
7343 gcc_assert (bbs_p
!= NULL
);
7345 gcc_assert (bbs_p
->length () > 0);
7347 FOR_EACH_VEC_ELT (*bbs_p
, i
, bb
)
7348 bitmap_set_bit (bbs
, bb
->index
);
7350 gcc_assert (bitmap_bit_p (bbs
, entry
->index
));
7351 gcc_assert (exit
== NULL
|| bitmap_bit_p (bbs
, exit
->index
));
7353 FOR_EACH_VEC_ELT (*bbs_p
, i
, bb
)
7357 gcc_assert (single_pred_p (entry
));
7358 gcc_assert (!bitmap_bit_p (bbs
, single_pred (entry
)->index
));
7361 for (ei
= ei_start (bb
->preds
); !ei_end_p (ei
); ei_next (&ei
))
7364 gcc_assert (bitmap_bit_p (bbs
, e
->src
->index
));
7369 gcc_assert (single_succ_p (exit
));
7370 gcc_assert (!bitmap_bit_p (bbs
, single_succ (exit
)->index
));
7373 for (ei
= ei_start (bb
->succs
); !ei_end_p (ei
); ei_next (&ei
))
7376 gcc_assert (bitmap_bit_p (bbs
, e
->dest
->index
));
7383 /* If FROM is an SSA_NAME, mark the version in bitmap DATA. */
7386 gather_ssa_name_hash_map_from (tree
const &from
, tree
const &, void *data
)
7388 bitmap release_names
= (bitmap
)data
;
7390 if (TREE_CODE (from
) != SSA_NAME
)
7393 bitmap_set_bit (release_names
, SSA_NAME_VERSION (from
));
7397 /* Return LOOP_DIST_ALIAS call if present in BB. */
7400 find_loop_dist_alias (basic_block bb
)
7402 gimple
*g
= last_stmt (bb
);
7403 if (g
== NULL
|| gimple_code (g
) != GIMPLE_COND
)
7406 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
7408 if (gsi_end_p (gsi
))
7412 if (gimple_call_internal_p (g
, IFN_LOOP_DIST_ALIAS
))
7417 /* Fold loop internal call G like IFN_LOOP_VECTORIZED/IFN_LOOP_DIST_ALIAS
7418 to VALUE and update any immediate uses of it's LHS. */
7421 fold_loop_internal_call (gimple
*g
, tree value
)
7423 tree lhs
= gimple_call_lhs (g
);
7424 use_operand_p use_p
;
7425 imm_use_iterator iter
;
7427 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
7429 update_call_from_tree (&gsi
, value
);
7430 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, lhs
)
7432 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
7433 SET_USE (use_p
, value
);
7434 update_stmt (use_stmt
);
7438 /* Move a single-entry, single-exit region delimited by ENTRY_BB and
7439 EXIT_BB to function DEST_CFUN. The whole region is replaced by a
7440 single basic block in the original CFG and the new basic block is
7441 returned. DEST_CFUN must not have a CFG yet.
7443 Note that the region need not be a pure SESE region. Blocks inside
7444 the region may contain calls to abort/exit. The only restriction
7445 is that ENTRY_BB should be the only entry point and it must
7448 Change TREE_BLOCK of all statements in ORIG_BLOCK to the new
7449 functions outermost BLOCK, move all subblocks of ORIG_BLOCK
7450 to the new function.
7452 All local variables referenced in the region are assumed to be in
7453 the corresponding BLOCK_VARS and unexpanded variable lists
7454 associated with DEST_CFUN.
7456 TODO: investigate whether we can reuse gimple_duplicate_sese_region to
7457 reimplement move_sese_region_to_fn by duplicating the region rather than
7461 move_sese_region_to_fn (struct function
*dest_cfun
, basic_block entry_bb
,
7462 basic_block exit_bb
, tree orig_block
)
7464 vec
<basic_block
> bbs
, dom_bbs
;
7465 basic_block dom_entry
= get_immediate_dominator (CDI_DOMINATORS
, entry_bb
);
7466 basic_block after
, bb
, *entry_pred
, *exit_succ
, abb
;
7467 struct function
*saved_cfun
= cfun
;
7468 int *entry_flag
, *exit_flag
;
7469 profile_probability
*entry_prob
, *exit_prob
;
7470 unsigned i
, num_entry_edges
, num_exit_edges
, num_nodes
;
7473 htab_t new_label_map
;
7474 hash_map
<void *, void *> *eh_map
;
7475 class loop
*loop
= entry_bb
->loop_father
;
7476 class loop
*loop0
= get_loop (saved_cfun
, 0);
7477 struct move_stmt_d d
;
7479 /* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
7481 gcc_assert (entry_bb
!= exit_bb
7483 || dominated_by_p (CDI_DOMINATORS
, exit_bb
, entry_bb
)));
7485 /* Collect all the blocks in the region. Manually add ENTRY_BB
7486 because it won't be added by dfs_enumerate_from. */
7488 bbs
.safe_push (entry_bb
);
7489 gather_blocks_in_sese_region (entry_bb
, exit_bb
, &bbs
);
7492 verify_sese (entry_bb
, exit_bb
, &bbs
);
7494 /* The blocks that used to be dominated by something in BBS will now be
7495 dominated by the new block. */
7496 dom_bbs
= get_dominated_by_region (CDI_DOMINATORS
,
7500 /* Detach ENTRY_BB and EXIT_BB from CFUN->CFG. We need to remember
7501 the predecessor edges to ENTRY_BB and the successor edges to
7502 EXIT_BB so that we can re-attach them to the new basic block that
7503 will replace the region. */
7504 num_entry_edges
= EDGE_COUNT (entry_bb
->preds
);
7505 entry_pred
= XNEWVEC (basic_block
, num_entry_edges
);
7506 entry_flag
= XNEWVEC (int, num_entry_edges
);
7507 entry_prob
= XNEWVEC (profile_probability
, num_entry_edges
);
7509 for (ei
= ei_start (entry_bb
->preds
); (e
= ei_safe_edge (ei
)) != NULL
;)
7511 entry_prob
[i
] = e
->probability
;
7512 entry_flag
[i
] = e
->flags
;
7513 entry_pred
[i
++] = e
->src
;
7519 num_exit_edges
= EDGE_COUNT (exit_bb
->succs
);
7520 exit_succ
= XNEWVEC (basic_block
, num_exit_edges
);
7521 exit_flag
= XNEWVEC (int, num_exit_edges
);
7522 exit_prob
= XNEWVEC (profile_probability
, num_exit_edges
);
7524 for (ei
= ei_start (exit_bb
->succs
); (e
= ei_safe_edge (ei
)) != NULL
;)
7526 exit_prob
[i
] = e
->probability
;
7527 exit_flag
[i
] = e
->flags
;
7528 exit_succ
[i
++] = e
->dest
;
7540 /* Switch context to the child function to initialize DEST_FN's CFG. */
7541 gcc_assert (dest_cfun
->cfg
== NULL
);
7542 push_cfun (dest_cfun
);
7544 init_empty_tree_cfg ();
7546 /* Initialize EH information for the new function. */
7548 new_label_map
= NULL
;
7551 eh_region region
= NULL
;
7554 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7556 region
= find_outermost_region_in_block (saved_cfun
, bb
, region
, &all
);
7561 init_eh_for_function ();
7562 if (region
!= NULL
|| all
)
7564 new_label_map
= htab_create (17, tree_map_hash
, tree_map_eq
, free
);
7565 eh_map
= duplicate_eh_regions (saved_cfun
, region
, 0,
7566 new_label_mapper
, new_label_map
);
7570 /* Initialize an empty loop tree. */
7571 struct loops
*loops
= ggc_cleared_alloc
<struct loops
> ();
7572 init_loops_structure (dest_cfun
, loops
, 1);
7573 loops
->state
= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
7574 set_loops_for_fn (dest_cfun
, loops
);
7576 vec
<loop_p
, va_gc
> *larray
= get_loops (saved_cfun
)->copy ();
7578 /* Move the outlined loop tree part. */
7579 num_nodes
= bbs
.length ();
7580 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7582 if (bb
->loop_father
->header
== bb
)
7584 class loop
*this_loop
= bb
->loop_father
;
7585 class loop
*outer
= loop_outer (this_loop
);
7587 /* If the SESE region contains some bbs ending with
7588 a noreturn call, those are considered to belong
7589 to the outermost loop in saved_cfun, rather than
7590 the entry_bb's loop_father. */
7594 num_nodes
-= this_loop
->num_nodes
;
7595 flow_loop_tree_node_remove (bb
->loop_father
);
7596 flow_loop_tree_node_add (get_loop (dest_cfun
, 0), this_loop
);
7597 fixup_loop_arrays_after_move (saved_cfun
, cfun
, this_loop
);
7600 else if (bb
->loop_father
== loop0
&& loop0
!= loop
)
7603 /* Remove loop exits from the outlined region. */
7604 if (loops_for_fn (saved_cfun
)->exits
)
7605 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7607 struct loops
*l
= loops_for_fn (saved_cfun
);
7609 = l
->exits
->find_slot_with_hash (e
, htab_hash_pointer (e
),
7612 l
->exits
->clear_slot (slot
);
7616 /* Adjust the number of blocks in the tree root of the outlined part. */
7617 get_loop (dest_cfun
, 0)->num_nodes
= bbs
.length () + 2;
7619 /* Setup a mapping to be used by move_block_to_fn. */
7620 loop
->aux
= current_loops
->tree_root
;
7621 loop0
->aux
= current_loops
->tree_root
;
7623 /* Fix up orig_loop_num. If the block referenced in it has been moved
7624 to dest_cfun, update orig_loop_num field, otherwise clear it. */
7626 signed char *moved_orig_loop_num
= NULL
;
7627 FOR_EACH_LOOP_FN (dest_cfun
, dloop
, 0)
7628 if (dloop
->orig_loop_num
)
7630 if (moved_orig_loop_num
== NULL
)
7632 = XCNEWVEC (signed char, vec_safe_length (larray
));
7633 if ((*larray
)[dloop
->orig_loop_num
] != NULL
7634 && get_loop (saved_cfun
, dloop
->orig_loop_num
) == NULL
)
7636 if (moved_orig_loop_num
[dloop
->orig_loop_num
] >= 0
7637 && moved_orig_loop_num
[dloop
->orig_loop_num
] < 2)
7638 moved_orig_loop_num
[dloop
->orig_loop_num
]++;
7639 dloop
->orig_loop_num
= (*larray
)[dloop
->orig_loop_num
]->num
;
7643 moved_orig_loop_num
[dloop
->orig_loop_num
] = -1;
7644 dloop
->orig_loop_num
= 0;
7649 if (moved_orig_loop_num
)
7651 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7653 gimple
*g
= find_loop_dist_alias (bb
);
7657 int orig_loop_num
= tree_to_shwi (gimple_call_arg (g
, 0));
7658 gcc_assert (orig_loop_num
7659 && (unsigned) orig_loop_num
< vec_safe_length (larray
));
7660 if (moved_orig_loop_num
[orig_loop_num
] == 2)
7662 /* If we have moved both loops with this orig_loop_num into
7663 dest_cfun and the LOOP_DIST_ALIAS call is being moved there
7664 too, update the first argument. */
7665 gcc_assert ((*larray
)[dloop
->orig_loop_num
] != NULL
7666 && (get_loop (saved_cfun
, dloop
->orig_loop_num
)
7668 tree t
= build_int_cst (integer_type_node
,
7669 (*larray
)[dloop
->orig_loop_num
]->num
);
7670 gimple_call_set_arg (g
, 0, t
);
7672 /* Make sure the following loop will not update it. */
7673 moved_orig_loop_num
[orig_loop_num
] = 0;
7676 /* Otherwise at least one of the loops stayed in saved_cfun.
7677 Remove the LOOP_DIST_ALIAS call. */
7678 fold_loop_internal_call (g
, gimple_call_arg (g
, 1));
7680 FOR_EACH_BB_FN (bb
, saved_cfun
)
7682 gimple
*g
= find_loop_dist_alias (bb
);
7685 int orig_loop_num
= tree_to_shwi (gimple_call_arg (g
, 0));
7686 gcc_assert (orig_loop_num
7687 && (unsigned) orig_loop_num
< vec_safe_length (larray
));
7688 if (moved_orig_loop_num
[orig_loop_num
])
7689 /* LOOP_DIST_ALIAS call remained in saved_cfun, if at least one
7690 of the corresponding loops was moved, remove it. */
7691 fold_loop_internal_call (g
, gimple_call_arg (g
, 1));
7693 XDELETEVEC (moved_orig_loop_num
);
7697 /* Move blocks from BBS into DEST_CFUN. */
7698 gcc_assert (bbs
.length () >= 2);
7699 after
= dest_cfun
->cfg
->x_entry_block_ptr
;
7700 hash_map
<tree
, tree
> vars_map
;
7702 memset (&d
, 0, sizeof (d
));
7703 d
.orig_block
= orig_block
;
7704 d
.new_block
= DECL_INITIAL (dest_cfun
->decl
);
7705 d
.from_context
= cfun
->decl
;
7706 d
.to_context
= dest_cfun
->decl
;
7707 d
.vars_map
= &vars_map
;
7708 d
.new_label_map
= new_label_map
;
7710 d
.remap_decls_p
= true;
7712 if (gimple_in_ssa_p (cfun
))
7713 for (tree arg
= DECL_ARGUMENTS (d
.to_context
); arg
; arg
= DECL_CHAIN (arg
))
7715 tree narg
= make_ssa_name_fn (dest_cfun
, arg
, gimple_build_nop ());
7716 set_ssa_default_def (dest_cfun
, arg
, narg
);
7717 vars_map
.put (arg
, narg
);
7720 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7722 /* No need to update edge counts on the last block. It has
7723 already been updated earlier when we detached the region from
7724 the original CFG. */
7725 move_block_to_fn (dest_cfun
, bb
, after
, bb
!= exit_bb
, &d
);
7731 /* Loop sizes are no longer correct, fix them up. */
7732 loop
->num_nodes
-= num_nodes
;
7733 for (class loop
*outer
= loop_outer (loop
);
7734 outer
; outer
= loop_outer (outer
))
7735 outer
->num_nodes
-= num_nodes
;
7736 loop0
->num_nodes
-= bbs
.length () - num_nodes
;
7738 if (saved_cfun
->has_simduid_loops
|| saved_cfun
->has_force_vectorize_loops
)
7741 for (i
= 0; vec_safe_iterate (loops
->larray
, i
, &aloop
); i
++)
7746 replace_by_duplicate_decl (&aloop
->simduid
, d
.vars_map
,
7748 dest_cfun
->has_simduid_loops
= true;
7750 if (aloop
->force_vectorize
)
7751 dest_cfun
->has_force_vectorize_loops
= true;
7755 /* Rewire BLOCK_SUBBLOCKS of orig_block. */
7759 gcc_assert (BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
7761 BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
7762 = BLOCK_SUBBLOCKS (orig_block
);
7763 for (block
= BLOCK_SUBBLOCKS (orig_block
);
7764 block
; block
= BLOCK_CHAIN (block
))
7765 BLOCK_SUPERCONTEXT (block
) = DECL_INITIAL (dest_cfun
->decl
);
7766 BLOCK_SUBBLOCKS (orig_block
) = NULL_TREE
;
7769 replace_block_vars_by_duplicates (DECL_INITIAL (dest_cfun
->decl
),
7770 &vars_map
, dest_cfun
->decl
);
7773 htab_delete (new_label_map
);
7777 if (gimple_in_ssa_p (cfun
))
7779 /* We need to release ssa-names in a defined order, so first find them,
7780 and then iterate in ascending version order. */
7781 bitmap release_names
= BITMAP_ALLOC (NULL
);
7782 vars_map
.traverse
<void *, gather_ssa_name_hash_map_from
> (release_names
);
7785 EXECUTE_IF_SET_IN_BITMAP (release_names
, 0, i
, bi
)
7786 release_ssa_name (ssa_name (i
));
7787 BITMAP_FREE (release_names
);
7790 /* Rewire the entry and exit blocks. The successor to the entry
7791 block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
7792 the child function. Similarly, the predecessor of DEST_FN's
7793 EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR. We
7794 need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
7795 various CFG manipulation function get to the right CFG.
7797 FIXME, this is silly. The CFG ought to become a parameter to
7799 push_cfun (dest_cfun
);
7800 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= entry_bb
->count
;
7801 make_single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
), entry_bb
, EDGE_FALLTHRU
);
7804 make_single_succ_edge (exit_bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
7805 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
= exit_bb
->count
;
7808 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
= profile_count::zero ();
7811 /* Back in the original function, the SESE region has disappeared,
7812 create a new basic block in its place. */
7813 bb
= create_empty_bb (entry_pred
[0]);
7815 add_bb_to_loop (bb
, loop
);
7816 for (i
= 0; i
< num_entry_edges
; i
++)
7818 e
= make_edge (entry_pred
[i
], bb
, entry_flag
[i
]);
7819 e
->probability
= entry_prob
[i
];
7822 for (i
= 0; i
< num_exit_edges
; i
++)
7824 e
= make_edge (bb
, exit_succ
[i
], exit_flag
[i
]);
7825 e
->probability
= exit_prob
[i
];
7828 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom_entry
);
7829 FOR_EACH_VEC_ELT (dom_bbs
, i
, abb
)
7830 set_immediate_dominator (CDI_DOMINATORS
, abb
, bb
);
7847 /* Dump default def DEF to file FILE using FLAGS and indentation
7851 dump_default_def (FILE *file
, tree def
, int spc
, dump_flags_t flags
)
7853 for (int i
= 0; i
< spc
; ++i
)
7854 fprintf (file
, " ");
7855 dump_ssaname_info_to_file (file
, def
, spc
);
7857 print_generic_expr (file
, TREE_TYPE (def
), flags
);
7858 fprintf (file
, " ");
7859 print_generic_expr (file
, def
, flags
);
7860 fprintf (file
, " = ");
7861 print_generic_expr (file
, SSA_NAME_VAR (def
), flags
);
7862 fprintf (file
, ";\n");
7865 /* Print no_sanitize attribute to FILE for a given attribute VALUE. */
7868 print_no_sanitize_attr_value (FILE *file
, tree value
)
7870 unsigned int flags
= tree_to_uhwi (value
);
7872 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
7874 if ((sanitizer_opts
[i
].flag
& flags
) == sanitizer_opts
[i
].flag
)
7877 fprintf (file
, " | ");
7878 fprintf (file
, "%s", sanitizer_opts
[i
].name
);
7884 /* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in dumpfile.h)
7888 dump_function_to_file (tree fndecl
, FILE *file
, dump_flags_t flags
)
7890 tree arg
, var
, old_current_fndecl
= current_function_decl
;
7891 struct function
*dsf
;
7892 bool ignore_topmost_bind
= false, any_var
= false;
7895 bool tmclone
= (TREE_CODE (fndecl
) == FUNCTION_DECL
7896 && decl_is_tm_clone (fndecl
));
7897 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
7899 if (DECL_ATTRIBUTES (fndecl
) != NULL_TREE
)
7901 fprintf (file
, "__attribute__((");
7905 for (chain
= DECL_ATTRIBUTES (fndecl
); chain
;
7906 first
= false, chain
= TREE_CHAIN (chain
))
7909 fprintf (file
, ", ");
7911 tree name
= get_attribute_name (chain
);
7912 print_generic_expr (file
, name
, dump_flags
);
7913 if (TREE_VALUE (chain
) != NULL_TREE
)
7915 fprintf (file
, " (");
7917 if (strstr (IDENTIFIER_POINTER (name
), "no_sanitize"))
7918 print_no_sanitize_attr_value (file
, TREE_VALUE (chain
));
7920 print_generic_expr (file
, TREE_VALUE (chain
), dump_flags
);
7921 fprintf (file
, ")");
7925 fprintf (file
, "))\n");
7928 current_function_decl
= fndecl
;
7929 if (flags
& TDF_GIMPLE
)
7931 static bool hotness_bb_param_printed
= false;
7932 if (profile_info
!= NULL
7933 && !hotness_bb_param_printed
)
7935 hotness_bb_param_printed
= true;
7937 "/* --param=gimple-fe-computed-hot-bb-threshold=%" PRId64
7938 " */\n", get_hot_bb_threshold ());
7941 print_generic_expr (file
, TREE_TYPE (TREE_TYPE (fndecl
)),
7942 dump_flags
| TDF_SLIM
);
7943 fprintf (file
, " __GIMPLE (%s",
7944 (fun
->curr_properties
& PROP_ssa
) ? "ssa"
7945 : (fun
->curr_properties
& PROP_cfg
) ? "cfg"
7950 basic_block bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
7951 if (bb
->count
.initialized_p ())
7952 fprintf (file
, ",%s(%d)",
7953 profile_quality_as_string (bb
->count
.quality ()),
7954 bb
->count
.value ());
7955 fprintf (file
, ")\n%s (", function_name (fun
));
7959 fprintf (file
, "%s %s(", function_name (fun
), tmclone
? "[tm-clone] " : "");
7961 arg
= DECL_ARGUMENTS (fndecl
);
7964 print_generic_expr (file
, TREE_TYPE (arg
), dump_flags
);
7965 fprintf (file
, " ");
7966 print_generic_expr (file
, arg
, dump_flags
);
7967 if (DECL_CHAIN (arg
))
7968 fprintf (file
, ", ");
7969 arg
= DECL_CHAIN (arg
);
7971 fprintf (file
, ")\n");
7973 dsf
= DECL_STRUCT_FUNCTION (fndecl
);
7974 if (dsf
&& (flags
& TDF_EH
))
7975 dump_eh_tree (file
, dsf
);
7977 if (flags
& TDF_RAW
&& !gimple_has_body_p (fndecl
))
7979 dump_node (fndecl
, TDF_SLIM
| flags
, file
);
7980 current_function_decl
= old_current_fndecl
;
7984 /* When GIMPLE is lowered, the variables are no longer available in
7985 BIND_EXPRs, so display them separately. */
7986 if (fun
&& fun
->decl
== fndecl
&& (fun
->curr_properties
& PROP_gimple_lcf
))
7989 ignore_topmost_bind
= true;
7991 fprintf (file
, "{\n");
7992 if (gimple_in_ssa_p (fun
)
7993 && (flags
& TDF_ALIAS
))
7995 for (arg
= DECL_ARGUMENTS (fndecl
); arg
!= NULL
;
7996 arg
= DECL_CHAIN (arg
))
7998 tree def
= ssa_default_def (fun
, arg
);
8000 dump_default_def (file
, def
, 2, flags
);
8003 tree res
= DECL_RESULT (fun
->decl
);
8004 if (res
!= NULL_TREE
8005 && DECL_BY_REFERENCE (res
))
8007 tree def
= ssa_default_def (fun
, res
);
8009 dump_default_def (file
, def
, 2, flags
);
8012 tree static_chain
= fun
->static_chain_decl
;
8013 if (static_chain
!= NULL_TREE
)
8015 tree def
= ssa_default_def (fun
, static_chain
);
8017 dump_default_def (file
, def
, 2, flags
);
8021 if (!vec_safe_is_empty (fun
->local_decls
))
8022 FOR_EACH_LOCAL_DECL (fun
, ix
, var
)
8024 print_generic_decl (file
, var
, flags
);
8025 fprintf (file
, "\n");
8032 if (gimple_in_ssa_p (cfun
))
8033 FOR_EACH_SSA_NAME (ix
, name
, cfun
)
8035 if (!SSA_NAME_VAR (name
))
8037 fprintf (file
, " ");
8038 print_generic_expr (file
, TREE_TYPE (name
), flags
);
8039 fprintf (file
, " ");
8040 print_generic_expr (file
, name
, flags
);
8041 fprintf (file
, ";\n");
8048 if (fun
&& fun
->decl
== fndecl
8050 && basic_block_info_for_fn (fun
))
8052 /* If the CFG has been built, emit a CFG-based dump. */
8053 if (!ignore_topmost_bind
)
8054 fprintf (file
, "{\n");
8056 if (any_var
&& n_basic_blocks_for_fn (fun
))
8057 fprintf (file
, "\n");
8059 FOR_EACH_BB_FN (bb
, fun
)
8060 dump_bb (file
, bb
, 2, flags
);
8062 fprintf (file
, "}\n");
8064 else if (fun
->curr_properties
& PROP_gimple_any
)
8066 /* The function is now in GIMPLE form but the CFG has not been
8067 built yet. Emit the single sequence of GIMPLE statements
8068 that make up its body. */
8069 gimple_seq body
= gimple_body (fndecl
);
8071 if (gimple_seq_first_stmt (body
)
8072 && gimple_seq_first_stmt (body
) == gimple_seq_last_stmt (body
)
8073 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
)
8074 print_gimple_seq (file
, body
, 0, flags
);
8077 if (!ignore_topmost_bind
)
8078 fprintf (file
, "{\n");
8081 fprintf (file
, "\n");
8083 print_gimple_seq (file
, body
, 2, flags
);
8084 fprintf (file
, "}\n");
8091 /* Make a tree based dump. */
8092 chain
= DECL_SAVED_TREE (fndecl
);
8093 if (chain
&& TREE_CODE (chain
) == BIND_EXPR
)
8095 if (ignore_topmost_bind
)
8097 chain
= BIND_EXPR_BODY (chain
);
8105 if (!ignore_topmost_bind
)
8107 fprintf (file
, "{\n");
8108 /* No topmost bind, pretend it's ignored for later. */
8109 ignore_topmost_bind
= true;
8115 fprintf (file
, "\n");
8117 print_generic_stmt_indented (file
, chain
, flags
, indent
);
8118 if (ignore_topmost_bind
)
8119 fprintf (file
, "}\n");
8122 if (flags
& TDF_ENUMERATE_LOCALS
)
8123 dump_enumerated_decls (file
, flags
);
8124 fprintf (file
, "\n\n");
8126 current_function_decl
= old_current_fndecl
;
8129 /* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h) */
8132 debug_function (tree fn
, dump_flags_t flags
)
8134 dump_function_to_file (fn
, stderr
, flags
);
8138 /* Print on FILE the indexes for the predecessors of basic_block BB. */
8141 print_pred_bbs (FILE *file
, basic_block bb
)
8146 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
8147 fprintf (file
, "bb_%d ", e
->src
->index
);
8151 /* Print on FILE the indexes for the successors of basic_block BB. */
8154 print_succ_bbs (FILE *file
, basic_block bb
)
8159 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8160 fprintf (file
, "bb_%d ", e
->dest
->index
);
8163 /* Print to FILE the basic block BB following the VERBOSITY level. */
8166 print_loops_bb (FILE *file
, basic_block bb
, int indent
, int verbosity
)
8168 char *s_indent
= (char *) alloca ((size_t) indent
+ 1);
8169 memset ((void *) s_indent
, ' ', (size_t) indent
);
8170 s_indent
[indent
] = '\0';
8172 /* Print basic_block's header. */
8175 fprintf (file
, "%s bb_%d (preds = {", s_indent
, bb
->index
);
8176 print_pred_bbs (file
, bb
);
8177 fprintf (file
, "}, succs = {");
8178 print_succ_bbs (file
, bb
);
8179 fprintf (file
, "})\n");
8182 /* Print basic_block's body. */
8185 fprintf (file
, "%s {\n", s_indent
);
8186 dump_bb (file
, bb
, indent
+ 4, TDF_VOPS
|TDF_MEMSYMS
);
8187 fprintf (file
, "%s }\n", s_indent
);
8191 static void print_loop_and_siblings (FILE *, class loop
*, int, int);
8193 /* Pretty print LOOP on FILE, indented INDENT spaces. Following
8194 VERBOSITY level this outputs the contents of the loop, or just its
8198 print_loop (FILE *file
, class loop
*loop
, int indent
, int verbosity
)
8206 s_indent
= (char *) alloca ((size_t) indent
+ 1);
8207 memset ((void *) s_indent
, ' ', (size_t) indent
);
8208 s_indent
[indent
] = '\0';
8210 /* Print loop's header. */
8211 fprintf (file
, "%sloop_%d (", s_indent
, loop
->num
);
8213 fprintf (file
, "header = %d", loop
->header
->index
);
8216 fprintf (file
, "deleted)\n");
8220 fprintf (file
, ", latch = %d", loop
->latch
->index
);
8222 fprintf (file
, ", multiple latches");
8223 fprintf (file
, ", niter = ");
8224 print_generic_expr (file
, loop
->nb_iterations
);
8226 if (loop
->any_upper_bound
)
8228 fprintf (file
, ", upper_bound = ");
8229 print_decu (loop
->nb_iterations_upper_bound
, file
);
8231 if (loop
->any_likely_upper_bound
)
8233 fprintf (file
, ", likely_upper_bound = ");
8234 print_decu (loop
->nb_iterations_likely_upper_bound
, file
);
8237 if (loop
->any_estimate
)
8239 fprintf (file
, ", estimate = ");
8240 print_decu (loop
->nb_iterations_estimate
, file
);
8243 fprintf (file
, ", unroll = %d", loop
->unroll
);
8244 fprintf (file
, ")\n");
8246 /* Print loop's body. */
8249 fprintf (file
, "%s{\n", s_indent
);
8250 FOR_EACH_BB_FN (bb
, cfun
)
8251 if (bb
->loop_father
== loop
)
8252 print_loops_bb (file
, bb
, indent
, verbosity
);
8254 print_loop_and_siblings (file
, loop
->inner
, indent
+ 2, verbosity
);
8255 fprintf (file
, "%s}\n", s_indent
);
8259 /* Print the LOOP and its sibling loops on FILE, indented INDENT
8260 spaces. Following VERBOSITY level this outputs the contents of the
8261 loop, or just its structure. */
8264 print_loop_and_siblings (FILE *file
, class loop
*loop
, int indent
,
8270 print_loop (file
, loop
, indent
, verbosity
);
8271 print_loop_and_siblings (file
, loop
->next
, indent
, verbosity
);
8274 /* Follow a CFG edge from the entry point of the program, and on entry
8275 of a loop, pretty print the loop structure on FILE. */
8278 print_loops (FILE *file
, int verbosity
)
8282 bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
8283 fprintf (file
, "\nLoops in function: %s\n", current_function_name ());
8284 if (bb
&& bb
->loop_father
)
8285 print_loop_and_siblings (file
, bb
->loop_father
, 0, verbosity
);
8291 debug (class loop
&ref
)
8293 print_loop (stderr
, &ref
, 0, /*verbosity*/0);
8297 debug (class loop
*ptr
)
8302 fprintf (stderr
, "<nil>\n");
8305 /* Dump a loop verbosely. */
8308 debug_verbose (class loop
&ref
)
8310 print_loop (stderr
, &ref
, 0, /*verbosity*/3);
8314 debug_verbose (class loop
*ptr
)
8319 fprintf (stderr
, "<nil>\n");
8323 /* Debugging loops structure at tree level, at some VERBOSITY level. */
8326 debug_loops (int verbosity
)
8328 print_loops (stderr
, verbosity
);
8331 /* Print on stderr the code of LOOP, at some VERBOSITY level. */
8334 debug_loop (class loop
*loop
, int verbosity
)
8336 print_loop (stderr
, loop
, 0, verbosity
);
8339 /* Print on stderr the code of loop number NUM, at some VERBOSITY
8343 debug_loop_num (unsigned num
, int verbosity
)
8345 debug_loop (get_loop (cfun
, num
), verbosity
);
8348 /* Return true if BB ends with a call, possibly followed by some
8349 instructions that must stay with the call. Return false,
8353 gimple_block_ends_with_call_p (basic_block bb
)
8355 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
8356 return !gsi_end_p (gsi
) && is_gimple_call (gsi_stmt (gsi
));
8360 /* Return true if BB ends with a conditional branch. Return false,
8364 gimple_block_ends_with_condjump_p (const_basic_block bb
)
8366 gimple
*stmt
= last_stmt (CONST_CAST_BB (bb
));
8367 return (stmt
&& gimple_code (stmt
) == GIMPLE_COND
);
8371 /* Return true if statement T may terminate execution of BB in ways not
8372 explicitly represtented in the CFG. */
8375 stmt_can_terminate_bb_p (gimple
*t
)
8377 tree fndecl
= NULL_TREE
;
8380 /* Eh exception not handled internally terminates execution of the whole
8382 if (stmt_can_throw_external (cfun
, t
))
8385 /* NORETURN and LONGJMP calls already have an edge to exit.
8386 CONST and PURE calls do not need one.
8387 We don't currently check for CONST and PURE here, although
8388 it would be a good idea, because those attributes are
8389 figured out from the RTL in mark_constant_function, and
8390 the counter incrementation code from -fprofile-arcs
8391 leads to different results from -fbranch-probabilities. */
8392 if (is_gimple_call (t
))
8394 fndecl
= gimple_call_fndecl (t
);
8395 call_flags
= gimple_call_flags (t
);
8398 if (is_gimple_call (t
)
8400 && fndecl_built_in_p (fndecl
)
8401 && (call_flags
& ECF_NOTHROW
)
8402 && !(call_flags
& ECF_RETURNS_TWICE
)
8403 /* fork() doesn't really return twice, but the effect of
8404 wrapping it in __gcov_fork() which calls __gcov_flush()
8405 and clears the counters before forking has the same
8406 effect as returning twice. Force a fake edge. */
8407 && !fndecl_built_in_p (fndecl
, BUILT_IN_FORK
))
8410 if (is_gimple_call (t
))
8416 if (call_flags
& (ECF_PURE
| ECF_CONST
)
8417 && !(call_flags
& ECF_LOOPING_CONST_OR_PURE
))
8420 /* Function call may do longjmp, terminate program or do other things.
8421 Special case noreturn that have non-abnormal edges out as in this case
8422 the fact is sufficiently represented by lack of edges out of T. */
8423 if (!(call_flags
& ECF_NORETURN
))
8427 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8428 if ((e
->flags
& EDGE_FAKE
) == 0)
8432 if (gasm
*asm_stmt
= dyn_cast
<gasm
*> (t
))
8433 if (gimple_asm_volatile_p (asm_stmt
) || gimple_asm_input_p (asm_stmt
))
8440 /* Add fake edges to the function exit for any non constant and non
8441 noreturn calls (or noreturn calls with EH/abnormal edges),
8442 volatile inline assembly in the bitmap of blocks specified by BLOCKS
8443 or to the whole CFG if BLOCKS is zero. Return the number of blocks
8446 The goal is to expose cases in which entering a basic block does
8447 not imply that all subsequent instructions must be executed. */
8450 gimple_flow_call_edges_add (sbitmap blocks
)
8453 int blocks_split
= 0;
8454 int last_bb
= last_basic_block_for_fn (cfun
);
8455 bool check_last_block
= false;
8457 if (n_basic_blocks_for_fn (cfun
) == NUM_FIXED_BLOCKS
)
8461 check_last_block
= true;
8463 check_last_block
= bitmap_bit_p (blocks
,
8464 EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
->index
);
8466 /* In the last basic block, before epilogue generation, there will be
8467 a fallthru edge to EXIT. Special care is required if the last insn
8468 of the last basic block is a call because make_edge folds duplicate
8469 edges, which would result in the fallthru edge also being marked
8470 fake, which would result in the fallthru edge being removed by
8471 remove_fake_edges, which would result in an invalid CFG.
8473 Moreover, we can't elide the outgoing fake edge, since the block
8474 profiler needs to take this into account in order to solve the minimal
8475 spanning tree in the case that the call doesn't return.
8477 Handle this by adding a dummy instruction in a new last basic block. */
8478 if (check_last_block
)
8480 basic_block bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
8481 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
8484 if (!gsi_end_p (gsi
))
8487 if (t
&& stmt_can_terminate_bb_p (t
))
8491 e
= find_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
8494 gsi_insert_on_edge (e
, gimple_build_nop ());
8495 gsi_commit_edge_inserts ();
8500 /* Now add fake edges to the function exit for any non constant
8501 calls since there is no way that we can determine if they will
8503 for (i
= 0; i
< last_bb
; i
++)
8505 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8506 gimple_stmt_iterator gsi
;
8507 gimple
*stmt
, *last_stmt
;
8512 if (blocks
&& !bitmap_bit_p (blocks
, i
))
8515 gsi
= gsi_last_nondebug_bb (bb
);
8516 if (!gsi_end_p (gsi
))
8518 last_stmt
= gsi_stmt (gsi
);
8521 stmt
= gsi_stmt (gsi
);
8522 if (stmt_can_terminate_bb_p (stmt
))
8526 /* The handling above of the final block before the
8527 epilogue should be enough to verify that there is
8528 no edge to the exit block in CFG already.
8529 Calling make_edge in such case would cause us to
8530 mark that edge as fake and remove it later. */
8531 if (flag_checking
&& stmt
== last_stmt
)
8533 e
= find_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
8534 gcc_assert (e
== NULL
);
8537 /* Note that the following may create a new basic block
8538 and renumber the existing basic blocks. */
8539 if (stmt
!= last_stmt
)
8541 e
= split_block (bb
, stmt
);
8545 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FAKE
);
8546 e
->probability
= profile_probability::guessed_never ();
8550 while (!gsi_end_p (gsi
));
8555 checking_verify_flow_info ();
8557 return blocks_split
;
8560 /* Removes edge E and all the blocks dominated by it, and updates dominance
8561 information. The IL in E->src needs to be updated separately.
8562 If dominance info is not available, only the edge E is removed.*/
8565 remove_edge_and_dominated_blocks (edge e
)
8567 vec
<basic_block
> bbs_to_remove
= vNULL
;
8568 vec
<basic_block
> bbs_to_fix_dom
= vNULL
;
8571 bool none_removed
= false;
8573 basic_block bb
, dbb
;
8576 /* If we are removing a path inside a non-root loop that may change
8577 loop ownership of blocks or remove loops. Mark loops for fixup. */
8579 && loop_outer (e
->src
->loop_father
) != NULL
8580 && e
->src
->loop_father
== e
->dest
->loop_father
)
8581 loops_state_set (LOOPS_NEED_FIXUP
);
8583 if (!dom_info_available_p (CDI_DOMINATORS
))
8589 /* No updating is needed for edges to exit. */
8590 if (e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
8592 if (cfgcleanup_altered_bbs
)
8593 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
8598 /* First, we find the basic blocks to remove. If E->dest has a predecessor
8599 that is not dominated by E->dest, then this set is empty. Otherwise,
8600 all the basic blocks dominated by E->dest are removed.
8602 Also, to DF_IDOM we store the immediate dominators of the blocks in
8603 the dominance frontier of E (i.e., of the successors of the
8604 removed blocks, if there are any, and of E->dest otherwise). */
8605 FOR_EACH_EDGE (f
, ei
, e
->dest
->preds
)
8610 if (!dominated_by_p (CDI_DOMINATORS
, f
->src
, e
->dest
))
8612 none_removed
= true;
8617 auto_bitmap df
, df_idom
;
8619 bitmap_set_bit (df_idom
,
8620 get_immediate_dominator (CDI_DOMINATORS
, e
->dest
)->index
);
8623 bbs_to_remove
= get_all_dominated_blocks (CDI_DOMINATORS
, e
->dest
);
8624 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
8626 FOR_EACH_EDGE (f
, ei
, bb
->succs
)
8628 if (f
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
8629 bitmap_set_bit (df
, f
->dest
->index
);
8632 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
8633 bitmap_clear_bit (df
, bb
->index
);
8635 EXECUTE_IF_SET_IN_BITMAP (df
, 0, i
, bi
)
8637 bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8638 bitmap_set_bit (df_idom
,
8639 get_immediate_dominator (CDI_DOMINATORS
, bb
)->index
);
8643 if (cfgcleanup_altered_bbs
)
8645 /* Record the set of the altered basic blocks. */
8646 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
8647 bitmap_ior_into (cfgcleanup_altered_bbs
, df
);
8650 /* Remove E and the cancelled blocks. */
8655 /* Walk backwards so as to get a chance to substitute all
8656 released DEFs into debug stmts. See
8657 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
8659 for (i
= bbs_to_remove
.length (); i
-- > 0; )
8660 delete_basic_block (bbs_to_remove
[i
]);
8663 /* Update the dominance information. The immediate dominator may change only
8664 for blocks whose immediate dominator belongs to DF_IDOM:
8666 Suppose that idom(X) = Y before removal of E and idom(X) != Y after the
8667 removal. Let Z the arbitrary block such that idom(Z) = Y and
8668 Z dominates X after the removal. Before removal, there exists a path P
8669 from Y to X that avoids Z. Let F be the last edge on P that is
8670 removed, and let W = F->dest. Before removal, idom(W) = Y (since Y
8671 dominates W, and because of P, Z does not dominate W), and W belongs to
8672 the dominance frontier of E. Therefore, Y belongs to DF_IDOM. */
8673 EXECUTE_IF_SET_IN_BITMAP (df_idom
, 0, i
, bi
)
8675 bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8676 for (dbb
= first_dom_son (CDI_DOMINATORS
, bb
);
8678 dbb
= next_dom_son (CDI_DOMINATORS
, dbb
))
8679 bbs_to_fix_dom
.safe_push (dbb
);
8682 iterate_fix_dominators (CDI_DOMINATORS
, bbs_to_fix_dom
, true);
8684 bbs_to_remove
.release ();
8685 bbs_to_fix_dom
.release ();
8688 /* Purge dead EH edges from basic block BB. */
8691 gimple_purge_dead_eh_edges (basic_block bb
)
8693 bool changed
= false;
8696 gimple
*stmt
= last_stmt (bb
);
8698 if (stmt
&& stmt_can_throw_internal (cfun
, stmt
))
8701 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
8703 if (e
->flags
& EDGE_EH
)
8705 remove_edge_and_dominated_blocks (e
);
8715 /* Purge dead EH edges from basic block listed in BLOCKS. */
8718 gimple_purge_all_dead_eh_edges (const_bitmap blocks
)
8720 bool changed
= false;
8724 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
8726 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8728 /* Earlier gimple_purge_dead_eh_edges could have removed
8729 this basic block already. */
8730 gcc_assert (bb
|| changed
);
8732 changed
|= gimple_purge_dead_eh_edges (bb
);
8738 /* Purge dead abnormal call edges from basic block BB. */
8741 gimple_purge_dead_abnormal_call_edges (basic_block bb
)
8743 bool changed
= false;
8746 gimple
*stmt
= last_stmt (bb
);
8748 if (!cfun
->has_nonlocal_label
8749 && !cfun
->calls_setjmp
)
8752 if (stmt
&& stmt_can_make_abnormal_goto (stmt
))
8755 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
8757 if (e
->flags
& EDGE_ABNORMAL
)
8759 if (e
->flags
& EDGE_FALLTHRU
)
8760 e
->flags
&= ~EDGE_ABNORMAL
;
8762 remove_edge_and_dominated_blocks (e
);
8772 /* Purge dead abnormal call edges from basic block listed in BLOCKS. */
8775 gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks
)
8777 bool changed
= false;
8781 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
8783 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8785 /* Earlier gimple_purge_dead_abnormal_call_edges could have removed
8786 this basic block already. */
8787 gcc_assert (bb
|| changed
);
8789 changed
|= gimple_purge_dead_abnormal_call_edges (bb
);
8795 /* This function is called whenever a new edge is created or
8799 gimple_execute_on_growing_pred (edge e
)
8801 basic_block bb
= e
->dest
;
8803 if (!gimple_seq_empty_p (phi_nodes (bb
)))
8804 reserve_phi_args_for_new_edge (bb
);
8807 /* This function is called immediately before edge E is removed from
8808 the edge vector E->dest->preds. */
8811 gimple_execute_on_shrinking_pred (edge e
)
8813 if (!gimple_seq_empty_p (phi_nodes (e
->dest
)))
8814 remove_phi_args (e
);
8817 /*---------------------------------------------------------------------------
8818 Helper functions for Loop versioning
8819 ---------------------------------------------------------------------------*/
8821 /* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy
8822 of 'first'. Both of them are dominated by 'new_head' basic block. When
8823 'new_head' was created by 'second's incoming edge it received phi arguments
8824 on the edge by split_edge(). Later, additional edge 'e' was created to
8825 connect 'new_head' and 'first'. Now this routine adds phi args on this
8826 additional edge 'e' that new_head to second edge received as part of edge
8830 gimple_lv_adjust_loop_header_phi (basic_block first
, basic_block second
,
8831 basic_block new_head
, edge e
)
8834 gphi_iterator psi1
, psi2
;
8836 edge e2
= find_edge (new_head
, second
);
8838 /* Because NEW_HEAD has been created by splitting SECOND's incoming
8839 edge, we should always have an edge from NEW_HEAD to SECOND. */
8840 gcc_assert (e2
!= NULL
);
8842 /* Browse all 'second' basic block phi nodes and add phi args to
8843 edge 'e' for 'first' head. PHI args are always in correct order. */
8845 for (psi2
= gsi_start_phis (second
),
8846 psi1
= gsi_start_phis (first
);
8847 !gsi_end_p (psi2
) && !gsi_end_p (psi1
);
8848 gsi_next (&psi2
), gsi_next (&psi1
))
8852 def
= PHI_ARG_DEF (phi2
, e2
->dest_idx
);
8853 add_phi_arg (phi1
, def
, e
, gimple_phi_arg_location_from_edge (phi2
, e2
));
8858 /* Adds a if else statement to COND_BB with condition COND_EXPR.
8859 SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
8860 the destination of the ELSE part. */
8863 gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED
,
8864 basic_block second_head ATTRIBUTE_UNUSED
,
8865 basic_block cond_bb
, void *cond_e
)
8867 gimple_stmt_iterator gsi
;
8868 gimple
*new_cond_expr
;
8869 tree cond_expr
= (tree
) cond_e
;
8872 /* Build new conditional expr */
8873 new_cond_expr
= gimple_build_cond_from_tree (cond_expr
,
8874 NULL_TREE
, NULL_TREE
);
8876 /* Add new cond in cond_bb. */
8877 gsi
= gsi_last_bb (cond_bb
);
8878 gsi_insert_after (&gsi
, new_cond_expr
, GSI_NEW_STMT
);
8880 /* Adjust edges appropriately to connect new head with first head
8881 as well as second head. */
8882 e0
= single_succ_edge (cond_bb
);
8883 e0
->flags
&= ~EDGE_FALLTHRU
;
8884 e0
->flags
|= EDGE_FALSE_VALUE
;
8888 /* Do book-keeping of basic block BB for the profile consistency checker.
8889 Store the counting in RECORD. */
8891 gimple_account_profile_record (basic_block bb
,
8892 struct profile_record
*record
)
8894 gimple_stmt_iterator i
;
8895 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
8898 += estimate_num_insns (gsi_stmt (i
), &eni_size_weights
);
8899 if (bb
->count
.initialized_p ())
8901 += estimate_num_insns (gsi_stmt (i
),
8902 &eni_time_weights
) * bb
->count
.to_gcov_type ();
8903 else if (profile_status_for_fn (cfun
) == PROFILE_GUESSED
)
8905 += estimate_num_insns (gsi_stmt (i
),
8906 &eni_time_weights
) * bb
->count
.to_frequency (cfun
);
8910 struct cfg_hooks gimple_cfg_hooks
= {
8912 gimple_verify_flow_info
,
8913 gimple_dump_bb
, /* dump_bb */
8914 gimple_dump_bb_for_graph
, /* dump_bb_for_graph */
8915 create_bb
, /* create_basic_block */
8916 gimple_redirect_edge_and_branch
, /* redirect_edge_and_branch */
8917 gimple_redirect_edge_and_branch_force
, /* redirect_edge_and_branch_force */
8918 gimple_can_remove_branch_p
, /* can_remove_branch_p */
8919 remove_bb
, /* delete_basic_block */
8920 gimple_split_block
, /* split_block */
8921 gimple_move_block_after
, /* move_block_after */
8922 gimple_can_merge_blocks_p
, /* can_merge_blocks_p */
8923 gimple_merge_blocks
, /* merge_blocks */
8924 gimple_predict_edge
, /* predict_edge */
8925 gimple_predicted_by_p
, /* predicted_by_p */
8926 gimple_can_duplicate_bb_p
, /* can_duplicate_block_p */
8927 gimple_duplicate_bb
, /* duplicate_block */
8928 gimple_split_edge
, /* split_edge */
8929 gimple_make_forwarder_block
, /* make_forward_block */
8930 NULL
, /* tidy_fallthru_edge */
8931 NULL
, /* force_nonfallthru */
8932 gimple_block_ends_with_call_p
,/* block_ends_with_call_p */
8933 gimple_block_ends_with_condjump_p
, /* block_ends_with_condjump_p */
8934 gimple_flow_call_edges_add
, /* flow_call_edges_add */
8935 gimple_execute_on_growing_pred
, /* execute_on_growing_pred */
8936 gimple_execute_on_shrinking_pred
, /* execute_on_shrinking_pred */
8937 gimple_duplicate_loop_to_header_edge
, /* duplicate loop for trees */
8938 gimple_lv_add_condition_to_bb
, /* lv_add_condition_to_bb */
8939 gimple_lv_adjust_loop_header_phi
, /* lv_adjust_loop_header_phi*/
8940 extract_true_false_edges_from_block
, /* extract_cond_bb_edges */
8941 flush_pending_stmts
, /* flush_pending_stmts */
8942 gimple_empty_block_p
, /* block_empty_p */
8943 gimple_split_block_before_cond_jump
, /* split_block_before_cond_jump */
8944 gimple_account_profile_record
,
8948 /* Split all critical edges. Split some extra (not necessarily critical) edges
8949 if FOR_EDGE_INSERTION_P is true. */
8952 split_critical_edges (bool for_edge_insertion_p
/* = false */)
8958 /* split_edge can redirect edges out of SWITCH_EXPRs, which can get
8959 expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
8960 mappings around the calls to split_edge. */
8961 start_recording_case_labels ();
8962 FOR_ALL_BB_FN (bb
, cfun
)
8964 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8966 if (EDGE_CRITICAL_P (e
) && !(e
->flags
& EDGE_ABNORMAL
))
8968 /* PRE inserts statements to edges and expects that
8969 since split_critical_edges was done beforehand, committing edge
8970 insertions will not split more edges. In addition to critical
8971 edges we must split edges that have multiple successors and
8972 end by control flow statements, such as RESX.
8973 Go ahead and split them too. This matches the logic in
8974 gimple_find_edge_insert_loc. */
8975 else if (for_edge_insertion_p
8976 && (!single_pred_p (e
->dest
)
8977 || !gimple_seq_empty_p (phi_nodes (e
->dest
))
8978 || e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
8979 && e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)
8980 && !(e
->flags
& EDGE_ABNORMAL
))
8982 gimple_stmt_iterator gsi
;
8984 gsi
= gsi_last_bb (e
->src
);
8985 if (!gsi_end_p (gsi
)
8986 && stmt_ends_bb_p (gsi_stmt (gsi
))
8987 && (gimple_code (gsi_stmt (gsi
)) != GIMPLE_RETURN
8988 && !gimple_call_builtin_p (gsi_stmt (gsi
),
8994 end_recording_case_labels ();
9000 const pass_data pass_data_split_crit_edges
=
9002 GIMPLE_PASS
, /* type */
9003 "crited", /* name */
9004 OPTGROUP_NONE
, /* optinfo_flags */
9005 TV_TREE_SPLIT_EDGES
, /* tv_id */
9006 PROP_cfg
, /* properties_required */
9007 PROP_no_crit_edges
, /* properties_provided */
9008 0, /* properties_destroyed */
9009 0, /* todo_flags_start */
9010 0, /* todo_flags_finish */
9013 class pass_split_crit_edges
: public gimple_opt_pass
9016 pass_split_crit_edges (gcc::context
*ctxt
)
9017 : gimple_opt_pass (pass_data_split_crit_edges
, ctxt
)
9020 /* opt_pass methods: */
9021 virtual unsigned int execute (function
*) { return split_critical_edges (); }
9023 opt_pass
* clone () { return new pass_split_crit_edges (m_ctxt
); }
9024 }; // class pass_split_crit_edges
9029 make_pass_split_crit_edges (gcc::context
*ctxt
)
9031 return new pass_split_crit_edges (ctxt
);
9035 /* Insert COND expression which is GIMPLE_COND after STMT
9036 in basic block BB with appropriate basic block split
9037 and creation of a new conditionally executed basic block.
9038 Update profile so the new bb is visited with probability PROB.
9039 Return created basic block. */
9041 insert_cond_bb (basic_block bb
, gimple
*stmt
, gimple
*cond
,
9042 profile_probability prob
)
9044 edge fall
= split_block (bb
, stmt
);
9045 gimple_stmt_iterator iter
= gsi_last_bb (bb
);
9048 /* Insert cond statement. */
9049 gcc_assert (gimple_code (cond
) == GIMPLE_COND
);
9050 if (gsi_end_p (iter
))
9051 gsi_insert_before (&iter
, cond
, GSI_CONTINUE_LINKING
);
9053 gsi_insert_after (&iter
, cond
, GSI_CONTINUE_LINKING
);
9055 /* Create conditionally executed block. */
9056 new_bb
= create_empty_bb (bb
);
9057 edge e
= make_edge (bb
, new_bb
, EDGE_TRUE_VALUE
);
9058 e
->probability
= prob
;
9059 new_bb
->count
= e
->count ();
9060 make_single_succ_edge (new_bb
, fall
->dest
, EDGE_FALLTHRU
);
9062 /* Fix edge for split bb. */
9063 fall
->flags
= EDGE_FALSE_VALUE
;
9064 fall
->probability
-= e
->probability
;
9066 /* Update dominance info. */
9067 if (dom_info_available_p (CDI_DOMINATORS
))
9069 set_immediate_dominator (CDI_DOMINATORS
, new_bb
, bb
);
9070 set_immediate_dominator (CDI_DOMINATORS
, fall
->dest
, bb
);
9073 /* Update loop info. */
9075 add_bb_to_loop (new_bb
, bb
->loop_father
);
9080 /* Build a ternary operation and gimplify it. Emit code before GSI.
9081 Return the gimple_val holding the result. */
9084 gimplify_build3 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
9085 tree type
, tree a
, tree b
, tree c
)
9088 location_t loc
= gimple_location (gsi_stmt (*gsi
));
9090 ret
= fold_build3_loc (loc
, code
, type
, a
, b
, c
);
9091 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
9095 /* Build a binary operation and gimplify it. Emit code before GSI.
9096 Return the gimple_val holding the result. */
9099 gimplify_build2 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
9100 tree type
, tree a
, tree b
)
9104 ret
= fold_build2_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
, b
);
9105 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
9109 /* Build a unary operation and gimplify it. Emit code before GSI.
9110 Return the gimple_val holding the result. */
9113 gimplify_build1 (gimple_stmt_iterator
*gsi
, enum tree_code code
, tree type
,
9118 ret
= fold_build1_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
);
9119 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
9125 /* Given a basic block B which ends with a conditional and has
9126 precisely two successors, determine which of the edges is taken if
9127 the conditional is true and which is taken if the conditional is
9128 false. Set TRUE_EDGE and FALSE_EDGE appropriately. */
9131 extract_true_false_edges_from_block (basic_block b
,
9135 edge e
= EDGE_SUCC (b
, 0);
9137 if (e
->flags
& EDGE_TRUE_VALUE
)
9140 *false_edge
= EDGE_SUCC (b
, 1);
9145 *true_edge
= EDGE_SUCC (b
, 1);
9150 /* From a controlling predicate in the immediate dominator DOM of
9151 PHIBLOCK determine the edges into PHIBLOCK that are chosen if the
9152 predicate evaluates to true and false and store them to
9153 *TRUE_CONTROLLED_EDGE and *FALSE_CONTROLLED_EDGE if
9154 they are non-NULL. Returns true if the edges can be determined,
9155 else return false. */
9158 extract_true_false_controlled_edges (basic_block dom
, basic_block phiblock
,
9159 edge
*true_controlled_edge
,
9160 edge
*false_controlled_edge
)
9162 basic_block bb
= phiblock
;
9163 edge true_edge
, false_edge
, tem
;
9164 edge e0
= NULL
, e1
= NULL
;
9166 /* We have to verify that one edge into the PHI node is dominated
9167 by the true edge of the predicate block and the other edge
9168 dominated by the false edge. This ensures that the PHI argument
9169 we are going to take is completely determined by the path we
9170 take from the predicate block.
9171 We can only use BB dominance checks below if the destination of
9172 the true/false edges are dominated by their edge, thus only
9173 have a single predecessor. */
9174 extract_true_false_edges_from_block (dom
, &true_edge
, &false_edge
);
9175 tem
= EDGE_PRED (bb
, 0);
9176 if (tem
== true_edge
9177 || (single_pred_p (true_edge
->dest
)
9178 && (tem
->src
== true_edge
->dest
9179 || dominated_by_p (CDI_DOMINATORS
,
9180 tem
->src
, true_edge
->dest
))))
9182 else if (tem
== false_edge
9183 || (single_pred_p (false_edge
->dest
)
9184 && (tem
->src
== false_edge
->dest
9185 || dominated_by_p (CDI_DOMINATORS
,
9186 tem
->src
, false_edge
->dest
))))
9190 tem
= EDGE_PRED (bb
, 1);
9191 if (tem
== true_edge
9192 || (single_pred_p (true_edge
->dest
)
9193 && (tem
->src
== true_edge
->dest
9194 || dominated_by_p (CDI_DOMINATORS
,
9195 tem
->src
, true_edge
->dest
))))
9197 else if (tem
== false_edge
9198 || (single_pred_p (false_edge
->dest
)
9199 && (tem
->src
== false_edge
->dest
9200 || dominated_by_p (CDI_DOMINATORS
,
9201 tem
->src
, false_edge
->dest
))))
9208 if (true_controlled_edge
)
9209 *true_controlled_edge
= e0
;
9210 if (false_controlled_edge
)
9211 *false_controlled_edge
= e1
;
9216 /* Generate a range test LHS CODE RHS that determines whether INDEX is in the
9217 range [low, high]. Place associated stmts before *GSI. */
9220 generate_range_test (basic_block bb
, tree index
, tree low
, tree high
,
9221 tree
*lhs
, tree
*rhs
)
9223 tree type
= TREE_TYPE (index
);
9224 tree utype
= range_check_type (type
);
9226 low
= fold_convert (utype
, low
);
9227 high
= fold_convert (utype
, high
);
9229 gimple_seq seq
= NULL
;
9230 index
= gimple_convert (&seq
, utype
, index
);
9231 *lhs
= gimple_build (&seq
, MINUS_EXPR
, utype
, index
, low
);
9232 *rhs
= const_binop (MINUS_EXPR
, utype
, high
, low
);
9234 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
9235 gsi_insert_seq_before (&gsi
, seq
, GSI_SAME_STMT
);
9238 /* Return the basic block that belongs to label numbered INDEX
9239 of a switch statement. */
9242 gimple_switch_label_bb (function
*ifun
, gswitch
*gs
, unsigned index
)
9244 return label_to_block (ifun
, CASE_LABEL (gimple_switch_label (gs
, index
)));
9247 /* Return the default basic block of a switch statement. */
9250 gimple_switch_default_bb (function
*ifun
, gswitch
*gs
)
9252 return gimple_switch_label_bb (ifun
, gs
, 0);
9255 /* Return the edge that belongs to label numbered INDEX
9256 of a switch statement. */
9259 gimple_switch_edge (function
*ifun
, gswitch
*gs
, unsigned index
)
9261 return find_edge (gimple_bb (gs
), gimple_switch_label_bb (ifun
, gs
, index
));
9264 /* Return the default edge of a switch statement. */
9267 gimple_switch_default_edge (function
*ifun
, gswitch
*gs
)
9269 return gimple_switch_edge (ifun
, gs
, 0);
9273 /* Emit return warnings. */
9277 const pass_data pass_data_warn_function_return
=
9279 GIMPLE_PASS
, /* type */
9280 "*warn_function_return", /* name */
9281 OPTGROUP_NONE
, /* optinfo_flags */
9282 TV_NONE
, /* tv_id */
9283 PROP_cfg
, /* properties_required */
9284 0, /* properties_provided */
9285 0, /* properties_destroyed */
9286 0, /* todo_flags_start */
9287 0, /* todo_flags_finish */
9290 class pass_warn_function_return
: public gimple_opt_pass
9293 pass_warn_function_return (gcc::context
*ctxt
)
9294 : gimple_opt_pass (pass_data_warn_function_return
, ctxt
)
9297 /* opt_pass methods: */
9298 virtual unsigned int execute (function
*);
9300 }; // class pass_warn_function_return
9303 pass_warn_function_return::execute (function
*fun
)
9305 location_t location
;
9310 if (!targetm
.warn_func_return (fun
->decl
))
9313 /* If we have a path to EXIT, then we do return. */
9314 if (TREE_THIS_VOLATILE (fun
->decl
)
9315 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) > 0)
9317 location
= UNKNOWN_LOCATION
;
9318 for (ei
= ei_start (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
);
9319 (e
= ei_safe_edge (ei
)); )
9321 last
= last_stmt (e
->src
);
9322 if ((gimple_code (last
) == GIMPLE_RETURN
9323 || gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
9324 && location
== UNKNOWN_LOCATION
9325 && ((location
= LOCATION_LOCUS (gimple_location (last
)))
9326 != UNKNOWN_LOCATION
)
9329 /* When optimizing, replace return stmts in noreturn functions
9330 with __builtin_unreachable () call. */
9331 if (optimize
&& gimple_code (last
) == GIMPLE_RETURN
)
9333 tree fndecl
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
9334 gimple
*new_stmt
= gimple_build_call (fndecl
, 0);
9335 gimple_set_location (new_stmt
, gimple_location (last
));
9336 gimple_stmt_iterator gsi
= gsi_for_stmt (last
);
9337 gsi_replace (&gsi
, new_stmt
, true);
9343 if (location
== UNKNOWN_LOCATION
)
9344 location
= cfun
->function_end_locus
;
9345 warning_at (location
, 0, "%<noreturn%> function does return");
9348 /* If we see "return;" in some basic block, then we do reach the end
9349 without returning a value. */
9350 else if (warn_return_type
> 0
9351 && !TREE_NO_WARNING (fun
->decl
)
9352 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fun
->decl
))))
9354 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
)
9356 gimple
*last
= last_stmt (e
->src
);
9357 greturn
*return_stmt
= dyn_cast
<greturn
*> (last
);
9359 && gimple_return_retval (return_stmt
) == NULL
9360 && !gimple_no_warning_p (last
))
9362 location
= gimple_location (last
);
9363 if (LOCATION_LOCUS (location
) == UNKNOWN_LOCATION
)
9364 location
= fun
->function_end_locus
;
9365 if (warning_at (location
, OPT_Wreturn_type
,
9366 "control reaches end of non-void function"))
9367 TREE_NO_WARNING (fun
->decl
) = 1;
9371 /* The C++ FE turns fallthrough from the end of non-void function
9372 into __builtin_unreachable () call with BUILTINS_LOCATION.
9373 Recognize those too. */
9375 if (!TREE_NO_WARNING (fun
->decl
))
9376 FOR_EACH_BB_FN (bb
, fun
)
9377 if (EDGE_COUNT (bb
->succs
) == 0)
9379 gimple
*last
= last_stmt (bb
);
9380 const enum built_in_function ubsan_missing_ret
9381 = BUILT_IN_UBSAN_HANDLE_MISSING_RETURN
;
9383 && ((LOCATION_LOCUS (gimple_location (last
))
9384 == BUILTINS_LOCATION
9385 && gimple_call_builtin_p (last
, BUILT_IN_UNREACHABLE
))
9386 || gimple_call_builtin_p (last
, ubsan_missing_ret
)))
9388 gimple_stmt_iterator gsi
= gsi_for_stmt (last
);
9389 gsi_prev_nondebug (&gsi
);
9390 gimple
*prev
= gsi_stmt (gsi
);
9392 location
= UNKNOWN_LOCATION
;
9394 location
= gimple_location (prev
);
9395 if (LOCATION_LOCUS (location
) == UNKNOWN_LOCATION
)
9396 location
= fun
->function_end_locus
;
9397 if (warning_at (location
, OPT_Wreturn_type
,
9398 "control reaches end of non-void function"))
9399 TREE_NO_WARNING (fun
->decl
) = 1;
9410 make_pass_warn_function_return (gcc::context
*ctxt
)
9412 return new pass_warn_function_return (ctxt
);
9415 /* Walk a gimplified function and warn for functions whose return value is
9416 ignored and attribute((warn_unused_result)) is set. This is done before
9417 inlining, so we don't have to worry about that. */
9420 do_warn_unused_result (gimple_seq seq
)
9423 gimple_stmt_iterator i
;
9425 for (i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
9427 gimple
*g
= gsi_stmt (i
);
9429 switch (gimple_code (g
))
9432 do_warn_unused_result (gimple_bind_body (as_a
<gbind
*>(g
)));
9435 do_warn_unused_result (gimple_try_eval (g
));
9436 do_warn_unused_result (gimple_try_cleanup (g
));
9439 do_warn_unused_result (gimple_catch_handler (
9440 as_a
<gcatch
*> (g
)));
9442 case GIMPLE_EH_FILTER
:
9443 do_warn_unused_result (gimple_eh_filter_failure (g
));
9447 if (gimple_call_lhs (g
))
9449 if (gimple_call_internal_p (g
))
9452 /* This is a naked call, as opposed to a GIMPLE_CALL with an
9453 LHS. All calls whose value is ignored should be
9454 represented like this. Look for the attribute. */
9455 fdecl
= gimple_call_fndecl (g
);
9456 ftype
= gimple_call_fntype (g
);
9458 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
9460 location_t loc
= gimple_location (g
);
9463 warning_at (loc
, OPT_Wunused_result
,
9464 "ignoring return value of %qD "
9465 "declared with attribute %<warn_unused_result%>",
9468 warning_at (loc
, OPT_Wunused_result
,
9469 "ignoring return value of function "
9470 "declared with attribute %<warn_unused_result%>");
9475 /* Not a container, not a call, or a call whose value is used. */
9483 const pass_data pass_data_warn_unused_result
=
9485 GIMPLE_PASS
, /* type */
9486 "*warn_unused_result", /* name */
9487 OPTGROUP_NONE
, /* optinfo_flags */
9488 TV_NONE
, /* tv_id */
9489 PROP_gimple_any
, /* properties_required */
9490 0, /* properties_provided */
9491 0, /* properties_destroyed */
9492 0, /* todo_flags_start */
9493 0, /* todo_flags_finish */
9496 class pass_warn_unused_result
: public gimple_opt_pass
9499 pass_warn_unused_result (gcc::context
*ctxt
)
9500 : gimple_opt_pass (pass_data_warn_unused_result
, ctxt
)
9503 /* opt_pass methods: */
9504 virtual bool gate (function
*) { return flag_warn_unused_result
; }
9505 virtual unsigned int execute (function
*)
9507 do_warn_unused_result (gimple_body (current_function_decl
));
9511 }; // class pass_warn_unused_result
9516 make_pass_warn_unused_result (gcc::context
*ctxt
)
9518 return new pass_warn_unused_result (ctxt
);
9521 /* IPA passes, compilation of earlier functions or inlining
9522 might have changed some properties, such as marked functions nothrow,
9523 pure, const or noreturn.
9524 Remove redundant edges and basic blocks, and create new ones if necessary.
9526 This pass can't be executed as stand alone pass from pass manager, because
9527 in between inlining and this fixup the verify_flow_info would fail. */
9530 execute_fixup_cfg (void)
9533 gimple_stmt_iterator gsi
;
9535 cgraph_node
*node
= cgraph_node::get (current_function_decl
);
9536 profile_count num
= node
->count
;
9537 profile_count den
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
9538 bool scale
= num
.initialized_p () && !(num
== den
);
9542 profile_count::adjust_for_ipa_scaling (&num
, &den
);
9543 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= node
->count
;
9544 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
9545 = EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
.apply_scale (num
, den
);
9548 FOR_EACH_BB_FN (bb
, cfun
)
9551 bb
->count
= bb
->count
.apply_scale (num
, den
);
9552 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
9554 gimple
*stmt
= gsi_stmt (gsi
);
9555 tree decl
= is_gimple_call (stmt
)
9556 ? gimple_call_fndecl (stmt
)
9560 int flags
= gimple_call_flags (stmt
);
9561 if (flags
& (ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
))
9563 if (gimple_purge_dead_abnormal_call_edges (bb
))
9564 todo
|= TODO_cleanup_cfg
;
9566 if (gimple_in_ssa_p (cfun
))
9568 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
9573 if (flags
& ECF_NORETURN
9574 && fixup_noreturn_call (stmt
))
9575 todo
|= TODO_cleanup_cfg
;
9578 /* Remove stores to variables we marked write-only.
9579 Keep access when store has side effect, i.e. in case when source
9581 if (gimple_store_p (stmt
)
9582 && !gimple_has_side_effects (stmt
)
9585 tree lhs
= get_base_address (gimple_get_lhs (stmt
));
9588 && (TREE_STATIC (lhs
) || DECL_EXTERNAL (lhs
))
9589 && varpool_node::get (lhs
)->writeonly
)
9591 unlink_stmt_vdef (stmt
);
9592 gsi_remove (&gsi
, true);
9593 release_defs (stmt
);
9594 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
9598 /* For calls we can simply remove LHS when it is known
9599 to be write-only. */
9600 if (is_gimple_call (stmt
)
9601 && gimple_get_lhs (stmt
))
9603 tree lhs
= get_base_address (gimple_get_lhs (stmt
));
9606 && (TREE_STATIC (lhs
) || DECL_EXTERNAL (lhs
))
9607 && varpool_node::get (lhs
)->writeonly
)
9609 gimple_call_set_lhs (stmt
, NULL
);
9611 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
9615 if (maybe_clean_eh_stmt (stmt
)
9616 && gimple_purge_dead_eh_edges (bb
))
9617 todo
|= TODO_cleanup_cfg
;
9621 /* If we have a basic block with no successors that does not
9622 end with a control statement or a noreturn call end it with
9623 a call to __builtin_unreachable. This situation can occur
9624 when inlining a noreturn call that does in fact return. */
9625 if (EDGE_COUNT (bb
->succs
) == 0)
9627 gimple
*stmt
= last_stmt (bb
);
9629 || (!is_ctrl_stmt (stmt
)
9630 && (!is_gimple_call (stmt
)
9631 || !gimple_call_noreturn_p (stmt
))))
9633 if (stmt
&& is_gimple_call (stmt
))
9634 gimple_call_set_ctrl_altering (stmt
, false);
9635 tree fndecl
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
9636 stmt
= gimple_build_call (fndecl
, 0);
9637 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
9638 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
9639 if (!cfun
->after_inlining
)
9641 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
9642 node
->create_edge (cgraph_node::get_create (fndecl
),
9643 call_stmt
, bb
->count
);
9649 compute_function_frequency ();
9652 && (todo
& TODO_cleanup_cfg
))
9653 loops_state_set (LOOPS_NEED_FIXUP
);
9660 const pass_data pass_data_fixup_cfg
=
9662 GIMPLE_PASS
, /* type */
9663 "fixup_cfg", /* name */
9664 OPTGROUP_NONE
, /* optinfo_flags */
9665 TV_NONE
, /* tv_id */
9666 PROP_cfg
, /* properties_required */
9667 0, /* properties_provided */
9668 0, /* properties_destroyed */
9669 0, /* todo_flags_start */
9670 0, /* todo_flags_finish */
9673 class pass_fixup_cfg
: public gimple_opt_pass
9676 pass_fixup_cfg (gcc::context
*ctxt
)
9677 : gimple_opt_pass (pass_data_fixup_cfg
, ctxt
)
9680 /* opt_pass methods: */
9681 opt_pass
* clone () { return new pass_fixup_cfg (m_ctxt
); }
9682 virtual unsigned int execute (function
*) { return execute_fixup_cfg (); }
9684 }; // class pass_fixup_cfg
9689 make_pass_fixup_cfg (gcc::context
*ctxt
)
9691 return new pass_fixup_cfg (ctxt
);
9694 /* Garbage collection support for edge_def. */
9696 extern void gt_ggc_mx (tree
&);
9697 extern void gt_ggc_mx (gimple
*&);
9698 extern void gt_ggc_mx (rtx
&);
9699 extern void gt_ggc_mx (basic_block
&);
9702 gt_ggc_mx (rtx_insn
*& x
)
9705 gt_ggc_mx_rtx_def ((void *) x
);
9709 gt_ggc_mx (edge_def
*e
)
9711 tree block
= LOCATION_BLOCK (e
->goto_locus
);
9713 gt_ggc_mx (e
->dest
);
9714 if (current_ir_type () == IR_GIMPLE
)
9715 gt_ggc_mx (e
->insns
.g
);
9717 gt_ggc_mx (e
->insns
.r
);
9721 /* PCH support for edge_def. */
9723 extern void gt_pch_nx (tree
&);
9724 extern void gt_pch_nx (gimple
*&);
9725 extern void gt_pch_nx (rtx
&);
9726 extern void gt_pch_nx (basic_block
&);
9729 gt_pch_nx (rtx_insn
*& x
)
9732 gt_pch_nx_rtx_def ((void *) x
);
9736 gt_pch_nx (edge_def
*e
)
9738 tree block
= LOCATION_BLOCK (e
->goto_locus
);
9740 gt_pch_nx (e
->dest
);
9741 if (current_ir_type () == IR_GIMPLE
)
9742 gt_pch_nx (e
->insns
.g
);
9744 gt_pch_nx (e
->insns
.r
);
9749 gt_pch_nx (edge_def
*e
, gt_pointer_operator op
, void *cookie
)
9751 tree block
= LOCATION_BLOCK (e
->goto_locus
);
9752 op (&(e
->src
), cookie
);
9753 op (&(e
->dest
), cookie
);
9754 if (current_ir_type () == IR_GIMPLE
)
9755 op (&(e
->insns
.g
), cookie
);
9757 op (&(e
->insns
.r
), cookie
);
9758 op (&(block
), cookie
);
9763 namespace selftest
{
9765 /* Helper function for CFG selftests: create a dummy function decl
9766 and push it as cfun. */
9769 push_fndecl (const char *name
)
9771 tree fn_type
= build_function_type_array (integer_type_node
, 0, NULL
);
9772 /* FIXME: this uses input_location: */
9773 tree fndecl
= build_fn_decl (name
, fn_type
);
9774 tree retval
= build_decl (UNKNOWN_LOCATION
, RESULT_DECL
,
9775 NULL_TREE
, integer_type_node
);
9776 DECL_RESULT (fndecl
) = retval
;
9777 push_struct_function (fndecl
);
9778 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
9779 ASSERT_TRUE (fun
!= NULL
);
9780 init_empty_tree_cfg_for_function (fun
);
9781 ASSERT_EQ (2, n_basic_blocks_for_fn (fun
));
9782 ASSERT_EQ (0, n_edges_for_fn (fun
));
9786 /* These tests directly create CFGs.
9787 Compare with the static fns within tree-cfg.c:
9789 - make_blocks: calls create_basic_block (seq, bb);
9792 /* Verify a simple cfg of the form:
9793 ENTRY -> A -> B -> C -> EXIT. */
9796 test_linear_chain ()
9798 gimple_register_cfg_hooks ();
9800 tree fndecl
= push_fndecl ("cfg_test_linear_chain");
9801 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
9803 /* Create some empty blocks. */
9804 basic_block bb_a
= create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
9805 basic_block bb_b
= create_empty_bb (bb_a
);
9806 basic_block bb_c
= create_empty_bb (bb_b
);
9808 ASSERT_EQ (5, n_basic_blocks_for_fn (fun
));
9809 ASSERT_EQ (0, n_edges_for_fn (fun
));
9811 /* Create some edges: a simple linear chain of BBs. */
9812 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
), bb_a
, EDGE_FALLTHRU
);
9813 make_edge (bb_a
, bb_b
, 0);
9814 make_edge (bb_b
, bb_c
, 0);
9815 make_edge (bb_c
, EXIT_BLOCK_PTR_FOR_FN (fun
), 0);
9817 /* Verify the edges. */
9818 ASSERT_EQ (4, n_edges_for_fn (fun
));
9819 ASSERT_EQ (NULL
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->preds
);
9820 ASSERT_EQ (1, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
->length ());
9821 ASSERT_EQ (1, bb_a
->preds
->length ());
9822 ASSERT_EQ (1, bb_a
->succs
->length ());
9823 ASSERT_EQ (1, bb_b
->preds
->length ());
9824 ASSERT_EQ (1, bb_b
->succs
->length ());
9825 ASSERT_EQ (1, bb_c
->preds
->length ());
9826 ASSERT_EQ (1, bb_c
->succs
->length ());
9827 ASSERT_EQ (1, EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
->length ());
9828 ASSERT_EQ (NULL
, EXIT_BLOCK_PTR_FOR_FN (fun
)->succs
);
9830 /* Verify the dominance information
9831 Each BB in our simple chain should be dominated by the one before
9833 calculate_dominance_info (CDI_DOMINATORS
);
9834 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_b
));
9835 ASSERT_EQ (bb_b
, get_immediate_dominator (CDI_DOMINATORS
, bb_c
));
9836 vec
<basic_block
> dom_by_b
= get_dominated_by (CDI_DOMINATORS
, bb_b
);
9837 ASSERT_EQ (1, dom_by_b
.length ());
9838 ASSERT_EQ (bb_c
, dom_by_b
[0]);
9839 free_dominance_info (CDI_DOMINATORS
);
9840 dom_by_b
.release ();
9842 /* Similarly for post-dominance: each BB in our chain is post-dominated
9843 by the one after it. */
9844 calculate_dominance_info (CDI_POST_DOMINATORS
);
9845 ASSERT_EQ (bb_b
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_a
));
9846 ASSERT_EQ (bb_c
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_b
));
9847 vec
<basic_block
> postdom_by_b
= get_dominated_by (CDI_POST_DOMINATORS
, bb_b
);
9848 ASSERT_EQ (1, postdom_by_b
.length ());
9849 ASSERT_EQ (bb_a
, postdom_by_b
[0]);
9850 free_dominance_info (CDI_POST_DOMINATORS
);
9851 postdom_by_b
.release ();
9856 /* Verify a simple CFG of the form:
9872 gimple_register_cfg_hooks ();
9874 tree fndecl
= push_fndecl ("cfg_test_diamond");
9875 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
9877 /* Create some empty blocks. */
9878 basic_block bb_a
= create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
9879 basic_block bb_b
= create_empty_bb (bb_a
);
9880 basic_block bb_c
= create_empty_bb (bb_a
);
9881 basic_block bb_d
= create_empty_bb (bb_b
);
9883 ASSERT_EQ (6, n_basic_blocks_for_fn (fun
));
9884 ASSERT_EQ (0, n_edges_for_fn (fun
));
9886 /* Create the edges. */
9887 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
), bb_a
, EDGE_FALLTHRU
);
9888 make_edge (bb_a
, bb_b
, EDGE_TRUE_VALUE
);
9889 make_edge (bb_a
, bb_c
, EDGE_FALSE_VALUE
);
9890 make_edge (bb_b
, bb_d
, 0);
9891 make_edge (bb_c
, bb_d
, 0);
9892 make_edge (bb_d
, EXIT_BLOCK_PTR_FOR_FN (fun
), 0);
9894 /* Verify the edges. */
9895 ASSERT_EQ (6, n_edges_for_fn (fun
));
9896 ASSERT_EQ (1, bb_a
->preds
->length ());
9897 ASSERT_EQ (2, bb_a
->succs
->length ());
9898 ASSERT_EQ (1, bb_b
->preds
->length ());
9899 ASSERT_EQ (1, bb_b
->succs
->length ());
9900 ASSERT_EQ (1, bb_c
->preds
->length ());
9901 ASSERT_EQ (1, bb_c
->succs
->length ());
9902 ASSERT_EQ (2, bb_d
->preds
->length ());
9903 ASSERT_EQ (1, bb_d
->succs
->length ());
9905 /* Verify the dominance information. */
9906 calculate_dominance_info (CDI_DOMINATORS
);
9907 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_b
));
9908 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_c
));
9909 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_d
));
9910 vec
<basic_block
> dom_by_a
= get_dominated_by (CDI_DOMINATORS
, bb_a
);
9911 ASSERT_EQ (3, dom_by_a
.length ()); /* B, C, D, in some order. */
9912 dom_by_a
.release ();
9913 vec
<basic_block
> dom_by_b
= get_dominated_by (CDI_DOMINATORS
, bb_b
);
9914 ASSERT_EQ (0, dom_by_b
.length ());
9915 dom_by_b
.release ();
9916 free_dominance_info (CDI_DOMINATORS
);
9918 /* Similarly for post-dominance. */
9919 calculate_dominance_info (CDI_POST_DOMINATORS
);
9920 ASSERT_EQ (bb_d
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_a
));
9921 ASSERT_EQ (bb_d
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_b
));
9922 ASSERT_EQ (bb_d
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_c
));
9923 vec
<basic_block
> postdom_by_d
= get_dominated_by (CDI_POST_DOMINATORS
, bb_d
);
9924 ASSERT_EQ (3, postdom_by_d
.length ()); /* A, B, C in some order. */
9925 postdom_by_d
.release ();
9926 vec
<basic_block
> postdom_by_b
= get_dominated_by (CDI_POST_DOMINATORS
, bb_b
);
9927 ASSERT_EQ (0, postdom_by_b
.length ());
9928 postdom_by_b
.release ();
9929 free_dominance_info (CDI_POST_DOMINATORS
);
9934 /* Verify that we can handle a CFG containing a "complete" aka
9935 fully-connected subgraph (where A B C D below all have edges
9936 pointing to each other node, also to themselves).
9954 test_fully_connected ()
9956 gimple_register_cfg_hooks ();
9958 tree fndecl
= push_fndecl ("cfg_fully_connected");
9959 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
9963 /* Create some empty blocks. */
9964 auto_vec
<basic_block
> subgraph_nodes
;
9965 for (int i
= 0; i
< n
; i
++)
9966 subgraph_nodes
.safe_push (create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
)));
9968 ASSERT_EQ (n
+ 2, n_basic_blocks_for_fn (fun
));
9969 ASSERT_EQ (0, n_edges_for_fn (fun
));
9971 /* Create the edges. */
9972 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
), subgraph_nodes
[0], EDGE_FALLTHRU
);
9973 make_edge (subgraph_nodes
[0], EXIT_BLOCK_PTR_FOR_FN (fun
), 0);
9974 for (int i
= 0; i
< n
; i
++)
9975 for (int j
= 0; j
< n
; j
++)
9976 make_edge (subgraph_nodes
[i
], subgraph_nodes
[j
], 0);
9978 /* Verify the edges. */
9979 ASSERT_EQ (2 + (n
* n
), n_edges_for_fn (fun
));
9980 /* The first one is linked to ENTRY/EXIT as well as itself and
9982 ASSERT_EQ (n
+ 1, subgraph_nodes
[0]->preds
->length ());
9983 ASSERT_EQ (n
+ 1, subgraph_nodes
[0]->succs
->length ());
9984 /* The other ones in the subgraph are linked to everything in
9985 the subgraph (including themselves). */
9986 for (int i
= 1; i
< n
; i
++)
9988 ASSERT_EQ (n
, subgraph_nodes
[i
]->preds
->length ());
9989 ASSERT_EQ (n
, subgraph_nodes
[i
]->succs
->length ());
9992 /* Verify the dominance information. */
9993 calculate_dominance_info (CDI_DOMINATORS
);
9994 /* The initial block in the subgraph should be dominated by ENTRY. */
9995 ASSERT_EQ (ENTRY_BLOCK_PTR_FOR_FN (fun
),
9996 get_immediate_dominator (CDI_DOMINATORS
,
9997 subgraph_nodes
[0]));
9998 /* Every other block in the subgraph should be dominated by the
10000 for (int i
= 1; i
< n
; i
++)
10001 ASSERT_EQ (subgraph_nodes
[0],
10002 get_immediate_dominator (CDI_DOMINATORS
,
10003 subgraph_nodes
[i
]));
10004 free_dominance_info (CDI_DOMINATORS
);
10006 /* Similarly for post-dominance. */
10007 calculate_dominance_info (CDI_POST_DOMINATORS
);
10008 /* The initial block in the subgraph should be postdominated by EXIT. */
10009 ASSERT_EQ (EXIT_BLOCK_PTR_FOR_FN (fun
),
10010 get_immediate_dominator (CDI_POST_DOMINATORS
,
10011 subgraph_nodes
[0]));
10012 /* Every other block in the subgraph should be postdominated by the
10013 initial block, since that leads to EXIT. */
10014 for (int i
= 1; i
< n
; i
++)
10015 ASSERT_EQ (subgraph_nodes
[0],
10016 get_immediate_dominator (CDI_POST_DOMINATORS
,
10017 subgraph_nodes
[i
]));
10018 free_dominance_info (CDI_POST_DOMINATORS
);
10023 /* Run all of the selftests within this file. */
10026 tree_cfg_c_tests ()
10028 test_linear_chain ();
10030 test_fully_connected ();
10033 } // namespace selftest
10035 /* TODO: test the dominator/postdominator logic with various graphs/nodes:
10038 - switch statement (a block with many out-edges)
10039 - something that jumps to itself
10042 #endif /* CHECKING_P */