1 /* Control flow functions for trees.
2 Copyright (C) 2001-2020 Free Software Foundation, Inc.
3 Contributed by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
30 #include "tree-pass.h"
33 #include "gimple-pretty-print.h"
34 #include "diagnostic-core.h"
35 #include "fold-const.h"
36 #include "trans-mem.h"
37 #include "stor-layout.h"
38 #include "print-tree.h"
40 #include "gimple-fold.h"
42 #include "gimple-iterator.h"
43 #include "gimplify-me.h"
44 #include "gimple-walk.h"
46 #include "tree-ssa-loop-manip.h"
47 #include "tree-ssa-loop-niter.h"
48 #include "tree-into-ssa.h"
53 #include "tree-ssa-propagate.h"
54 #include "value-prof.h"
55 #include "tree-inline.h"
56 #include "tree-ssa-live.h"
57 #include "omp-general.h"
58 #include "omp-expand.h"
59 #include "tree-cfgcleanup.h"
67 /* This file contains functions for building the Control Flow Graph (CFG)
68 for a function tree. */
70 /* Local declarations. */
72 /* Initial capacity for the basic block array. */
73 static const int initial_cfg_capacity
= 20;
75 /* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
76 which use a particular edge. The CASE_LABEL_EXPRs are chained together
77 via their CASE_CHAIN field, which we clear after we're done with the
78 hash table to prevent problems with duplication of GIMPLE_SWITCHes.
80 Access to this list of CASE_LABEL_EXPRs allows us to efficiently
81 update the case vector in response to edge redirections.
83 Right now this table is set up and torn down at key points in the
84 compilation process. It would be nice if we could make the table
85 more persistent. The key is getting notification of changes to
86 the CFG (particularly edge removal, creation and redirection). */
88 static hash_map
<edge
, tree
> *edge_to_cases
;
90 /* If we record edge_to_cases, this bitmap will hold indexes
91 of basic blocks that end in a GIMPLE_SWITCH which we touched
92 due to edge manipulations. */
94 static bitmap touched_switch_bbs
;
99 long num_merged_labels
;
102 static struct cfg_stats_d cfg_stats
;
104 /* Data to pass to replace_block_vars_by_duplicates_1. */
105 struct replace_decls_d
107 hash_map
<tree
, tree
> *vars_map
;
111 /* Hash table to store last discriminator assigned for each locus. */
112 struct locus_discrim_map
118 /* Hashtable helpers. */
120 struct locus_discrim_hasher
: free_ptr_hash
<locus_discrim_map
>
122 static inline hashval_t
hash (const locus_discrim_map
*);
123 static inline bool equal (const locus_discrim_map
*,
124 const locus_discrim_map
*);
127 /* Trivial hash function for a location_t. ITEM is a pointer to
128 a hash table entry that maps a location_t to a discriminator. */
131 locus_discrim_hasher::hash (const locus_discrim_map
*item
)
133 return item
->location_line
;
136 /* Equality function for the locus-to-discriminator map. A and B
137 point to the two hash table entries to compare. */
140 locus_discrim_hasher::equal (const locus_discrim_map
*a
,
141 const locus_discrim_map
*b
)
143 return a
->location_line
== b
->location_line
;
146 static hash_table
<locus_discrim_hasher
> *discriminator_per_locus
;
148 /* Basic blocks and flowgraphs. */
149 static void make_blocks (gimple_seq
);
152 static void make_edges (void);
153 static void assign_discriminators (void);
154 static void make_cond_expr_edges (basic_block
);
155 static void make_gimple_switch_edges (gswitch
*, basic_block
);
156 static bool make_goto_expr_edges (basic_block
);
157 static void make_gimple_asm_edges (basic_block
);
158 static edge
gimple_redirect_edge_and_branch (edge
, basic_block
);
159 static edge
gimple_try_redirect_by_replacing_jump (edge
, basic_block
);
161 /* Various helpers. */
162 static inline bool stmt_starts_bb_p (gimple
*, gimple
*);
163 static int gimple_verify_flow_info (void);
164 static void gimple_make_forwarder_block (edge
);
165 static gimple
*first_non_label_stmt (basic_block
);
166 static bool verify_gimple_transaction (gtransaction
*);
167 static bool call_can_make_abnormal_goto (gimple
*);
169 /* Flowgraph optimization and cleanup. */
170 static void gimple_merge_blocks (basic_block
, basic_block
);
171 static bool gimple_can_merge_blocks_p (basic_block
, basic_block
);
172 static void remove_bb (basic_block
);
173 static edge
find_taken_edge_computed_goto (basic_block
, tree
);
174 static edge
find_taken_edge_cond_expr (const gcond
*, tree
);
177 init_empty_tree_cfg_for_function (struct function
*fn
)
179 /* Initialize the basic block array. */
181 profile_status_for_fn (fn
) = PROFILE_ABSENT
;
182 n_basic_blocks_for_fn (fn
) = NUM_FIXED_BLOCKS
;
183 last_basic_block_for_fn (fn
) = NUM_FIXED_BLOCKS
;
184 vec_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
);
3229 if (MR_DEPENDENCE_CLIQUE (expr
) != 0
3230 && MR_DEPENDENCE_CLIQUE (expr
) > cfun
->last_clique
)
3232 error ("invalid clique in %qs", code_name
);
3233 debug_generic_stmt (expr
);
3237 else if (TREE_CODE (expr
) == TARGET_MEM_REF
)
3239 if (!TMR_BASE (expr
)
3240 || !is_gimple_mem_ref_addr (TMR_BASE (expr
))
3241 || (TREE_CODE (TMR_BASE (expr
)) == ADDR_EXPR
3242 && verify_address (TMR_BASE (expr
), false)))
3244 error ("invalid address operand in %qs", code_name
);
3247 if (!TMR_OFFSET (expr
)
3248 || !poly_int_tree_p (TMR_OFFSET (expr
))
3249 || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr
))))
3251 error ("invalid offset operand in %qs", code_name
);
3252 debug_generic_stmt (expr
);
3255 if (MR_DEPENDENCE_CLIQUE (expr
) != 0
3256 && MR_DEPENDENCE_CLIQUE (expr
) > cfun
->last_clique
)
3258 error ("invalid clique in %qs", code_name
);
3259 debug_generic_stmt (expr
);
3263 else if (TREE_CODE (expr
) == INDIRECT_REF
)
3265 error ("%qs in gimple IL", code_name
);
3266 debug_generic_stmt (expr
);
3270 return ((require_lvalue
|| !is_gimple_min_invariant (expr
))
3271 && verify_types_in_gimple_min_lval (expr
));
3274 /* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
3275 list of pointer-to types that is trivially convertible to DEST. */
3278 one_pointer_to_useless_type_conversion_p (tree dest
, tree src_obj
)
3282 if (!TYPE_POINTER_TO (src_obj
))
3285 for (src
= TYPE_POINTER_TO (src_obj
); src
; src
= TYPE_NEXT_PTR_TO (src
))
3286 if (useless_type_conversion_p (dest
, src
))
3292 /* Return true if TYPE1 is a fixed-point type and if conversions to and
3293 from TYPE2 can be handled by FIXED_CONVERT_EXPR. */
3296 valid_fixed_convert_types_p (tree type1
, tree type2
)
3298 return (FIXED_POINT_TYPE_P (type1
)
3299 && (INTEGRAL_TYPE_P (type2
)
3300 || SCALAR_FLOAT_TYPE_P (type2
)
3301 || FIXED_POINT_TYPE_P (type2
)));
3304 /* Verify the contents of a GIMPLE_CALL STMT. Returns true when there
3305 is a problem, otherwise false. */
3308 verify_gimple_call (gcall
*stmt
)
3310 tree fn
= gimple_call_fn (stmt
);
3311 tree fntype
, fndecl
;
3314 if (gimple_call_internal_p (stmt
))
3318 error ("gimple call has two targets");
3319 debug_generic_stmt (fn
);
3327 error ("gimple call has no target");
3332 if (fn
&& !is_gimple_call_addr (fn
))
3334 error ("invalid function in gimple call");
3335 debug_generic_stmt (fn
);
3340 && (!POINTER_TYPE_P (TREE_TYPE (fn
))
3341 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != FUNCTION_TYPE
3342 && TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != METHOD_TYPE
)))
3344 error ("non-function in gimple call");
3348 fndecl
= gimple_call_fndecl (stmt
);
3350 && TREE_CODE (fndecl
) == FUNCTION_DECL
3351 && DECL_LOOPING_CONST_OR_PURE_P (fndecl
)
3352 && !DECL_PURE_P (fndecl
)
3353 && !TREE_READONLY (fndecl
))
3355 error ("invalid pure const state for function");
3359 tree lhs
= gimple_call_lhs (stmt
);
3361 && (!is_gimple_lvalue (lhs
)
3362 || verify_types_in_gimple_reference (lhs
, true)))
3364 error ("invalid LHS in gimple call");
3368 if (gimple_call_ctrl_altering_p (stmt
)
3369 && gimple_call_noreturn_p (stmt
)
3370 && should_remove_lhs_p (lhs
))
3372 error ("LHS in %<noreturn%> call");
3376 fntype
= gimple_call_fntype (stmt
);
3379 && !useless_type_conversion_p (TREE_TYPE (lhs
), TREE_TYPE (fntype
))
3380 /* ??? At least C++ misses conversions at assignments from
3381 void * call results.
3382 For now simply allow arbitrary pointer type conversions. */
3383 && !(POINTER_TYPE_P (TREE_TYPE (lhs
))
3384 && POINTER_TYPE_P (TREE_TYPE (fntype
))))
3386 error ("invalid conversion in gimple call");
3387 debug_generic_stmt (TREE_TYPE (lhs
));
3388 debug_generic_stmt (TREE_TYPE (fntype
));
3392 if (gimple_call_chain (stmt
)
3393 && !is_gimple_val (gimple_call_chain (stmt
)))
3395 error ("invalid static chain in gimple call");
3396 debug_generic_stmt (gimple_call_chain (stmt
));
3400 /* If there is a static chain argument, the call should either be
3401 indirect, or the decl should have DECL_STATIC_CHAIN set. */
3402 if (gimple_call_chain (stmt
)
3404 && !DECL_STATIC_CHAIN (fndecl
))
3406 error ("static chain with function that doesn%'t use one");
3410 if (fndecl
&& fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
))
3412 switch (DECL_FUNCTION_CODE (fndecl
))
3414 case BUILT_IN_UNREACHABLE
:
3416 if (gimple_call_num_args (stmt
) > 0)
3418 /* Built-in unreachable with parameters might not be caught by
3419 undefined behavior sanitizer. Front-ends do check users do not
3420 call them that way but we also produce calls to
3421 __builtin_unreachable internally, for example when IPA figures
3422 out a call cannot happen in a legal program. In such cases,
3423 we must make sure arguments are stripped off. */
3424 error ("%<__builtin_unreachable%> or %<__builtin_trap%> call "
3434 /* ??? The C frontend passes unpromoted arguments in case it
3435 didn't see a function declaration before the call. So for now
3436 leave the call arguments mostly unverified. Once we gimplify
3437 unit-at-a-time we have a chance to fix this. */
3439 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
3441 tree arg
= gimple_call_arg (stmt
, i
);
3442 if ((is_gimple_reg_type (TREE_TYPE (arg
))
3443 && !is_gimple_val (arg
))
3444 || (!is_gimple_reg_type (TREE_TYPE (arg
))
3445 && !is_gimple_lvalue (arg
)))
3447 error ("invalid argument to gimple call");
3448 debug_generic_expr (arg
);
3456 /* Verifies the gimple comparison with the result type TYPE and
3457 the operands OP0 and OP1, comparison code is CODE. */
3460 verify_gimple_comparison (tree type
, tree op0
, tree op1
, enum tree_code code
)
3462 tree op0_type
= TREE_TYPE (op0
);
3463 tree op1_type
= TREE_TYPE (op1
);
3465 if (!is_gimple_val (op0
) || !is_gimple_val (op1
))
3467 error ("invalid operands in gimple comparison");
3471 /* For comparisons we do not have the operations type as the
3472 effective type the comparison is carried out in. Instead
3473 we require that either the first operand is trivially
3474 convertible into the second, or the other way around.
3475 Because we special-case pointers to void we allow
3476 comparisons of pointers with the same mode as well. */
3477 if (!useless_type_conversion_p (op0_type
, op1_type
)
3478 && !useless_type_conversion_p (op1_type
, op0_type
)
3479 && (!POINTER_TYPE_P (op0_type
)
3480 || !POINTER_TYPE_P (op1_type
)
3481 || TYPE_MODE (op0_type
) != TYPE_MODE (op1_type
)))
3483 error ("mismatching comparison operand types");
3484 debug_generic_expr (op0_type
);
3485 debug_generic_expr (op1_type
);
3489 /* The resulting type of a comparison may be an effective boolean type. */
3490 if (INTEGRAL_TYPE_P (type
)
3491 && (TREE_CODE (type
) == BOOLEAN_TYPE
3492 || TYPE_PRECISION (type
) == 1))
3494 if ((TREE_CODE (op0_type
) == VECTOR_TYPE
3495 || TREE_CODE (op1_type
) == VECTOR_TYPE
)
3496 && code
!= EQ_EXPR
&& code
!= NE_EXPR
3497 && !VECTOR_BOOLEAN_TYPE_P (op0_type
)
3498 && !VECTOR_INTEGER_TYPE_P (op0_type
))
3500 error ("unsupported operation or type for vector comparison"
3501 " returning a boolean");
3502 debug_generic_expr (op0_type
);
3503 debug_generic_expr (op1_type
);
3507 /* Or a boolean vector type with the same element count
3508 as the comparison operand types. */
3509 else if (TREE_CODE (type
) == VECTOR_TYPE
3510 && TREE_CODE (TREE_TYPE (type
)) == BOOLEAN_TYPE
)
3512 if (TREE_CODE (op0_type
) != VECTOR_TYPE
3513 || TREE_CODE (op1_type
) != VECTOR_TYPE
)
3515 error ("non-vector operands in vector comparison");
3516 debug_generic_expr (op0_type
);
3517 debug_generic_expr (op1_type
);
3521 if (maybe_ne (TYPE_VECTOR_SUBPARTS (type
),
3522 TYPE_VECTOR_SUBPARTS (op0_type
)))
3524 error ("invalid vector comparison resulting type");
3525 debug_generic_expr (type
);
3531 error ("bogus comparison result type");
3532 debug_generic_expr (type
);
3539 /* Verify a gimple assignment statement STMT with an unary rhs.
3540 Returns true if anything is wrong. */
3543 verify_gimple_assign_unary (gassign
*stmt
)
3545 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3546 tree lhs
= gimple_assign_lhs (stmt
);
3547 tree lhs_type
= TREE_TYPE (lhs
);
3548 tree rhs1
= gimple_assign_rhs1 (stmt
);
3549 tree rhs1_type
= TREE_TYPE (rhs1
);
3551 if (!is_gimple_reg (lhs
))
3553 error ("non-register as LHS of unary operation");
3557 if (!is_gimple_val (rhs1
))
3559 error ("invalid operand in unary operation");
3563 const char* const code_name
= get_tree_code_name (rhs_code
);
3565 /* First handle conversions. */
3570 /* Allow conversions between vectors with the same number of elements,
3571 provided that the conversion is OK for the element types too. */
3572 if (VECTOR_TYPE_P (lhs_type
)
3573 && VECTOR_TYPE_P (rhs1_type
)
3574 && known_eq (TYPE_VECTOR_SUBPARTS (lhs_type
),
3575 TYPE_VECTOR_SUBPARTS (rhs1_type
)))
3577 lhs_type
= TREE_TYPE (lhs_type
);
3578 rhs1_type
= TREE_TYPE (rhs1_type
);
3580 else if (VECTOR_TYPE_P (lhs_type
) || VECTOR_TYPE_P (rhs1_type
))
3582 error ("invalid vector types in nop conversion");
3583 debug_generic_expr (lhs_type
);
3584 debug_generic_expr (rhs1_type
);
3588 /* Allow conversions from pointer type to integral type only if
3589 there is no sign or zero extension involved.
3590 For targets were the precision of ptrofftype doesn't match that
3591 of pointers we need to allow arbitrary conversions to ptrofftype. */
3592 if ((POINTER_TYPE_P (lhs_type
)
3593 && INTEGRAL_TYPE_P (rhs1_type
))
3594 || (POINTER_TYPE_P (rhs1_type
)
3595 && INTEGRAL_TYPE_P (lhs_type
)
3596 && (TYPE_PRECISION (rhs1_type
) >= TYPE_PRECISION (lhs_type
)
3597 || ptrofftype_p (lhs_type
))))
3600 /* Allow conversion from integral to offset type and vice versa. */
3601 if ((TREE_CODE (lhs_type
) == OFFSET_TYPE
3602 && INTEGRAL_TYPE_P (rhs1_type
))
3603 || (INTEGRAL_TYPE_P (lhs_type
)
3604 && TREE_CODE (rhs1_type
) == OFFSET_TYPE
))
3607 /* Otherwise assert we are converting between types of the
3609 if (INTEGRAL_TYPE_P (lhs_type
) != INTEGRAL_TYPE_P (rhs1_type
))
3611 error ("invalid types in nop conversion");
3612 debug_generic_expr (lhs_type
);
3613 debug_generic_expr (rhs1_type
);
3620 case ADDR_SPACE_CONVERT_EXPR
:
3622 if (!POINTER_TYPE_P (rhs1_type
) || !POINTER_TYPE_P (lhs_type
)
3623 || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type
))
3624 == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type
))))
3626 error ("invalid types in address space conversion");
3627 debug_generic_expr (lhs_type
);
3628 debug_generic_expr (rhs1_type
);
3635 case FIXED_CONVERT_EXPR
:
3637 if (!valid_fixed_convert_types_p (lhs_type
, rhs1_type
)
3638 && !valid_fixed_convert_types_p (rhs1_type
, lhs_type
))
3640 error ("invalid types in fixed-point conversion");
3641 debug_generic_expr (lhs_type
);
3642 debug_generic_expr (rhs1_type
);
3651 if ((!INTEGRAL_TYPE_P (rhs1_type
) || !SCALAR_FLOAT_TYPE_P (lhs_type
))
3652 && (!VECTOR_INTEGER_TYPE_P (rhs1_type
)
3653 || !VECTOR_FLOAT_TYPE_P (lhs_type
)))
3655 error ("invalid types in conversion to floating-point");
3656 debug_generic_expr (lhs_type
);
3657 debug_generic_expr (rhs1_type
);
3664 case FIX_TRUNC_EXPR
:
3666 if ((!INTEGRAL_TYPE_P (lhs_type
) || !SCALAR_FLOAT_TYPE_P (rhs1_type
))
3667 && (!VECTOR_INTEGER_TYPE_P (lhs_type
)
3668 || !VECTOR_FLOAT_TYPE_P (rhs1_type
)))
3670 error ("invalid types in conversion to integer");
3671 debug_generic_expr (lhs_type
);
3672 debug_generic_expr (rhs1_type
);
3679 case VEC_UNPACK_HI_EXPR
:
3680 case VEC_UNPACK_LO_EXPR
:
3681 case VEC_UNPACK_FLOAT_HI_EXPR
:
3682 case VEC_UNPACK_FLOAT_LO_EXPR
:
3683 case VEC_UNPACK_FIX_TRUNC_HI_EXPR
:
3684 case VEC_UNPACK_FIX_TRUNC_LO_EXPR
:
3685 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3686 || TREE_CODE (lhs_type
) != VECTOR_TYPE
3687 || (!INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3688 && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type
)))
3689 || (!INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3690 && !SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
)))
3691 || ((rhs_code
== VEC_UNPACK_HI_EXPR
3692 || rhs_code
== VEC_UNPACK_LO_EXPR
)
3693 && (INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3694 != INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))))
3695 || ((rhs_code
== VEC_UNPACK_FLOAT_HI_EXPR
3696 || rhs_code
== VEC_UNPACK_FLOAT_LO_EXPR
)
3697 && (INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3698 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
))))
3699 || ((rhs_code
== VEC_UNPACK_FIX_TRUNC_HI_EXPR
3700 || rhs_code
== VEC_UNPACK_FIX_TRUNC_LO_EXPR
)
3701 && (INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3702 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type
))))
3703 || (maybe_ne (GET_MODE_SIZE (element_mode (lhs_type
)),
3704 2 * GET_MODE_SIZE (element_mode (rhs1_type
)))
3705 && (!VECTOR_BOOLEAN_TYPE_P (lhs_type
)
3706 || !VECTOR_BOOLEAN_TYPE_P (rhs1_type
)))
3707 || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (lhs_type
),
3708 TYPE_VECTOR_SUBPARTS (rhs1_type
)))
3710 error ("type mismatch in %qs expression", code_name
);
3711 debug_generic_expr (lhs_type
);
3712 debug_generic_expr (rhs1_type
);
3726 if (!ANY_INTEGRAL_TYPE_P (lhs_type
)
3727 || !TYPE_UNSIGNED (lhs_type
)
3728 || !ANY_INTEGRAL_TYPE_P (rhs1_type
)
3729 || TYPE_UNSIGNED (rhs1_type
)
3730 || element_precision (lhs_type
) != element_precision (rhs1_type
))
3732 error ("invalid types for %qs", code_name
);
3733 debug_generic_expr (lhs_type
);
3734 debug_generic_expr (rhs1_type
);
3739 case VEC_DUPLICATE_EXPR
:
3740 if (TREE_CODE (lhs_type
) != VECTOR_TYPE
3741 || !useless_type_conversion_p (TREE_TYPE (lhs_type
), rhs1_type
))
3743 error ("%qs should be from a scalar to a like vector", code_name
);
3744 debug_generic_expr (lhs_type
);
3745 debug_generic_expr (rhs1_type
);
3754 /* For the remaining codes assert there is no conversion involved. */
3755 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3757 error ("non-trivial conversion in unary operation");
3758 debug_generic_expr (lhs_type
);
3759 debug_generic_expr (rhs1_type
);
3766 /* Verify a gimple assignment statement STMT with a binary rhs.
3767 Returns true if anything is wrong. */
3770 verify_gimple_assign_binary (gassign
*stmt
)
3772 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3773 tree lhs
= gimple_assign_lhs (stmt
);
3774 tree lhs_type
= TREE_TYPE (lhs
);
3775 tree rhs1
= gimple_assign_rhs1 (stmt
);
3776 tree rhs1_type
= TREE_TYPE (rhs1
);
3777 tree rhs2
= gimple_assign_rhs2 (stmt
);
3778 tree rhs2_type
= TREE_TYPE (rhs2
);
3780 if (!is_gimple_reg (lhs
))
3782 error ("non-register as LHS of binary operation");
3786 if (!is_gimple_val (rhs1
)
3787 || !is_gimple_val (rhs2
))
3789 error ("invalid operands in binary operation");
3793 const char* const code_name
= get_tree_code_name (rhs_code
);
3795 /* First handle operations that involve different types. */
3800 if (TREE_CODE (lhs_type
) != COMPLEX_TYPE
3801 || !(INTEGRAL_TYPE_P (rhs1_type
)
3802 || SCALAR_FLOAT_TYPE_P (rhs1_type
))
3803 || !(INTEGRAL_TYPE_P (rhs2_type
)
3804 || SCALAR_FLOAT_TYPE_P (rhs2_type
)))
3806 error ("type mismatch in %qs", code_name
);
3807 debug_generic_expr (lhs_type
);
3808 debug_generic_expr (rhs1_type
);
3809 debug_generic_expr (rhs2_type
);
3821 /* Shifts and rotates are ok on integral types, fixed point
3822 types and integer vector types. */
3823 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3824 && !FIXED_POINT_TYPE_P (rhs1_type
)
3825 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3826 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))))
3827 || (!INTEGRAL_TYPE_P (rhs2_type
)
3828 /* Vector shifts of vectors are also ok. */
3829 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3830 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3831 && TREE_CODE (rhs2_type
) == VECTOR_TYPE
3832 && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3833 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3835 error ("type mismatch in %qs", code_name
);
3836 debug_generic_expr (lhs_type
);
3837 debug_generic_expr (rhs1_type
);
3838 debug_generic_expr (rhs2_type
);
3845 case WIDEN_LSHIFT_EXPR
:
3847 if (!INTEGRAL_TYPE_P (lhs_type
)
3848 || !INTEGRAL_TYPE_P (rhs1_type
)
3849 || TREE_CODE (rhs2
) != INTEGER_CST
3850 || (2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)))
3852 error ("type mismatch in %qs", code_name
);
3853 debug_generic_expr (lhs_type
);
3854 debug_generic_expr (rhs1_type
);
3855 debug_generic_expr (rhs2_type
);
3862 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3863 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3865 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3866 || TREE_CODE (lhs_type
) != VECTOR_TYPE
3867 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3868 || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3869 || TREE_CODE (rhs2
) != INTEGER_CST
3870 || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type
))
3871 > TYPE_PRECISION (TREE_TYPE (lhs_type
))))
3873 error ("type mismatch in %qs", code_name
);
3874 debug_generic_expr (lhs_type
);
3875 debug_generic_expr (rhs1_type
);
3876 debug_generic_expr (rhs2_type
);
3886 tree lhs_etype
= lhs_type
;
3887 tree rhs1_etype
= rhs1_type
;
3888 tree rhs2_etype
= rhs2_type
;
3889 if (TREE_CODE (lhs_type
) == VECTOR_TYPE
)
3891 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3892 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
)
3894 error ("invalid non-vector operands to %qs", code_name
);
3897 lhs_etype
= TREE_TYPE (lhs_type
);
3898 rhs1_etype
= TREE_TYPE (rhs1_type
);
3899 rhs2_etype
= TREE_TYPE (rhs2_type
);
3901 if (POINTER_TYPE_P (lhs_etype
)
3902 || POINTER_TYPE_P (rhs1_etype
)
3903 || POINTER_TYPE_P (rhs2_etype
))
3905 error ("invalid (pointer) operands %qs", code_name
);
3909 /* Continue with generic binary expression handling. */
3913 case POINTER_PLUS_EXPR
:
3915 if (!POINTER_TYPE_P (rhs1_type
)
3916 || !useless_type_conversion_p (lhs_type
, rhs1_type
)
3917 || !ptrofftype_p (rhs2_type
))
3919 error ("type mismatch in %qs", code_name
);
3920 debug_generic_stmt (lhs_type
);
3921 debug_generic_stmt (rhs1_type
);
3922 debug_generic_stmt (rhs2_type
);
3929 case POINTER_DIFF_EXPR
:
3931 if (!POINTER_TYPE_P (rhs1_type
)
3932 || !POINTER_TYPE_P (rhs2_type
)
3933 /* Because we special-case pointers to void we allow difference
3934 of arbitrary pointers with the same mode. */
3935 || TYPE_MODE (rhs1_type
) != TYPE_MODE (rhs2_type
)
3936 || TREE_CODE (lhs_type
) != INTEGER_TYPE
3937 || TYPE_UNSIGNED (lhs_type
)
3938 || TYPE_PRECISION (lhs_type
) != TYPE_PRECISION (rhs1_type
))
3940 error ("type mismatch in %qs", code_name
);
3941 debug_generic_stmt (lhs_type
);
3942 debug_generic_stmt (rhs1_type
);
3943 debug_generic_stmt (rhs2_type
);
3950 case TRUTH_ANDIF_EXPR
:
3951 case TRUTH_ORIF_EXPR
:
3952 case TRUTH_AND_EXPR
:
3954 case TRUTH_XOR_EXPR
:
3964 case UNORDERED_EXPR
:
3972 /* Comparisons are also binary, but the result type is not
3973 connected to the operand types. */
3974 return verify_gimple_comparison (lhs_type
, rhs1
, rhs2
, rhs_code
);
3976 case WIDEN_MULT_EXPR
:
3977 if (TREE_CODE (lhs_type
) != INTEGER_TYPE
)
3979 return ((2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
))
3980 || (TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
)));
3982 case WIDEN_SUM_EXPR
:
3984 if (((TREE_CODE (rhs1_type
) != VECTOR_TYPE
3985 || TREE_CODE (lhs_type
) != VECTOR_TYPE
)
3986 && ((!INTEGRAL_TYPE_P (rhs1_type
)
3987 && !SCALAR_FLOAT_TYPE_P (rhs1_type
))
3988 || (!INTEGRAL_TYPE_P (lhs_type
)
3989 && !SCALAR_FLOAT_TYPE_P (lhs_type
))))
3990 || !useless_type_conversion_p (lhs_type
, rhs2_type
)
3991 || maybe_lt (GET_MODE_SIZE (element_mode (rhs2_type
)),
3992 2 * GET_MODE_SIZE (element_mode (rhs1_type
))))
3994 error ("type mismatch in %qs", code_name
);
3995 debug_generic_expr (lhs_type
);
3996 debug_generic_expr (rhs1_type
);
3997 debug_generic_expr (rhs2_type
);
4003 case VEC_WIDEN_MULT_HI_EXPR
:
4004 case VEC_WIDEN_MULT_LO_EXPR
:
4005 case VEC_WIDEN_MULT_EVEN_EXPR
:
4006 case VEC_WIDEN_MULT_ODD_EXPR
:
4008 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4009 || TREE_CODE (lhs_type
) != VECTOR_TYPE
4010 || !types_compatible_p (rhs1_type
, rhs2_type
)
4011 || maybe_ne (GET_MODE_SIZE (element_mode (lhs_type
)),
4012 2 * GET_MODE_SIZE (element_mode (rhs1_type
))))
4014 error ("type mismatch in %qs", code_name
);
4015 debug_generic_expr (lhs_type
);
4016 debug_generic_expr (rhs1_type
);
4017 debug_generic_expr (rhs2_type
);
4023 case VEC_PACK_TRUNC_EXPR
:
4024 /* ??? We currently use VEC_PACK_TRUNC_EXPR to simply concat
4025 vector boolean types. */
4026 if (VECTOR_BOOLEAN_TYPE_P (lhs_type
)
4027 && VECTOR_BOOLEAN_TYPE_P (rhs1_type
)
4028 && types_compatible_p (rhs1_type
, rhs2_type
)
4029 && known_eq (TYPE_VECTOR_SUBPARTS (lhs_type
),
4030 2 * TYPE_VECTOR_SUBPARTS (rhs1_type
)))
4034 case VEC_PACK_SAT_EXPR
:
4035 case VEC_PACK_FIX_TRUNC_EXPR
:
4037 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4038 || TREE_CODE (lhs_type
) != VECTOR_TYPE
4039 || !((rhs_code
== VEC_PACK_FIX_TRUNC_EXPR
4040 && SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
))
4041 && INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
)))
4042 || (INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
4043 == INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))))
4044 || !types_compatible_p (rhs1_type
, rhs2_type
)
4045 || maybe_ne (GET_MODE_SIZE (element_mode (rhs1_type
)),
4046 2 * GET_MODE_SIZE (element_mode (lhs_type
)))
4047 || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (rhs1_type
),
4048 TYPE_VECTOR_SUBPARTS (lhs_type
)))
4050 error ("type mismatch in %qs", code_name
);
4051 debug_generic_expr (lhs_type
);
4052 debug_generic_expr (rhs1_type
);
4053 debug_generic_expr (rhs2_type
);
4060 case VEC_PACK_FLOAT_EXPR
:
4061 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4062 || TREE_CODE (lhs_type
) != VECTOR_TYPE
4063 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
4064 || !SCALAR_FLOAT_TYPE_P (TREE_TYPE (lhs_type
))
4065 || !types_compatible_p (rhs1_type
, rhs2_type
)
4066 || maybe_ne (GET_MODE_SIZE (element_mode (rhs1_type
)),
4067 2 * GET_MODE_SIZE (element_mode (lhs_type
)))
4068 || maybe_ne (2 * TYPE_VECTOR_SUBPARTS (rhs1_type
),
4069 TYPE_VECTOR_SUBPARTS (lhs_type
)))
4071 error ("type mismatch in %qs", code_name
);
4072 debug_generic_expr (lhs_type
);
4073 debug_generic_expr (rhs1_type
);
4074 debug_generic_expr (rhs2_type
);
4081 case MULT_HIGHPART_EXPR
:
4082 case TRUNC_DIV_EXPR
:
4084 case FLOOR_DIV_EXPR
:
4085 case ROUND_DIV_EXPR
:
4086 case TRUNC_MOD_EXPR
:
4088 case FLOOR_MOD_EXPR
:
4089 case ROUND_MOD_EXPR
:
4091 case EXACT_DIV_EXPR
:
4097 /* Continue with generic binary expression handling. */
4100 case VEC_SERIES_EXPR
:
4101 if (!useless_type_conversion_p (rhs1_type
, rhs2_type
))
4103 error ("type mismatch in %qs", code_name
);
4104 debug_generic_expr (rhs1_type
);
4105 debug_generic_expr (rhs2_type
);
4108 if (TREE_CODE (lhs_type
) != VECTOR_TYPE
4109 || !useless_type_conversion_p (TREE_TYPE (lhs_type
), rhs1_type
))
4111 error ("vector type expected in %qs", code_name
);
4112 debug_generic_expr (lhs_type
);
4121 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
4122 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
4124 error ("type mismatch in binary expression");
4125 debug_generic_stmt (lhs_type
);
4126 debug_generic_stmt (rhs1_type
);
4127 debug_generic_stmt (rhs2_type
);
4134 /* Verify a gimple assignment statement STMT with a ternary rhs.
4135 Returns true if anything is wrong. */
4138 verify_gimple_assign_ternary (gassign
*stmt
)
4140 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
4141 tree lhs
= gimple_assign_lhs (stmt
);
4142 tree lhs_type
= TREE_TYPE (lhs
);
4143 tree rhs1
= gimple_assign_rhs1 (stmt
);
4144 tree rhs1_type
= TREE_TYPE (rhs1
);
4145 tree rhs2
= gimple_assign_rhs2 (stmt
);
4146 tree rhs2_type
= TREE_TYPE (rhs2
);
4147 tree rhs3
= gimple_assign_rhs3 (stmt
);
4148 tree rhs3_type
= TREE_TYPE (rhs3
);
4150 if (!is_gimple_reg (lhs
))
4152 error ("non-register as LHS of ternary operation");
4156 if (((rhs_code
== VEC_COND_EXPR
|| rhs_code
== COND_EXPR
)
4157 ? !is_gimple_condexpr (rhs1
) : !is_gimple_val (rhs1
))
4158 || !is_gimple_val (rhs2
)
4159 || !is_gimple_val (rhs3
))
4161 error ("invalid operands in ternary operation");
4165 const char* const code_name
= get_tree_code_name (rhs_code
);
4167 /* First handle operations that involve different types. */
4170 case WIDEN_MULT_PLUS_EXPR
:
4171 case WIDEN_MULT_MINUS_EXPR
:
4172 if ((!INTEGRAL_TYPE_P (rhs1_type
)
4173 && !FIXED_POINT_TYPE_P (rhs1_type
))
4174 || !useless_type_conversion_p (rhs1_type
, rhs2_type
)
4175 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
4176 || 2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)
4177 || TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
))
4179 error ("type mismatch in %qs", code_name
);
4180 debug_generic_expr (lhs_type
);
4181 debug_generic_expr (rhs1_type
);
4182 debug_generic_expr (rhs2_type
);
4183 debug_generic_expr (rhs3_type
);
4189 if (!VECTOR_BOOLEAN_TYPE_P (rhs1_type
)
4190 || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs1_type
),
4191 TYPE_VECTOR_SUBPARTS (lhs_type
)))
4193 error ("the first argument of a %qs must be of a "
4194 "boolean vector type of the same number of elements "
4195 "as the result", code_name
);
4196 debug_generic_expr (lhs_type
);
4197 debug_generic_expr (rhs1_type
);
4202 if (!is_gimple_val (rhs1
)
4203 && verify_gimple_comparison (TREE_TYPE (rhs1
),
4204 TREE_OPERAND (rhs1
, 0),
4205 TREE_OPERAND (rhs1
, 1),
4208 if (!useless_type_conversion_p (lhs_type
, rhs2_type
)
4209 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
4211 error ("type mismatch in %qs", code_name
);
4212 debug_generic_expr (lhs_type
);
4213 debug_generic_expr (rhs2_type
);
4214 debug_generic_expr (rhs3_type
);
4220 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
4221 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
4223 error ("type mismatch in %qs", code_name
);
4224 debug_generic_expr (lhs_type
);
4225 debug_generic_expr (rhs1_type
);
4226 debug_generic_expr (rhs2_type
);
4227 debug_generic_expr (rhs3_type
);
4231 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4232 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
4233 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
4235 error ("vector types expected in %qs", code_name
);
4236 debug_generic_expr (lhs_type
);
4237 debug_generic_expr (rhs1_type
);
4238 debug_generic_expr (rhs2_type
);
4239 debug_generic_expr (rhs3_type
);
4243 if (maybe_ne (TYPE_VECTOR_SUBPARTS (rhs1_type
),
4244 TYPE_VECTOR_SUBPARTS (rhs2_type
))
4245 || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs2_type
),
4246 TYPE_VECTOR_SUBPARTS (rhs3_type
))
4247 || maybe_ne (TYPE_VECTOR_SUBPARTS (rhs3_type
),
4248 TYPE_VECTOR_SUBPARTS (lhs_type
)))
4250 error ("vectors with different element number found in %qs",
4252 debug_generic_expr (lhs_type
);
4253 debug_generic_expr (rhs1_type
);
4254 debug_generic_expr (rhs2_type
);
4255 debug_generic_expr (rhs3_type
);
4259 if (TREE_CODE (TREE_TYPE (rhs3_type
)) != INTEGER_TYPE
4260 || (TREE_CODE (rhs3
) != VECTOR_CST
4261 && (GET_MODE_BITSIZE (SCALAR_INT_TYPE_MODE
4262 (TREE_TYPE (rhs3_type
)))
4263 != GET_MODE_BITSIZE (SCALAR_TYPE_MODE
4264 (TREE_TYPE (rhs1_type
))))))
4266 error ("invalid mask type in %qs", code_name
);
4267 debug_generic_expr (lhs_type
);
4268 debug_generic_expr (rhs1_type
);
4269 debug_generic_expr (rhs2_type
);
4270 debug_generic_expr (rhs3_type
);
4277 if (!useless_type_conversion_p (rhs1_type
, rhs2_type
)
4278 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
4279 || 2 * GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type
)))
4280 > GET_MODE_UNIT_BITSIZE (TYPE_MODE (TREE_TYPE (lhs_type
))))
4282 error ("type mismatch in %qs", code_name
);
4283 debug_generic_expr (lhs_type
);
4284 debug_generic_expr (rhs1_type
);
4285 debug_generic_expr (rhs2_type
);
4286 debug_generic_expr (rhs3_type
);
4290 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4291 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
4292 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
4294 error ("vector types expected in %qs", code_name
);
4295 debug_generic_expr (lhs_type
);
4296 debug_generic_expr (rhs1_type
);
4297 debug_generic_expr (rhs2_type
);
4298 debug_generic_expr (rhs3_type
);
4304 case BIT_INSERT_EXPR
:
4305 if (! useless_type_conversion_p (lhs_type
, rhs1_type
))
4307 error ("type mismatch in %qs", code_name
);
4308 debug_generic_expr (lhs_type
);
4309 debug_generic_expr (rhs1_type
);
4312 if (! ((INTEGRAL_TYPE_P (rhs1_type
)
4313 && INTEGRAL_TYPE_P (rhs2_type
))
4314 /* Vector element insert. */
4315 || (VECTOR_TYPE_P (rhs1_type
)
4316 && types_compatible_p (TREE_TYPE (rhs1_type
), rhs2_type
))
4317 /* Aligned sub-vector insert. */
4318 || (VECTOR_TYPE_P (rhs1_type
)
4319 && VECTOR_TYPE_P (rhs2_type
)
4320 && types_compatible_p (TREE_TYPE (rhs1_type
),
4321 TREE_TYPE (rhs2_type
))
4322 && multiple_p (TYPE_VECTOR_SUBPARTS (rhs1_type
),
4323 TYPE_VECTOR_SUBPARTS (rhs2_type
))
4324 && multiple_of_p (bitsizetype
, rhs3
, TYPE_SIZE (rhs2_type
)))))
4326 error ("not allowed type combination in %qs", code_name
);
4327 debug_generic_expr (rhs1_type
);
4328 debug_generic_expr (rhs2_type
);
4331 if (! tree_fits_uhwi_p (rhs3
)
4332 || ! types_compatible_p (bitsizetype
, TREE_TYPE (rhs3
))
4333 || ! tree_fits_uhwi_p (TYPE_SIZE (rhs2_type
)))
4335 error ("invalid position or size in %qs", code_name
);
4338 if (INTEGRAL_TYPE_P (rhs1_type
)
4339 && !type_has_mode_precision_p (rhs1_type
))
4341 error ("%qs into non-mode-precision operand", code_name
);
4344 if (INTEGRAL_TYPE_P (rhs1_type
))
4346 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (rhs3
);
4347 if (bitpos
>= TYPE_PRECISION (rhs1_type
)
4348 || (bitpos
+ TYPE_PRECISION (rhs2_type
)
4349 > TYPE_PRECISION (rhs1_type
)))
4351 error ("insertion out of range in %qs", code_name
);
4355 else if (VECTOR_TYPE_P (rhs1_type
))
4357 unsigned HOST_WIDE_INT bitpos
= tree_to_uhwi (rhs3
);
4358 unsigned HOST_WIDE_INT bitsize
= tree_to_uhwi (TYPE_SIZE (rhs2_type
));
4359 if (bitpos
% bitsize
!= 0)
4361 error ("%qs not at element boundary", code_name
);
4369 if (((TREE_CODE (rhs1_type
) != VECTOR_TYPE
4370 || TREE_CODE (lhs_type
) != VECTOR_TYPE
)
4371 && ((!INTEGRAL_TYPE_P (rhs1_type
)
4372 && !SCALAR_FLOAT_TYPE_P (rhs1_type
))
4373 || (!INTEGRAL_TYPE_P (lhs_type
)
4374 && !SCALAR_FLOAT_TYPE_P (lhs_type
))))
4375 || !types_compatible_p (rhs1_type
, rhs2_type
)
4376 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
4377 || maybe_lt (GET_MODE_SIZE (element_mode (rhs3_type
)),
4378 2 * GET_MODE_SIZE (element_mode (rhs1_type
))))
4380 error ("type mismatch in %qs", code_name
);
4381 debug_generic_expr (lhs_type
);
4382 debug_generic_expr (rhs1_type
);
4383 debug_generic_expr (rhs2_type
);
4389 case REALIGN_LOAD_EXPR
:
4399 /* Verify a gimple assignment statement STMT with a single rhs.
4400 Returns true if anything is wrong. */
4403 verify_gimple_assign_single (gassign
*stmt
)
4405 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
4406 tree lhs
= gimple_assign_lhs (stmt
);
4407 tree lhs_type
= TREE_TYPE (lhs
);
4408 tree rhs1
= gimple_assign_rhs1 (stmt
);
4409 tree rhs1_type
= TREE_TYPE (rhs1
);
4412 const char* const code_name
= get_tree_code_name (rhs_code
);
4414 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
4416 error ("non-trivial conversion in %qs", code_name
);
4417 debug_generic_expr (lhs_type
);
4418 debug_generic_expr (rhs1_type
);
4422 if (gimple_clobber_p (stmt
)
4423 && !(DECL_P (lhs
) || TREE_CODE (lhs
) == MEM_REF
))
4425 error ("%qs LHS in clobber statement",
4426 get_tree_code_name (TREE_CODE (lhs
)));
4427 debug_generic_expr (lhs
);
4431 if (handled_component_p (lhs
)
4432 || TREE_CODE (lhs
) == MEM_REF
4433 || TREE_CODE (lhs
) == TARGET_MEM_REF
)
4434 res
|= verify_types_in_gimple_reference (lhs
, true);
4436 /* Special codes we cannot handle via their class. */
4441 tree op
= TREE_OPERAND (rhs1
, 0);
4442 if (!is_gimple_addressable (op
))
4444 error ("invalid operand in %qs", code_name
);
4448 /* Technically there is no longer a need for matching types, but
4449 gimple hygiene asks for this check. In LTO we can end up
4450 combining incompatible units and thus end up with addresses
4451 of globals that change their type to a common one. */
4453 && !types_compatible_p (TREE_TYPE (op
),
4454 TREE_TYPE (TREE_TYPE (rhs1
)))
4455 && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1
),
4458 error ("type mismatch in %qs", code_name
);
4459 debug_generic_stmt (TREE_TYPE (rhs1
));
4460 debug_generic_stmt (TREE_TYPE (op
));
4464 return (verify_address (rhs1
, true)
4465 || verify_types_in_gimple_reference (op
, true));
4470 error ("%qs in gimple IL", code_name
);
4476 case ARRAY_RANGE_REF
:
4477 case VIEW_CONVERT_EXPR
:
4480 case TARGET_MEM_REF
:
4482 if (!is_gimple_reg (lhs
)
4483 && is_gimple_reg_type (TREE_TYPE (lhs
)))
4485 error ("invalid RHS for gimple memory store: %qs", code_name
);
4486 debug_generic_stmt (lhs
);
4487 debug_generic_stmt (rhs1
);
4490 return res
|| verify_types_in_gimple_reference (rhs1
, false);
4502 /* tcc_declaration */
4507 if (!is_gimple_reg (lhs
)
4508 && !is_gimple_reg (rhs1
)
4509 && is_gimple_reg_type (TREE_TYPE (lhs
)))
4511 error ("invalid RHS for gimple memory store: %qs", code_name
);
4512 debug_generic_stmt (lhs
);
4513 debug_generic_stmt (rhs1
);
4519 if (TREE_CODE (rhs1_type
) == VECTOR_TYPE
)
4522 tree elt_i
, elt_v
, elt_t
= NULL_TREE
;
4524 if (CONSTRUCTOR_NELTS (rhs1
) == 0)
4526 /* For vector CONSTRUCTORs we require that either it is empty
4527 CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
4528 (then the element count must be correct to cover the whole
4529 outer vector and index must be NULL on all elements, or it is
4530 a CONSTRUCTOR of scalar elements, where we as an exception allow
4531 smaller number of elements (assuming zero filling) and
4532 consecutive indexes as compared to NULL indexes (such
4533 CONSTRUCTORs can appear in the IL from FEs). */
4534 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1
), i
, elt_i
, elt_v
)
4536 if (elt_t
== NULL_TREE
)
4538 elt_t
= TREE_TYPE (elt_v
);
4539 if (TREE_CODE (elt_t
) == VECTOR_TYPE
)
4541 tree elt_t
= TREE_TYPE (elt_v
);
4542 if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
4545 error ("incorrect type of vector %qs elements",
4547 debug_generic_stmt (rhs1
);
4550 else if (maybe_ne (CONSTRUCTOR_NELTS (rhs1
)
4551 * TYPE_VECTOR_SUBPARTS (elt_t
),
4552 TYPE_VECTOR_SUBPARTS (rhs1_type
)))
4554 error ("incorrect number of vector %qs elements",
4556 debug_generic_stmt (rhs1
);
4560 else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
4563 error ("incorrect type of vector %qs elements",
4565 debug_generic_stmt (rhs1
);
4568 else if (maybe_gt (CONSTRUCTOR_NELTS (rhs1
),
4569 TYPE_VECTOR_SUBPARTS (rhs1_type
)))
4571 error ("incorrect number of vector %qs elements",
4573 debug_generic_stmt (rhs1
);
4577 else if (!useless_type_conversion_p (elt_t
, TREE_TYPE (elt_v
)))
4579 error ("incorrect type of vector CONSTRUCTOR elements");
4580 debug_generic_stmt (rhs1
);
4583 if (elt_i
!= NULL_TREE
4584 && (TREE_CODE (elt_t
) == VECTOR_TYPE
4585 || TREE_CODE (elt_i
) != INTEGER_CST
4586 || compare_tree_int (elt_i
, i
) != 0))
4588 error ("vector %qs with non-NULL element index",
4590 debug_generic_stmt (rhs1
);
4593 if (!is_gimple_val (elt_v
))
4595 error ("vector %qs element is not a GIMPLE value",
4597 debug_generic_stmt (rhs1
);
4602 else if (CONSTRUCTOR_NELTS (rhs1
) != 0)
4604 error ("non-vector %qs with elements", code_name
);
4605 debug_generic_stmt (rhs1
);
4612 rhs1
= fold (ASSERT_EXPR_COND (rhs1
));
4613 if (rhs1
== boolean_false_node
)
4615 error ("%qs with an always-false condition", code_name
);
4616 debug_generic_stmt (rhs1
);
4622 case WITH_SIZE_EXPR
:
4632 /* Verify the contents of a GIMPLE_ASSIGN STMT. Returns true when there
4633 is a problem, otherwise false. */
4636 verify_gimple_assign (gassign
*stmt
)
4638 switch (gimple_assign_rhs_class (stmt
))
4640 case GIMPLE_SINGLE_RHS
:
4641 return verify_gimple_assign_single (stmt
);
4643 case GIMPLE_UNARY_RHS
:
4644 return verify_gimple_assign_unary (stmt
);
4646 case GIMPLE_BINARY_RHS
:
4647 return verify_gimple_assign_binary (stmt
);
4649 case GIMPLE_TERNARY_RHS
:
4650 return verify_gimple_assign_ternary (stmt
);
4657 /* Verify the contents of a GIMPLE_RETURN STMT. Returns true when there
4658 is a problem, otherwise false. */
4661 verify_gimple_return (greturn
*stmt
)
4663 tree op
= gimple_return_retval (stmt
);
4664 tree restype
= TREE_TYPE (TREE_TYPE (cfun
->decl
));
4666 /* We cannot test for present return values as we do not fix up missing
4667 return values from the original source. */
4671 if (!is_gimple_val (op
)
4672 && TREE_CODE (op
) != RESULT_DECL
)
4674 error ("invalid operand in return statement");
4675 debug_generic_stmt (op
);
4679 if ((TREE_CODE (op
) == RESULT_DECL
4680 && DECL_BY_REFERENCE (op
))
4681 || (TREE_CODE (op
) == SSA_NAME
4682 && SSA_NAME_VAR (op
)
4683 && TREE_CODE (SSA_NAME_VAR (op
)) == RESULT_DECL
4684 && DECL_BY_REFERENCE (SSA_NAME_VAR (op
))))
4685 op
= TREE_TYPE (op
);
4687 if (!useless_type_conversion_p (restype
, TREE_TYPE (op
)))
4689 error ("invalid conversion in return statement");
4690 debug_generic_stmt (restype
);
4691 debug_generic_stmt (TREE_TYPE (op
));
4699 /* Verify the contents of a GIMPLE_GOTO STMT. Returns true when there
4700 is a problem, otherwise false. */
4703 verify_gimple_goto (ggoto
*stmt
)
4705 tree dest
= gimple_goto_dest (stmt
);
4707 /* ??? We have two canonical forms of direct goto destinations, a
4708 bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
4709 if (TREE_CODE (dest
) != LABEL_DECL
4710 && (!is_gimple_val (dest
)
4711 || !POINTER_TYPE_P (TREE_TYPE (dest
))))
4713 error ("goto destination is neither a label nor a pointer");
4720 /* Verify the contents of a GIMPLE_SWITCH STMT. Returns true when there
4721 is a problem, otherwise false. */
4724 verify_gimple_switch (gswitch
*stmt
)
4727 tree elt
, prev_upper_bound
= NULL_TREE
;
4728 tree index_type
, elt_type
= NULL_TREE
;
4730 if (!is_gimple_val (gimple_switch_index (stmt
)))
4732 error ("invalid operand to switch statement");
4733 debug_generic_stmt (gimple_switch_index (stmt
));
4737 index_type
= TREE_TYPE (gimple_switch_index (stmt
));
4738 if (! INTEGRAL_TYPE_P (index_type
))
4740 error ("non-integral type switch statement");
4741 debug_generic_expr (index_type
);
4745 elt
= gimple_switch_label (stmt
, 0);
4746 if (CASE_LOW (elt
) != NULL_TREE
4747 || CASE_HIGH (elt
) != NULL_TREE
4748 || CASE_CHAIN (elt
) != NULL_TREE
)
4750 error ("invalid default case label in switch statement");
4751 debug_generic_expr (elt
);
4755 n
= gimple_switch_num_labels (stmt
);
4756 for (i
= 1; i
< n
; i
++)
4758 elt
= gimple_switch_label (stmt
, i
);
4760 if (CASE_CHAIN (elt
))
4762 error ("invalid %<CASE_CHAIN%>");
4763 debug_generic_expr (elt
);
4766 if (! CASE_LOW (elt
))
4768 error ("invalid case label in switch statement");
4769 debug_generic_expr (elt
);
4773 && ! tree_int_cst_lt (CASE_LOW (elt
), CASE_HIGH (elt
)))
4775 error ("invalid case range in switch statement");
4776 debug_generic_expr (elt
);
4782 if (TREE_TYPE (CASE_LOW (elt
)) != elt_type
4783 || (CASE_HIGH (elt
) && TREE_TYPE (CASE_HIGH (elt
)) != elt_type
))
4785 error ("type mismatch for case label in switch statement");
4786 debug_generic_expr (elt
);
4792 elt_type
= TREE_TYPE (CASE_LOW (elt
));
4793 if (TYPE_PRECISION (index_type
) < TYPE_PRECISION (elt_type
))
4795 error ("type precision mismatch in switch statement");
4800 if (prev_upper_bound
)
4802 if (! tree_int_cst_lt (prev_upper_bound
, CASE_LOW (elt
)))
4804 error ("case labels not sorted in switch statement");
4809 prev_upper_bound
= CASE_HIGH (elt
);
4810 if (! prev_upper_bound
)
4811 prev_upper_bound
= CASE_LOW (elt
);
4817 /* Verify a gimple debug statement STMT.
4818 Returns true if anything is wrong. */
4821 verify_gimple_debug (gimple
*stmt ATTRIBUTE_UNUSED
)
4823 /* There isn't much that could be wrong in a gimple debug stmt. A
4824 gimple debug bind stmt, for example, maps a tree, that's usually
4825 a VAR_DECL or a PARM_DECL, but that could also be some scalarized
4826 component or member of an aggregate type, to another tree, that
4827 can be an arbitrary expression. These stmts expand into debug
4828 insns, and are converted to debug notes by var-tracking.c. */
4832 /* Verify a gimple label statement STMT.
4833 Returns true if anything is wrong. */
4836 verify_gimple_label (glabel
*stmt
)
4838 tree decl
= gimple_label_label (stmt
);
4842 if (TREE_CODE (decl
) != LABEL_DECL
)
4844 if (!DECL_NONLOCAL (decl
) && !FORCED_LABEL (decl
)
4845 && DECL_CONTEXT (decl
) != current_function_decl
)
4847 error ("label context is not the current function declaration");
4851 uid
= LABEL_DECL_UID (decl
);
4854 || (*label_to_block_map_for_fn (cfun
))[uid
] != gimple_bb (stmt
)))
4856 error ("incorrect entry in %<label_to_block_map%>");
4860 uid
= EH_LANDING_PAD_NR (decl
);
4863 eh_landing_pad lp
= get_eh_landing_pad_from_number (uid
);
4864 if (decl
!= lp
->post_landing_pad
)
4866 error ("incorrect setting of landing pad number");
4874 /* Verify a gimple cond statement STMT.
4875 Returns true if anything is wrong. */
4878 verify_gimple_cond (gcond
*stmt
)
4880 if (TREE_CODE_CLASS (gimple_cond_code (stmt
)) != tcc_comparison
)
4882 error ("invalid comparison code in gimple cond");
4885 if (!(!gimple_cond_true_label (stmt
)
4886 || TREE_CODE (gimple_cond_true_label (stmt
)) == LABEL_DECL
)
4887 || !(!gimple_cond_false_label (stmt
)
4888 || TREE_CODE (gimple_cond_false_label (stmt
)) == LABEL_DECL
))
4890 error ("invalid labels in gimple cond");
4894 return verify_gimple_comparison (boolean_type_node
,
4895 gimple_cond_lhs (stmt
),
4896 gimple_cond_rhs (stmt
),
4897 gimple_cond_code (stmt
));
4900 /* Verify the GIMPLE statement STMT. Returns true if there is an
4901 error, otherwise false. */
4904 verify_gimple_stmt (gimple
*stmt
)
4906 switch (gimple_code (stmt
))
4909 return verify_gimple_assign (as_a
<gassign
*> (stmt
));
4912 return verify_gimple_label (as_a
<glabel
*> (stmt
));
4915 return verify_gimple_call (as_a
<gcall
*> (stmt
));
4918 return verify_gimple_cond (as_a
<gcond
*> (stmt
));
4921 return verify_gimple_goto (as_a
<ggoto
*> (stmt
));
4924 return verify_gimple_switch (as_a
<gswitch
*> (stmt
));
4927 return verify_gimple_return (as_a
<greturn
*> (stmt
));
4932 case GIMPLE_TRANSACTION
:
4933 return verify_gimple_transaction (as_a
<gtransaction
*> (stmt
));
4935 /* Tuples that do not have tree operands. */
4937 case GIMPLE_PREDICT
:
4939 case GIMPLE_EH_DISPATCH
:
4940 case GIMPLE_EH_MUST_NOT_THROW
:
4944 /* OpenMP directives are validated by the FE and never operated
4945 on by the optimizers. Furthermore, GIMPLE_OMP_FOR may contain
4946 non-gimple expressions when the main index variable has had
4947 its address taken. This does not affect the loop itself
4948 because the header of an GIMPLE_OMP_FOR is merely used to determine
4949 how to setup the parallel iteration. */
4953 return verify_gimple_debug (stmt
);
4960 /* Verify the contents of a GIMPLE_PHI. Returns true if there is a problem,
4961 and false otherwise. */
4964 verify_gimple_phi (gphi
*phi
)
4968 tree phi_result
= gimple_phi_result (phi
);
4973 error ("invalid %<PHI%> result");
4977 virtual_p
= virtual_operand_p (phi_result
);
4978 if (TREE_CODE (phi_result
) != SSA_NAME
4980 && SSA_NAME_VAR (phi_result
) != gimple_vop (cfun
)))
4982 error ("invalid %<PHI%> result");
4986 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4988 tree t
= gimple_phi_arg_def (phi
, i
);
4992 error ("missing %<PHI%> def");
4996 /* Addressable variables do have SSA_NAMEs but they
4997 are not considered gimple values. */
4998 else if ((TREE_CODE (t
) == SSA_NAME
4999 && virtual_p
!= virtual_operand_p (t
))
5001 && (TREE_CODE (t
) != SSA_NAME
5002 || SSA_NAME_VAR (t
) != gimple_vop (cfun
)))
5004 && !is_gimple_val (t
)))
5006 error ("invalid %<PHI%> argument");
5007 debug_generic_expr (t
);
5010 #ifdef ENABLE_TYPES_CHECKING
5011 if (!useless_type_conversion_p (TREE_TYPE (phi_result
), TREE_TYPE (t
)))
5013 error ("incompatible types in %<PHI%> argument %u", i
);
5014 debug_generic_stmt (TREE_TYPE (phi_result
));
5015 debug_generic_stmt (TREE_TYPE (t
));
5024 /* Verify the GIMPLE statements inside the sequence STMTS. */
5027 verify_gimple_in_seq_2 (gimple_seq stmts
)
5029 gimple_stmt_iterator ittr
;
5032 for (ittr
= gsi_start (stmts
); !gsi_end_p (ittr
); gsi_next (&ittr
))
5034 gimple
*stmt
= gsi_stmt (ittr
);
5036 switch (gimple_code (stmt
))
5039 err
|= verify_gimple_in_seq_2 (
5040 gimple_bind_body (as_a
<gbind
*> (stmt
)));
5044 err
|= verify_gimple_in_seq_2 (gimple_try_eval (stmt
));
5045 err
|= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt
));
5048 case GIMPLE_EH_FILTER
:
5049 err
|= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt
));
5052 case GIMPLE_EH_ELSE
:
5054 geh_else
*eh_else
= as_a
<geh_else
*> (stmt
);
5055 err
|= verify_gimple_in_seq_2 (gimple_eh_else_n_body (eh_else
));
5056 err
|= verify_gimple_in_seq_2 (gimple_eh_else_e_body (eh_else
));
5061 err
|= verify_gimple_in_seq_2 (gimple_catch_handler (
5062 as_a
<gcatch
*> (stmt
)));
5065 case GIMPLE_TRANSACTION
:
5066 err
|= verify_gimple_transaction (as_a
<gtransaction
*> (stmt
));
5071 bool err2
= verify_gimple_stmt (stmt
);
5073 debug_gimple_stmt (stmt
);
5082 /* Verify the contents of a GIMPLE_TRANSACTION. Returns true if there
5083 is a problem, otherwise false. */
5086 verify_gimple_transaction (gtransaction
*stmt
)
5090 lab
= gimple_transaction_label_norm (stmt
);
5091 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
5093 lab
= gimple_transaction_label_uninst (stmt
);
5094 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
5096 lab
= gimple_transaction_label_over (stmt
);
5097 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
5100 return verify_gimple_in_seq_2 (gimple_transaction_body (stmt
));
5104 /* Verify the GIMPLE statements inside the statement list STMTS. */
5107 verify_gimple_in_seq (gimple_seq stmts
)
5109 timevar_push (TV_TREE_STMT_VERIFY
);
5110 if (verify_gimple_in_seq_2 (stmts
))
5111 internal_error ("%<verify_gimple%> failed");
5112 timevar_pop (TV_TREE_STMT_VERIFY
);
5115 /* Return true when the T can be shared. */
5118 tree_node_can_be_shared (tree t
)
5120 if (IS_TYPE_OR_DECL_P (t
)
5121 || TREE_CODE (t
) == SSA_NAME
5122 || TREE_CODE (t
) == IDENTIFIER_NODE
5123 || TREE_CODE (t
) == CASE_LABEL_EXPR
5124 || is_gimple_min_invariant (t
))
5127 if (t
== error_mark_node
)
5133 /* Called via walk_tree. Verify tree sharing. */
5136 verify_node_sharing_1 (tree
*tp
, int *walk_subtrees
, void *data
)
5138 hash_set
<void *> *visited
= (hash_set
<void *> *) data
;
5140 if (tree_node_can_be_shared (*tp
))
5142 *walk_subtrees
= false;
5146 if (visited
->add (*tp
))
5152 /* Called via walk_gimple_stmt. Verify tree sharing. */
5155 verify_node_sharing (tree
*tp
, int *walk_subtrees
, void *data
)
5157 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
5158 return verify_node_sharing_1 (tp
, walk_subtrees
, wi
->info
);
5161 static bool eh_error_found
;
5163 verify_eh_throw_stmt_node (gimple
*const &stmt
, const int &,
5164 hash_set
<gimple
*> *visited
)
5166 if (!visited
->contains (stmt
))
5168 error ("dead statement in EH table");
5169 debug_gimple_stmt (stmt
);
5170 eh_error_found
= true;
5175 /* Verify if the location LOCs block is in BLOCKS. */
5178 verify_location (hash_set
<tree
> *blocks
, location_t loc
)
5180 tree block
= LOCATION_BLOCK (loc
);
5181 if (block
!= NULL_TREE
5182 && !blocks
->contains (block
))
5184 error ("location references block not in block tree");
5187 if (block
!= NULL_TREE
)
5188 return verify_location (blocks
, BLOCK_SOURCE_LOCATION (block
));
5192 /* Called via walk_tree. Verify that expressions have no blocks. */
5195 verify_expr_no_block (tree
*tp
, int *walk_subtrees
, void *)
5199 *walk_subtrees
= false;
5203 location_t loc
= EXPR_LOCATION (*tp
);
5204 if (LOCATION_BLOCK (loc
) != NULL
)
5210 /* Called via walk_tree. Verify locations of expressions. */
5213 verify_expr_location_1 (tree
*tp
, int *walk_subtrees
, void *data
)
5215 hash_set
<tree
> *blocks
= (hash_set
<tree
> *) data
;
5218 /* ??? This doesn't really belong here but there's no good place to
5219 stick this remainder of old verify_expr. */
5220 /* ??? This barfs on debug stmts which contain binds to vars with
5221 different function context. */
5224 || TREE_CODE (t
) == PARM_DECL
5225 || TREE_CODE (t
) == RESULT_DECL
)
5227 tree context
= decl_function_context (t
);
5228 if (context
!= cfun
->decl
5229 && !SCOPE_FILE_SCOPE_P (context
)
5231 && !DECL_EXTERNAL (t
))
5233 error ("local declaration from a different function");
5239 if (VAR_P (t
) && DECL_HAS_DEBUG_EXPR_P (t
))
5241 tree x
= DECL_DEBUG_EXPR (t
);
5242 tree addr
= walk_tree (&x
, verify_expr_no_block
, NULL
, NULL
);
5247 || TREE_CODE (t
) == PARM_DECL
5248 || TREE_CODE (t
) == RESULT_DECL
)
5249 && DECL_HAS_VALUE_EXPR_P (t
))
5251 tree x
= DECL_VALUE_EXPR (t
);
5252 tree addr
= walk_tree (&x
, verify_expr_no_block
, NULL
, NULL
);
5259 *walk_subtrees
= false;
5263 location_t loc
= EXPR_LOCATION (t
);
5264 if (verify_location (blocks
, loc
))
5270 /* Called via walk_gimple_op. Verify locations of expressions. */
5273 verify_expr_location (tree
*tp
, int *walk_subtrees
, void *data
)
5275 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
5276 return verify_expr_location_1 (tp
, walk_subtrees
, wi
->info
);
5279 /* Insert all subblocks of BLOCK into BLOCKS and recurse. */
5282 collect_subblocks (hash_set
<tree
> *blocks
, tree block
)
5285 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
5288 collect_subblocks (blocks
, t
);
5292 /* Disable warnings about missing quoting in GCC diagnostics for
5293 the verification errors. Their format strings don't follow
5294 GCC diagnostic conventions and trigger an ICE in the end. */
5296 # pragma GCC diagnostic push
5297 # pragma GCC diagnostic ignored "-Wformat-diag"
5300 /* Verify the GIMPLE statements in the CFG of FN. */
5303 verify_gimple_in_cfg (struct function
*fn
, bool verify_nothrow
)
5308 timevar_push (TV_TREE_STMT_VERIFY
);
5309 hash_set
<void *> visited
;
5310 hash_set
<gimple
*> visited_throwing_stmts
;
5312 /* Collect all BLOCKs referenced by the BLOCK tree of FN. */
5313 hash_set
<tree
> blocks
;
5314 if (DECL_INITIAL (fn
->decl
))
5316 blocks
.add (DECL_INITIAL (fn
->decl
));
5317 collect_subblocks (&blocks
, DECL_INITIAL (fn
->decl
));
5320 FOR_EACH_BB_FN (bb
, fn
)
5322 gimple_stmt_iterator gsi
;
5326 for (gphi_iterator gpi
= gsi_start_phis (bb
);
5330 gphi
*phi
= gpi
.phi ();
5334 if (gimple_bb (phi
) != bb
)
5336 error ("gimple_bb (phi) is set to a wrong basic block");
5340 err2
|= verify_gimple_phi (phi
);
5342 /* Only PHI arguments have locations. */
5343 if (gimple_location (phi
) != UNKNOWN_LOCATION
)
5345 error ("PHI node with location");
5349 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
5351 tree arg
= gimple_phi_arg_def (phi
, i
);
5352 tree addr
= walk_tree (&arg
, verify_node_sharing_1
,
5356 error ("incorrect sharing of tree nodes");
5357 debug_generic_expr (addr
);
5360 location_t loc
= gimple_phi_arg_location (phi
, i
);
5361 if (virtual_operand_p (gimple_phi_result (phi
))
5362 && loc
!= UNKNOWN_LOCATION
)
5364 error ("virtual PHI with argument locations");
5367 addr
= walk_tree (&arg
, verify_expr_location_1
, &blocks
, NULL
);
5370 debug_generic_expr (addr
);
5373 err2
|= verify_location (&blocks
, loc
);
5377 debug_gimple_stmt (phi
);
5381 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5383 gimple
*stmt
= gsi_stmt (gsi
);
5385 struct walk_stmt_info wi
;
5389 if (gimple_bb (stmt
) != bb
)
5391 error ("gimple_bb (stmt) is set to a wrong basic block");
5395 err2
|= verify_gimple_stmt (stmt
);
5396 err2
|= verify_location (&blocks
, gimple_location (stmt
));
5398 memset (&wi
, 0, sizeof (wi
));
5399 wi
.info
= (void *) &visited
;
5400 addr
= walk_gimple_op (stmt
, verify_node_sharing
, &wi
);
5403 error ("incorrect sharing of tree nodes");
5404 debug_generic_expr (addr
);
5408 memset (&wi
, 0, sizeof (wi
));
5409 wi
.info
= (void *) &blocks
;
5410 addr
= walk_gimple_op (stmt
, verify_expr_location
, &wi
);
5413 debug_generic_expr (addr
);
5417 /* If the statement is marked as part of an EH region, then it is
5418 expected that the statement could throw. Verify that when we
5419 have optimizations that simplify statements such that we prove
5420 that they cannot throw, that we update other data structures
5422 lp_nr
= lookup_stmt_eh_lp (stmt
);
5424 visited_throwing_stmts
.add (stmt
);
5427 if (!stmt_could_throw_p (cfun
, stmt
))
5431 error ("statement marked for throw, but doesn%'t");
5435 else if (!gsi_one_before_end_p (gsi
))
5437 error ("statement marked for throw in middle of block");
5443 debug_gimple_stmt (stmt
);
5447 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5448 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
5449 err
|= verify_location (&blocks
, e
->goto_locus
);
5452 hash_map
<gimple
*, int> *eh_table
= get_eh_throw_stmt_table (cfun
);
5453 eh_error_found
= false;
5455 eh_table
->traverse
<hash_set
<gimple
*> *, verify_eh_throw_stmt_node
>
5456 (&visited_throwing_stmts
);
5458 if (err
|| eh_error_found
)
5459 internal_error ("verify_gimple failed");
5461 verify_histograms ();
5462 timevar_pop (TV_TREE_STMT_VERIFY
);
5466 /* Verifies that the flow information is OK. */
5469 gimple_verify_flow_info (void)
5473 gimple_stmt_iterator gsi
;
5478 if (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.seq
5479 || ENTRY_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.phi_nodes
)
5481 error ("ENTRY_BLOCK has IL associated with it");
5485 if (EXIT_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.seq
5486 || EXIT_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.phi_nodes
)
5488 error ("EXIT_BLOCK has IL associated with it");
5492 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5493 if (e
->flags
& EDGE_FALLTHRU
)
5495 error ("fallthru to exit from bb %d", e
->src
->index
);
5499 FOR_EACH_BB_FN (bb
, cfun
)
5501 bool found_ctrl_stmt
= false;
5505 /* Skip labels on the start of basic block. */
5506 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5509 gimple
*prev_stmt
= stmt
;
5511 stmt
= gsi_stmt (gsi
);
5513 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5516 label
= gimple_label_label (as_a
<glabel
*> (stmt
));
5517 if (prev_stmt
&& DECL_NONLOCAL (label
))
5519 error ("nonlocal label ");
5520 print_generic_expr (stderr
, label
);
5521 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
5526 if (prev_stmt
&& EH_LANDING_PAD_NR (label
) != 0)
5528 error ("EH landing pad label ");
5529 print_generic_expr (stderr
, label
);
5530 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
5535 if (label_to_block (cfun
, label
) != bb
)
5538 print_generic_expr (stderr
, label
);
5539 fprintf (stderr
, " to block does not match in bb %d",
5544 if (decl_function_context (label
) != current_function_decl
)
5547 print_generic_expr (stderr
, label
);
5548 fprintf (stderr
, " has incorrect context in bb %d",
5554 /* Verify that body of basic block BB is free of control flow. */
5555 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5557 gimple
*stmt
= gsi_stmt (gsi
);
5559 if (found_ctrl_stmt
)
5561 error ("control flow in the middle of basic block %d",
5566 if (stmt_ends_bb_p (stmt
))
5567 found_ctrl_stmt
= true;
5569 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
5572 print_generic_expr (stderr
, gimple_label_label (label_stmt
));
5573 fprintf (stderr
, " in the middle of basic block %d", bb
->index
);
5578 gsi
= gsi_last_nondebug_bb (bb
);
5579 if (gsi_end_p (gsi
))
5582 stmt
= gsi_stmt (gsi
);
5584 if (gimple_code (stmt
) == GIMPLE_LABEL
)
5587 err
|= verify_eh_edges (stmt
);
5589 if (is_ctrl_stmt (stmt
))
5591 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5592 if (e
->flags
& EDGE_FALLTHRU
)
5594 error ("fallthru edge after a control statement in bb %d",
5600 if (gimple_code (stmt
) != GIMPLE_COND
)
5602 /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
5603 after anything else but if statement. */
5604 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5605 if (e
->flags
& (EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
))
5607 error ("true/false edge after a non-GIMPLE_COND in bb %d",
5613 switch (gimple_code (stmt
))
5620 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
5624 || !(true_edge
->flags
& EDGE_TRUE_VALUE
)
5625 || !(false_edge
->flags
& EDGE_FALSE_VALUE
)
5626 || (true_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
5627 || (false_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
5628 || EDGE_COUNT (bb
->succs
) >= 3)
5630 error ("wrong outgoing edge flags at end of bb %d",
5638 if (simple_goto_p (stmt
))
5640 error ("explicit goto at end of bb %d", bb
->index
);
5645 /* FIXME. We should double check that the labels in the
5646 destination blocks have their address taken. */
5647 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5648 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_TRUE_VALUE
5649 | EDGE_FALSE_VALUE
))
5650 || !(e
->flags
& EDGE_ABNORMAL
))
5652 error ("wrong outgoing edge flags at end of bb %d",
5660 if (!gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
))
5664 if (!single_succ_p (bb
)
5665 || (single_succ_edge (bb
)->flags
5666 & (EDGE_FALLTHRU
| EDGE_ABNORMAL
5667 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5669 error ("wrong outgoing edge flags at end of bb %d", bb
->index
);
5672 if (single_succ (bb
) != EXIT_BLOCK_PTR_FOR_FN (cfun
))
5674 error ("return edge does not point to exit in bb %d",
5682 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
5687 n
= gimple_switch_num_labels (switch_stmt
);
5689 /* Mark all the destination basic blocks. */
5690 for (i
= 0; i
< n
; ++i
)
5692 basic_block label_bb
= gimple_switch_label_bb (cfun
, switch_stmt
, i
);
5693 gcc_assert (!label_bb
->aux
|| label_bb
->aux
== (void *)1);
5694 label_bb
->aux
= (void *)1;
5697 /* Verify that the case labels are sorted. */
5698 prev
= gimple_switch_label (switch_stmt
, 0);
5699 for (i
= 1; i
< n
; ++i
)
5701 tree c
= gimple_switch_label (switch_stmt
, i
);
5704 error ("found default case not at the start of "
5710 && !tree_int_cst_lt (CASE_LOW (prev
), CASE_LOW (c
)))
5712 error ("case labels not sorted: ");
5713 print_generic_expr (stderr
, prev
);
5714 fprintf (stderr
," is greater than ");
5715 print_generic_expr (stderr
, c
);
5716 fprintf (stderr
," but comes before it.\n");
5721 /* VRP will remove the default case if it can prove it will
5722 never be executed. So do not verify there always exists
5723 a default case here. */
5725 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5729 error ("extra outgoing edge %d->%d",
5730 bb
->index
, e
->dest
->index
);
5734 e
->dest
->aux
= (void *)2;
5735 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
5736 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5738 error ("wrong outgoing edge flags at end of bb %d",
5744 /* Check that we have all of them. */
5745 for (i
= 0; i
< n
; ++i
)
5747 basic_block label_bb
= gimple_switch_label_bb (cfun
,
5750 if (label_bb
->aux
!= (void *)2)
5752 error ("missing edge %i->%i", bb
->index
, label_bb
->index
);
5757 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5758 e
->dest
->aux
= (void *)0;
5762 case GIMPLE_EH_DISPATCH
:
5763 err
|= verify_eh_dispatch_edge (as_a
<geh_dispatch
*> (stmt
));
5771 if (dom_info_state (CDI_DOMINATORS
) >= DOM_NO_FAST_QUERY
)
5772 verify_dominators (CDI_DOMINATORS
);
5778 # pragma GCC diagnostic pop
5781 /* Updates phi nodes after creating a forwarder block joined
5782 by edge FALLTHRU. */
5785 gimple_make_forwarder_block (edge fallthru
)
5789 basic_block dummy
, bb
;
5792 bool forward_location_p
;
5794 dummy
= fallthru
->src
;
5795 bb
= fallthru
->dest
;
5797 if (single_pred_p (bb
))
5800 /* We can forward location info if we have only one predecessor. */
5801 forward_location_p
= single_pred_p (dummy
);
5803 /* If we redirected a branch we must create new PHI nodes at the
5805 for (gsi
= gsi_start_phis (dummy
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5807 gphi
*phi
, *new_phi
;
5810 var
= gimple_phi_result (phi
);
5811 new_phi
= create_phi_node (var
, bb
);
5812 gimple_phi_set_result (phi
, copy_ssa_name (var
, phi
));
5813 add_phi_arg (new_phi
, gimple_phi_result (phi
), fallthru
,
5815 ? gimple_phi_arg_location (phi
, 0) : UNKNOWN_LOCATION
);
5818 /* Add the arguments we have stored on edges. */
5819 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
5824 flush_pending_stmts (e
);
5829 /* Return a non-special label in the head of basic block BLOCK.
5830 Create one if it doesn't exist. */
5833 gimple_block_label (basic_block bb
)
5835 gimple_stmt_iterator i
, s
= gsi_start_bb (bb
);
5840 for (i
= s
; !gsi_end_p (i
); first
= false, gsi_next (&i
))
5842 stmt
= dyn_cast
<glabel
*> (gsi_stmt (i
));
5845 label
= gimple_label_label (stmt
);
5846 if (!DECL_NONLOCAL (label
))
5849 gsi_move_before (&i
, &s
);
5854 label
= create_artificial_label (UNKNOWN_LOCATION
);
5855 stmt
= gimple_build_label (label
);
5856 gsi_insert_before (&s
, stmt
, GSI_NEW_STMT
);
5861 /* Attempt to perform edge redirection by replacing a possibly complex
5862 jump instruction by a goto or by removing the jump completely.
5863 This can apply only if all edges now point to the same block. The
5864 parameters and return values are equivalent to
5865 redirect_edge_and_branch. */
5868 gimple_try_redirect_by_replacing_jump (edge e
, basic_block target
)
5870 basic_block src
= e
->src
;
5871 gimple_stmt_iterator i
;
5874 /* We can replace or remove a complex jump only when we have exactly
5876 if (EDGE_COUNT (src
->succs
) != 2
5877 /* Verify that all targets will be TARGET. Specifically, the
5878 edge that is not E must also go to TARGET. */
5879 || EDGE_SUCC (src
, EDGE_SUCC (src
, 0) == e
)->dest
!= target
)
5882 i
= gsi_last_bb (src
);
5886 stmt
= gsi_stmt (i
);
5888 if (gimple_code (stmt
) == GIMPLE_COND
|| gimple_code (stmt
) == GIMPLE_SWITCH
)
5890 gsi_remove (&i
, true);
5891 e
= ssa_redirect_edge (e
, target
);
5892 e
->flags
= EDGE_FALLTHRU
;
5900 /* Redirect E to DEST. Return NULL on failure. Otherwise, return the
5901 edge representing the redirected branch. */
5904 gimple_redirect_edge_and_branch (edge e
, basic_block dest
)
5906 basic_block bb
= e
->src
;
5907 gimple_stmt_iterator gsi
;
5911 if (e
->flags
& EDGE_ABNORMAL
)
5914 if (e
->dest
== dest
)
5917 if (e
->flags
& EDGE_EH
)
5918 return redirect_eh_edge (e
, dest
);
5920 if (e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
))
5922 ret
= gimple_try_redirect_by_replacing_jump (e
, dest
);
5927 gsi
= gsi_last_nondebug_bb (bb
);
5928 stmt
= gsi_end_p (gsi
) ? NULL
: gsi_stmt (gsi
);
5930 switch (stmt
? gimple_code (stmt
) : GIMPLE_ERROR_MARK
)
5933 /* For COND_EXPR, we only need to redirect the edge. */
5937 /* No non-abnormal edges should lead from a non-simple goto, and
5938 simple ones should be represented implicitly. */
5943 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
5944 tree label
= gimple_block_label (dest
);
5945 tree cases
= get_cases_for_edge (e
, switch_stmt
);
5947 /* If we have a list of cases associated with E, then use it
5948 as it's a lot faster than walking the entire case vector. */
5951 edge e2
= find_edge (e
->src
, dest
);
5958 CASE_LABEL (cases
) = label
;
5959 cases
= CASE_CHAIN (cases
);
5962 /* If there was already an edge in the CFG, then we need
5963 to move all the cases associated with E to E2. */
5966 tree cases2
= get_cases_for_edge (e2
, switch_stmt
);
5968 CASE_CHAIN (last
) = CASE_CHAIN (cases2
);
5969 CASE_CHAIN (cases2
) = first
;
5971 bitmap_set_bit (touched_switch_bbs
, gimple_bb (stmt
)->index
);
5975 size_t i
, n
= gimple_switch_num_labels (switch_stmt
);
5977 for (i
= 0; i
< n
; i
++)
5979 tree elt
= gimple_switch_label (switch_stmt
, i
);
5980 if (label_to_block (cfun
, CASE_LABEL (elt
)) == e
->dest
)
5981 CASE_LABEL (elt
) = label
;
5989 gasm
*asm_stmt
= as_a
<gasm
*> (stmt
);
5990 int i
, n
= gimple_asm_nlabels (asm_stmt
);
5993 for (i
= 0; i
< n
; ++i
)
5995 tree cons
= gimple_asm_label_op (asm_stmt
, i
);
5996 if (label_to_block (cfun
, TREE_VALUE (cons
)) == e
->dest
)
5999 label
= gimple_block_label (dest
);
6000 TREE_VALUE (cons
) = label
;
6004 /* If we didn't find any label matching the former edge in the
6005 asm labels, we must be redirecting the fallthrough
6007 gcc_assert (label
|| (e
->flags
& EDGE_FALLTHRU
));
6012 gsi_remove (&gsi
, true);
6013 e
->flags
|= EDGE_FALLTHRU
;
6016 case GIMPLE_OMP_RETURN
:
6017 case GIMPLE_OMP_CONTINUE
:
6018 case GIMPLE_OMP_SECTIONS_SWITCH
:
6019 case GIMPLE_OMP_FOR
:
6020 /* The edges from OMP constructs can be simply redirected. */
6023 case GIMPLE_EH_DISPATCH
:
6024 if (!(e
->flags
& EDGE_FALLTHRU
))
6025 redirect_eh_dispatch_edge (as_a
<geh_dispatch
*> (stmt
), e
, dest
);
6028 case GIMPLE_TRANSACTION
:
6029 if (e
->flags
& EDGE_TM_ABORT
)
6030 gimple_transaction_set_label_over (as_a
<gtransaction
*> (stmt
),
6031 gimple_block_label (dest
));
6032 else if (e
->flags
& EDGE_TM_UNINSTRUMENTED
)
6033 gimple_transaction_set_label_uninst (as_a
<gtransaction
*> (stmt
),
6034 gimple_block_label (dest
));
6036 gimple_transaction_set_label_norm (as_a
<gtransaction
*> (stmt
),
6037 gimple_block_label (dest
));
6041 /* Otherwise it must be a fallthru edge, and we don't need to
6042 do anything besides redirecting it. */
6043 gcc_assert (e
->flags
& EDGE_FALLTHRU
);
6047 /* Update/insert PHI nodes as necessary. */
6049 /* Now update the edges in the CFG. */
6050 e
= ssa_redirect_edge (e
, dest
);
6055 /* Returns true if it is possible to remove edge E by redirecting
6056 it to the destination of the other edge from E->src. */
6059 gimple_can_remove_branch_p (const_edge e
)
6061 if (e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
))
6067 /* Simple wrapper, as we can always redirect fallthru edges. */
6070 gimple_redirect_edge_and_branch_force (edge e
, basic_block dest
)
6072 e
= gimple_redirect_edge_and_branch (e
, dest
);
6079 /* Splits basic block BB after statement STMT (but at least after the
6080 labels). If STMT is NULL, BB is split just after the labels. */
6083 gimple_split_block (basic_block bb
, void *stmt
)
6085 gimple_stmt_iterator gsi
;
6086 gimple_stmt_iterator gsi_tgt
;
6092 new_bb
= create_empty_bb (bb
);
6094 /* Redirect the outgoing edges. */
6095 new_bb
->succs
= bb
->succs
;
6097 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
6100 /* Get a stmt iterator pointing to the first stmt to move. */
6101 if (!stmt
|| gimple_code ((gimple
*) stmt
) == GIMPLE_LABEL
)
6102 gsi
= gsi_after_labels (bb
);
6105 gsi
= gsi_for_stmt ((gimple
*) stmt
);
6109 /* Move everything from GSI to the new basic block. */
6110 if (gsi_end_p (gsi
))
6113 /* Split the statement list - avoid re-creating new containers as this
6114 brings ugly quadratic memory consumption in the inliner.
6115 (We are still quadratic since we need to update stmt BB pointers,
6117 gsi_split_seq_before (&gsi
, &list
);
6118 set_bb_seq (new_bb
, list
);
6119 for (gsi_tgt
= gsi_start (list
);
6120 !gsi_end_p (gsi_tgt
); gsi_next (&gsi_tgt
))
6121 gimple_set_bb (gsi_stmt (gsi_tgt
), new_bb
);
6127 /* Moves basic block BB after block AFTER. */
6130 gimple_move_block_after (basic_block bb
, basic_block after
)
6132 if (bb
->prev_bb
== after
)
6136 link_block (bb
, after
);
6142 /* Return TRUE if block BB has no executable statements, otherwise return
6146 gimple_empty_block_p (basic_block bb
)
6148 /* BB must have no executable statements. */
6149 gimple_stmt_iterator gsi
= gsi_after_labels (bb
);
6152 while (!gsi_end_p (gsi
))
6154 gimple
*stmt
= gsi_stmt (gsi
);
6155 if (is_gimple_debug (stmt
))
6157 else if (gimple_code (stmt
) == GIMPLE_NOP
6158 || gimple_code (stmt
) == GIMPLE_PREDICT
)
6168 /* Split a basic block if it ends with a conditional branch and if the
6169 other part of the block is not empty. */
6172 gimple_split_block_before_cond_jump (basic_block bb
)
6174 gimple
*last
, *split_point
;
6175 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
6176 if (gsi_end_p (gsi
))
6178 last
= gsi_stmt (gsi
);
6179 if (gimple_code (last
) != GIMPLE_COND
6180 && gimple_code (last
) != GIMPLE_SWITCH
)
6183 split_point
= gsi_stmt (gsi
);
6184 return split_block (bb
, split_point
)->dest
;
6188 /* Return true if basic_block can be duplicated. */
6191 gimple_can_duplicate_bb_p (const_basic_block bb ATTRIBUTE_UNUSED
)
6196 /* Create a duplicate of the basic block BB. NOTE: This does not
6197 preserve SSA form. */
6200 gimple_duplicate_bb (basic_block bb
, copy_bb_data
*id
)
6203 gimple_stmt_iterator gsi_tgt
;
6205 new_bb
= create_empty_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
);
6207 /* Copy the PHI nodes. We ignore PHI node arguments here because
6208 the incoming edges have not been setup yet. */
6209 for (gphi_iterator gpi
= gsi_start_phis (bb
);
6215 copy
= create_phi_node (NULL_TREE
, new_bb
);
6216 create_new_def_for (gimple_phi_result (phi
), copy
,
6217 gimple_phi_result_ptr (copy
));
6218 gimple_set_uid (copy
, gimple_uid (phi
));
6221 gsi_tgt
= gsi_start_bb (new_bb
);
6222 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
6226 def_operand_p def_p
;
6227 ssa_op_iter op_iter
;
6229 gimple
*stmt
, *copy
;
6231 stmt
= gsi_stmt (gsi
);
6232 if (gimple_code (stmt
) == GIMPLE_LABEL
)
6235 /* Don't duplicate label debug stmts. */
6236 if (gimple_debug_bind_p (stmt
)
6237 && TREE_CODE (gimple_debug_bind_get_var (stmt
))
6241 /* Create a new copy of STMT and duplicate STMT's virtual
6243 copy
= gimple_copy (stmt
);
6244 gsi_insert_after (&gsi_tgt
, copy
, GSI_NEW_STMT
);
6246 maybe_duplicate_eh_stmt (copy
, stmt
);
6247 gimple_duplicate_stmt_histograms (cfun
, copy
, cfun
, stmt
);
6249 /* When copying around a stmt writing into a local non-user
6250 aggregate, make sure it won't share stack slot with other
6252 lhs
= gimple_get_lhs (stmt
);
6253 if (lhs
&& TREE_CODE (lhs
) != SSA_NAME
)
6255 tree base
= get_base_address (lhs
);
6257 && (VAR_P (base
) || TREE_CODE (base
) == RESULT_DECL
)
6258 && DECL_IGNORED_P (base
)
6259 && !TREE_STATIC (base
)
6260 && !DECL_EXTERNAL (base
)
6261 && (!VAR_P (base
) || !DECL_HAS_VALUE_EXPR_P (base
)))
6262 DECL_NONSHAREABLE (base
) = 1;
6265 /* If requested remap dependence info of cliques brought in
6268 for (unsigned i
= 0; i
< gimple_num_ops (copy
); ++i
)
6270 tree op
= gimple_op (copy
, i
);
6273 if (TREE_CODE (op
) == ADDR_EXPR
6274 || TREE_CODE (op
) == WITH_SIZE_EXPR
)
6275 op
= TREE_OPERAND (op
, 0);
6276 while (handled_component_p (op
))
6277 op
= TREE_OPERAND (op
, 0);
6278 if ((TREE_CODE (op
) == MEM_REF
6279 || TREE_CODE (op
) == TARGET_MEM_REF
)
6280 && MR_DEPENDENCE_CLIQUE (op
) > 1
6281 && MR_DEPENDENCE_CLIQUE (op
) != bb
->loop_father
->owned_clique
)
6283 if (!id
->dependence_map
)
6284 id
->dependence_map
= new hash_map
<dependence_hash
,
6287 unsigned short &newc
= id
->dependence_map
->get_or_insert
6288 (MR_DEPENDENCE_CLIQUE (op
), &existed
);
6291 gcc_assert (MR_DEPENDENCE_CLIQUE (op
) <= cfun
->last_clique
);
6292 newc
= ++cfun
->last_clique
;
6294 MR_DEPENDENCE_CLIQUE (op
) = newc
;
6298 /* Create new names for all the definitions created by COPY and
6299 add replacement mappings for each new name. */
6300 FOR_EACH_SSA_DEF_OPERAND (def_p
, copy
, op_iter
, SSA_OP_ALL_DEFS
)
6301 create_new_def_for (DEF_FROM_PTR (def_p
), copy
, def_p
);
6307 /* Adds phi node arguments for edge E_COPY after basic block duplication. */
6310 add_phi_args_after_copy_edge (edge e_copy
)
6312 basic_block bb
, bb_copy
= e_copy
->src
, dest
;
6315 gphi
*phi
, *phi_copy
;
6317 gphi_iterator psi
, psi_copy
;
6319 if (gimple_seq_empty_p (phi_nodes (e_copy
->dest
)))
6322 bb
= bb_copy
->flags
& BB_DUPLICATED
? get_bb_original (bb_copy
) : bb_copy
;
6324 if (e_copy
->dest
->flags
& BB_DUPLICATED
)
6325 dest
= get_bb_original (e_copy
->dest
);
6327 dest
= e_copy
->dest
;
6329 e
= find_edge (bb
, dest
);
6332 /* During loop unrolling the target of the latch edge is copied.
6333 In this case we are not looking for edge to dest, but to
6334 duplicated block whose original was dest. */
6335 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6337 if ((e
->dest
->flags
& BB_DUPLICATED
)
6338 && get_bb_original (e
->dest
) == dest
)
6342 gcc_assert (e
!= NULL
);
6345 for (psi
= gsi_start_phis (e
->dest
),
6346 psi_copy
= gsi_start_phis (e_copy
->dest
);
6348 gsi_next (&psi
), gsi_next (&psi_copy
))
6351 phi_copy
= psi_copy
.phi ();
6352 def
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
6353 add_phi_arg (phi_copy
, def
, e_copy
,
6354 gimple_phi_arg_location_from_edge (phi
, e
));
6359 /* Basic block BB_COPY was created by code duplication. Add phi node
6360 arguments for edges going out of BB_COPY. The blocks that were
6361 duplicated have BB_DUPLICATED set. */
6364 add_phi_args_after_copy_bb (basic_block bb_copy
)
6369 FOR_EACH_EDGE (e_copy
, ei
, bb_copy
->succs
)
6371 add_phi_args_after_copy_edge (e_copy
);
6375 /* Blocks in REGION_COPY array of length N_REGION were created by
6376 duplication of basic blocks. Add phi node arguments for edges
6377 going from these blocks. If E_COPY is not NULL, also add
6378 phi node arguments for its destination.*/
6381 add_phi_args_after_copy (basic_block
*region_copy
, unsigned n_region
,
6386 for (i
= 0; i
< n_region
; i
++)
6387 region_copy
[i
]->flags
|= BB_DUPLICATED
;
6389 for (i
= 0; i
< n_region
; i
++)
6390 add_phi_args_after_copy_bb (region_copy
[i
]);
6392 add_phi_args_after_copy_edge (e_copy
);
6394 for (i
= 0; i
< n_region
; i
++)
6395 region_copy
[i
]->flags
&= ~BB_DUPLICATED
;
6398 /* Duplicates a REGION (set of N_REGION basic blocks) with just a single
6399 important exit edge EXIT. By important we mean that no SSA name defined
6400 inside region is live over the other exit edges of the region. All entry
6401 edges to the region must go to ENTRY->dest. The edge ENTRY is redirected
6402 to the duplicate of the region. Dominance and loop information is
6403 updated if UPDATE_DOMINANCE is true, but not the SSA web. If
6404 UPDATE_DOMINANCE is false then we assume that the caller will update the
6405 dominance information after calling this function. The new basic
6406 blocks are stored to REGION_COPY in the same order as they had in REGION,
6407 provided that REGION_COPY is not NULL.
6408 The function returns false if it is unable to copy the region,
6412 gimple_duplicate_sese_region (edge entry
, edge exit
,
6413 basic_block
*region
, unsigned n_region
,
6414 basic_block
*region_copy
,
6415 bool update_dominance
)
6418 bool free_region_copy
= false, copying_header
= false;
6419 class loop
*loop
= entry
->dest
->loop_father
;
6421 vec
<basic_block
> doms
= vNULL
;
6423 profile_count total_count
= profile_count::uninitialized ();
6424 profile_count entry_count
= profile_count::uninitialized ();
6426 if (!can_copy_bbs_p (region
, n_region
))
6429 /* Some sanity checking. Note that we do not check for all possible
6430 missuses of the functions. I.e. if you ask to copy something weird,
6431 it will work, but the state of structures probably will not be
6433 for (i
= 0; i
< n_region
; i
++)
6435 /* We do not handle subloops, i.e. all the blocks must belong to the
6437 if (region
[i
]->loop_father
!= loop
)
6440 if (region
[i
] != entry
->dest
6441 && region
[i
] == loop
->header
)
6445 /* In case the function is used for loop header copying (which is the primary
6446 use), ensure that EXIT and its copy will be new latch and entry edges. */
6447 if (loop
->header
== entry
->dest
)
6449 copying_header
= true;
6451 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, exit
->src
))
6454 for (i
= 0; i
< n_region
; i
++)
6455 if (region
[i
] != exit
->src
6456 && dominated_by_p (CDI_DOMINATORS
, region
[i
], exit
->src
))
6460 initialize_original_copy_tables ();
6463 set_loop_copy (loop
, loop_outer (loop
));
6465 set_loop_copy (loop
, loop
);
6469 region_copy
= XNEWVEC (basic_block
, n_region
);
6470 free_region_copy
= true;
6473 /* Record blocks outside the region that are dominated by something
6475 if (update_dominance
)
6478 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
6481 if (entry
->dest
->count
.initialized_p ())
6483 total_count
= entry
->dest
->count
;
6484 entry_count
= entry
->count ();
6485 /* Fix up corner cases, to avoid division by zero or creation of negative
6487 if (entry_count
> total_count
)
6488 entry_count
= total_count
;
6491 copy_bbs (region
, n_region
, region_copy
, &exit
, 1, &exit_copy
, loop
,
6492 split_edge_bb_loc (entry
), update_dominance
);
6493 if (total_count
.initialized_p () && entry_count
.initialized_p ())
6495 scale_bbs_frequencies_profile_count (region
, n_region
,
6496 total_count
- entry_count
,
6498 scale_bbs_frequencies_profile_count (region_copy
, n_region
, entry_count
,
6504 loop
->header
= exit
->dest
;
6505 loop
->latch
= exit
->src
;
6508 /* Redirect the entry and add the phi node arguments. */
6509 redirected
= redirect_edge_and_branch (entry
, get_bb_copy (entry
->dest
));
6510 gcc_assert (redirected
!= NULL
);
6511 flush_pending_stmts (entry
);
6513 /* Concerning updating of dominators: We must recount dominators
6514 for entry block and its copy. Anything that is outside of the
6515 region, but was dominated by something inside needs recounting as
6517 if (update_dominance
)
6519 set_immediate_dominator (CDI_DOMINATORS
, entry
->dest
, entry
->src
);
6520 doms
.safe_push (get_bb_original (entry
->dest
));
6521 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6525 /* Add the other PHI node arguments. */
6526 add_phi_args_after_copy (region_copy
, n_region
, NULL
);
6528 if (free_region_copy
)
6531 free_original_copy_tables ();
6535 /* Checks if BB is part of the region defined by N_REGION BBS. */
6537 bb_part_of_region_p (basic_block bb
, basic_block
* bbs
, unsigned n_region
)
6541 for (n
= 0; n
< n_region
; n
++)
6549 /* Duplicates REGION consisting of N_REGION blocks. The new blocks
6550 are stored to REGION_COPY in the same order in that they appear
6551 in REGION, if REGION_COPY is not NULL. ENTRY is the entry to
6552 the region, EXIT an exit from it. The condition guarding EXIT
6553 is moved to ENTRY. Returns true if duplication succeeds, false
6579 gimple_duplicate_sese_tail (edge entry
, edge exit
,
6580 basic_block
*region
, unsigned n_region
,
6581 basic_block
*region_copy
)
6584 bool free_region_copy
= false;
6585 class loop
*loop
= exit
->dest
->loop_father
;
6586 class loop
*orig_loop
= entry
->dest
->loop_father
;
6587 basic_block switch_bb
, entry_bb
, nentry_bb
;
6588 vec
<basic_block
> doms
;
6589 profile_count total_count
= profile_count::uninitialized (),
6590 exit_count
= profile_count::uninitialized ();
6591 edge exits
[2], nexits
[2], e
;
6592 gimple_stmt_iterator gsi
;
6595 basic_block exit_bb
;
6599 class loop
*target
, *aloop
, *cloop
;
6601 gcc_assert (EDGE_COUNT (exit
->src
->succs
) == 2);
6603 exits
[1] = EDGE_SUCC (exit
->src
, EDGE_SUCC (exit
->src
, 0) == exit
);
6605 if (!can_copy_bbs_p (region
, n_region
))
6608 initialize_original_copy_tables ();
6609 set_loop_copy (orig_loop
, loop
);
6612 for (aloop
= orig_loop
->inner
; aloop
; aloop
= aloop
->next
)
6614 if (bb_part_of_region_p (aloop
->header
, region
, n_region
))
6616 cloop
= duplicate_loop (aloop
, target
);
6617 duplicate_subloops (aloop
, cloop
);
6623 region_copy
= XNEWVEC (basic_block
, n_region
);
6624 free_region_copy
= true;
6627 gcc_assert (!need_ssa_update_p (cfun
));
6629 /* Record blocks outside the region that are dominated by something
6631 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
6633 total_count
= exit
->src
->count
;
6634 exit_count
= exit
->count ();
6635 /* Fix up corner cases, to avoid division by zero or creation of negative
6637 if (exit_count
> total_count
)
6638 exit_count
= total_count
;
6640 copy_bbs (region
, n_region
, region_copy
, exits
, 2, nexits
, orig_loop
,
6641 split_edge_bb_loc (exit
), true);
6642 if (total_count
.initialized_p () && exit_count
.initialized_p ())
6644 scale_bbs_frequencies_profile_count (region
, n_region
,
6645 total_count
- exit_count
,
6647 scale_bbs_frequencies_profile_count (region_copy
, n_region
, exit_count
,
6651 /* Create the switch block, and put the exit condition to it. */
6652 entry_bb
= entry
->dest
;
6653 nentry_bb
= get_bb_copy (entry_bb
);
6654 if (!last_stmt (entry
->src
)
6655 || !stmt_ends_bb_p (last_stmt (entry
->src
)))
6656 switch_bb
= entry
->src
;
6658 switch_bb
= split_edge (entry
);
6659 set_immediate_dominator (CDI_DOMINATORS
, nentry_bb
, switch_bb
);
6661 gsi
= gsi_last_bb (switch_bb
);
6662 cond_stmt
= last_stmt (exit
->src
);
6663 gcc_assert (gimple_code (cond_stmt
) == GIMPLE_COND
);
6664 cond_stmt
= gimple_copy (cond_stmt
);
6666 gsi_insert_after (&gsi
, cond_stmt
, GSI_NEW_STMT
);
6668 sorig
= single_succ_edge (switch_bb
);
6669 sorig
->flags
= exits
[1]->flags
;
6670 sorig
->probability
= exits
[1]->probability
;
6671 snew
= make_edge (switch_bb
, nentry_bb
, exits
[0]->flags
);
6672 snew
->probability
= exits
[0]->probability
;
6675 /* Register the new edge from SWITCH_BB in loop exit lists. */
6676 rescan_loop_exit (snew
, true, false);
6678 /* Add the PHI node arguments. */
6679 add_phi_args_after_copy (region_copy
, n_region
, snew
);
6681 /* Get rid of now superfluous conditions and associated edges (and phi node
6683 exit_bb
= exit
->dest
;
6685 e
= redirect_edge_and_branch (exits
[0], exits
[1]->dest
);
6686 PENDING_STMT (e
) = NULL
;
6688 /* The latch of ORIG_LOOP was copied, and so was the backedge
6689 to the original header. We redirect this backedge to EXIT_BB. */
6690 for (i
= 0; i
< n_region
; i
++)
6691 if (get_bb_original (region_copy
[i
]) == orig_loop
->latch
)
6693 gcc_assert (single_succ_edge (region_copy
[i
]));
6694 e
= redirect_edge_and_branch (single_succ_edge (region_copy
[i
]), exit_bb
);
6695 PENDING_STMT (e
) = NULL
;
6696 for (psi
= gsi_start_phis (exit_bb
);
6701 def
= PHI_ARG_DEF (phi
, nexits
[0]->dest_idx
);
6702 add_phi_arg (phi
, def
, e
, gimple_phi_arg_location_from_edge (phi
, e
));
6705 e
= redirect_edge_and_branch (nexits
[1], nexits
[0]->dest
);
6706 PENDING_STMT (e
) = NULL
;
6708 /* Anything that is outside of the region, but was dominated by something
6709 inside needs to update dominance info. */
6710 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6712 /* Update the SSA web. */
6713 update_ssa (TODO_update_ssa
);
6715 if (free_region_copy
)
6718 free_original_copy_tables ();
6722 /* Add all the blocks dominated by ENTRY to the array BBS_P. Stop
6723 adding blocks when the dominator traversal reaches EXIT. This
6724 function silently assumes that ENTRY strictly dominates EXIT. */
6727 gather_blocks_in_sese_region (basic_block entry
, basic_block exit
,
6728 vec
<basic_block
> *bbs_p
)
6732 for (son
= first_dom_son (CDI_DOMINATORS
, entry
);
6734 son
= next_dom_son (CDI_DOMINATORS
, son
))
6736 bbs_p
->safe_push (son
);
6738 gather_blocks_in_sese_region (son
, exit
, bbs_p
);
6742 /* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
6743 The duplicates are recorded in VARS_MAP. */
6746 replace_by_duplicate_decl (tree
*tp
, hash_map
<tree
, tree
> *vars_map
,
6749 tree t
= *tp
, new_t
;
6750 struct function
*f
= DECL_STRUCT_FUNCTION (to_context
);
6752 if (DECL_CONTEXT (t
) == to_context
)
6756 tree
&loc
= vars_map
->get_or_insert (t
, &existed
);
6762 new_t
= copy_var_decl (t
, DECL_NAME (t
), TREE_TYPE (t
));
6763 add_local_decl (f
, new_t
);
6767 gcc_assert (TREE_CODE (t
) == CONST_DECL
);
6768 new_t
= copy_node (t
);
6770 DECL_CONTEXT (new_t
) = to_context
;
6781 /* Creates an ssa name in TO_CONTEXT equivalent to NAME.
6782 VARS_MAP maps old ssa names and var_decls to the new ones. */
6785 replace_ssa_name (tree name
, hash_map
<tree
, tree
> *vars_map
,
6790 gcc_assert (!virtual_operand_p (name
));
6792 tree
*loc
= vars_map
->get (name
);
6796 tree decl
= SSA_NAME_VAR (name
);
6799 gcc_assert (!SSA_NAME_IS_DEFAULT_DEF (name
));
6800 replace_by_duplicate_decl (&decl
, vars_map
, to_context
);
6801 new_name
= make_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6802 decl
, SSA_NAME_DEF_STMT (name
));
6805 new_name
= copy_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6806 name
, SSA_NAME_DEF_STMT (name
));
6808 /* Now that we've used the def stmt to define new_name, make sure it
6809 doesn't define name anymore. */
6810 SSA_NAME_DEF_STMT (name
) = NULL
;
6812 vars_map
->put (name
, new_name
);
6826 hash_map
<tree
, tree
> *vars_map
;
6827 htab_t new_label_map
;
6828 hash_map
<void *, void *> *eh_map
;
6832 /* Helper for move_block_to_fn. Set TREE_BLOCK in every expression
6833 contained in *TP if it has been ORIG_BLOCK previously and change the
6834 DECL_CONTEXT of every local variable referenced in *TP. */
6837 move_stmt_op (tree
*tp
, int *walk_subtrees
, void *data
)
6839 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
6840 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6845 tree block
= TREE_BLOCK (t
);
6846 if (block
== NULL_TREE
)
6848 else if (block
== p
->orig_block
6849 || p
->orig_block
== NULL_TREE
)
6851 /* tree_node_can_be_shared says we can share invariant
6852 addresses but unshare_expr copies them anyways. Make sure
6853 to unshare before adjusting the block in place - we do not
6854 always see a copy here. */
6855 if (TREE_CODE (t
) == ADDR_EXPR
6856 && is_gimple_min_invariant (t
))
6857 *tp
= t
= unshare_expr (t
);
6858 TREE_SET_BLOCK (t
, p
->new_block
);
6860 else if (flag_checking
)
6862 while (block
&& TREE_CODE (block
) == BLOCK
&& block
!= p
->orig_block
)
6863 block
= BLOCK_SUPERCONTEXT (block
);
6864 gcc_assert (block
== p
->orig_block
);
6867 else if (DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
)
6869 if (TREE_CODE (t
) == SSA_NAME
)
6870 *tp
= replace_ssa_name (t
, p
->vars_map
, p
->to_context
);
6871 else if (TREE_CODE (t
) == PARM_DECL
6872 && gimple_in_ssa_p (cfun
))
6873 *tp
= *(p
->vars_map
->get (t
));
6874 else if (TREE_CODE (t
) == LABEL_DECL
)
6876 if (p
->new_label_map
)
6878 struct tree_map in
, *out
;
6880 out
= (struct tree_map
*)
6881 htab_find_with_hash (p
->new_label_map
, &in
, DECL_UID (t
));
6886 /* For FORCED_LABELs we can end up with references from other
6887 functions if some SESE regions are outlined. It is UB to
6888 jump in between them, but they could be used just for printing
6889 addresses etc. In that case, DECL_CONTEXT on the label should
6890 be the function containing the glabel stmt with that LABEL_DECL,
6891 rather than whatever function a reference to the label was seen
6893 if (!FORCED_LABEL (t
) && !DECL_NONLOCAL (t
))
6894 DECL_CONTEXT (t
) = p
->to_context
;
6896 else if (p
->remap_decls_p
)
6898 /* Replace T with its duplicate. T should no longer appear in the
6899 parent function, so this looks wasteful; however, it may appear
6900 in referenced_vars, and more importantly, as virtual operands of
6901 statements, and in alias lists of other variables. It would be
6902 quite difficult to expunge it from all those places. ??? It might
6903 suffice to do this for addressable variables. */
6904 if ((VAR_P (t
) && !is_global_var (t
))
6905 || TREE_CODE (t
) == CONST_DECL
)
6906 replace_by_duplicate_decl (tp
, p
->vars_map
, p
->to_context
);
6910 else if (TYPE_P (t
))
6916 /* Helper for move_stmt_r. Given an EH region number for the source
6917 function, map that to the duplicate EH regio number in the dest. */
6920 move_stmt_eh_region_nr (int old_nr
, struct move_stmt_d
*p
)
6922 eh_region old_r
, new_r
;
6924 old_r
= get_eh_region_from_number (old_nr
);
6925 new_r
= static_cast<eh_region
> (*p
->eh_map
->get (old_r
));
6927 return new_r
->index
;
6930 /* Similar, but operate on INTEGER_CSTs. */
6933 move_stmt_eh_region_tree_nr (tree old_t_nr
, struct move_stmt_d
*p
)
6937 old_nr
= tree_to_shwi (old_t_nr
);
6938 new_nr
= move_stmt_eh_region_nr (old_nr
, p
);
6940 return build_int_cst (integer_type_node
, new_nr
);
6943 /* Like move_stmt_op, but for gimple statements.
6945 Helper for move_block_to_fn. Set GIMPLE_BLOCK in every expression
6946 contained in the current statement in *GSI_P and change the
6947 DECL_CONTEXT of every local variable referenced in the current
6951 move_stmt_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
6952 struct walk_stmt_info
*wi
)
6954 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6955 gimple
*stmt
= gsi_stmt (*gsi_p
);
6956 tree block
= gimple_block (stmt
);
6958 if (block
== p
->orig_block
6959 || (p
->orig_block
== NULL_TREE
6960 && block
!= NULL_TREE
))
6961 gimple_set_block (stmt
, p
->new_block
);
6963 switch (gimple_code (stmt
))
6966 /* Remap the region numbers for __builtin_eh_{pointer,filter}. */
6968 tree r
, fndecl
= gimple_call_fndecl (stmt
);
6969 if (fndecl
&& fndecl_built_in_p (fndecl
, BUILT_IN_NORMAL
))
6970 switch (DECL_FUNCTION_CODE (fndecl
))
6972 case BUILT_IN_EH_COPY_VALUES
:
6973 r
= gimple_call_arg (stmt
, 1);
6974 r
= move_stmt_eh_region_tree_nr (r
, p
);
6975 gimple_call_set_arg (stmt
, 1, r
);
6978 case BUILT_IN_EH_POINTER
:
6979 case BUILT_IN_EH_FILTER
:
6980 r
= gimple_call_arg (stmt
, 0);
6981 r
= move_stmt_eh_region_tree_nr (r
, p
);
6982 gimple_call_set_arg (stmt
, 0, r
);
6993 gresx
*resx_stmt
= as_a
<gresx
*> (stmt
);
6994 int r
= gimple_resx_region (resx_stmt
);
6995 r
= move_stmt_eh_region_nr (r
, p
);
6996 gimple_resx_set_region (resx_stmt
, r
);
7000 case GIMPLE_EH_DISPATCH
:
7002 geh_dispatch
*eh_dispatch_stmt
= as_a
<geh_dispatch
*> (stmt
);
7003 int r
= gimple_eh_dispatch_region (eh_dispatch_stmt
);
7004 r
= move_stmt_eh_region_nr (r
, p
);
7005 gimple_eh_dispatch_set_region (eh_dispatch_stmt
, r
);
7009 case GIMPLE_OMP_RETURN
:
7010 case GIMPLE_OMP_CONTINUE
:
7015 /* For FORCED_LABEL, move_stmt_op doesn't adjust DECL_CONTEXT,
7016 so that such labels can be referenced from other regions.
7017 Make sure to update it when seeing a GIMPLE_LABEL though,
7018 that is the owner of the label. */
7019 walk_gimple_op (stmt
, move_stmt_op
, wi
);
7020 *handled_ops_p
= true;
7021 tree label
= gimple_label_label (as_a
<glabel
*> (stmt
));
7022 if (FORCED_LABEL (label
) || DECL_NONLOCAL (label
))
7023 DECL_CONTEXT (label
) = p
->to_context
;
7028 if (is_gimple_omp (stmt
))
7030 /* Do not remap variables inside OMP directives. Variables
7031 referenced in clauses and directive header belong to the
7032 parent function and should not be moved into the child
7034 bool save_remap_decls_p
= p
->remap_decls_p
;
7035 p
->remap_decls_p
= false;
7036 *handled_ops_p
= true;
7038 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt
), move_stmt_r
,
7041 p
->remap_decls_p
= save_remap_decls_p
;
7049 /* Move basic block BB from function CFUN to function DEST_FN. The
7050 block is moved out of the original linked list and placed after
7051 block AFTER in the new list. Also, the block is removed from the
7052 original array of blocks and placed in DEST_FN's array of blocks.
7053 If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
7054 updated to reflect the moved edges.
7056 The local variables are remapped to new instances, VARS_MAP is used
7057 to record the mapping. */
7060 move_block_to_fn (struct function
*dest_cfun
, basic_block bb
,
7061 basic_block after
, bool update_edge_count_p
,
7062 struct move_stmt_d
*d
)
7064 struct control_flow_graph
*cfg
;
7067 gimple_stmt_iterator si
;
7068 unsigned old_len
, new_len
;
7070 /* Remove BB from dominance structures. */
7071 delete_from_dominance_info (CDI_DOMINATORS
, bb
);
7073 /* Move BB from its current loop to the copy in the new function. */
7076 class loop
*new_loop
= (class loop
*)bb
->loop_father
->aux
;
7078 bb
->loop_father
= new_loop
;
7081 /* Link BB to the new linked list. */
7082 move_block_after (bb
, after
);
7084 /* Update the edge count in the corresponding flowgraphs. */
7085 if (update_edge_count_p
)
7086 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7088 cfun
->cfg
->x_n_edges
--;
7089 dest_cfun
->cfg
->x_n_edges
++;
7092 /* Remove BB from the original basic block array. */
7093 (*cfun
->cfg
->x_basic_block_info
)[bb
->index
] = NULL
;
7094 cfun
->cfg
->x_n_basic_blocks
--;
7096 /* Grow DEST_CFUN's basic block array if needed. */
7097 cfg
= dest_cfun
->cfg
;
7098 cfg
->x_n_basic_blocks
++;
7099 if (bb
->index
>= cfg
->x_last_basic_block
)
7100 cfg
->x_last_basic_block
= bb
->index
+ 1;
7102 old_len
= vec_safe_length (cfg
->x_basic_block_info
);
7103 if ((unsigned) cfg
->x_last_basic_block
>= old_len
)
7105 new_len
= cfg
->x_last_basic_block
+ (cfg
->x_last_basic_block
+ 3) / 4;
7106 vec_safe_grow_cleared (cfg
->x_basic_block_info
, new_len
);
7109 (*cfg
->x_basic_block_info
)[bb
->index
] = bb
;
7111 /* Remap the variables in phi nodes. */
7112 for (gphi_iterator psi
= gsi_start_phis (bb
);
7115 gphi
*phi
= psi
.phi ();
7117 tree op
= PHI_RESULT (phi
);
7121 if (virtual_operand_p (op
))
7123 /* Remove the phi nodes for virtual operands (alias analysis will be
7124 run for the new function, anyway). But replace all uses that
7125 might be outside of the region we move. */
7126 use_operand_p use_p
;
7127 imm_use_iterator iter
;
7129 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, op
)
7130 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
7131 SET_USE (use_p
, SSA_NAME_VAR (op
));
7132 remove_phi_node (&psi
, true);
7136 SET_PHI_RESULT (phi
,
7137 replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
7138 FOR_EACH_PHI_ARG (use
, phi
, oi
, SSA_OP_USE
)
7140 op
= USE_FROM_PTR (use
);
7141 if (TREE_CODE (op
) == SSA_NAME
)
7142 SET_USE (use
, replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
7145 for (i
= 0; i
< EDGE_COUNT (bb
->preds
); i
++)
7147 location_t locus
= gimple_phi_arg_location (phi
, i
);
7148 tree block
= LOCATION_BLOCK (locus
);
7150 if (locus
== UNKNOWN_LOCATION
)
7152 if (d
->orig_block
== NULL_TREE
|| block
== d
->orig_block
)
7154 locus
= set_block (locus
, d
->new_block
);
7155 gimple_phi_arg_set_location (phi
, i
, locus
);
7162 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
7164 gimple
*stmt
= gsi_stmt (si
);
7165 struct walk_stmt_info wi
;
7167 memset (&wi
, 0, sizeof (wi
));
7169 walk_gimple_stmt (&si
, move_stmt_r
, move_stmt_op
, &wi
);
7171 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
7173 tree label
= gimple_label_label (label_stmt
);
7174 int uid
= LABEL_DECL_UID (label
);
7176 gcc_assert (uid
> -1);
7178 old_len
= vec_safe_length (cfg
->x_label_to_block_map
);
7179 if (old_len
<= (unsigned) uid
)
7181 new_len
= 3 * uid
/ 2 + 1;
7182 vec_safe_grow_cleared (cfg
->x_label_to_block_map
, new_len
);
7185 (*cfg
->x_label_to_block_map
)[uid
] = bb
;
7186 (*cfun
->cfg
->x_label_to_block_map
)[uid
] = NULL
;
7188 gcc_assert (DECL_CONTEXT (label
) == dest_cfun
->decl
);
7190 if (uid
>= dest_cfun
->cfg
->last_label_uid
)
7191 dest_cfun
->cfg
->last_label_uid
= uid
+ 1;
7194 maybe_duplicate_eh_stmt_fn (dest_cfun
, stmt
, cfun
, stmt
, d
->eh_map
, 0);
7195 remove_stmt_from_eh_lp_fn (cfun
, stmt
);
7197 gimple_duplicate_stmt_histograms (dest_cfun
, stmt
, cfun
, stmt
);
7198 gimple_remove_stmt_histograms (cfun
, stmt
);
7200 /* We cannot leave any operands allocated from the operand caches of
7201 the current function. */
7202 free_stmt_operands (cfun
, stmt
);
7203 push_cfun (dest_cfun
);
7208 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7209 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
7211 tree block
= LOCATION_BLOCK (e
->goto_locus
);
7212 if (d
->orig_block
== NULL_TREE
7213 || block
== d
->orig_block
)
7214 e
->goto_locus
= set_block (e
->goto_locus
, d
->new_block
);
7218 /* Examine the statements in BB (which is in SRC_CFUN); find and return
7219 the outermost EH region. Use REGION as the incoming base EH region.
7220 If there is no single outermost region, return NULL and set *ALL to
7224 find_outermost_region_in_block (struct function
*src_cfun
,
7225 basic_block bb
, eh_region region
,
7228 gimple_stmt_iterator si
;
7230 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
7232 gimple
*stmt
= gsi_stmt (si
);
7233 eh_region stmt_region
;
7236 lp_nr
= lookup_stmt_eh_lp_fn (src_cfun
, stmt
);
7237 stmt_region
= get_eh_region_from_lp_number_fn (src_cfun
, lp_nr
);
7241 region
= stmt_region
;
7242 else if (stmt_region
!= region
)
7244 region
= eh_region_outermost (src_cfun
, stmt_region
, region
);
7258 new_label_mapper (tree decl
, void *data
)
7260 htab_t hash
= (htab_t
) data
;
7264 gcc_assert (TREE_CODE (decl
) == LABEL_DECL
);
7266 m
= XNEW (struct tree_map
);
7267 m
->hash
= DECL_UID (decl
);
7268 m
->base
.from
= decl
;
7269 m
->to
= create_artificial_label (UNKNOWN_LOCATION
);
7270 LABEL_DECL_UID (m
->to
) = LABEL_DECL_UID (decl
);
7271 if (LABEL_DECL_UID (m
->to
) >= cfun
->cfg
->last_label_uid
)
7272 cfun
->cfg
->last_label_uid
= LABEL_DECL_UID (m
->to
) + 1;
7274 slot
= htab_find_slot_with_hash (hash
, m
, m
->hash
, INSERT
);
7275 gcc_assert (*slot
== NULL
);
7282 /* Tree walker to replace the decls used inside value expressions by
7286 replace_block_vars_by_duplicates_1 (tree
*tp
, int *walk_subtrees
, void *data
)
7288 struct replace_decls_d
*rd
= (struct replace_decls_d
*)data
;
7290 switch (TREE_CODE (*tp
))
7295 replace_by_duplicate_decl (tp
, rd
->vars_map
, rd
->to_context
);
7301 if (IS_TYPE_OR_DECL_P (*tp
))
7302 *walk_subtrees
= false;
7307 /* Change DECL_CONTEXT of all BLOCK_VARS in block, including
7311 replace_block_vars_by_duplicates (tree block
, hash_map
<tree
, tree
> *vars_map
,
7316 for (tp
= &BLOCK_VARS (block
); *tp
; tp
= &DECL_CHAIN (*tp
))
7319 if (!VAR_P (t
) && TREE_CODE (t
) != CONST_DECL
)
7321 replace_by_duplicate_decl (&t
, vars_map
, to_context
);
7324 if (VAR_P (*tp
) && DECL_HAS_VALUE_EXPR_P (*tp
))
7326 tree x
= DECL_VALUE_EXPR (*tp
);
7327 struct replace_decls_d rd
= { vars_map
, to_context
};
7329 walk_tree (&x
, replace_block_vars_by_duplicates_1
, &rd
, NULL
);
7330 SET_DECL_VALUE_EXPR (t
, x
);
7331 DECL_HAS_VALUE_EXPR_P (t
) = 1;
7333 DECL_CHAIN (t
) = DECL_CHAIN (*tp
);
7338 for (block
= BLOCK_SUBBLOCKS (block
); block
; block
= BLOCK_CHAIN (block
))
7339 replace_block_vars_by_duplicates (block
, vars_map
, to_context
);
7342 /* Fixup the loop arrays and numbers after moving LOOP and its subloops
7346 fixup_loop_arrays_after_move (struct function
*fn1
, struct function
*fn2
,
7349 /* Discard it from the old loop array. */
7350 (*get_loops (fn1
))[loop
->num
] = NULL
;
7352 /* Place it in the new loop array, assigning it a new number. */
7353 loop
->num
= number_of_loops (fn2
);
7354 vec_safe_push (loops_for_fn (fn2
)->larray
, loop
);
7356 /* Recurse to children. */
7357 for (loop
= loop
->inner
; loop
; loop
= loop
->next
)
7358 fixup_loop_arrays_after_move (fn1
, fn2
, loop
);
7361 /* Verify that the blocks in BBS_P are a single-entry, single-exit region
7362 delimited by ENTRY_BB and EXIT_BB, possibly containing noreturn blocks. */
7365 verify_sese (basic_block entry
, basic_block exit
, vec
<basic_block
> *bbs_p
)
7370 bitmap bbs
= BITMAP_ALLOC (NULL
);
7373 gcc_assert (entry
!= NULL
);
7374 gcc_assert (entry
!= exit
);
7375 gcc_assert (bbs_p
!= NULL
);
7377 gcc_assert (bbs_p
->length () > 0);
7379 FOR_EACH_VEC_ELT (*bbs_p
, i
, bb
)
7380 bitmap_set_bit (bbs
, bb
->index
);
7382 gcc_assert (bitmap_bit_p (bbs
, entry
->index
));
7383 gcc_assert (exit
== NULL
|| bitmap_bit_p (bbs
, exit
->index
));
7385 FOR_EACH_VEC_ELT (*bbs_p
, i
, bb
)
7389 gcc_assert (single_pred_p (entry
));
7390 gcc_assert (!bitmap_bit_p (bbs
, single_pred (entry
)->index
));
7393 for (ei
= ei_start (bb
->preds
); !ei_end_p (ei
); ei_next (&ei
))
7396 gcc_assert (bitmap_bit_p (bbs
, e
->src
->index
));
7401 gcc_assert (single_succ_p (exit
));
7402 gcc_assert (!bitmap_bit_p (bbs
, single_succ (exit
)->index
));
7405 for (ei
= ei_start (bb
->succs
); !ei_end_p (ei
); ei_next (&ei
))
7408 gcc_assert (bitmap_bit_p (bbs
, e
->dest
->index
));
7415 /* If FROM is an SSA_NAME, mark the version in bitmap DATA. */
7418 gather_ssa_name_hash_map_from (tree
const &from
, tree
const &, void *data
)
7420 bitmap release_names
= (bitmap
)data
;
7422 if (TREE_CODE (from
) != SSA_NAME
)
7425 bitmap_set_bit (release_names
, SSA_NAME_VERSION (from
));
7429 /* Return LOOP_DIST_ALIAS call if present in BB. */
7432 find_loop_dist_alias (basic_block bb
)
7434 gimple
*g
= last_stmt (bb
);
7435 if (g
== NULL
|| gimple_code (g
) != GIMPLE_COND
)
7438 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
7440 if (gsi_end_p (gsi
))
7444 if (gimple_call_internal_p (g
, IFN_LOOP_DIST_ALIAS
))
7449 /* Fold loop internal call G like IFN_LOOP_VECTORIZED/IFN_LOOP_DIST_ALIAS
7450 to VALUE and update any immediate uses of it's LHS. */
7453 fold_loop_internal_call (gimple
*g
, tree value
)
7455 tree lhs
= gimple_call_lhs (g
);
7456 use_operand_p use_p
;
7457 imm_use_iterator iter
;
7459 gimple_stmt_iterator gsi
= gsi_for_stmt (g
);
7461 update_call_from_tree (&gsi
, value
);
7462 FOR_EACH_IMM_USE_STMT (use_stmt
, iter
, lhs
)
7464 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
7465 SET_USE (use_p
, value
);
7466 update_stmt (use_stmt
);
7470 /* Move a single-entry, single-exit region delimited by ENTRY_BB and
7471 EXIT_BB to function DEST_CFUN. The whole region is replaced by a
7472 single basic block in the original CFG and the new basic block is
7473 returned. DEST_CFUN must not have a CFG yet.
7475 Note that the region need not be a pure SESE region. Blocks inside
7476 the region may contain calls to abort/exit. The only restriction
7477 is that ENTRY_BB should be the only entry point and it must
7480 Change TREE_BLOCK of all statements in ORIG_BLOCK to the new
7481 functions outermost BLOCK, move all subblocks of ORIG_BLOCK
7482 to the new function.
7484 All local variables referenced in the region are assumed to be in
7485 the corresponding BLOCK_VARS and unexpanded variable lists
7486 associated with DEST_CFUN.
7488 TODO: investigate whether we can reuse gimple_duplicate_sese_region to
7489 reimplement move_sese_region_to_fn by duplicating the region rather than
7493 move_sese_region_to_fn (struct function
*dest_cfun
, basic_block entry_bb
,
7494 basic_block exit_bb
, tree orig_block
)
7496 vec
<basic_block
> bbs
, dom_bbs
;
7497 basic_block dom_entry
= get_immediate_dominator (CDI_DOMINATORS
, entry_bb
);
7498 basic_block after
, bb
, *entry_pred
, *exit_succ
, abb
;
7499 struct function
*saved_cfun
= cfun
;
7500 int *entry_flag
, *exit_flag
;
7501 profile_probability
*entry_prob
, *exit_prob
;
7502 unsigned i
, num_entry_edges
, num_exit_edges
, num_nodes
;
7505 htab_t new_label_map
;
7506 hash_map
<void *, void *> *eh_map
;
7507 class loop
*loop
= entry_bb
->loop_father
;
7508 class loop
*loop0
= get_loop (saved_cfun
, 0);
7509 struct move_stmt_d d
;
7511 /* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
7513 gcc_assert (entry_bb
!= exit_bb
7515 || dominated_by_p (CDI_DOMINATORS
, exit_bb
, entry_bb
)));
7517 /* Collect all the blocks in the region. Manually add ENTRY_BB
7518 because it won't be added by dfs_enumerate_from. */
7520 bbs
.safe_push (entry_bb
);
7521 gather_blocks_in_sese_region (entry_bb
, exit_bb
, &bbs
);
7524 verify_sese (entry_bb
, exit_bb
, &bbs
);
7526 /* The blocks that used to be dominated by something in BBS will now be
7527 dominated by the new block. */
7528 dom_bbs
= get_dominated_by_region (CDI_DOMINATORS
,
7532 /* Detach ENTRY_BB and EXIT_BB from CFUN->CFG. We need to remember
7533 the predecessor edges to ENTRY_BB and the successor edges to
7534 EXIT_BB so that we can re-attach them to the new basic block that
7535 will replace the region. */
7536 num_entry_edges
= EDGE_COUNT (entry_bb
->preds
);
7537 entry_pred
= XNEWVEC (basic_block
, num_entry_edges
);
7538 entry_flag
= XNEWVEC (int, num_entry_edges
);
7539 entry_prob
= XNEWVEC (profile_probability
, num_entry_edges
);
7541 for (ei
= ei_start (entry_bb
->preds
); (e
= ei_safe_edge (ei
)) != NULL
;)
7543 entry_prob
[i
] = e
->probability
;
7544 entry_flag
[i
] = e
->flags
;
7545 entry_pred
[i
++] = e
->src
;
7551 num_exit_edges
= EDGE_COUNT (exit_bb
->succs
);
7552 exit_succ
= XNEWVEC (basic_block
, num_exit_edges
);
7553 exit_flag
= XNEWVEC (int, num_exit_edges
);
7554 exit_prob
= XNEWVEC (profile_probability
, num_exit_edges
);
7556 for (ei
= ei_start (exit_bb
->succs
); (e
= ei_safe_edge (ei
)) != NULL
;)
7558 exit_prob
[i
] = e
->probability
;
7559 exit_flag
[i
] = e
->flags
;
7560 exit_succ
[i
++] = e
->dest
;
7572 /* Switch context to the child function to initialize DEST_FN's CFG. */
7573 gcc_assert (dest_cfun
->cfg
== NULL
);
7574 push_cfun (dest_cfun
);
7576 init_empty_tree_cfg ();
7578 /* Initialize EH information for the new function. */
7580 new_label_map
= NULL
;
7583 eh_region region
= NULL
;
7586 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7588 region
= find_outermost_region_in_block (saved_cfun
, bb
, region
, &all
);
7593 init_eh_for_function ();
7594 if (region
!= NULL
|| all
)
7596 new_label_map
= htab_create (17, tree_map_hash
, tree_map_eq
, free
);
7597 eh_map
= duplicate_eh_regions (saved_cfun
, region
, 0,
7598 new_label_mapper
, new_label_map
);
7602 /* Initialize an empty loop tree. */
7603 struct loops
*loops
= ggc_cleared_alloc
<struct loops
> ();
7604 init_loops_structure (dest_cfun
, loops
, 1);
7605 loops
->state
= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
7606 set_loops_for_fn (dest_cfun
, loops
);
7608 vec
<loop_p
, va_gc
> *larray
= get_loops (saved_cfun
)->copy ();
7610 /* Move the outlined loop tree part. */
7611 num_nodes
= bbs
.length ();
7612 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7614 if (bb
->loop_father
->header
== bb
)
7616 class loop
*this_loop
= bb
->loop_father
;
7617 class loop
*outer
= loop_outer (this_loop
);
7619 /* If the SESE region contains some bbs ending with
7620 a noreturn call, those are considered to belong
7621 to the outermost loop in saved_cfun, rather than
7622 the entry_bb's loop_father. */
7626 num_nodes
-= this_loop
->num_nodes
;
7627 flow_loop_tree_node_remove (bb
->loop_father
);
7628 flow_loop_tree_node_add (get_loop (dest_cfun
, 0), this_loop
);
7629 fixup_loop_arrays_after_move (saved_cfun
, cfun
, this_loop
);
7632 else if (bb
->loop_father
== loop0
&& loop0
!= loop
)
7635 /* Remove loop exits from the outlined region. */
7636 if (loops_for_fn (saved_cfun
)->exits
)
7637 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7639 struct loops
*l
= loops_for_fn (saved_cfun
);
7641 = l
->exits
->find_slot_with_hash (e
, htab_hash_pointer (e
),
7644 l
->exits
->clear_slot (slot
);
7648 /* Adjust the number of blocks in the tree root of the outlined part. */
7649 get_loop (dest_cfun
, 0)->num_nodes
= bbs
.length () + 2;
7651 /* Setup a mapping to be used by move_block_to_fn. */
7652 loop
->aux
= current_loops
->tree_root
;
7653 loop0
->aux
= current_loops
->tree_root
;
7655 /* Fix up orig_loop_num. If the block referenced in it has been moved
7656 to dest_cfun, update orig_loop_num field, otherwise clear it. */
7658 signed char *moved_orig_loop_num
= NULL
;
7659 FOR_EACH_LOOP_FN (dest_cfun
, dloop
, 0)
7660 if (dloop
->orig_loop_num
)
7662 if (moved_orig_loop_num
== NULL
)
7664 = XCNEWVEC (signed char, vec_safe_length (larray
));
7665 if ((*larray
)[dloop
->orig_loop_num
] != NULL
7666 && get_loop (saved_cfun
, dloop
->orig_loop_num
) == NULL
)
7668 if (moved_orig_loop_num
[dloop
->orig_loop_num
] >= 0
7669 && moved_orig_loop_num
[dloop
->orig_loop_num
] < 2)
7670 moved_orig_loop_num
[dloop
->orig_loop_num
]++;
7671 dloop
->orig_loop_num
= (*larray
)[dloop
->orig_loop_num
]->num
;
7675 moved_orig_loop_num
[dloop
->orig_loop_num
] = -1;
7676 dloop
->orig_loop_num
= 0;
7681 if (moved_orig_loop_num
)
7683 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7685 gimple
*g
= find_loop_dist_alias (bb
);
7689 int orig_loop_num
= tree_to_shwi (gimple_call_arg (g
, 0));
7690 gcc_assert (orig_loop_num
7691 && (unsigned) orig_loop_num
< vec_safe_length (larray
));
7692 if (moved_orig_loop_num
[orig_loop_num
] == 2)
7694 /* If we have moved both loops with this orig_loop_num into
7695 dest_cfun and the LOOP_DIST_ALIAS call is being moved there
7696 too, update the first argument. */
7697 gcc_assert ((*larray
)[dloop
->orig_loop_num
] != NULL
7698 && (get_loop (saved_cfun
, dloop
->orig_loop_num
)
7700 tree t
= build_int_cst (integer_type_node
,
7701 (*larray
)[dloop
->orig_loop_num
]->num
);
7702 gimple_call_set_arg (g
, 0, t
);
7704 /* Make sure the following loop will not update it. */
7705 moved_orig_loop_num
[orig_loop_num
] = 0;
7708 /* Otherwise at least one of the loops stayed in saved_cfun.
7709 Remove the LOOP_DIST_ALIAS call. */
7710 fold_loop_internal_call (g
, gimple_call_arg (g
, 1));
7712 FOR_EACH_BB_FN (bb
, saved_cfun
)
7714 gimple
*g
= find_loop_dist_alias (bb
);
7717 int orig_loop_num
= tree_to_shwi (gimple_call_arg (g
, 0));
7718 gcc_assert (orig_loop_num
7719 && (unsigned) orig_loop_num
< vec_safe_length (larray
));
7720 if (moved_orig_loop_num
[orig_loop_num
])
7721 /* LOOP_DIST_ALIAS call remained in saved_cfun, if at least one
7722 of the corresponding loops was moved, remove it. */
7723 fold_loop_internal_call (g
, gimple_call_arg (g
, 1));
7725 XDELETEVEC (moved_orig_loop_num
);
7729 /* Move blocks from BBS into DEST_CFUN. */
7730 gcc_assert (bbs
.length () >= 2);
7731 after
= dest_cfun
->cfg
->x_entry_block_ptr
;
7732 hash_map
<tree
, tree
> vars_map
;
7734 memset (&d
, 0, sizeof (d
));
7735 d
.orig_block
= orig_block
;
7736 d
.new_block
= DECL_INITIAL (dest_cfun
->decl
);
7737 d
.from_context
= cfun
->decl
;
7738 d
.to_context
= dest_cfun
->decl
;
7739 d
.vars_map
= &vars_map
;
7740 d
.new_label_map
= new_label_map
;
7742 d
.remap_decls_p
= true;
7744 if (gimple_in_ssa_p (cfun
))
7745 for (tree arg
= DECL_ARGUMENTS (d
.to_context
); arg
; arg
= DECL_CHAIN (arg
))
7747 tree narg
= make_ssa_name_fn (dest_cfun
, arg
, gimple_build_nop ());
7748 set_ssa_default_def (dest_cfun
, arg
, narg
);
7749 vars_map
.put (arg
, narg
);
7752 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7754 /* No need to update edge counts on the last block. It has
7755 already been updated earlier when we detached the region from
7756 the original CFG. */
7757 move_block_to_fn (dest_cfun
, bb
, after
, bb
!= exit_bb
, &d
);
7761 /* Adjust the maximum clique used. */
7762 dest_cfun
->last_clique
= saved_cfun
->last_clique
;
7766 /* Loop sizes are no longer correct, fix them up. */
7767 loop
->num_nodes
-= num_nodes
;
7768 for (class loop
*outer
= loop_outer (loop
);
7769 outer
; outer
= loop_outer (outer
))
7770 outer
->num_nodes
-= num_nodes
;
7771 loop0
->num_nodes
-= bbs
.length () - num_nodes
;
7773 if (saved_cfun
->has_simduid_loops
|| saved_cfun
->has_force_vectorize_loops
)
7776 for (i
= 0; vec_safe_iterate (loops
->larray
, i
, &aloop
); i
++)
7781 replace_by_duplicate_decl (&aloop
->simduid
, d
.vars_map
,
7783 dest_cfun
->has_simduid_loops
= true;
7785 if (aloop
->force_vectorize
)
7786 dest_cfun
->has_force_vectorize_loops
= true;
7790 /* Rewire BLOCK_SUBBLOCKS of orig_block. */
7794 gcc_assert (BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
7796 BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
7797 = BLOCK_SUBBLOCKS (orig_block
);
7798 for (block
= BLOCK_SUBBLOCKS (orig_block
);
7799 block
; block
= BLOCK_CHAIN (block
))
7800 BLOCK_SUPERCONTEXT (block
) = DECL_INITIAL (dest_cfun
->decl
);
7801 BLOCK_SUBBLOCKS (orig_block
) = NULL_TREE
;
7804 replace_block_vars_by_duplicates (DECL_INITIAL (dest_cfun
->decl
),
7805 &vars_map
, dest_cfun
->decl
);
7808 htab_delete (new_label_map
);
7812 if (gimple_in_ssa_p (cfun
))
7814 /* We need to release ssa-names in a defined order, so first find them,
7815 and then iterate in ascending version order. */
7816 bitmap release_names
= BITMAP_ALLOC (NULL
);
7817 vars_map
.traverse
<void *, gather_ssa_name_hash_map_from
> (release_names
);
7820 EXECUTE_IF_SET_IN_BITMAP (release_names
, 0, i
, bi
)
7821 release_ssa_name (ssa_name (i
));
7822 BITMAP_FREE (release_names
);
7825 /* Rewire the entry and exit blocks. The successor to the entry
7826 block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
7827 the child function. Similarly, the predecessor of DEST_FN's
7828 EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR. We
7829 need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
7830 various CFG manipulation function get to the right CFG.
7832 FIXME, this is silly. The CFG ought to become a parameter to
7834 push_cfun (dest_cfun
);
7835 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= entry_bb
->count
;
7836 make_single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
), entry_bb
, EDGE_FALLTHRU
);
7839 make_single_succ_edge (exit_bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
7840 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
= exit_bb
->count
;
7843 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
= profile_count::zero ();
7846 /* Back in the original function, the SESE region has disappeared,
7847 create a new basic block in its place. */
7848 bb
= create_empty_bb (entry_pred
[0]);
7850 add_bb_to_loop (bb
, loop
);
7851 for (i
= 0; i
< num_entry_edges
; i
++)
7853 e
= make_edge (entry_pred
[i
], bb
, entry_flag
[i
]);
7854 e
->probability
= entry_prob
[i
];
7857 for (i
= 0; i
< num_exit_edges
; i
++)
7859 e
= make_edge (bb
, exit_succ
[i
], exit_flag
[i
]);
7860 e
->probability
= exit_prob
[i
];
7863 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom_entry
);
7864 FOR_EACH_VEC_ELT (dom_bbs
, i
, abb
)
7865 set_immediate_dominator (CDI_DOMINATORS
, abb
, bb
);
7882 /* Dump default def DEF to file FILE using FLAGS and indentation
7886 dump_default_def (FILE *file
, tree def
, int spc
, dump_flags_t flags
)
7888 for (int i
= 0; i
< spc
; ++i
)
7889 fprintf (file
, " ");
7890 dump_ssaname_info_to_file (file
, def
, spc
);
7892 print_generic_expr (file
, TREE_TYPE (def
), flags
);
7893 fprintf (file
, " ");
7894 print_generic_expr (file
, def
, flags
);
7895 fprintf (file
, " = ");
7896 print_generic_expr (file
, SSA_NAME_VAR (def
), flags
);
7897 fprintf (file
, ";\n");
7900 /* Print no_sanitize attribute to FILE for a given attribute VALUE. */
7903 print_no_sanitize_attr_value (FILE *file
, tree value
)
7905 unsigned int flags
= tree_to_uhwi (value
);
7907 for (int i
= 0; sanitizer_opts
[i
].name
!= NULL
; ++i
)
7909 if ((sanitizer_opts
[i
].flag
& flags
) == sanitizer_opts
[i
].flag
)
7912 fprintf (file
, " | ");
7913 fprintf (file
, "%s", sanitizer_opts
[i
].name
);
7919 /* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in dumpfile.h)
7923 dump_function_to_file (tree fndecl
, FILE *file
, dump_flags_t flags
)
7925 tree arg
, var
, old_current_fndecl
= current_function_decl
;
7926 struct function
*dsf
;
7927 bool ignore_topmost_bind
= false, any_var
= false;
7930 bool tmclone
= (TREE_CODE (fndecl
) == FUNCTION_DECL
7931 && decl_is_tm_clone (fndecl
));
7932 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
7934 if (DECL_ATTRIBUTES (fndecl
) != NULL_TREE
)
7936 fprintf (file
, "__attribute__((");
7940 for (chain
= DECL_ATTRIBUTES (fndecl
); chain
;
7941 first
= false, chain
= TREE_CHAIN (chain
))
7944 fprintf (file
, ", ");
7946 tree name
= get_attribute_name (chain
);
7947 print_generic_expr (file
, name
, dump_flags
);
7948 if (TREE_VALUE (chain
) != NULL_TREE
)
7950 fprintf (file
, " (");
7952 if (strstr (IDENTIFIER_POINTER (name
), "no_sanitize"))
7953 print_no_sanitize_attr_value (file
, TREE_VALUE (chain
));
7955 print_generic_expr (file
, TREE_VALUE (chain
), dump_flags
);
7956 fprintf (file
, ")");
7960 fprintf (file
, "))\n");
7963 current_function_decl
= fndecl
;
7964 if (flags
& TDF_GIMPLE
)
7966 static bool hotness_bb_param_printed
= false;
7967 if (profile_info
!= NULL
7968 && !hotness_bb_param_printed
)
7970 hotness_bb_param_printed
= true;
7972 "/* --param=gimple-fe-computed-hot-bb-threshold=%" PRId64
7973 " */\n", get_hot_bb_threshold ());
7976 print_generic_expr (file
, TREE_TYPE (TREE_TYPE (fndecl
)),
7977 dump_flags
| TDF_SLIM
);
7978 fprintf (file
, " __GIMPLE (%s",
7979 (fun
->curr_properties
& PROP_ssa
) ? "ssa"
7980 : (fun
->curr_properties
& PROP_cfg
) ? "cfg"
7985 basic_block bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
7986 if (bb
->count
.initialized_p ())
7987 fprintf (file
, ",%s(%d)",
7988 profile_quality_as_string (bb
->count
.quality ()),
7989 bb
->count
.value ());
7990 fprintf (file
, ")\n%s (", function_name (fun
));
7994 fprintf (file
, "%s %s(", function_name (fun
), tmclone
? "[tm-clone] " : "");
7996 arg
= DECL_ARGUMENTS (fndecl
);
7999 print_generic_expr (file
, TREE_TYPE (arg
), dump_flags
);
8000 fprintf (file
, " ");
8001 print_generic_expr (file
, arg
, dump_flags
);
8002 if (DECL_CHAIN (arg
))
8003 fprintf (file
, ", ");
8004 arg
= DECL_CHAIN (arg
);
8006 fprintf (file
, ")\n");
8008 dsf
= DECL_STRUCT_FUNCTION (fndecl
);
8009 if (dsf
&& (flags
& TDF_EH
))
8010 dump_eh_tree (file
, dsf
);
8012 if (flags
& TDF_RAW
&& !gimple_has_body_p (fndecl
))
8014 dump_node (fndecl
, TDF_SLIM
| flags
, file
);
8015 current_function_decl
= old_current_fndecl
;
8019 /* When GIMPLE is lowered, the variables are no longer available in
8020 BIND_EXPRs, so display them separately. */
8021 if (fun
&& fun
->decl
== fndecl
&& (fun
->curr_properties
& PROP_gimple_lcf
))
8024 ignore_topmost_bind
= true;
8026 fprintf (file
, "{\n");
8027 if (gimple_in_ssa_p (fun
)
8028 && (flags
& TDF_ALIAS
))
8030 for (arg
= DECL_ARGUMENTS (fndecl
); arg
!= NULL
;
8031 arg
= DECL_CHAIN (arg
))
8033 tree def
= ssa_default_def (fun
, arg
);
8035 dump_default_def (file
, def
, 2, flags
);
8038 tree res
= DECL_RESULT (fun
->decl
);
8039 if (res
!= NULL_TREE
8040 && DECL_BY_REFERENCE (res
))
8042 tree def
= ssa_default_def (fun
, res
);
8044 dump_default_def (file
, def
, 2, flags
);
8047 tree static_chain
= fun
->static_chain_decl
;
8048 if (static_chain
!= NULL_TREE
)
8050 tree def
= ssa_default_def (fun
, static_chain
);
8052 dump_default_def (file
, def
, 2, flags
);
8056 if (!vec_safe_is_empty (fun
->local_decls
))
8057 FOR_EACH_LOCAL_DECL (fun
, ix
, var
)
8059 print_generic_decl (file
, var
, flags
);
8060 fprintf (file
, "\n");
8067 if (gimple_in_ssa_p (cfun
))
8068 FOR_EACH_SSA_NAME (ix
, name
, cfun
)
8070 if (!SSA_NAME_VAR (name
))
8072 fprintf (file
, " ");
8073 print_generic_expr (file
, TREE_TYPE (name
), flags
);
8074 fprintf (file
, " ");
8075 print_generic_expr (file
, name
, flags
);
8076 fprintf (file
, ";\n");
8083 if (fun
&& fun
->decl
== fndecl
8085 && basic_block_info_for_fn (fun
))
8087 /* If the CFG has been built, emit a CFG-based dump. */
8088 if (!ignore_topmost_bind
)
8089 fprintf (file
, "{\n");
8091 if (any_var
&& n_basic_blocks_for_fn (fun
))
8092 fprintf (file
, "\n");
8094 FOR_EACH_BB_FN (bb
, fun
)
8095 dump_bb (file
, bb
, 2, flags
);
8097 fprintf (file
, "}\n");
8099 else if (fun
->curr_properties
& PROP_gimple_any
)
8101 /* The function is now in GIMPLE form but the CFG has not been
8102 built yet. Emit the single sequence of GIMPLE statements
8103 that make up its body. */
8104 gimple_seq body
= gimple_body (fndecl
);
8106 if (gimple_seq_first_stmt (body
)
8107 && gimple_seq_first_stmt (body
) == gimple_seq_last_stmt (body
)
8108 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
)
8109 print_gimple_seq (file
, body
, 0, flags
);
8112 if (!ignore_topmost_bind
)
8113 fprintf (file
, "{\n");
8116 fprintf (file
, "\n");
8118 print_gimple_seq (file
, body
, 2, flags
);
8119 fprintf (file
, "}\n");
8126 /* Make a tree based dump. */
8127 chain
= DECL_SAVED_TREE (fndecl
);
8128 if (chain
&& TREE_CODE (chain
) == BIND_EXPR
)
8130 if (ignore_topmost_bind
)
8132 chain
= BIND_EXPR_BODY (chain
);
8140 if (!ignore_topmost_bind
)
8142 fprintf (file
, "{\n");
8143 /* No topmost bind, pretend it's ignored for later. */
8144 ignore_topmost_bind
= true;
8150 fprintf (file
, "\n");
8152 print_generic_stmt_indented (file
, chain
, flags
, indent
);
8153 if (ignore_topmost_bind
)
8154 fprintf (file
, "}\n");
8157 if (flags
& TDF_ENUMERATE_LOCALS
)
8158 dump_enumerated_decls (file
, flags
);
8159 fprintf (file
, "\n\n");
8161 current_function_decl
= old_current_fndecl
;
8164 /* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h) */
8167 debug_function (tree fn
, dump_flags_t flags
)
8169 dump_function_to_file (fn
, stderr
, flags
);
8173 /* Print on FILE the indexes for the predecessors of basic_block BB. */
8176 print_pred_bbs (FILE *file
, basic_block bb
)
8181 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
8182 fprintf (file
, "bb_%d ", e
->src
->index
);
8186 /* Print on FILE the indexes for the successors of basic_block BB. */
8189 print_succ_bbs (FILE *file
, basic_block bb
)
8194 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8195 fprintf (file
, "bb_%d ", e
->dest
->index
);
8198 /* Print to FILE the basic block BB following the VERBOSITY level. */
8201 print_loops_bb (FILE *file
, basic_block bb
, int indent
, int verbosity
)
8203 char *s_indent
= (char *) alloca ((size_t) indent
+ 1);
8204 memset ((void *) s_indent
, ' ', (size_t) indent
);
8205 s_indent
[indent
] = '\0';
8207 /* Print basic_block's header. */
8210 fprintf (file
, "%s bb_%d (preds = {", s_indent
, bb
->index
);
8211 print_pred_bbs (file
, bb
);
8212 fprintf (file
, "}, succs = {");
8213 print_succ_bbs (file
, bb
);
8214 fprintf (file
, "})\n");
8217 /* Print basic_block's body. */
8220 fprintf (file
, "%s {\n", s_indent
);
8221 dump_bb (file
, bb
, indent
+ 4, TDF_VOPS
|TDF_MEMSYMS
);
8222 fprintf (file
, "%s }\n", s_indent
);
8226 static void print_loop_and_siblings (FILE *, class loop
*, int, int);
8228 /* Pretty print LOOP on FILE, indented INDENT spaces. Following
8229 VERBOSITY level this outputs the contents of the loop, or just its
8233 print_loop (FILE *file
, class loop
*loop
, int indent
, int verbosity
)
8241 s_indent
= (char *) alloca ((size_t) indent
+ 1);
8242 memset ((void *) s_indent
, ' ', (size_t) indent
);
8243 s_indent
[indent
] = '\0';
8245 /* Print loop's header. */
8246 fprintf (file
, "%sloop_%d (", s_indent
, loop
->num
);
8248 fprintf (file
, "header = %d", loop
->header
->index
);
8251 fprintf (file
, "deleted)\n");
8255 fprintf (file
, ", latch = %d", loop
->latch
->index
);
8257 fprintf (file
, ", multiple latches");
8258 fprintf (file
, ", niter = ");
8259 print_generic_expr (file
, loop
->nb_iterations
);
8261 if (loop
->any_upper_bound
)
8263 fprintf (file
, ", upper_bound = ");
8264 print_decu (loop
->nb_iterations_upper_bound
, file
);
8266 if (loop
->any_likely_upper_bound
)
8268 fprintf (file
, ", likely_upper_bound = ");
8269 print_decu (loop
->nb_iterations_likely_upper_bound
, file
);
8272 if (loop
->any_estimate
)
8274 fprintf (file
, ", estimate = ");
8275 print_decu (loop
->nb_iterations_estimate
, file
);
8278 fprintf (file
, ", unroll = %d", loop
->unroll
);
8279 fprintf (file
, ")\n");
8281 /* Print loop's body. */
8284 fprintf (file
, "%s{\n", s_indent
);
8285 FOR_EACH_BB_FN (bb
, cfun
)
8286 if (bb
->loop_father
== loop
)
8287 print_loops_bb (file
, bb
, indent
, verbosity
);
8289 print_loop_and_siblings (file
, loop
->inner
, indent
+ 2, verbosity
);
8290 fprintf (file
, "%s}\n", s_indent
);
8294 /* Print the LOOP and its sibling loops on FILE, indented INDENT
8295 spaces. Following VERBOSITY level this outputs the contents of the
8296 loop, or just its structure. */
8299 print_loop_and_siblings (FILE *file
, class loop
*loop
, int indent
,
8305 print_loop (file
, loop
, indent
, verbosity
);
8306 print_loop_and_siblings (file
, loop
->next
, indent
, verbosity
);
8309 /* Follow a CFG edge from the entry point of the program, and on entry
8310 of a loop, pretty print the loop structure on FILE. */
8313 print_loops (FILE *file
, int verbosity
)
8317 bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
8318 fprintf (file
, "\nLoops in function: %s\n", current_function_name ());
8319 if (bb
&& bb
->loop_father
)
8320 print_loop_and_siblings (file
, bb
->loop_father
, 0, verbosity
);
8326 debug (class loop
&ref
)
8328 print_loop (stderr
, &ref
, 0, /*verbosity*/0);
8332 debug (class loop
*ptr
)
8337 fprintf (stderr
, "<nil>\n");
8340 /* Dump a loop verbosely. */
8343 debug_verbose (class loop
&ref
)
8345 print_loop (stderr
, &ref
, 0, /*verbosity*/3);
8349 debug_verbose (class loop
*ptr
)
8354 fprintf (stderr
, "<nil>\n");
8358 /* Debugging loops structure at tree level, at some VERBOSITY level. */
8361 debug_loops (int verbosity
)
8363 print_loops (stderr
, verbosity
);
8366 /* Print on stderr the code of LOOP, at some VERBOSITY level. */
8369 debug_loop (class loop
*loop
, int verbosity
)
8371 print_loop (stderr
, loop
, 0, verbosity
);
8374 /* Print on stderr the code of loop number NUM, at some VERBOSITY
8378 debug_loop_num (unsigned num
, int verbosity
)
8380 debug_loop (get_loop (cfun
, num
), verbosity
);
8383 /* Return true if BB ends with a call, possibly followed by some
8384 instructions that must stay with the call. Return false,
8388 gimple_block_ends_with_call_p (basic_block bb
)
8390 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
8391 return !gsi_end_p (gsi
) && is_gimple_call (gsi_stmt (gsi
));
8395 /* Return true if BB ends with a conditional branch. Return false,
8399 gimple_block_ends_with_condjump_p (const_basic_block bb
)
8401 gimple
*stmt
= last_stmt (CONST_CAST_BB (bb
));
8402 return (stmt
&& gimple_code (stmt
) == GIMPLE_COND
);
8406 /* Return true if statement T may terminate execution of BB in ways not
8407 explicitly represtented in the CFG. */
8410 stmt_can_terminate_bb_p (gimple
*t
)
8412 tree fndecl
= NULL_TREE
;
8415 /* Eh exception not handled internally terminates execution of the whole
8417 if (stmt_can_throw_external (cfun
, t
))
8420 /* NORETURN and LONGJMP calls already have an edge to exit.
8421 CONST and PURE calls do not need one.
8422 We don't currently check for CONST and PURE here, although
8423 it would be a good idea, because those attributes are
8424 figured out from the RTL in mark_constant_function, and
8425 the counter incrementation code from -fprofile-arcs
8426 leads to different results from -fbranch-probabilities. */
8427 if (is_gimple_call (t
))
8429 fndecl
= gimple_call_fndecl (t
);
8430 call_flags
= gimple_call_flags (t
);
8433 if (is_gimple_call (t
)
8435 && fndecl_built_in_p (fndecl
)
8436 && (call_flags
& ECF_NOTHROW
)
8437 && !(call_flags
& ECF_RETURNS_TWICE
)
8438 /* fork() doesn't really return twice, but the effect of
8439 wrapping it in __gcov_fork() which calls __gcov_flush()
8440 and clears the counters before forking has the same
8441 effect as returning twice. Force a fake edge. */
8442 && !fndecl_built_in_p (fndecl
, BUILT_IN_FORK
))
8445 if (is_gimple_call (t
))
8451 if (call_flags
& (ECF_PURE
| ECF_CONST
)
8452 && !(call_flags
& ECF_LOOPING_CONST_OR_PURE
))
8455 /* Function call may do longjmp, terminate program or do other things.
8456 Special case noreturn that have non-abnormal edges out as in this case
8457 the fact is sufficiently represented by lack of edges out of T. */
8458 if (!(call_flags
& ECF_NORETURN
))
8462 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8463 if ((e
->flags
& EDGE_FAKE
) == 0)
8467 if (gasm
*asm_stmt
= dyn_cast
<gasm
*> (t
))
8468 if (gimple_asm_volatile_p (asm_stmt
) || gimple_asm_input_p (asm_stmt
))
8475 /* Add fake edges to the function exit for any non constant and non
8476 noreturn calls (or noreturn calls with EH/abnormal edges),
8477 volatile inline assembly in the bitmap of blocks specified by BLOCKS
8478 or to the whole CFG if BLOCKS is zero. Return the number of blocks
8481 The goal is to expose cases in which entering a basic block does
8482 not imply that all subsequent instructions must be executed. */
8485 gimple_flow_call_edges_add (sbitmap blocks
)
8488 int blocks_split
= 0;
8489 int last_bb
= last_basic_block_for_fn (cfun
);
8490 bool check_last_block
= false;
8492 if (n_basic_blocks_for_fn (cfun
) == NUM_FIXED_BLOCKS
)
8496 check_last_block
= true;
8498 check_last_block
= bitmap_bit_p (blocks
,
8499 EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
->index
);
8501 /* In the last basic block, before epilogue generation, there will be
8502 a fallthru edge to EXIT. Special care is required if the last insn
8503 of the last basic block is a call because make_edge folds duplicate
8504 edges, which would result in the fallthru edge also being marked
8505 fake, which would result in the fallthru edge being removed by
8506 remove_fake_edges, which would result in an invalid CFG.
8508 Moreover, we can't elide the outgoing fake edge, since the block
8509 profiler needs to take this into account in order to solve the minimal
8510 spanning tree in the case that the call doesn't return.
8512 Handle this by adding a dummy instruction in a new last basic block. */
8513 if (check_last_block
)
8515 basic_block bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
8516 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
8519 if (!gsi_end_p (gsi
))
8522 if (t
&& stmt_can_terminate_bb_p (t
))
8526 e
= find_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
8529 gsi_insert_on_edge (e
, gimple_build_nop ());
8530 gsi_commit_edge_inserts ();
8535 /* Now add fake edges to the function exit for any non constant
8536 calls since there is no way that we can determine if they will
8538 for (i
= 0; i
< last_bb
; i
++)
8540 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8541 gimple_stmt_iterator gsi
;
8542 gimple
*stmt
, *last_stmt
;
8547 if (blocks
&& !bitmap_bit_p (blocks
, i
))
8550 gsi
= gsi_last_nondebug_bb (bb
);
8551 if (!gsi_end_p (gsi
))
8553 last_stmt
= gsi_stmt (gsi
);
8556 stmt
= gsi_stmt (gsi
);
8557 if (stmt_can_terminate_bb_p (stmt
))
8561 /* The handling above of the final block before the
8562 epilogue should be enough to verify that there is
8563 no edge to the exit block in CFG already.
8564 Calling make_edge in such case would cause us to
8565 mark that edge as fake and remove it later. */
8566 if (flag_checking
&& stmt
== last_stmt
)
8568 e
= find_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
8569 gcc_assert (e
== NULL
);
8572 /* Note that the following may create a new basic block
8573 and renumber the existing basic blocks. */
8574 if (stmt
!= last_stmt
)
8576 e
= split_block (bb
, stmt
);
8580 e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FAKE
);
8581 e
->probability
= profile_probability::guessed_never ();
8585 while (!gsi_end_p (gsi
));
8590 checking_verify_flow_info ();
8592 return blocks_split
;
8595 /* Removes edge E and all the blocks dominated by it, and updates dominance
8596 information. The IL in E->src needs to be updated separately.
8597 If dominance info is not available, only the edge E is removed.*/
8600 remove_edge_and_dominated_blocks (edge e
)
8602 vec
<basic_block
> bbs_to_remove
= vNULL
;
8603 vec
<basic_block
> bbs_to_fix_dom
= vNULL
;
8606 bool none_removed
= false;
8608 basic_block bb
, dbb
;
8611 /* If we are removing a path inside a non-root loop that may change
8612 loop ownership of blocks or remove loops. Mark loops for fixup. */
8614 && loop_outer (e
->src
->loop_father
) != NULL
8615 && e
->src
->loop_father
== e
->dest
->loop_father
)
8616 loops_state_set (LOOPS_NEED_FIXUP
);
8618 if (!dom_info_available_p (CDI_DOMINATORS
))
8624 /* No updating is needed for edges to exit. */
8625 if (e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
8627 if (cfgcleanup_altered_bbs
)
8628 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
8633 /* First, we find the basic blocks to remove. If E->dest has a predecessor
8634 that is not dominated by E->dest, then this set is empty. Otherwise,
8635 all the basic blocks dominated by E->dest are removed.
8637 Also, to DF_IDOM we store the immediate dominators of the blocks in
8638 the dominance frontier of E (i.e., of the successors of the
8639 removed blocks, if there are any, and of E->dest otherwise). */
8640 FOR_EACH_EDGE (f
, ei
, e
->dest
->preds
)
8645 if (!dominated_by_p (CDI_DOMINATORS
, f
->src
, e
->dest
))
8647 none_removed
= true;
8652 auto_bitmap df
, df_idom
;
8654 bitmap_set_bit (df_idom
,
8655 get_immediate_dominator (CDI_DOMINATORS
, e
->dest
)->index
);
8658 bbs_to_remove
= get_all_dominated_blocks (CDI_DOMINATORS
, e
->dest
);
8659 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
8661 FOR_EACH_EDGE (f
, ei
, bb
->succs
)
8663 if (f
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
8664 bitmap_set_bit (df
, f
->dest
->index
);
8667 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
8668 bitmap_clear_bit (df
, bb
->index
);
8670 EXECUTE_IF_SET_IN_BITMAP (df
, 0, i
, bi
)
8672 bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8673 bitmap_set_bit (df_idom
,
8674 get_immediate_dominator (CDI_DOMINATORS
, bb
)->index
);
8678 if (cfgcleanup_altered_bbs
)
8680 /* Record the set of the altered basic blocks. */
8681 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
8682 bitmap_ior_into (cfgcleanup_altered_bbs
, df
);
8685 /* Remove E and the cancelled blocks. */
8690 /* Walk backwards so as to get a chance to substitute all
8691 released DEFs into debug stmts. See
8692 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
8694 for (i
= bbs_to_remove
.length (); i
-- > 0; )
8695 delete_basic_block (bbs_to_remove
[i
]);
8698 /* Update the dominance information. The immediate dominator may change only
8699 for blocks whose immediate dominator belongs to DF_IDOM:
8701 Suppose that idom(X) = Y before removal of E and idom(X) != Y after the
8702 removal. Let Z the arbitrary block such that idom(Z) = Y and
8703 Z dominates X after the removal. Before removal, there exists a path P
8704 from Y to X that avoids Z. Let F be the last edge on P that is
8705 removed, and let W = F->dest. Before removal, idom(W) = Y (since Y
8706 dominates W, and because of P, Z does not dominate W), and W belongs to
8707 the dominance frontier of E. Therefore, Y belongs to DF_IDOM. */
8708 EXECUTE_IF_SET_IN_BITMAP (df_idom
, 0, i
, bi
)
8710 bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8711 for (dbb
= first_dom_son (CDI_DOMINATORS
, bb
);
8713 dbb
= next_dom_son (CDI_DOMINATORS
, dbb
))
8714 bbs_to_fix_dom
.safe_push (dbb
);
8717 iterate_fix_dominators (CDI_DOMINATORS
, bbs_to_fix_dom
, true);
8719 bbs_to_remove
.release ();
8720 bbs_to_fix_dom
.release ();
8723 /* Purge dead EH edges from basic block BB. */
8726 gimple_purge_dead_eh_edges (basic_block bb
)
8728 bool changed
= false;
8731 gimple
*stmt
= last_stmt (bb
);
8733 if (stmt
&& stmt_can_throw_internal (cfun
, stmt
))
8736 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
8738 if (e
->flags
& EDGE_EH
)
8740 remove_edge_and_dominated_blocks (e
);
8750 /* Purge dead EH edges from basic block listed in BLOCKS. */
8753 gimple_purge_all_dead_eh_edges (const_bitmap blocks
)
8755 bool changed
= false;
8759 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
8761 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8763 /* Earlier gimple_purge_dead_eh_edges could have removed
8764 this basic block already. */
8765 gcc_assert (bb
|| changed
);
8767 changed
|= gimple_purge_dead_eh_edges (bb
);
8773 /* Purge dead abnormal call edges from basic block BB. */
8776 gimple_purge_dead_abnormal_call_edges (basic_block bb
)
8778 bool changed
= false;
8781 gimple
*stmt
= last_stmt (bb
);
8783 if (!cfun
->has_nonlocal_label
8784 && !cfun
->calls_setjmp
)
8787 if (stmt
&& stmt_can_make_abnormal_goto (stmt
))
8790 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
8792 if (e
->flags
& EDGE_ABNORMAL
)
8794 if (e
->flags
& EDGE_FALLTHRU
)
8795 e
->flags
&= ~EDGE_ABNORMAL
;
8797 remove_edge_and_dominated_blocks (e
);
8807 /* Purge dead abnormal call edges from basic block listed in BLOCKS. */
8810 gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks
)
8812 bool changed
= false;
8816 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
8818 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
8820 /* Earlier gimple_purge_dead_abnormal_call_edges could have removed
8821 this basic block already. */
8822 gcc_assert (bb
|| changed
);
8824 changed
|= gimple_purge_dead_abnormal_call_edges (bb
);
8830 /* This function is called whenever a new edge is created or
8834 gimple_execute_on_growing_pred (edge e
)
8836 basic_block bb
= e
->dest
;
8838 if (!gimple_seq_empty_p (phi_nodes (bb
)))
8839 reserve_phi_args_for_new_edge (bb
);
8842 /* This function is called immediately before edge E is removed from
8843 the edge vector E->dest->preds. */
8846 gimple_execute_on_shrinking_pred (edge e
)
8848 if (!gimple_seq_empty_p (phi_nodes (e
->dest
)))
8849 remove_phi_args (e
);
8852 /*---------------------------------------------------------------------------
8853 Helper functions for Loop versioning
8854 ---------------------------------------------------------------------------*/
8856 /* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy
8857 of 'first'. Both of them are dominated by 'new_head' basic block. When
8858 'new_head' was created by 'second's incoming edge it received phi arguments
8859 on the edge by split_edge(). Later, additional edge 'e' was created to
8860 connect 'new_head' and 'first'. Now this routine adds phi args on this
8861 additional edge 'e' that new_head to second edge received as part of edge
8865 gimple_lv_adjust_loop_header_phi (basic_block first
, basic_block second
,
8866 basic_block new_head
, edge e
)
8869 gphi_iterator psi1
, psi2
;
8871 edge e2
= find_edge (new_head
, second
);
8873 /* Because NEW_HEAD has been created by splitting SECOND's incoming
8874 edge, we should always have an edge from NEW_HEAD to SECOND. */
8875 gcc_assert (e2
!= NULL
);
8877 /* Browse all 'second' basic block phi nodes and add phi args to
8878 edge 'e' for 'first' head. PHI args are always in correct order. */
8880 for (psi2
= gsi_start_phis (second
),
8881 psi1
= gsi_start_phis (first
);
8882 !gsi_end_p (psi2
) && !gsi_end_p (psi1
);
8883 gsi_next (&psi2
), gsi_next (&psi1
))
8887 def
= PHI_ARG_DEF (phi2
, e2
->dest_idx
);
8888 add_phi_arg (phi1
, def
, e
, gimple_phi_arg_location_from_edge (phi2
, e2
));
8893 /* Adds a if else statement to COND_BB with condition COND_EXPR.
8894 SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
8895 the destination of the ELSE part. */
8898 gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED
,
8899 basic_block second_head ATTRIBUTE_UNUSED
,
8900 basic_block cond_bb
, void *cond_e
)
8902 gimple_stmt_iterator gsi
;
8903 gimple
*new_cond_expr
;
8904 tree cond_expr
= (tree
) cond_e
;
8907 /* Build new conditional expr */
8908 new_cond_expr
= gimple_build_cond_from_tree (cond_expr
,
8909 NULL_TREE
, NULL_TREE
);
8911 /* Add new cond in cond_bb. */
8912 gsi
= gsi_last_bb (cond_bb
);
8913 gsi_insert_after (&gsi
, new_cond_expr
, GSI_NEW_STMT
);
8915 /* Adjust edges appropriately to connect new head with first head
8916 as well as second head. */
8917 e0
= single_succ_edge (cond_bb
);
8918 e0
->flags
&= ~EDGE_FALLTHRU
;
8919 e0
->flags
|= EDGE_FALSE_VALUE
;
8923 /* Do book-keeping of basic block BB for the profile consistency checker.
8924 Store the counting in RECORD. */
8926 gimple_account_profile_record (basic_block bb
,
8927 struct profile_record
*record
)
8929 gimple_stmt_iterator i
;
8930 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
8933 += estimate_num_insns (gsi_stmt (i
), &eni_size_weights
);
8934 if (bb
->count
.initialized_p ())
8936 += estimate_num_insns (gsi_stmt (i
),
8937 &eni_time_weights
) * bb
->count
.to_gcov_type ();
8938 else if (profile_status_for_fn (cfun
) == PROFILE_GUESSED
)
8940 += estimate_num_insns (gsi_stmt (i
),
8941 &eni_time_weights
) * bb
->count
.to_frequency (cfun
);
8945 struct cfg_hooks gimple_cfg_hooks
= {
8947 gimple_verify_flow_info
,
8948 gimple_dump_bb
, /* dump_bb */
8949 gimple_dump_bb_for_graph
, /* dump_bb_for_graph */
8950 create_bb
, /* create_basic_block */
8951 gimple_redirect_edge_and_branch
, /* redirect_edge_and_branch */
8952 gimple_redirect_edge_and_branch_force
, /* redirect_edge_and_branch_force */
8953 gimple_can_remove_branch_p
, /* can_remove_branch_p */
8954 remove_bb
, /* delete_basic_block */
8955 gimple_split_block
, /* split_block */
8956 gimple_move_block_after
, /* move_block_after */
8957 gimple_can_merge_blocks_p
, /* can_merge_blocks_p */
8958 gimple_merge_blocks
, /* merge_blocks */
8959 gimple_predict_edge
, /* predict_edge */
8960 gimple_predicted_by_p
, /* predicted_by_p */
8961 gimple_can_duplicate_bb_p
, /* can_duplicate_block_p */
8962 gimple_duplicate_bb
, /* duplicate_block */
8963 gimple_split_edge
, /* split_edge */
8964 gimple_make_forwarder_block
, /* make_forward_block */
8965 NULL
, /* tidy_fallthru_edge */
8966 NULL
, /* force_nonfallthru */
8967 gimple_block_ends_with_call_p
,/* block_ends_with_call_p */
8968 gimple_block_ends_with_condjump_p
, /* block_ends_with_condjump_p */
8969 gimple_flow_call_edges_add
, /* flow_call_edges_add */
8970 gimple_execute_on_growing_pred
, /* execute_on_growing_pred */
8971 gimple_execute_on_shrinking_pred
, /* execute_on_shrinking_pred */
8972 gimple_duplicate_loop_to_header_edge
, /* duplicate loop for trees */
8973 gimple_lv_add_condition_to_bb
, /* lv_add_condition_to_bb */
8974 gimple_lv_adjust_loop_header_phi
, /* lv_adjust_loop_header_phi*/
8975 extract_true_false_edges_from_block
, /* extract_cond_bb_edges */
8976 flush_pending_stmts
, /* flush_pending_stmts */
8977 gimple_empty_block_p
, /* block_empty_p */
8978 gimple_split_block_before_cond_jump
, /* split_block_before_cond_jump */
8979 gimple_account_profile_record
,
8983 /* Split all critical edges. Split some extra (not necessarily critical) edges
8984 if FOR_EDGE_INSERTION_P is true. */
8987 split_critical_edges (bool for_edge_insertion_p
/* = false */)
8993 /* split_edge can redirect edges out of SWITCH_EXPRs, which can get
8994 expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
8995 mappings around the calls to split_edge. */
8996 start_recording_case_labels ();
8997 FOR_ALL_BB_FN (bb
, cfun
)
8999 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
9001 if (EDGE_CRITICAL_P (e
) && !(e
->flags
& EDGE_ABNORMAL
))
9003 /* PRE inserts statements to edges and expects that
9004 since split_critical_edges was done beforehand, committing edge
9005 insertions will not split more edges. In addition to critical
9006 edges we must split edges that have multiple successors and
9007 end by control flow statements, such as RESX.
9008 Go ahead and split them too. This matches the logic in
9009 gimple_find_edge_insert_loc. */
9010 else if (for_edge_insertion_p
9011 && (!single_pred_p (e
->dest
)
9012 || !gimple_seq_empty_p (phi_nodes (e
->dest
))
9013 || e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
9014 && e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)
9015 && !(e
->flags
& EDGE_ABNORMAL
))
9017 gimple_stmt_iterator gsi
;
9019 gsi
= gsi_last_bb (e
->src
);
9020 if (!gsi_end_p (gsi
)
9021 && stmt_ends_bb_p (gsi_stmt (gsi
))
9022 && (gimple_code (gsi_stmt (gsi
)) != GIMPLE_RETURN
9023 && !gimple_call_builtin_p (gsi_stmt (gsi
),
9029 end_recording_case_labels ();
9035 const pass_data pass_data_split_crit_edges
=
9037 GIMPLE_PASS
, /* type */
9038 "crited", /* name */
9039 OPTGROUP_NONE
, /* optinfo_flags */
9040 TV_TREE_SPLIT_EDGES
, /* tv_id */
9041 PROP_cfg
, /* properties_required */
9042 PROP_no_crit_edges
, /* properties_provided */
9043 0, /* properties_destroyed */
9044 0, /* todo_flags_start */
9045 0, /* todo_flags_finish */
9048 class pass_split_crit_edges
: public gimple_opt_pass
9051 pass_split_crit_edges (gcc::context
*ctxt
)
9052 : gimple_opt_pass (pass_data_split_crit_edges
, ctxt
)
9055 /* opt_pass methods: */
9056 virtual unsigned int execute (function
*) { return split_critical_edges (); }
9058 opt_pass
* clone () { return new pass_split_crit_edges (m_ctxt
); }
9059 }; // class pass_split_crit_edges
9064 make_pass_split_crit_edges (gcc::context
*ctxt
)
9066 return new pass_split_crit_edges (ctxt
);
9070 /* Insert COND expression which is GIMPLE_COND after STMT
9071 in basic block BB with appropriate basic block split
9072 and creation of a new conditionally executed basic block.
9073 Update profile so the new bb is visited with probability PROB.
9074 Return created basic block. */
9076 insert_cond_bb (basic_block bb
, gimple
*stmt
, gimple
*cond
,
9077 profile_probability prob
)
9079 edge fall
= split_block (bb
, stmt
);
9080 gimple_stmt_iterator iter
= gsi_last_bb (bb
);
9083 /* Insert cond statement. */
9084 gcc_assert (gimple_code (cond
) == GIMPLE_COND
);
9085 if (gsi_end_p (iter
))
9086 gsi_insert_before (&iter
, cond
, GSI_CONTINUE_LINKING
);
9088 gsi_insert_after (&iter
, cond
, GSI_CONTINUE_LINKING
);
9090 /* Create conditionally executed block. */
9091 new_bb
= create_empty_bb (bb
);
9092 edge e
= make_edge (bb
, new_bb
, EDGE_TRUE_VALUE
);
9093 e
->probability
= prob
;
9094 new_bb
->count
= e
->count ();
9095 make_single_succ_edge (new_bb
, fall
->dest
, EDGE_FALLTHRU
);
9097 /* Fix edge for split bb. */
9098 fall
->flags
= EDGE_FALSE_VALUE
;
9099 fall
->probability
-= e
->probability
;
9101 /* Update dominance info. */
9102 if (dom_info_available_p (CDI_DOMINATORS
))
9104 set_immediate_dominator (CDI_DOMINATORS
, new_bb
, bb
);
9105 set_immediate_dominator (CDI_DOMINATORS
, fall
->dest
, bb
);
9108 /* Update loop info. */
9110 add_bb_to_loop (new_bb
, bb
->loop_father
);
9115 /* Build a ternary operation and gimplify it. Emit code before GSI.
9116 Return the gimple_val holding the result. */
9119 gimplify_build3 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
9120 tree type
, tree a
, tree b
, tree c
)
9123 location_t loc
= gimple_location (gsi_stmt (*gsi
));
9125 ret
= fold_build3_loc (loc
, code
, type
, a
, b
, c
);
9126 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
9130 /* Build a binary operation and gimplify it. Emit code before GSI.
9131 Return the gimple_val holding the result. */
9134 gimplify_build2 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
9135 tree type
, tree a
, tree b
)
9139 ret
= fold_build2_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
, b
);
9140 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
9144 /* Build a unary operation and gimplify it. Emit code before GSI.
9145 Return the gimple_val holding the result. */
9148 gimplify_build1 (gimple_stmt_iterator
*gsi
, enum tree_code code
, tree type
,
9153 ret
= fold_build1_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
);
9154 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
9160 /* Given a basic block B which ends with a conditional and has
9161 precisely two successors, determine which of the edges is taken if
9162 the conditional is true and which is taken if the conditional is
9163 false. Set TRUE_EDGE and FALSE_EDGE appropriately. */
9166 extract_true_false_edges_from_block (basic_block b
,
9170 edge e
= EDGE_SUCC (b
, 0);
9172 if (e
->flags
& EDGE_TRUE_VALUE
)
9175 *false_edge
= EDGE_SUCC (b
, 1);
9180 *true_edge
= EDGE_SUCC (b
, 1);
9185 /* From a controlling predicate in the immediate dominator DOM of
9186 PHIBLOCK determine the edges into PHIBLOCK that are chosen if the
9187 predicate evaluates to true and false and store them to
9188 *TRUE_CONTROLLED_EDGE and *FALSE_CONTROLLED_EDGE if
9189 they are non-NULL. Returns true if the edges can be determined,
9190 else return false. */
9193 extract_true_false_controlled_edges (basic_block dom
, basic_block phiblock
,
9194 edge
*true_controlled_edge
,
9195 edge
*false_controlled_edge
)
9197 basic_block bb
= phiblock
;
9198 edge true_edge
, false_edge
, tem
;
9199 edge e0
= NULL
, e1
= NULL
;
9201 /* We have to verify that one edge into the PHI node is dominated
9202 by the true edge of the predicate block and the other edge
9203 dominated by the false edge. This ensures that the PHI argument
9204 we are going to take is completely determined by the path we
9205 take from the predicate block.
9206 We can only use BB dominance checks below if the destination of
9207 the true/false edges are dominated by their edge, thus only
9208 have a single predecessor. */
9209 extract_true_false_edges_from_block (dom
, &true_edge
, &false_edge
);
9210 tem
= EDGE_PRED (bb
, 0);
9211 if (tem
== true_edge
9212 || (single_pred_p (true_edge
->dest
)
9213 && (tem
->src
== true_edge
->dest
9214 || dominated_by_p (CDI_DOMINATORS
,
9215 tem
->src
, true_edge
->dest
))))
9217 else if (tem
== false_edge
9218 || (single_pred_p (false_edge
->dest
)
9219 && (tem
->src
== false_edge
->dest
9220 || dominated_by_p (CDI_DOMINATORS
,
9221 tem
->src
, false_edge
->dest
))))
9225 tem
= EDGE_PRED (bb
, 1);
9226 if (tem
== true_edge
9227 || (single_pred_p (true_edge
->dest
)
9228 && (tem
->src
== true_edge
->dest
9229 || dominated_by_p (CDI_DOMINATORS
,
9230 tem
->src
, true_edge
->dest
))))
9232 else if (tem
== false_edge
9233 || (single_pred_p (false_edge
->dest
)
9234 && (tem
->src
== false_edge
->dest
9235 || dominated_by_p (CDI_DOMINATORS
,
9236 tem
->src
, false_edge
->dest
))))
9243 if (true_controlled_edge
)
9244 *true_controlled_edge
= e0
;
9245 if (false_controlled_edge
)
9246 *false_controlled_edge
= e1
;
9251 /* Generate a range test LHS CODE RHS that determines whether INDEX is in the
9252 range [low, high]. Place associated stmts before *GSI. */
9255 generate_range_test (basic_block bb
, tree index
, tree low
, tree high
,
9256 tree
*lhs
, tree
*rhs
)
9258 tree type
= TREE_TYPE (index
);
9259 tree utype
= range_check_type (type
);
9261 low
= fold_convert (utype
, low
);
9262 high
= fold_convert (utype
, high
);
9264 gimple_seq seq
= NULL
;
9265 index
= gimple_convert (&seq
, utype
, index
);
9266 *lhs
= gimple_build (&seq
, MINUS_EXPR
, utype
, index
, low
);
9267 *rhs
= const_binop (MINUS_EXPR
, utype
, high
, low
);
9269 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
9270 gsi_insert_seq_before (&gsi
, seq
, GSI_SAME_STMT
);
9273 /* Return the basic block that belongs to label numbered INDEX
9274 of a switch statement. */
9277 gimple_switch_label_bb (function
*ifun
, gswitch
*gs
, unsigned index
)
9279 return label_to_block (ifun
, CASE_LABEL (gimple_switch_label (gs
, index
)));
9282 /* Return the default basic block of a switch statement. */
9285 gimple_switch_default_bb (function
*ifun
, gswitch
*gs
)
9287 return gimple_switch_label_bb (ifun
, gs
, 0);
9290 /* Return the edge that belongs to label numbered INDEX
9291 of a switch statement. */
9294 gimple_switch_edge (function
*ifun
, gswitch
*gs
, unsigned index
)
9296 return find_edge (gimple_bb (gs
), gimple_switch_label_bb (ifun
, gs
, index
));
9299 /* Return the default edge of a switch statement. */
9302 gimple_switch_default_edge (function
*ifun
, gswitch
*gs
)
9304 return gimple_switch_edge (ifun
, gs
, 0);
9308 /* Emit return warnings. */
9312 const pass_data pass_data_warn_function_return
=
9314 GIMPLE_PASS
, /* type */
9315 "*warn_function_return", /* name */
9316 OPTGROUP_NONE
, /* optinfo_flags */
9317 TV_NONE
, /* tv_id */
9318 PROP_cfg
, /* properties_required */
9319 0, /* properties_provided */
9320 0, /* properties_destroyed */
9321 0, /* todo_flags_start */
9322 0, /* todo_flags_finish */
9325 class pass_warn_function_return
: public gimple_opt_pass
9328 pass_warn_function_return (gcc::context
*ctxt
)
9329 : gimple_opt_pass (pass_data_warn_function_return
, ctxt
)
9332 /* opt_pass methods: */
9333 virtual unsigned int execute (function
*);
9335 }; // class pass_warn_function_return
9338 pass_warn_function_return::execute (function
*fun
)
9340 location_t location
;
9345 if (!targetm
.warn_func_return (fun
->decl
))
9348 /* If we have a path to EXIT, then we do return. */
9349 if (TREE_THIS_VOLATILE (fun
->decl
)
9350 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) > 0)
9352 location
= UNKNOWN_LOCATION
;
9353 for (ei
= ei_start (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
);
9354 (e
= ei_safe_edge (ei
)); )
9356 last
= last_stmt (e
->src
);
9357 if ((gimple_code (last
) == GIMPLE_RETURN
9358 || gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
9359 && location
== UNKNOWN_LOCATION
9360 && ((location
= LOCATION_LOCUS (gimple_location (last
)))
9361 != UNKNOWN_LOCATION
)
9364 /* When optimizing, replace return stmts in noreturn functions
9365 with __builtin_unreachable () call. */
9366 if (optimize
&& gimple_code (last
) == GIMPLE_RETURN
)
9368 tree fndecl
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
9369 gimple
*new_stmt
= gimple_build_call (fndecl
, 0);
9370 gimple_set_location (new_stmt
, gimple_location (last
));
9371 gimple_stmt_iterator gsi
= gsi_for_stmt (last
);
9372 gsi_replace (&gsi
, new_stmt
, true);
9378 if (location
== UNKNOWN_LOCATION
)
9379 location
= cfun
->function_end_locus
;
9380 warning_at (location
, 0, "%<noreturn%> function does return");
9383 /* If we see "return;" in some basic block, then we do reach the end
9384 without returning a value. */
9385 else if (warn_return_type
> 0
9386 && !TREE_NO_WARNING (fun
->decl
)
9387 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fun
->decl
))))
9389 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
)
9391 gimple
*last
= last_stmt (e
->src
);
9392 greturn
*return_stmt
= dyn_cast
<greturn
*> (last
);
9394 && gimple_return_retval (return_stmt
) == NULL
9395 && !gimple_no_warning_p (last
))
9397 location
= gimple_location (last
);
9398 if (LOCATION_LOCUS (location
) == UNKNOWN_LOCATION
)
9399 location
= fun
->function_end_locus
;
9400 if (warning_at (location
, OPT_Wreturn_type
,
9401 "control reaches end of non-void function"))
9402 TREE_NO_WARNING (fun
->decl
) = 1;
9406 /* The C++ FE turns fallthrough from the end of non-void function
9407 into __builtin_unreachable () call with BUILTINS_LOCATION.
9408 Recognize those too. */
9410 if (!TREE_NO_WARNING (fun
->decl
))
9411 FOR_EACH_BB_FN (bb
, fun
)
9412 if (EDGE_COUNT (bb
->succs
) == 0)
9414 gimple
*last
= last_stmt (bb
);
9415 const enum built_in_function ubsan_missing_ret
9416 = BUILT_IN_UBSAN_HANDLE_MISSING_RETURN
;
9418 && ((LOCATION_LOCUS (gimple_location (last
))
9419 == BUILTINS_LOCATION
9420 && gimple_call_builtin_p (last
, BUILT_IN_UNREACHABLE
))
9421 || gimple_call_builtin_p (last
, ubsan_missing_ret
)))
9423 gimple_stmt_iterator gsi
= gsi_for_stmt (last
);
9424 gsi_prev_nondebug (&gsi
);
9425 gimple
*prev
= gsi_stmt (gsi
);
9427 location
= UNKNOWN_LOCATION
;
9429 location
= gimple_location (prev
);
9430 if (LOCATION_LOCUS (location
) == UNKNOWN_LOCATION
)
9431 location
= fun
->function_end_locus
;
9432 if (warning_at (location
, OPT_Wreturn_type
,
9433 "control reaches end of non-void function"))
9434 TREE_NO_WARNING (fun
->decl
) = 1;
9445 make_pass_warn_function_return (gcc::context
*ctxt
)
9447 return new pass_warn_function_return (ctxt
);
9450 /* Walk a gimplified function and warn for functions whose return value is
9451 ignored and attribute((warn_unused_result)) is set. This is done before
9452 inlining, so we don't have to worry about that. */
9455 do_warn_unused_result (gimple_seq seq
)
9458 gimple_stmt_iterator i
;
9460 for (i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
9462 gimple
*g
= gsi_stmt (i
);
9464 switch (gimple_code (g
))
9467 do_warn_unused_result (gimple_bind_body (as_a
<gbind
*>(g
)));
9470 do_warn_unused_result (gimple_try_eval (g
));
9471 do_warn_unused_result (gimple_try_cleanup (g
));
9474 do_warn_unused_result (gimple_catch_handler (
9475 as_a
<gcatch
*> (g
)));
9477 case GIMPLE_EH_FILTER
:
9478 do_warn_unused_result (gimple_eh_filter_failure (g
));
9482 if (gimple_call_lhs (g
))
9484 if (gimple_call_internal_p (g
))
9487 /* This is a naked call, as opposed to a GIMPLE_CALL with an
9488 LHS. All calls whose value is ignored should be
9489 represented like this. Look for the attribute. */
9490 fdecl
= gimple_call_fndecl (g
);
9491 ftype
= gimple_call_fntype (g
);
9493 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
9495 location_t loc
= gimple_location (g
);
9498 warning_at (loc
, OPT_Wunused_result
,
9499 "ignoring return value of %qD "
9500 "declared with attribute %<warn_unused_result%>",
9503 warning_at (loc
, OPT_Wunused_result
,
9504 "ignoring return value of function "
9505 "declared with attribute %<warn_unused_result%>");
9510 /* Not a container, not a call, or a call whose value is used. */
9518 const pass_data pass_data_warn_unused_result
=
9520 GIMPLE_PASS
, /* type */
9521 "*warn_unused_result", /* name */
9522 OPTGROUP_NONE
, /* optinfo_flags */
9523 TV_NONE
, /* tv_id */
9524 PROP_gimple_any
, /* properties_required */
9525 0, /* properties_provided */
9526 0, /* properties_destroyed */
9527 0, /* todo_flags_start */
9528 0, /* todo_flags_finish */
9531 class pass_warn_unused_result
: public gimple_opt_pass
9534 pass_warn_unused_result (gcc::context
*ctxt
)
9535 : gimple_opt_pass (pass_data_warn_unused_result
, ctxt
)
9538 /* opt_pass methods: */
9539 virtual bool gate (function
*) { return flag_warn_unused_result
; }
9540 virtual unsigned int execute (function
*)
9542 do_warn_unused_result (gimple_body (current_function_decl
));
9546 }; // class pass_warn_unused_result
9551 make_pass_warn_unused_result (gcc::context
*ctxt
)
9553 return new pass_warn_unused_result (ctxt
);
9556 /* IPA passes, compilation of earlier functions or inlining
9557 might have changed some properties, such as marked functions nothrow,
9558 pure, const or noreturn.
9559 Remove redundant edges and basic blocks, and create new ones if necessary.
9561 This pass can't be executed as stand alone pass from pass manager, because
9562 in between inlining and this fixup the verify_flow_info would fail. */
9565 execute_fixup_cfg (void)
9568 gimple_stmt_iterator gsi
;
9570 cgraph_node
*node
= cgraph_node::get (current_function_decl
);
9571 /* Same scaling is also done by ipa_merge_profiles. */
9572 profile_count num
= node
->count
;
9573 profile_count den
= ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
;
9574 bool scale
= num
.initialized_p () && !(num
== den
);
9578 profile_count::adjust_for_ipa_scaling (&num
, &den
);
9579 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
= node
->count
;
9580 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
9581 = EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
.apply_scale (num
, den
);
9584 FOR_EACH_BB_FN (bb
, cfun
)
9587 bb
->count
= bb
->count
.apply_scale (num
, den
);
9588 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
9590 gimple
*stmt
= gsi_stmt (gsi
);
9591 tree decl
= is_gimple_call (stmt
)
9592 ? gimple_call_fndecl (stmt
)
9596 int flags
= gimple_call_flags (stmt
);
9597 if (flags
& (ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
))
9599 if (gimple_purge_dead_abnormal_call_edges (bb
))
9600 todo
|= TODO_cleanup_cfg
;
9602 if (gimple_in_ssa_p (cfun
))
9604 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
9609 if (flags
& ECF_NORETURN
9610 && fixup_noreturn_call (stmt
))
9611 todo
|= TODO_cleanup_cfg
;
9614 /* Remove stores to variables we marked write-only.
9615 Keep access when store has side effect, i.e. in case when source
9617 if (gimple_store_p (stmt
)
9618 && !gimple_has_side_effects (stmt
)
9621 tree lhs
= get_base_address (gimple_get_lhs (stmt
));
9624 && (TREE_STATIC (lhs
) || DECL_EXTERNAL (lhs
))
9625 && varpool_node::get (lhs
)->writeonly
)
9627 unlink_stmt_vdef (stmt
);
9628 gsi_remove (&gsi
, true);
9629 release_defs (stmt
);
9630 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
9634 /* For calls we can simply remove LHS when it is known
9635 to be write-only. */
9636 if (is_gimple_call (stmt
)
9637 && gimple_get_lhs (stmt
))
9639 tree lhs
= get_base_address (gimple_get_lhs (stmt
));
9642 && (TREE_STATIC (lhs
) || DECL_EXTERNAL (lhs
))
9643 && varpool_node::get (lhs
)->writeonly
)
9645 gimple_call_set_lhs (stmt
, NULL
);
9647 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
9651 if (maybe_clean_eh_stmt (stmt
)
9652 && gimple_purge_dead_eh_edges (bb
))
9653 todo
|= TODO_cleanup_cfg
;
9657 /* If we have a basic block with no successors that does not
9658 end with a control statement or a noreturn call end it with
9659 a call to __builtin_unreachable. This situation can occur
9660 when inlining a noreturn call that does in fact return. */
9661 if (EDGE_COUNT (bb
->succs
) == 0)
9663 gimple
*stmt
= last_stmt (bb
);
9665 || (!is_ctrl_stmt (stmt
)
9666 && (!is_gimple_call (stmt
)
9667 || !gimple_call_noreturn_p (stmt
))))
9669 if (stmt
&& is_gimple_call (stmt
))
9670 gimple_call_set_ctrl_altering (stmt
, false);
9671 tree fndecl
= builtin_decl_implicit (BUILT_IN_UNREACHABLE
);
9672 stmt
= gimple_build_call (fndecl
, 0);
9673 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
9674 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
9675 if (!cfun
->after_inlining
)
9677 gcall
*call_stmt
= dyn_cast
<gcall
*> (stmt
);
9678 node
->create_edge (cgraph_node::get_create (fndecl
),
9679 call_stmt
, bb
->count
);
9686 update_max_bb_count ();
9687 compute_function_frequency ();
9691 && (todo
& TODO_cleanup_cfg
))
9692 loops_state_set (LOOPS_NEED_FIXUP
);
9699 const pass_data pass_data_fixup_cfg
=
9701 GIMPLE_PASS
, /* type */
9702 "fixup_cfg", /* name */
9703 OPTGROUP_NONE
, /* optinfo_flags */
9704 TV_NONE
, /* tv_id */
9705 PROP_cfg
, /* properties_required */
9706 0, /* properties_provided */
9707 0, /* properties_destroyed */
9708 0, /* todo_flags_start */
9709 0, /* todo_flags_finish */
9712 class pass_fixup_cfg
: public gimple_opt_pass
9715 pass_fixup_cfg (gcc::context
*ctxt
)
9716 : gimple_opt_pass (pass_data_fixup_cfg
, ctxt
)
9719 /* opt_pass methods: */
9720 opt_pass
* clone () { return new pass_fixup_cfg (m_ctxt
); }
9721 virtual unsigned int execute (function
*) { return execute_fixup_cfg (); }
9723 }; // class pass_fixup_cfg
9728 make_pass_fixup_cfg (gcc::context
*ctxt
)
9730 return new pass_fixup_cfg (ctxt
);
9733 /* Garbage collection support for edge_def. */
9735 extern void gt_ggc_mx (tree
&);
9736 extern void gt_ggc_mx (gimple
*&);
9737 extern void gt_ggc_mx (rtx
&);
9738 extern void gt_ggc_mx (basic_block
&);
9741 gt_ggc_mx (rtx_insn
*& x
)
9744 gt_ggc_mx_rtx_def ((void *) x
);
9748 gt_ggc_mx (edge_def
*e
)
9750 tree block
= LOCATION_BLOCK (e
->goto_locus
);
9752 gt_ggc_mx (e
->dest
);
9753 if (current_ir_type () == IR_GIMPLE
)
9754 gt_ggc_mx (e
->insns
.g
);
9756 gt_ggc_mx (e
->insns
.r
);
9760 /* PCH support for edge_def. */
9762 extern void gt_pch_nx (tree
&);
9763 extern void gt_pch_nx (gimple
*&);
9764 extern void gt_pch_nx (rtx
&);
9765 extern void gt_pch_nx (basic_block
&);
9768 gt_pch_nx (rtx_insn
*& x
)
9771 gt_pch_nx_rtx_def ((void *) x
);
9775 gt_pch_nx (edge_def
*e
)
9777 tree block
= LOCATION_BLOCK (e
->goto_locus
);
9779 gt_pch_nx (e
->dest
);
9780 if (current_ir_type () == IR_GIMPLE
)
9781 gt_pch_nx (e
->insns
.g
);
9783 gt_pch_nx (e
->insns
.r
);
9788 gt_pch_nx (edge_def
*e
, gt_pointer_operator op
, void *cookie
)
9790 tree block
= LOCATION_BLOCK (e
->goto_locus
);
9791 op (&(e
->src
), cookie
);
9792 op (&(e
->dest
), cookie
);
9793 if (current_ir_type () == IR_GIMPLE
)
9794 op (&(e
->insns
.g
), cookie
);
9796 op (&(e
->insns
.r
), cookie
);
9797 op (&(block
), cookie
);
9802 namespace selftest
{
9804 /* Helper function for CFG selftests: create a dummy function decl
9805 and push it as cfun. */
9808 push_fndecl (const char *name
)
9810 tree fn_type
= build_function_type_array (integer_type_node
, 0, NULL
);
9811 /* FIXME: this uses input_location: */
9812 tree fndecl
= build_fn_decl (name
, fn_type
);
9813 tree retval
= build_decl (UNKNOWN_LOCATION
, RESULT_DECL
,
9814 NULL_TREE
, integer_type_node
);
9815 DECL_RESULT (fndecl
) = retval
;
9816 push_struct_function (fndecl
);
9817 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
9818 ASSERT_TRUE (fun
!= NULL
);
9819 init_empty_tree_cfg_for_function (fun
);
9820 ASSERT_EQ (2, n_basic_blocks_for_fn (fun
));
9821 ASSERT_EQ (0, n_edges_for_fn (fun
));
9825 /* These tests directly create CFGs.
9826 Compare with the static fns within tree-cfg.c:
9828 - make_blocks: calls create_basic_block (seq, bb);
9831 /* Verify a simple cfg of the form:
9832 ENTRY -> A -> B -> C -> EXIT. */
9835 test_linear_chain ()
9837 gimple_register_cfg_hooks ();
9839 tree fndecl
= push_fndecl ("cfg_test_linear_chain");
9840 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
9842 /* Create some empty blocks. */
9843 basic_block bb_a
= create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
9844 basic_block bb_b
= create_empty_bb (bb_a
);
9845 basic_block bb_c
= create_empty_bb (bb_b
);
9847 ASSERT_EQ (5, n_basic_blocks_for_fn (fun
));
9848 ASSERT_EQ (0, n_edges_for_fn (fun
));
9850 /* Create some edges: a simple linear chain of BBs. */
9851 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
), bb_a
, EDGE_FALLTHRU
);
9852 make_edge (bb_a
, bb_b
, 0);
9853 make_edge (bb_b
, bb_c
, 0);
9854 make_edge (bb_c
, EXIT_BLOCK_PTR_FOR_FN (fun
), 0);
9856 /* Verify the edges. */
9857 ASSERT_EQ (4, n_edges_for_fn (fun
));
9858 ASSERT_EQ (NULL
, ENTRY_BLOCK_PTR_FOR_FN (fun
)->preds
);
9859 ASSERT_EQ (1, ENTRY_BLOCK_PTR_FOR_FN (fun
)->succs
->length ());
9860 ASSERT_EQ (1, bb_a
->preds
->length ());
9861 ASSERT_EQ (1, bb_a
->succs
->length ());
9862 ASSERT_EQ (1, bb_b
->preds
->length ());
9863 ASSERT_EQ (1, bb_b
->succs
->length ());
9864 ASSERT_EQ (1, bb_c
->preds
->length ());
9865 ASSERT_EQ (1, bb_c
->succs
->length ());
9866 ASSERT_EQ (1, EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
->length ());
9867 ASSERT_EQ (NULL
, EXIT_BLOCK_PTR_FOR_FN (fun
)->succs
);
9869 /* Verify the dominance information
9870 Each BB in our simple chain should be dominated by the one before
9872 calculate_dominance_info (CDI_DOMINATORS
);
9873 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_b
));
9874 ASSERT_EQ (bb_b
, get_immediate_dominator (CDI_DOMINATORS
, bb_c
));
9875 vec
<basic_block
> dom_by_b
= get_dominated_by (CDI_DOMINATORS
, bb_b
);
9876 ASSERT_EQ (1, dom_by_b
.length ());
9877 ASSERT_EQ (bb_c
, dom_by_b
[0]);
9878 free_dominance_info (CDI_DOMINATORS
);
9879 dom_by_b
.release ();
9881 /* Similarly for post-dominance: each BB in our chain is post-dominated
9882 by the one after it. */
9883 calculate_dominance_info (CDI_POST_DOMINATORS
);
9884 ASSERT_EQ (bb_b
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_a
));
9885 ASSERT_EQ (bb_c
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_b
));
9886 vec
<basic_block
> postdom_by_b
= get_dominated_by (CDI_POST_DOMINATORS
, bb_b
);
9887 ASSERT_EQ (1, postdom_by_b
.length ());
9888 ASSERT_EQ (bb_a
, postdom_by_b
[0]);
9889 free_dominance_info (CDI_POST_DOMINATORS
);
9890 postdom_by_b
.release ();
9895 /* Verify a simple CFG of the form:
9911 gimple_register_cfg_hooks ();
9913 tree fndecl
= push_fndecl ("cfg_test_diamond");
9914 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
9916 /* Create some empty blocks. */
9917 basic_block bb_a
= create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
));
9918 basic_block bb_b
= create_empty_bb (bb_a
);
9919 basic_block bb_c
= create_empty_bb (bb_a
);
9920 basic_block bb_d
= create_empty_bb (bb_b
);
9922 ASSERT_EQ (6, n_basic_blocks_for_fn (fun
));
9923 ASSERT_EQ (0, n_edges_for_fn (fun
));
9925 /* Create the edges. */
9926 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
), bb_a
, EDGE_FALLTHRU
);
9927 make_edge (bb_a
, bb_b
, EDGE_TRUE_VALUE
);
9928 make_edge (bb_a
, bb_c
, EDGE_FALSE_VALUE
);
9929 make_edge (bb_b
, bb_d
, 0);
9930 make_edge (bb_c
, bb_d
, 0);
9931 make_edge (bb_d
, EXIT_BLOCK_PTR_FOR_FN (fun
), 0);
9933 /* Verify the edges. */
9934 ASSERT_EQ (6, n_edges_for_fn (fun
));
9935 ASSERT_EQ (1, bb_a
->preds
->length ());
9936 ASSERT_EQ (2, bb_a
->succs
->length ());
9937 ASSERT_EQ (1, bb_b
->preds
->length ());
9938 ASSERT_EQ (1, bb_b
->succs
->length ());
9939 ASSERT_EQ (1, bb_c
->preds
->length ());
9940 ASSERT_EQ (1, bb_c
->succs
->length ());
9941 ASSERT_EQ (2, bb_d
->preds
->length ());
9942 ASSERT_EQ (1, bb_d
->succs
->length ());
9944 /* Verify the dominance information. */
9945 calculate_dominance_info (CDI_DOMINATORS
);
9946 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_b
));
9947 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_c
));
9948 ASSERT_EQ (bb_a
, get_immediate_dominator (CDI_DOMINATORS
, bb_d
));
9949 vec
<basic_block
> dom_by_a
= get_dominated_by (CDI_DOMINATORS
, bb_a
);
9950 ASSERT_EQ (3, dom_by_a
.length ()); /* B, C, D, in some order. */
9951 dom_by_a
.release ();
9952 vec
<basic_block
> dom_by_b
= get_dominated_by (CDI_DOMINATORS
, bb_b
);
9953 ASSERT_EQ (0, dom_by_b
.length ());
9954 dom_by_b
.release ();
9955 free_dominance_info (CDI_DOMINATORS
);
9957 /* Similarly for post-dominance. */
9958 calculate_dominance_info (CDI_POST_DOMINATORS
);
9959 ASSERT_EQ (bb_d
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_a
));
9960 ASSERT_EQ (bb_d
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_b
));
9961 ASSERT_EQ (bb_d
, get_immediate_dominator (CDI_POST_DOMINATORS
, bb_c
));
9962 vec
<basic_block
> postdom_by_d
= get_dominated_by (CDI_POST_DOMINATORS
, bb_d
);
9963 ASSERT_EQ (3, postdom_by_d
.length ()); /* A, B, C in some order. */
9964 postdom_by_d
.release ();
9965 vec
<basic_block
> postdom_by_b
= get_dominated_by (CDI_POST_DOMINATORS
, bb_b
);
9966 ASSERT_EQ (0, postdom_by_b
.length ());
9967 postdom_by_b
.release ();
9968 free_dominance_info (CDI_POST_DOMINATORS
);
9973 /* Verify that we can handle a CFG containing a "complete" aka
9974 fully-connected subgraph (where A B C D below all have edges
9975 pointing to each other node, also to themselves).
9993 test_fully_connected ()
9995 gimple_register_cfg_hooks ();
9997 tree fndecl
= push_fndecl ("cfg_fully_connected");
9998 function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
10002 /* Create some empty blocks. */
10003 auto_vec
<basic_block
> subgraph_nodes
;
10004 for (int i
= 0; i
< n
; i
++)
10005 subgraph_nodes
.safe_push (create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (fun
)));
10007 ASSERT_EQ (n
+ 2, n_basic_blocks_for_fn (fun
));
10008 ASSERT_EQ (0, n_edges_for_fn (fun
));
10010 /* Create the edges. */
10011 make_edge (ENTRY_BLOCK_PTR_FOR_FN (fun
), subgraph_nodes
[0], EDGE_FALLTHRU
);
10012 make_edge (subgraph_nodes
[0], EXIT_BLOCK_PTR_FOR_FN (fun
), 0);
10013 for (int i
= 0; i
< n
; i
++)
10014 for (int j
= 0; j
< n
; j
++)
10015 make_edge (subgraph_nodes
[i
], subgraph_nodes
[j
], 0);
10017 /* Verify the edges. */
10018 ASSERT_EQ (2 + (n
* n
), n_edges_for_fn (fun
));
10019 /* The first one is linked to ENTRY/EXIT as well as itself and
10020 everything else. */
10021 ASSERT_EQ (n
+ 1, subgraph_nodes
[0]->preds
->length ());
10022 ASSERT_EQ (n
+ 1, subgraph_nodes
[0]->succs
->length ());
10023 /* The other ones in the subgraph are linked to everything in
10024 the subgraph (including themselves). */
10025 for (int i
= 1; i
< n
; i
++)
10027 ASSERT_EQ (n
, subgraph_nodes
[i
]->preds
->length ());
10028 ASSERT_EQ (n
, subgraph_nodes
[i
]->succs
->length ());
10031 /* Verify the dominance information. */
10032 calculate_dominance_info (CDI_DOMINATORS
);
10033 /* The initial block in the subgraph should be dominated by ENTRY. */
10034 ASSERT_EQ (ENTRY_BLOCK_PTR_FOR_FN (fun
),
10035 get_immediate_dominator (CDI_DOMINATORS
,
10036 subgraph_nodes
[0]));
10037 /* Every other block in the subgraph should be dominated by the
10039 for (int i
= 1; i
< n
; i
++)
10040 ASSERT_EQ (subgraph_nodes
[0],
10041 get_immediate_dominator (CDI_DOMINATORS
,
10042 subgraph_nodes
[i
]));
10043 free_dominance_info (CDI_DOMINATORS
);
10045 /* Similarly for post-dominance. */
10046 calculate_dominance_info (CDI_POST_DOMINATORS
);
10047 /* The initial block in the subgraph should be postdominated by EXIT. */
10048 ASSERT_EQ (EXIT_BLOCK_PTR_FOR_FN (fun
),
10049 get_immediate_dominator (CDI_POST_DOMINATORS
,
10050 subgraph_nodes
[0]));
10051 /* Every other block in the subgraph should be postdominated by the
10052 initial block, since that leads to EXIT. */
10053 for (int i
= 1; i
< n
; i
++)
10054 ASSERT_EQ (subgraph_nodes
[0],
10055 get_immediate_dominator (CDI_POST_DOMINATORS
,
10056 subgraph_nodes
[i
]));
10057 free_dominance_info (CDI_POST_DOMINATORS
);
10062 /* Run all of the selftests within this file. */
10065 tree_cfg_c_tests ()
10067 test_linear_chain ();
10069 test_fully_connected ();
10072 } // namespace selftest
10074 /* TODO: test the dominator/postdominator logic with various graphs/nodes:
10077 - switch statement (a block with many out-edges)
10078 - something that jumps to itself
10081 #endif /* CHECKING_P */