1 /* Control flow functions for trees.
2 Copyright (C) 2001-2014 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"
24 #include "hash-table.h"
27 #include "trans-mem.h"
28 #include "stor-layout.h"
29 #include "print-tree.h"
31 #include "basic-block.h"
34 #include "gimple-pretty-print.h"
35 #include "pointer-set.h"
36 #include "tree-ssa-alias.h"
37 #include "internal-fn.h"
38 #include "gimple-fold.h"
40 #include "gimple-expr.h"
43 #include "gimple-iterator.h"
44 #include "gimplify-me.h"
45 #include "gimple-walk.h"
46 #include "gimple-ssa.h"
49 #include "tree-phinodes.h"
50 #include "ssa-iterators.h"
51 #include "stringpool.h"
52 #include "tree-ssanames.h"
53 #include "tree-ssa-loop-manip.h"
54 #include "tree-ssa-loop-niter.h"
55 #include "tree-into-ssa.h"
59 #include "tree-dump.h"
60 #include "tree-pass.h"
61 #include "diagnostic-core.h"
64 #include "tree-ssa-propagate.h"
65 #include "value-prof.h"
66 #include "tree-inline.h"
68 #include "tree-ssa-live.h"
70 #include "tree-cfgcleanup.h"
72 #include "wide-int-print.h"
74 /* This file contains functions for building the Control Flow Graph (CFG)
75 for a function tree. */
77 /* Local declarations. */
79 /* Initial capacity for the basic block array. */
80 static const int initial_cfg_capacity
= 20;
82 /* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
83 which use a particular edge. The CASE_LABEL_EXPRs are chained together
84 via their CASE_CHAIN field, which we clear after we're done with the
85 hash table to prevent problems with duplication of GIMPLE_SWITCHes.
87 Access to this list of CASE_LABEL_EXPRs allows us to efficiently
88 update the case vector in response to edge redirections.
90 Right now this table is set up and torn down at key points in the
91 compilation process. It would be nice if we could make the table
92 more persistent. The key is getting notification of changes to
93 the CFG (particularly edge removal, creation and redirection). */
95 static struct pointer_map_t
*edge_to_cases
;
97 /* If we record edge_to_cases, this bitmap will hold indexes
98 of basic blocks that end in a GIMPLE_SWITCH which we touched
99 due to edge manipulations. */
101 static bitmap touched_switch_bbs
;
103 /* CFG statistics. */
106 long num_merged_labels
;
109 static struct cfg_stats_d cfg_stats
;
111 /* Hash table to store last discriminator assigned for each locus. */
112 struct locus_discrim_map
118 /* Hashtable helpers. */
120 struct locus_discrim_hasher
: typed_free_remove
<locus_discrim_map
>
122 typedef locus_discrim_map value_type
;
123 typedef locus_discrim_map compare_type
;
124 static inline hashval_t
hash (const value_type
*);
125 static inline bool equal (const value_type
*, const compare_type
*);
128 /* Trivial hash function for a location_t. ITEM is a pointer to
129 a hash table entry that maps a location_t to a discriminator. */
132 locus_discrim_hasher::hash (const value_type
*item
)
134 return LOCATION_LINE (item
->locus
);
137 /* Equality function for the locus-to-discriminator map. A and B
138 point to the two hash table entries to compare. */
141 locus_discrim_hasher::equal (const value_type
*a
, const compare_type
*b
)
143 return LOCATION_LINE (a
->locus
) == LOCATION_LINE (b
->locus
);
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 (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 (gimple
);
168 /* Flowgraph optimization and cleanup. */
169 static void gimple_merge_blocks (basic_block
, basic_block
);
170 static bool gimple_can_merge_blocks_p (basic_block
, basic_block
);
171 static void remove_bb (basic_block
);
172 static edge
find_taken_edge_computed_goto (basic_block
, tree
);
173 static edge
find_taken_edge_cond_expr (basic_block
, tree
);
174 static edge
find_taken_edge_switch_expr (basic_block
, tree
);
175 static tree
find_case_label_for_value (gimple
, tree
);
178 init_empty_tree_cfg_for_function (struct function
*fn
)
180 /* Initialize the basic block array. */
182 profile_status_for_fn (fn
) = PROFILE_ABSENT
;
183 n_basic_blocks_for_fn (fn
) = NUM_FIXED_BLOCKS
;
184 last_basic_block_for_fn (fn
) = NUM_FIXED_BLOCKS
;
185 vec_alloc (basic_block_info_for_fn (fn
), initial_cfg_capacity
);
186 vec_safe_grow_cleared (basic_block_info_for_fn (fn
),
187 initial_cfg_capacity
);
189 /* Build a mapping of labels to their associated blocks. */
190 vec_alloc (label_to_block_map_for_fn (fn
), initial_cfg_capacity
);
191 vec_safe_grow_cleared (label_to_block_map_for_fn (fn
),
192 initial_cfg_capacity
);
194 SET_BASIC_BLOCK_FOR_FN (fn
, ENTRY_BLOCK
, ENTRY_BLOCK_PTR_FOR_FN (fn
));
195 SET_BASIC_BLOCK_FOR_FN (fn
, EXIT_BLOCK
, EXIT_BLOCK_PTR_FOR_FN (fn
));
197 ENTRY_BLOCK_PTR_FOR_FN (fn
)->next_bb
198 = EXIT_BLOCK_PTR_FOR_FN (fn
);
199 EXIT_BLOCK_PTR_FOR_FN (fn
)->prev_bb
200 = ENTRY_BLOCK_PTR_FOR_FN (fn
);
204 init_empty_tree_cfg (void)
206 init_empty_tree_cfg_for_function (cfun
);
209 /*---------------------------------------------------------------------------
211 ---------------------------------------------------------------------------*/
213 /* Entry point to the CFG builder for trees. SEQ is the sequence of
214 statements to be added to the flowgraph. */
217 build_gimple_cfg (gimple_seq seq
)
219 /* Register specific gimple functions. */
220 gimple_register_cfg_hooks ();
222 memset ((void *) &cfg_stats
, 0, sizeof (cfg_stats
));
224 init_empty_tree_cfg ();
228 /* Make sure there is always at least one block, even if it's empty. */
229 if (n_basic_blocks_for_fn (cfun
) == NUM_FIXED_BLOCKS
)
230 create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
232 /* Adjust the size of the array. */
233 if (basic_block_info_for_fn (cfun
)->length ()
234 < (size_t) n_basic_blocks_for_fn (cfun
))
235 vec_safe_grow_cleared (basic_block_info_for_fn (cfun
),
236 n_basic_blocks_for_fn (cfun
));
238 /* To speed up statement iterator walks, we first purge dead labels. */
239 cleanup_dead_labels ();
241 /* Group case nodes to reduce the number of edges.
242 We do this after cleaning up dead labels because otherwise we miss
243 a lot of obvious case merging opportunities. */
244 group_case_labels ();
246 /* Create the edges of the flowgraph. */
247 discriminator_per_locus
.create (13);
249 assign_discriminators ();
250 cleanup_dead_labels ();
251 discriminator_per_locus
.dispose ();
255 /* Look for ANNOTATE calls with loop annotation kind; if found, remove
256 them and propagate the information to the loop. We assume that the
257 annotations come immediately before the condition of the loop. */
260 replace_loop_annotate ()
264 gimple_stmt_iterator gsi
;
267 FOR_EACH_LOOP (loop
, 0)
269 gsi
= gsi_last_bb (loop
->header
);
270 stmt
= gsi_stmt (gsi
);
271 if (!(stmt
&& gimple_code (stmt
) == GIMPLE_COND
))
273 for (gsi_prev_nondebug (&gsi
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
275 stmt
= gsi_stmt (gsi
);
276 if (gimple_code (stmt
) != GIMPLE_CALL
)
278 if (!gimple_call_internal_p (stmt
)
279 || gimple_call_internal_fn (stmt
) != IFN_ANNOTATE
)
281 switch ((annot_expr_kind
) tree_to_shwi (gimple_call_arg (stmt
, 1)))
283 case annot_expr_ivdep_kind
:
284 loop
->safelen
= INT_MAX
;
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;
296 stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
297 gimple_call_arg (stmt
, 0));
298 gsi_replace (&gsi
, stmt
, true);
302 /* Remove IFN_ANNOTATE. Safeguard for the case loop->latch == NULL. */
303 FOR_EACH_BB_FN (bb
, cfun
)
305 for (gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
307 stmt
= gsi_stmt (gsi
);
308 if (gimple_code (stmt
) != GIMPLE_CALL
)
310 if (!gimple_call_internal_p (stmt
)
311 || gimple_call_internal_fn (stmt
) != IFN_ANNOTATE
)
313 switch ((annot_expr_kind
) tree_to_shwi (gimple_call_arg (stmt
, 1)))
315 case annot_expr_ivdep_kind
:
316 case annot_expr_no_vector_kind
:
317 case annot_expr_vector_kind
:
322 warning_at (gimple_location (stmt
), 0, "ignoring loop annotation");
323 stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
324 gimple_call_arg (stmt
, 0));
325 gsi_replace (&gsi
, stmt
, true);
332 execute_build_cfg (void)
334 gimple_seq body
= gimple_body (current_function_decl
);
336 build_gimple_cfg (body
);
337 gimple_set_body (current_function_decl
, NULL
);
338 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
340 fprintf (dump_file
, "Scope blocks:\n");
341 dump_scope_blocks (dump_file
, dump_flags
);
344 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
345 replace_loop_annotate ();
351 const pass_data pass_data_build_cfg
=
353 GIMPLE_PASS
, /* type */
355 OPTGROUP_NONE
, /* optinfo_flags */
356 true, /* has_execute */
357 TV_TREE_CFG
, /* tv_id */
358 PROP_gimple_leh
, /* properties_required */
359 ( PROP_cfg
| PROP_loops
), /* properties_provided */
360 0, /* properties_destroyed */
361 0, /* todo_flags_start */
362 0, /* todo_flags_finish */
365 class pass_build_cfg
: public gimple_opt_pass
368 pass_build_cfg (gcc::context
*ctxt
)
369 : gimple_opt_pass (pass_data_build_cfg
, ctxt
)
372 /* opt_pass methods: */
373 virtual unsigned int execute (function
*) { return execute_build_cfg (); }
375 }; // class pass_build_cfg
380 make_pass_build_cfg (gcc::context
*ctxt
)
382 return new pass_build_cfg (ctxt
);
386 /* Return true if T is a computed goto. */
389 computed_goto_p (gimple t
)
391 return (gimple_code (t
) == GIMPLE_GOTO
392 && TREE_CODE (gimple_goto_dest (t
)) != LABEL_DECL
);
395 /* Returns true for edge E where e->src ends with a GIMPLE_COND and
396 the other edge points to a bb with just __builtin_unreachable ().
397 I.e. return true for C->M edge in:
405 __builtin_unreachable ();
409 assert_unreachable_fallthru_edge_p (edge e
)
411 basic_block pred_bb
= e
->src
;
412 gimple last
= last_stmt (pred_bb
);
413 if (last
&& gimple_code (last
) == GIMPLE_COND
)
415 basic_block other_bb
= EDGE_SUCC (pred_bb
, 0)->dest
;
416 if (other_bb
== e
->dest
)
417 other_bb
= EDGE_SUCC (pred_bb
, 1)->dest
;
418 if (EDGE_COUNT (other_bb
->succs
) == 0)
420 gimple_stmt_iterator gsi
= gsi_after_labels (other_bb
);
425 stmt
= gsi_stmt (gsi
);
426 while (is_gimple_debug (stmt
) || gimple_clobber_p (stmt
))
431 stmt
= gsi_stmt (gsi
);
433 return gimple_call_builtin_p (stmt
, BUILT_IN_UNREACHABLE
);
440 /* Build a flowgraph for the sequence of stmts SEQ. */
443 make_blocks (gimple_seq seq
)
445 gimple_stmt_iterator i
= gsi_start (seq
);
447 bool start_new_block
= true;
448 bool first_stmt_of_seq
= true;
449 basic_block bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
451 while (!gsi_end_p (i
))
458 /* If the statement starts a new basic block or if we have determined
459 in a previous pass that we need to create a new block for STMT, do
461 if (start_new_block
|| stmt_starts_bb_p (stmt
, prev_stmt
))
463 if (!first_stmt_of_seq
)
464 gsi_split_seq_before (&i
, &seq
);
465 bb
= create_basic_block (seq
, NULL
, bb
);
466 start_new_block
= false;
469 /* Now add STMT to BB and create the subgraphs for special statement
471 gimple_set_bb (stmt
, bb
);
473 /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
475 if (stmt_ends_bb_p (stmt
))
477 /* If the stmt can make abnormal goto use a new temporary
478 for the assignment to the LHS. This makes sure the old value
479 of the LHS is available on the abnormal edge. Otherwise
480 we will end up with overlapping life-ranges for abnormal
482 if (gimple_has_lhs (stmt
)
483 && stmt_can_make_abnormal_goto (stmt
)
484 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt
))))
486 tree lhs
= gimple_get_lhs (stmt
);
487 tree tmp
= create_tmp_var (TREE_TYPE (lhs
), NULL
);
488 gimple s
= gimple_build_assign (lhs
, tmp
);
489 gimple_set_location (s
, gimple_location (stmt
));
490 gimple_set_block (s
, gimple_block (stmt
));
491 gimple_set_lhs (stmt
, tmp
);
492 if (TREE_CODE (TREE_TYPE (tmp
)) == COMPLEX_TYPE
493 || TREE_CODE (TREE_TYPE (tmp
)) == VECTOR_TYPE
)
494 DECL_GIMPLE_REG_P (tmp
) = 1;
495 gsi_insert_after (&i
, s
, GSI_SAME_STMT
);
497 start_new_block
= true;
501 first_stmt_of_seq
= false;
506 /* Create and return a new empty basic block after bb AFTER. */
509 create_bb (void *h
, void *e
, basic_block after
)
515 /* Create and initialize a new basic block. Since alloc_block uses
516 GC allocation that clears memory to allocate a basic block, we do
517 not have to clear the newly allocated basic block here. */
520 bb
->index
= last_basic_block_for_fn (cfun
);
522 set_bb_seq (bb
, h
? (gimple_seq
) h
: NULL
);
524 /* Add the new block to the linked list of blocks. */
525 link_block (bb
, after
);
527 /* Grow the basic block array if needed. */
528 if ((size_t) last_basic_block_for_fn (cfun
)
529 == basic_block_info_for_fn (cfun
)->length ())
532 (last_basic_block_for_fn (cfun
)
533 + (last_basic_block_for_fn (cfun
) + 3) / 4);
534 vec_safe_grow_cleared (basic_block_info_for_fn (cfun
), new_size
);
537 /* Add the newly created block to the array. */
538 SET_BASIC_BLOCK_FOR_FN (cfun
, last_basic_block_for_fn (cfun
), bb
);
540 n_basic_blocks_for_fn (cfun
)++;
541 last_basic_block_for_fn (cfun
)++;
547 /*---------------------------------------------------------------------------
549 ---------------------------------------------------------------------------*/
551 /* Fold COND_EXPR_COND of each COND_EXPR. */
554 fold_cond_expr_cond (void)
558 FOR_EACH_BB_FN (bb
, cfun
)
560 gimple stmt
= last_stmt (bb
);
562 if (stmt
&& gimple_code (stmt
) == GIMPLE_COND
)
564 location_t loc
= gimple_location (stmt
);
568 fold_defer_overflow_warnings ();
569 cond
= fold_binary_loc (loc
, gimple_cond_code (stmt
), boolean_type_node
,
570 gimple_cond_lhs (stmt
), gimple_cond_rhs (stmt
));
573 zerop
= integer_zerop (cond
);
574 onep
= integer_onep (cond
);
577 zerop
= onep
= false;
579 fold_undefer_overflow_warnings (zerop
|| onep
,
581 WARN_STRICT_OVERFLOW_CONDITIONAL
);
583 gimple_cond_make_false (stmt
);
585 gimple_cond_make_true (stmt
);
590 /* If basic block BB has an abnormal edge to a basic block
591 containing IFN_ABNORMAL_DISPATCHER internal call, return
592 that the dispatcher's basic block, otherwise return NULL. */
595 get_abnormal_succ_dispatcher (basic_block bb
)
600 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
601 if ((e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)) == EDGE_ABNORMAL
)
603 gimple_stmt_iterator gsi
604 = gsi_start_nondebug_after_labels_bb (e
->dest
);
605 gimple g
= gsi_stmt (gsi
);
607 && is_gimple_call (g
)
608 && gimple_call_internal_p (g
)
609 && gimple_call_internal_fn (g
) == IFN_ABNORMAL_DISPATCHER
)
615 /* Helper function for make_edges. Create a basic block with
616 with ABNORMAL_DISPATCHER internal call in it if needed, and
617 create abnormal edges from BBS to it and from it to FOR_BB
618 if COMPUTED_GOTO is false, otherwise factor the computed gotos. */
621 handle_abnormal_edges (basic_block
*dispatcher_bbs
,
622 basic_block for_bb
, int *bb_to_omp_idx
,
623 auto_vec
<basic_block
> *bbs
, bool computed_goto
)
625 basic_block
*dispatcher
= dispatcher_bbs
+ (computed_goto
? 1 : 0);
626 unsigned int idx
= 0;
632 dispatcher
= dispatcher_bbs
+ 2 * bb_to_omp_idx
[for_bb
->index
];
633 if (bb_to_omp_idx
[for_bb
->index
] != 0)
637 /* If the dispatcher has been created already, then there are basic
638 blocks with abnormal edges to it, so just make a new edge to
640 if (*dispatcher
== NULL
)
642 /* Check if there are any basic blocks that need to have
643 abnormal edges to this dispatcher. If there are none, return
645 if (bb_to_omp_idx
== NULL
)
647 if (bbs
->is_empty ())
652 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
653 if (bb_to_omp_idx
[bb
->index
] == bb_to_omp_idx
[for_bb
->index
])
659 /* Create the dispatcher bb. */
660 *dispatcher
= create_basic_block (NULL
, NULL
, for_bb
);
663 /* Factor computed gotos into a common computed goto site. Also
664 record the location of that site so that we can un-factor the
665 gotos after we have converted back to normal form. */
666 gimple_stmt_iterator gsi
= gsi_start_bb (*dispatcher
);
668 /* Create the destination of the factored goto. Each original
669 computed goto will put its desired destination into this
670 variable and jump to the label we create immediately below. */
671 tree var
= create_tmp_var (ptr_type_node
, "gotovar");
673 /* Build a label for the new block which will contain the
674 factored computed goto. */
675 tree factored_label_decl
676 = create_artificial_label (UNKNOWN_LOCATION
);
677 gimple factored_computed_goto_label
678 = gimple_build_label (factored_label_decl
);
679 gsi_insert_after (&gsi
, factored_computed_goto_label
, GSI_NEW_STMT
);
681 /* Build our new computed goto. */
682 gimple factored_computed_goto
= gimple_build_goto (var
);
683 gsi_insert_after (&gsi
, factored_computed_goto
, GSI_NEW_STMT
);
685 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
688 && bb_to_omp_idx
[bb
->index
] != bb_to_omp_idx
[for_bb
->index
])
691 gsi
= gsi_last_bb (bb
);
692 gimple last
= gsi_stmt (gsi
);
694 gcc_assert (computed_goto_p (last
));
696 /* Copy the original computed goto's destination into VAR. */
698 = gimple_build_assign (var
, gimple_goto_dest (last
));
699 gsi_insert_before (&gsi
, assignment
, GSI_SAME_STMT
);
701 edge e
= make_edge (bb
, *dispatcher
, EDGE_FALLTHRU
);
702 e
->goto_locus
= gimple_location (last
);
703 gsi_remove (&gsi
, true);
708 tree arg
= inner
? boolean_true_node
: boolean_false_node
;
709 gimple g
= gimple_build_call_internal (IFN_ABNORMAL_DISPATCHER
,
711 gimple_stmt_iterator gsi
= gsi_after_labels (*dispatcher
);
712 gsi_insert_after (&gsi
, g
, GSI_NEW_STMT
);
714 /* Create predecessor edges of the dispatcher. */
715 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
718 && bb_to_omp_idx
[bb
->index
] != bb_to_omp_idx
[for_bb
->index
])
720 make_edge (bb
, *dispatcher
, EDGE_ABNORMAL
);
725 make_edge (*dispatcher
, for_bb
, EDGE_ABNORMAL
);
728 /* Join all the blocks in the flowgraph. */
734 struct omp_region
*cur_region
= NULL
;
735 auto_vec
<basic_block
> ab_edge_goto
;
736 auto_vec
<basic_block
> ab_edge_call
;
737 int *bb_to_omp_idx
= NULL
;
738 int cur_omp_region_idx
= 0;
740 /* Create an edge from entry to the first block with executable
742 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
743 BASIC_BLOCK_FOR_FN (cfun
, NUM_FIXED_BLOCKS
),
746 /* Traverse the basic block array placing edges. */
747 FOR_EACH_BB_FN (bb
, cfun
)
749 gimple last
= last_stmt (bb
);
753 bb_to_omp_idx
[bb
->index
] = cur_omp_region_idx
;
757 enum gimple_code code
= gimple_code (last
);
761 if (make_goto_expr_edges (bb
))
762 ab_edge_goto
.safe_push (bb
);
766 make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
770 make_cond_expr_edges (bb
);
774 make_gimple_switch_edges (bb
);
778 make_eh_edges (last
);
781 case GIMPLE_EH_DISPATCH
:
782 fallthru
= make_eh_dispatch_edges (last
);
786 /* If this function receives a nonlocal goto, then we need to
787 make edges from this call site to all the nonlocal goto
789 if (stmt_can_make_abnormal_goto (last
))
790 ab_edge_call
.safe_push (bb
);
792 /* If this statement has reachable exception handlers, then
793 create abnormal edges to them. */
794 make_eh_edges (last
);
796 /* BUILTIN_RETURN is really a return statement. */
797 if (gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
799 make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
802 /* Some calls are known not to return. */
804 fallthru
= !(gimple_call_flags (last
) & ECF_NORETURN
);
808 /* A GIMPLE_ASSIGN may throw internally and thus be considered
810 if (is_ctrl_altering_stmt (last
))
811 make_eh_edges (last
);
816 make_gimple_asm_edges (bb
);
821 fallthru
= make_gimple_omp_edges (bb
, &cur_region
,
822 &cur_omp_region_idx
);
823 if (cur_region
&& bb_to_omp_idx
== NULL
)
824 bb_to_omp_idx
= XCNEWVEC (int, n_basic_blocks_for_fn (cfun
));
827 case GIMPLE_TRANSACTION
:
829 tree abort_label
= gimple_transaction_label (last
);
831 make_edge (bb
, label_to_block (abort_label
), EDGE_TM_ABORT
);
837 gcc_assert (!stmt_ends_bb_p (last
));
845 make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
848 /* Computed gotos are hell to deal with, especially if there are
849 lots of them with a large number of destinations. So we factor
850 them to a common computed goto location before we build the
851 edge list. After we convert back to normal form, we will un-factor
852 the computed gotos since factoring introduces an unwanted jump.
853 For non-local gotos and abnormal edges from calls to calls that return
854 twice or forced labels, factor the abnormal edges too, by having all
855 abnormal edges from the calls go to a common artificial basic block
856 with ABNORMAL_DISPATCHER internal call and abnormal edges from that
857 basic block to all forced labels and calls returning twice.
858 We do this per-OpenMP structured block, because those regions
859 are guaranteed to be single entry single exit by the standard,
860 so it is not allowed to enter or exit such regions abnormally this way,
861 thus all computed gotos, non-local gotos and setjmp/longjmp calls
862 must not transfer control across SESE region boundaries. */
863 if (!ab_edge_goto
.is_empty () || !ab_edge_call
.is_empty ())
865 gimple_stmt_iterator gsi
;
866 basic_block dispatcher_bb_array
[2] = { NULL
, NULL
};
867 basic_block
*dispatcher_bbs
= dispatcher_bb_array
;
868 int count
= n_basic_blocks_for_fn (cfun
);
871 dispatcher_bbs
= XCNEWVEC (basic_block
, 2 * count
);
873 FOR_EACH_BB_FN (bb
, cfun
)
875 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
877 gimple label_stmt
= gsi_stmt (gsi
);
880 if (gimple_code (label_stmt
) != GIMPLE_LABEL
)
883 target
= gimple_label_label (label_stmt
);
885 /* Make an edge to every label block that has been marked as a
886 potential target for a computed goto or a non-local goto. */
887 if (FORCED_LABEL (target
))
888 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
889 &ab_edge_goto
, true);
890 if (DECL_NONLOCAL (target
))
892 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
893 &ab_edge_call
, false);
898 if (!gsi_end_p (gsi
) && is_gimple_debug (gsi_stmt (gsi
)))
899 gsi_next_nondebug (&gsi
);
900 if (!gsi_end_p (gsi
))
902 /* Make an edge to every setjmp-like call. */
903 gimple call_stmt
= gsi_stmt (gsi
);
904 if (is_gimple_call (call_stmt
)
905 && ((gimple_call_flags (call_stmt
) & ECF_RETURNS_TWICE
)
906 || gimple_call_builtin_p (call_stmt
,
907 BUILT_IN_SETJMP_RECEIVER
)))
908 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
909 &ab_edge_call
, false);
914 XDELETE (dispatcher_bbs
);
917 XDELETE (bb_to_omp_idx
);
921 /* Fold COND_EXPR_COND of each COND_EXPR. */
922 fold_cond_expr_cond ();
925 /* Find the next available discriminator value for LOCUS. The
926 discriminator distinguishes among several basic blocks that
927 share a common locus, allowing for more accurate sample-based
931 next_discriminator_for_locus (location_t locus
)
933 struct locus_discrim_map item
;
934 struct locus_discrim_map
**slot
;
937 item
.discriminator
= 0;
938 slot
= discriminator_per_locus
.find_slot_with_hash (
939 &item
, LOCATION_LINE (locus
), INSERT
);
941 if (*slot
== HTAB_EMPTY_ENTRY
)
943 *slot
= XNEW (struct locus_discrim_map
);
945 (*slot
)->locus
= locus
;
946 (*slot
)->discriminator
= 0;
948 (*slot
)->discriminator
++;
949 return (*slot
)->discriminator
;
952 /* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line. */
955 same_line_p (location_t locus1
, location_t locus2
)
957 expanded_location from
, to
;
959 if (locus1
== locus2
)
962 from
= expand_location (locus1
);
963 to
= expand_location (locus2
);
965 if (from
.line
!= to
.line
)
967 if (from
.file
== to
.file
)
969 return (from
.file
!= NULL
971 && filename_cmp (from
.file
, to
.file
) == 0);
974 /* Assign discriminators to each basic block. */
977 assign_discriminators (void)
981 FOR_EACH_BB_FN (bb
, cfun
)
985 gimple last
= last_stmt (bb
);
986 location_t locus
= last
? gimple_location (last
) : UNKNOWN_LOCATION
;
988 if (locus
== UNKNOWN_LOCATION
)
991 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
993 gimple first
= first_non_label_stmt (e
->dest
);
994 gimple last
= last_stmt (e
->dest
);
995 if ((first
&& same_line_p (locus
, gimple_location (first
)))
996 || (last
&& same_line_p (locus
, gimple_location (last
))))
998 if (e
->dest
->discriminator
!= 0 && bb
->discriminator
== 0)
999 bb
->discriminator
= next_discriminator_for_locus (locus
);
1001 e
->dest
->discriminator
= next_discriminator_for_locus (locus
);
1007 /* Create the edges for a GIMPLE_COND starting at block BB. */
1010 make_cond_expr_edges (basic_block bb
)
1012 gimple entry
= last_stmt (bb
);
1013 gimple then_stmt
, else_stmt
;
1014 basic_block then_bb
, else_bb
;
1015 tree then_label
, else_label
;
1019 gcc_assert (gimple_code (entry
) == GIMPLE_COND
);
1021 /* Entry basic blocks for each component. */
1022 then_label
= gimple_cond_true_label (entry
);
1023 else_label
= gimple_cond_false_label (entry
);
1024 then_bb
= label_to_block (then_label
);
1025 else_bb
= label_to_block (else_label
);
1026 then_stmt
= first_stmt (then_bb
);
1027 else_stmt
= first_stmt (else_bb
);
1029 e
= make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1030 e
->goto_locus
= gimple_location (then_stmt
);
1031 e
= make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1033 e
->goto_locus
= gimple_location (else_stmt
);
1035 /* We do not need the labels anymore. */
1036 gimple_cond_set_true_label (entry
, NULL_TREE
);
1037 gimple_cond_set_false_label (entry
, NULL_TREE
);
1041 /* Called for each element in the hash table (P) as we delete the
1042 edge to cases hash table.
1044 Clear all the TREE_CHAINs to prevent problems with copying of
1045 SWITCH_EXPRs and structure sharing rules, then free the hash table
1049 edge_to_cases_cleanup (const void *key ATTRIBUTE_UNUSED
, void **value
,
1050 void *data ATTRIBUTE_UNUSED
)
1054 for (t
= (tree
) *value
; t
; t
= next
)
1056 next
= CASE_CHAIN (t
);
1057 CASE_CHAIN (t
) = NULL
;
1064 /* Start recording information mapping edges to case labels. */
1067 start_recording_case_labels (void)
1069 gcc_assert (edge_to_cases
== NULL
);
1070 edge_to_cases
= pointer_map_create ();
1071 touched_switch_bbs
= BITMAP_ALLOC (NULL
);
1074 /* Return nonzero if we are recording information for case labels. */
1077 recording_case_labels_p (void)
1079 return (edge_to_cases
!= NULL
);
1082 /* Stop recording information mapping edges to case labels and
1083 remove any information we have recorded. */
1085 end_recording_case_labels (void)
1089 pointer_map_traverse (edge_to_cases
, edge_to_cases_cleanup
, NULL
);
1090 pointer_map_destroy (edge_to_cases
);
1091 edge_to_cases
= NULL
;
1092 EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs
, 0, i
, bi
)
1094 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
1097 gimple stmt
= last_stmt (bb
);
1098 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1099 group_case_labels_stmt (stmt
);
1102 BITMAP_FREE (touched_switch_bbs
);
1105 /* If we are inside a {start,end}_recording_cases block, then return
1106 a chain of CASE_LABEL_EXPRs from T which reference E.
1108 Otherwise return NULL. */
1111 get_cases_for_edge (edge e
, gimple t
)
1116 /* If we are not recording cases, then we do not have CASE_LABEL_EXPR
1117 chains available. Return NULL so the caller can detect this case. */
1118 if (!recording_case_labels_p ())
1121 slot
= pointer_map_contains (edge_to_cases
, e
);
1123 return (tree
) *slot
;
1125 /* If we did not find E in the hash table, then this must be the first
1126 time we have been queried for information about E & T. Add all the
1127 elements from T to the hash table then perform the query again. */
1129 n
= gimple_switch_num_labels (t
);
1130 for (i
= 0; i
< n
; i
++)
1132 tree elt
= gimple_switch_label (t
, i
);
1133 tree lab
= CASE_LABEL (elt
);
1134 basic_block label_bb
= label_to_block (lab
);
1135 edge this_edge
= find_edge (e
->src
, label_bb
);
1137 /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
1139 slot
= pointer_map_insert (edge_to_cases
, this_edge
);
1140 CASE_CHAIN (elt
) = (tree
) *slot
;
1144 return (tree
) *pointer_map_contains (edge_to_cases
, e
);
1147 /* Create the edges for a GIMPLE_SWITCH starting at block BB. */
1150 make_gimple_switch_edges (basic_block bb
)
1152 gimple entry
= last_stmt (bb
);
1155 n
= gimple_switch_num_labels (entry
);
1157 for (i
= 0; i
< n
; ++i
)
1159 tree lab
= CASE_LABEL (gimple_switch_label (entry
, i
));
1160 basic_block label_bb
= label_to_block (lab
);
1161 make_edge (bb
, label_bb
, 0);
1166 /* Return the basic block holding label DEST. */
1169 label_to_block_fn (struct function
*ifun
, tree dest
)
1171 int uid
= LABEL_DECL_UID (dest
);
1173 /* We would die hard when faced by an undefined label. Emit a label to
1174 the very first basic block. This will hopefully make even the dataflow
1175 and undefined variable warnings quite right. */
1176 if (seen_error () && uid
< 0)
1178 gimple_stmt_iterator gsi
=
1179 gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, NUM_FIXED_BLOCKS
));
1182 stmt
= gimple_build_label (dest
);
1183 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
1184 uid
= LABEL_DECL_UID (dest
);
1186 if (vec_safe_length (ifun
->cfg
->x_label_to_block_map
) <= (unsigned int) uid
)
1188 return (*ifun
->cfg
->x_label_to_block_map
)[uid
];
1191 /* Create edges for a goto statement at block BB. Returns true
1192 if abnormal edges should be created. */
1195 make_goto_expr_edges (basic_block bb
)
1197 gimple_stmt_iterator last
= gsi_last_bb (bb
);
1198 gimple goto_t
= gsi_stmt (last
);
1200 /* A simple GOTO creates normal edges. */
1201 if (simple_goto_p (goto_t
))
1203 tree dest
= gimple_goto_dest (goto_t
);
1204 basic_block label_bb
= label_to_block (dest
);
1205 edge e
= make_edge (bb
, label_bb
, EDGE_FALLTHRU
);
1206 e
->goto_locus
= gimple_location (goto_t
);
1207 gsi_remove (&last
, true);
1211 /* A computed GOTO creates abnormal edges. */
1215 /* Create edges for an asm statement with labels at block BB. */
1218 make_gimple_asm_edges (basic_block bb
)
1220 gimple stmt
= last_stmt (bb
);
1221 int i
, n
= gimple_asm_nlabels (stmt
);
1223 for (i
= 0; i
< n
; ++i
)
1225 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
1226 basic_block label_bb
= label_to_block (label
);
1227 make_edge (bb
, label_bb
, 0);
1231 /*---------------------------------------------------------------------------
1233 ---------------------------------------------------------------------------*/
1235 /* Cleanup useless labels in basic blocks. This is something we wish
1236 to do early because it allows us to group case labels before creating
1237 the edges for the CFG, and it speeds up block statement iterators in
1238 all passes later on.
1239 We rerun this pass after CFG is created, to get rid of the labels that
1240 are no longer referenced. After then we do not run it any more, since
1241 (almost) no new labels should be created. */
1243 /* A map from basic block index to the leading label of that block. */
1244 static struct label_record
1249 /* True if the label is referenced from somewhere. */
1253 /* Given LABEL return the first label in the same basic block. */
1256 main_block_label (tree label
)
1258 basic_block bb
= label_to_block (label
);
1259 tree main_label
= label_for_bb
[bb
->index
].label
;
1261 /* label_to_block possibly inserted undefined label into the chain. */
1264 label_for_bb
[bb
->index
].label
= label
;
1268 label_for_bb
[bb
->index
].used
= true;
1272 /* Clean up redundant labels within the exception tree. */
1275 cleanup_dead_labels_eh (void)
1282 if (cfun
->eh
== NULL
)
1285 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1286 if (lp
&& lp
->post_landing_pad
)
1288 lab
= main_block_label (lp
->post_landing_pad
);
1289 if (lab
!= lp
->post_landing_pad
)
1291 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1292 EH_LANDING_PAD_NR (lab
) = lp
->index
;
1296 FOR_ALL_EH_REGION (r
)
1300 case ERT_MUST_NOT_THROW
:
1306 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
1310 c
->label
= main_block_label (lab
);
1315 case ERT_ALLOWED_EXCEPTIONS
:
1316 lab
= r
->u
.allowed
.label
;
1318 r
->u
.allowed
.label
= main_block_label (lab
);
1324 /* Cleanup redundant labels. This is a three-step process:
1325 1) Find the leading label for each block.
1326 2) Redirect all references to labels to the leading labels.
1327 3) Cleanup all useless labels. */
1330 cleanup_dead_labels (void)
1333 label_for_bb
= XCNEWVEC (struct label_record
, last_basic_block_for_fn (cfun
));
1335 /* Find a suitable label for each block. We use the first user-defined
1336 label if there is one, or otherwise just the first label we see. */
1337 FOR_EACH_BB_FN (bb
, cfun
)
1339 gimple_stmt_iterator i
;
1341 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
1344 gimple stmt
= gsi_stmt (i
);
1346 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1349 label
= gimple_label_label (stmt
);
1351 /* If we have not yet seen a label for the current block,
1352 remember this one and see if there are more labels. */
1353 if (!label_for_bb
[bb
->index
].label
)
1355 label_for_bb
[bb
->index
].label
= label
;
1359 /* If we did see a label for the current block already, but it
1360 is an artificially created label, replace it if the current
1361 label is a user defined label. */
1362 if (!DECL_ARTIFICIAL (label
)
1363 && DECL_ARTIFICIAL (label_for_bb
[bb
->index
].label
))
1365 label_for_bb
[bb
->index
].label
= label
;
1371 /* Now redirect all jumps/branches to the selected label.
1372 First do so for each block ending in a control statement. */
1373 FOR_EACH_BB_FN (bb
, cfun
)
1375 gimple stmt
= last_stmt (bb
);
1376 tree label
, new_label
;
1381 switch (gimple_code (stmt
))
1384 label
= gimple_cond_true_label (stmt
);
1387 new_label
= main_block_label (label
);
1388 if (new_label
!= label
)
1389 gimple_cond_set_true_label (stmt
, new_label
);
1392 label
= gimple_cond_false_label (stmt
);
1395 new_label
= main_block_label (label
);
1396 if (new_label
!= label
)
1397 gimple_cond_set_false_label (stmt
, new_label
);
1403 size_t i
, n
= gimple_switch_num_labels (stmt
);
1405 /* Replace all destination labels. */
1406 for (i
= 0; i
< n
; ++i
)
1408 tree case_label
= gimple_switch_label (stmt
, i
);
1409 label
= CASE_LABEL (case_label
);
1410 new_label
= main_block_label (label
);
1411 if (new_label
!= label
)
1412 CASE_LABEL (case_label
) = new_label
;
1419 int i
, n
= gimple_asm_nlabels (stmt
);
1421 for (i
= 0; i
< n
; ++i
)
1423 tree cons
= gimple_asm_label_op (stmt
, i
);
1424 tree label
= main_block_label (TREE_VALUE (cons
));
1425 TREE_VALUE (cons
) = label
;
1430 /* We have to handle gotos until they're removed, and we don't
1431 remove them until after we've created the CFG edges. */
1433 if (!computed_goto_p (stmt
))
1435 label
= gimple_goto_dest (stmt
);
1436 new_label
= main_block_label (label
);
1437 if (new_label
!= label
)
1438 gimple_goto_set_dest (stmt
, new_label
);
1442 case GIMPLE_TRANSACTION
:
1444 tree label
= gimple_transaction_label (stmt
);
1447 tree new_label
= main_block_label (label
);
1448 if (new_label
!= label
)
1449 gimple_transaction_set_label (stmt
, new_label
);
1459 /* Do the same for the exception region tree labels. */
1460 cleanup_dead_labels_eh ();
1462 /* Finally, purge dead labels. All user-defined labels and labels that
1463 can be the target of non-local gotos and labels which have their
1464 address taken are preserved. */
1465 FOR_EACH_BB_FN (bb
, cfun
)
1467 gimple_stmt_iterator i
;
1468 tree label_for_this_bb
= label_for_bb
[bb
->index
].label
;
1470 if (!label_for_this_bb
)
1473 /* If the main label of the block is unused, we may still remove it. */
1474 if (!label_for_bb
[bb
->index
].used
)
1475 label_for_this_bb
= NULL
;
1477 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); )
1480 gimple stmt
= gsi_stmt (i
);
1482 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1485 label
= gimple_label_label (stmt
);
1487 if (label
== label_for_this_bb
1488 || !DECL_ARTIFICIAL (label
)
1489 || DECL_NONLOCAL (label
)
1490 || FORCED_LABEL (label
))
1493 gsi_remove (&i
, true);
1497 free (label_for_bb
);
1500 /* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
1501 the ones jumping to the same label.
1502 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
1505 group_case_labels_stmt (gimple stmt
)
1507 int old_size
= gimple_switch_num_labels (stmt
);
1508 int i
, j
, new_size
= old_size
;
1509 basic_block default_bb
= NULL
;
1511 default_bb
= label_to_block (CASE_LABEL (gimple_switch_default_label (stmt
)));
1513 /* Look for possible opportunities to merge cases. */
1515 while (i
< old_size
)
1517 tree base_case
, base_high
;
1518 basic_block base_bb
;
1520 base_case
= gimple_switch_label (stmt
, i
);
1522 gcc_assert (base_case
);
1523 base_bb
= label_to_block (CASE_LABEL (base_case
));
1525 /* Discard cases that have the same destination as the
1527 if (base_bb
== default_bb
)
1529 gimple_switch_set_label (stmt
, i
, NULL_TREE
);
1535 base_high
= CASE_HIGH (base_case
)
1536 ? CASE_HIGH (base_case
)
1537 : CASE_LOW (base_case
);
1540 /* Try to merge case labels. Break out when we reach the end
1541 of the label vector or when we cannot merge the next case
1542 label with the current one. */
1543 while (i
< old_size
)
1545 tree merge_case
= gimple_switch_label (stmt
, i
);
1546 basic_block merge_bb
= label_to_block (CASE_LABEL (merge_case
));
1547 wide_int bhp1
= wi::add (base_high
, 1);
1549 /* Merge the cases if they jump to the same place,
1550 and their ranges are consecutive. */
1551 if (merge_bb
== base_bb
1552 && wi::eq_p (CASE_LOW (merge_case
), bhp1
))
1554 base_high
= CASE_HIGH (merge_case
) ?
1555 CASE_HIGH (merge_case
) : CASE_LOW (merge_case
);
1556 CASE_HIGH (base_case
) = base_high
;
1557 gimple_switch_set_label (stmt
, i
, NULL_TREE
);
1566 /* Compress the case labels in the label vector, and adjust the
1567 length of the vector. */
1568 for (i
= 0, j
= 0; i
< new_size
; i
++)
1570 while (! gimple_switch_label (stmt
, j
))
1572 gimple_switch_set_label (stmt
, i
,
1573 gimple_switch_label (stmt
, j
++));
1576 gcc_assert (new_size
<= old_size
);
1577 gimple_switch_set_num_labels (stmt
, new_size
);
1580 /* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
1581 and scan the sorted vector of cases. Combine the ones jumping to the
1585 group_case_labels (void)
1589 FOR_EACH_BB_FN (bb
, cfun
)
1591 gimple stmt
= last_stmt (bb
);
1592 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1593 group_case_labels_stmt (stmt
);
1597 /* Checks whether we can merge block B into block A. */
1600 gimple_can_merge_blocks_p (basic_block a
, basic_block b
)
1603 gimple_stmt_iterator gsi
;
1605 if (!single_succ_p (a
))
1608 if (single_succ_edge (a
)->flags
& EDGE_COMPLEX
)
1611 if (single_succ (a
) != b
)
1614 if (!single_pred_p (b
))
1617 if (b
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
1620 /* If A ends by a statement causing exceptions or something similar, we
1621 cannot merge the blocks. */
1622 stmt
= last_stmt (a
);
1623 if (stmt
&& stmt_ends_bb_p (stmt
))
1626 /* Do not allow a block with only a non-local label to be merged. */
1628 && gimple_code (stmt
) == GIMPLE_LABEL
1629 && DECL_NONLOCAL (gimple_label_label (stmt
)))
1632 /* Examine the labels at the beginning of B. */
1633 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1636 stmt
= gsi_stmt (gsi
);
1637 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1639 lab
= gimple_label_label (stmt
);
1641 /* Do not remove user forced labels or for -O0 any user labels. */
1642 if (!DECL_ARTIFICIAL (lab
) && (!optimize
|| FORCED_LABEL (lab
)))
1646 /* Protect the loop latches. */
1647 if (current_loops
&& b
->loop_father
->latch
== b
)
1650 /* It must be possible to eliminate all phi nodes in B. If ssa form
1651 is not up-to-date and a name-mapping is registered, we cannot eliminate
1652 any phis. Symbols marked for renaming are never a problem though. */
1653 for (gsi
= gsi_start_phis (b
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1655 gimple phi
= gsi_stmt (gsi
);
1656 /* Technically only new names matter. */
1657 if (name_registered_for_update_p (PHI_RESULT (phi
)))
1661 /* When not optimizing, don't merge if we'd lose goto_locus. */
1663 && single_succ_edge (a
)->goto_locus
!= UNKNOWN_LOCATION
)
1665 location_t goto_locus
= single_succ_edge (a
)->goto_locus
;
1666 gimple_stmt_iterator prev
, next
;
1667 prev
= gsi_last_nondebug_bb (a
);
1668 next
= gsi_after_labels (b
);
1669 if (!gsi_end_p (next
) && is_gimple_debug (gsi_stmt (next
)))
1670 gsi_next_nondebug (&next
);
1671 if ((gsi_end_p (prev
)
1672 || gimple_location (gsi_stmt (prev
)) != goto_locus
)
1673 && (gsi_end_p (next
)
1674 || gimple_location (gsi_stmt (next
)) != goto_locus
))
1681 /* Replaces all uses of NAME by VAL. */
1684 replace_uses_by (tree name
, tree val
)
1686 imm_use_iterator imm_iter
;
1691 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, name
)
1693 /* Mark the block if we change the last stmt in it. */
1694 if (cfgcleanup_altered_bbs
1695 && stmt_ends_bb_p (stmt
))
1696 bitmap_set_bit (cfgcleanup_altered_bbs
, gimple_bb (stmt
)->index
);
1698 FOR_EACH_IMM_USE_ON_STMT (use
, imm_iter
)
1700 replace_exp (use
, val
);
1702 if (gimple_code (stmt
) == GIMPLE_PHI
)
1704 e
= gimple_phi_arg_edge (stmt
, PHI_ARG_INDEX_FROM_USE (use
));
1705 if (e
->flags
& EDGE_ABNORMAL
)
1707 /* This can only occur for virtual operands, since
1708 for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
1709 would prevent replacement. */
1710 gcc_checking_assert (virtual_operand_p (name
));
1711 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val
) = 1;
1716 if (gimple_code (stmt
) != GIMPLE_PHI
)
1718 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
1719 gimple orig_stmt
= stmt
;
1722 /* FIXME. It shouldn't be required to keep TREE_CONSTANT
1723 on ADDR_EXPRs up-to-date on GIMPLE. Propagation will
1724 only change sth from non-invariant to invariant, and only
1725 when propagating constants. */
1726 if (is_gimple_min_invariant (val
))
1727 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1729 tree op
= gimple_op (stmt
, i
);
1730 /* Operands may be empty here. For example, the labels
1731 of a GIMPLE_COND are nulled out following the creation
1732 of the corresponding CFG edges. */
1733 if (op
&& TREE_CODE (op
) == ADDR_EXPR
)
1734 recompute_tree_invariant_for_addr_expr (op
);
1737 if (fold_stmt (&gsi
))
1738 stmt
= gsi_stmt (gsi
);
1740 if (maybe_clean_or_replace_eh_stmt (orig_stmt
, stmt
))
1741 gimple_purge_dead_eh_edges (gimple_bb (stmt
));
1747 gcc_checking_assert (has_zero_uses (name
));
1749 /* Also update the trees stored in loop structures. */
1754 FOR_EACH_LOOP (loop
, 0)
1756 substitute_in_loop_info (loop
, name
, val
);
1761 /* Merge block B into block A. */
1764 gimple_merge_blocks (basic_block a
, basic_block b
)
1766 gimple_stmt_iterator last
, gsi
, psi
;
1769 fprintf (dump_file
, "Merging blocks %d and %d\n", a
->index
, b
->index
);
1771 /* Remove all single-valued PHI nodes from block B of the form
1772 V_i = PHI <V_j> by propagating V_j to all the uses of V_i. */
1773 gsi
= gsi_last_bb (a
);
1774 for (psi
= gsi_start_phis (b
); !gsi_end_p (psi
); )
1776 gimple phi
= gsi_stmt (psi
);
1777 tree def
= gimple_phi_result (phi
), use
= gimple_phi_arg_def (phi
, 0);
1779 bool may_replace_uses
= (virtual_operand_p (def
)
1780 || may_propagate_copy (def
, use
));
1782 /* In case we maintain loop closed ssa form, do not propagate arguments
1783 of loop exit phi nodes. */
1785 && loops_state_satisfies_p (LOOP_CLOSED_SSA
)
1786 && !virtual_operand_p (def
)
1787 && TREE_CODE (use
) == SSA_NAME
1788 && a
->loop_father
!= b
->loop_father
)
1789 may_replace_uses
= false;
1791 if (!may_replace_uses
)
1793 gcc_assert (!virtual_operand_p (def
));
1795 /* Note that just emitting the copies is fine -- there is no problem
1796 with ordering of phi nodes. This is because A is the single
1797 predecessor of B, therefore results of the phi nodes cannot
1798 appear as arguments of the phi nodes. */
1799 copy
= gimple_build_assign (def
, use
);
1800 gsi_insert_after (&gsi
, copy
, GSI_NEW_STMT
);
1801 remove_phi_node (&psi
, false);
1805 /* If we deal with a PHI for virtual operands, we can simply
1806 propagate these without fussing with folding or updating
1808 if (virtual_operand_p (def
))
1810 imm_use_iterator iter
;
1811 use_operand_p use_p
;
1814 FOR_EACH_IMM_USE_STMT (stmt
, iter
, def
)
1815 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
1816 SET_USE (use_p
, use
);
1818 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
1819 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use
) = 1;
1822 replace_uses_by (def
, use
);
1824 remove_phi_node (&psi
, true);
1828 /* Ensure that B follows A. */
1829 move_block_after (b
, a
);
1831 gcc_assert (single_succ_edge (a
)->flags
& EDGE_FALLTHRU
);
1832 gcc_assert (!last_stmt (a
) || !stmt_ends_bb_p (last_stmt (a
)));
1834 /* Remove labels from B and set gimple_bb to A for other statements. */
1835 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
);)
1837 gimple stmt
= gsi_stmt (gsi
);
1838 if (gimple_code (stmt
) == GIMPLE_LABEL
)
1840 tree label
= gimple_label_label (stmt
);
1843 gsi_remove (&gsi
, false);
1845 /* Now that we can thread computed gotos, we might have
1846 a situation where we have a forced label in block B
1847 However, the label at the start of block B might still be
1848 used in other ways (think about the runtime checking for
1849 Fortran assigned gotos). So we can not just delete the
1850 label. Instead we move the label to the start of block A. */
1851 if (FORCED_LABEL (label
))
1853 gimple_stmt_iterator dest_gsi
= gsi_start_bb (a
);
1854 gsi_insert_before (&dest_gsi
, stmt
, GSI_NEW_STMT
);
1856 /* Other user labels keep around in a form of a debug stmt. */
1857 else if (!DECL_ARTIFICIAL (label
) && MAY_HAVE_DEBUG_STMTS
)
1859 gimple dbg
= gimple_build_debug_bind (label
,
1862 gimple_debug_bind_reset_value (dbg
);
1863 gsi_insert_before (&gsi
, dbg
, GSI_SAME_STMT
);
1866 lp_nr
= EH_LANDING_PAD_NR (label
);
1869 eh_landing_pad lp
= get_eh_landing_pad_from_number (lp_nr
);
1870 lp
->post_landing_pad
= NULL
;
1875 gimple_set_bb (stmt
, a
);
1880 /* When merging two BBs, if their counts are different, the larger count
1881 is selected as the new bb count. This is to handle inconsistent
1883 a
->count
= MAX (a
->count
, b
->count
);
1884 a
->frequency
= MAX (a
->frequency
, b
->frequency
);
1886 /* Merge the sequences. */
1887 last
= gsi_last_bb (a
);
1888 gsi_insert_seq_after (&last
, bb_seq (b
), GSI_NEW_STMT
);
1889 set_bb_seq (b
, NULL
);
1891 if (cfgcleanup_altered_bbs
)
1892 bitmap_set_bit (cfgcleanup_altered_bbs
, a
->index
);
1896 /* Return the one of two successors of BB that is not reachable by a
1897 complex edge, if there is one. Else, return BB. We use
1898 this in optimizations that use post-dominators for their heuristics,
1899 to catch the cases in C++ where function calls are involved. */
1902 single_noncomplex_succ (basic_block bb
)
1905 if (EDGE_COUNT (bb
->succs
) != 2)
1908 e0
= EDGE_SUCC (bb
, 0);
1909 e1
= EDGE_SUCC (bb
, 1);
1910 if (e0
->flags
& EDGE_COMPLEX
)
1912 if (e1
->flags
& EDGE_COMPLEX
)
1918 /* T is CALL_EXPR. Set current_function_calls_* flags. */
1921 notice_special_calls (gimple call
)
1923 int flags
= gimple_call_flags (call
);
1925 if (flags
& ECF_MAY_BE_ALLOCA
)
1926 cfun
->calls_alloca
= true;
1927 if (flags
& ECF_RETURNS_TWICE
)
1928 cfun
->calls_setjmp
= true;
1932 /* Clear flags set by notice_special_calls. Used by dead code removal
1933 to update the flags. */
1936 clear_special_calls (void)
1938 cfun
->calls_alloca
= false;
1939 cfun
->calls_setjmp
= false;
1942 /* Remove PHI nodes associated with basic block BB and all edges out of BB. */
1945 remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb
)
1947 /* Since this block is no longer reachable, we can just delete all
1948 of its PHI nodes. */
1949 remove_phi_nodes (bb
);
1951 /* Remove edges to BB's successors. */
1952 while (EDGE_COUNT (bb
->succs
) > 0)
1953 remove_edge (EDGE_SUCC (bb
, 0));
1957 /* Remove statements of basic block BB. */
1960 remove_bb (basic_block bb
)
1962 gimple_stmt_iterator i
;
1966 fprintf (dump_file
, "Removing basic block %d\n", bb
->index
);
1967 if (dump_flags
& TDF_DETAILS
)
1969 dump_bb (dump_file
, bb
, 0, TDF_BLOCKS
);
1970 fprintf (dump_file
, "\n");
1976 struct loop
*loop
= bb
->loop_father
;
1978 /* If a loop gets removed, clean up the information associated
1980 if (loop
->latch
== bb
1981 || loop
->header
== bb
)
1982 free_numbers_of_iterations_estimates_loop (loop
);
1985 /* Remove all the instructions in the block. */
1986 if (bb_seq (bb
) != NULL
)
1988 /* Walk backwards so as to get a chance to substitute all
1989 released DEFs into debug stmts. See
1990 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
1992 for (i
= gsi_last_bb (bb
); !gsi_end_p (i
);)
1994 gimple stmt
= gsi_stmt (i
);
1995 if (gimple_code (stmt
) == GIMPLE_LABEL
1996 && (FORCED_LABEL (gimple_label_label (stmt
))
1997 || DECL_NONLOCAL (gimple_label_label (stmt
))))
2000 gimple_stmt_iterator new_gsi
;
2002 /* A non-reachable non-local label may still be referenced.
2003 But it no longer needs to carry the extra semantics of
2005 if (DECL_NONLOCAL (gimple_label_label (stmt
)))
2007 DECL_NONLOCAL (gimple_label_label (stmt
)) = 0;
2008 FORCED_LABEL (gimple_label_label (stmt
)) = 1;
2011 new_bb
= bb
->prev_bb
;
2012 new_gsi
= gsi_start_bb (new_bb
);
2013 gsi_remove (&i
, false);
2014 gsi_insert_before (&new_gsi
, stmt
, GSI_NEW_STMT
);
2018 /* Release SSA definitions if we are in SSA. Note that we
2019 may be called when not in SSA. For example,
2020 final_cleanup calls this function via
2021 cleanup_tree_cfg. */
2022 if (gimple_in_ssa_p (cfun
))
2023 release_defs (stmt
);
2025 gsi_remove (&i
, true);
2029 i
= gsi_last_bb (bb
);
2035 remove_phi_nodes_and_edges_for_unreachable_block (bb
);
2036 bb
->il
.gimple
.seq
= NULL
;
2037 bb
->il
.gimple
.phi_nodes
= NULL
;
2041 /* Given a basic block BB ending with COND_EXPR or SWITCH_EXPR, and a
2042 predicate VAL, return the edge that will be taken out of the block.
2043 If VAL does not match a unique edge, NULL is returned. */
2046 find_taken_edge (basic_block bb
, tree val
)
2050 stmt
= last_stmt (bb
);
2053 gcc_assert (is_ctrl_stmt (stmt
));
2058 if (!is_gimple_min_invariant (val
))
2061 if (gimple_code (stmt
) == GIMPLE_COND
)
2062 return find_taken_edge_cond_expr (bb
, val
);
2064 if (gimple_code (stmt
) == GIMPLE_SWITCH
)
2065 return find_taken_edge_switch_expr (bb
, val
);
2067 if (computed_goto_p (stmt
))
2069 /* Only optimize if the argument is a label, if the argument is
2070 not a label then we can not construct a proper CFG.
2072 It may be the case that we only need to allow the LABEL_REF to
2073 appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
2074 appear inside a LABEL_EXPR just to be safe. */
2075 if ((TREE_CODE (val
) == ADDR_EXPR
|| TREE_CODE (val
) == LABEL_EXPR
)
2076 && TREE_CODE (TREE_OPERAND (val
, 0)) == LABEL_DECL
)
2077 return find_taken_edge_computed_goto (bb
, TREE_OPERAND (val
, 0));
2084 /* Given a constant value VAL and the entry block BB to a GOTO_EXPR
2085 statement, determine which of the outgoing edges will be taken out of the
2086 block. Return NULL if either edge may be taken. */
2089 find_taken_edge_computed_goto (basic_block bb
, tree val
)
2094 dest
= label_to_block (val
);
2097 e
= find_edge (bb
, dest
);
2098 gcc_assert (e
!= NULL
);
2104 /* Given a constant value VAL and the entry block BB to a COND_EXPR
2105 statement, determine which of the two edges will be taken out of the
2106 block. Return NULL if either edge may be taken. */
2109 find_taken_edge_cond_expr (basic_block bb
, tree val
)
2111 edge true_edge
, false_edge
;
2113 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2115 gcc_assert (TREE_CODE (val
) == INTEGER_CST
);
2116 return (integer_zerop (val
) ? false_edge
: true_edge
);
2119 /* Given an INTEGER_CST VAL and the entry block BB to a SWITCH_EXPR
2120 statement, determine which edge will be taken out of the block. Return
2121 NULL if any edge may be taken. */
2124 find_taken_edge_switch_expr (basic_block bb
, tree val
)
2126 basic_block dest_bb
;
2131 switch_stmt
= last_stmt (bb
);
2132 taken_case
= find_case_label_for_value (switch_stmt
, val
);
2133 dest_bb
= label_to_block (CASE_LABEL (taken_case
));
2135 e
= find_edge (bb
, dest_bb
);
2141 /* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
2142 We can make optimal use here of the fact that the case labels are
2143 sorted: We can do a binary search for a case matching VAL. */
2146 find_case_label_for_value (gimple switch_stmt
, tree val
)
2148 size_t low
, high
, n
= gimple_switch_num_labels (switch_stmt
);
2149 tree default_case
= gimple_switch_default_label (switch_stmt
);
2151 for (low
= 0, high
= n
; high
- low
> 1; )
2153 size_t i
= (high
+ low
) / 2;
2154 tree t
= gimple_switch_label (switch_stmt
, i
);
2157 /* Cache the result of comparing CASE_LOW and val. */
2158 cmp
= tree_int_cst_compare (CASE_LOW (t
), val
);
2165 if (CASE_HIGH (t
) == NULL
)
2167 /* A singe-valued case label. */
2173 /* A case range. We can only handle integer ranges. */
2174 if (cmp
<= 0 && tree_int_cst_compare (CASE_HIGH (t
), val
) >= 0)
2179 return default_case
;
2183 /* Dump a basic block on stderr. */
2186 gimple_debug_bb (basic_block bb
)
2188 dump_bb (stderr
, bb
, 0, TDF_VOPS
|TDF_MEMSYMS
|TDF_BLOCKS
);
2192 /* Dump basic block with index N on stderr. */
2195 gimple_debug_bb_n (int n
)
2197 gimple_debug_bb (BASIC_BLOCK_FOR_FN (cfun
, n
));
2198 return BASIC_BLOCK_FOR_FN (cfun
, n
);
2202 /* Dump the CFG on stderr.
2204 FLAGS are the same used by the tree dumping functions
2205 (see TDF_* in dumpfile.h). */
2208 gimple_debug_cfg (int flags
)
2210 gimple_dump_cfg (stderr
, flags
);
2214 /* Dump the program showing basic block boundaries on the given FILE.
2216 FLAGS are the same used by the tree dumping functions (see TDF_* in
2220 gimple_dump_cfg (FILE *file
, int flags
)
2222 if (flags
& TDF_DETAILS
)
2224 dump_function_header (file
, current_function_decl
, flags
);
2225 fprintf (file
, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
2226 n_basic_blocks_for_fn (cfun
), n_edges_for_fn (cfun
),
2227 last_basic_block_for_fn (cfun
));
2229 brief_dump_cfg (file
, flags
| TDF_COMMENT
);
2230 fprintf (file
, "\n");
2233 if (flags
& TDF_STATS
)
2234 dump_cfg_stats (file
);
2236 dump_function_to_file (current_function_decl
, file
, flags
| TDF_BLOCKS
);
2240 /* Dump CFG statistics on FILE. */
2243 dump_cfg_stats (FILE *file
)
2245 static long max_num_merged_labels
= 0;
2246 unsigned long size
, total
= 0;
2249 const char * const fmt_str
= "%-30s%-13s%12s\n";
2250 const char * const fmt_str_1
= "%-30s%13d%11lu%c\n";
2251 const char * const fmt_str_2
= "%-30s%13ld%11lu%c\n";
2252 const char * const fmt_str_3
= "%-43s%11lu%c\n";
2253 const char *funcname
= current_function_name ();
2255 fprintf (file
, "\nCFG Statistics for %s\n\n", funcname
);
2257 fprintf (file
, "---------------------------------------------------------\n");
2258 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
2259 fprintf (file
, fmt_str
, "", " instances ", "used ");
2260 fprintf (file
, "---------------------------------------------------------\n");
2262 size
= n_basic_blocks_for_fn (cfun
) * sizeof (struct basic_block_def
);
2264 fprintf (file
, fmt_str_1
, "Basic blocks", n_basic_blocks_for_fn (cfun
),
2265 SCALE (size
), LABEL (size
));
2268 FOR_EACH_BB_FN (bb
, cfun
)
2269 num_edges
+= EDGE_COUNT (bb
->succs
);
2270 size
= num_edges
* sizeof (struct edge_def
);
2272 fprintf (file
, fmt_str_2
, "Edges", num_edges
, SCALE (size
), LABEL (size
));
2274 fprintf (file
, "---------------------------------------------------------\n");
2275 fprintf (file
, fmt_str_3
, "Total memory used by CFG data", SCALE (total
),
2277 fprintf (file
, "---------------------------------------------------------\n");
2278 fprintf (file
, "\n");
2280 if (cfg_stats
.num_merged_labels
> max_num_merged_labels
)
2281 max_num_merged_labels
= cfg_stats
.num_merged_labels
;
2283 fprintf (file
, "Coalesced label blocks: %ld (Max so far: %ld)\n",
2284 cfg_stats
.num_merged_labels
, max_num_merged_labels
);
2286 fprintf (file
, "\n");
2290 /* Dump CFG statistics on stderr. Keep extern so that it's always
2291 linked in the final executable. */
2294 debug_cfg_stats (void)
2296 dump_cfg_stats (stderr
);
2299 /*---------------------------------------------------------------------------
2300 Miscellaneous helpers
2301 ---------------------------------------------------------------------------*/
2303 /* Return true if T, a GIMPLE_CALL, can make an abnormal transfer of control
2304 flow. Transfers of control flow associated with EH are excluded. */
2307 call_can_make_abnormal_goto (gimple t
)
2309 /* If the function has no non-local labels, then a call cannot make an
2310 abnormal transfer of control. */
2311 if (!cfun
->has_nonlocal_label
2312 && !cfun
->calls_setjmp
)
2315 /* Likewise if the call has no side effects. */
2316 if (!gimple_has_side_effects (t
))
2319 /* Likewise if the called function is leaf. */
2320 if (gimple_call_flags (t
) & ECF_LEAF
)
2327 /* Return true if T can make an abnormal transfer of control flow.
2328 Transfers of control flow associated with EH are excluded. */
2331 stmt_can_make_abnormal_goto (gimple t
)
2333 if (computed_goto_p (t
))
2335 if (is_gimple_call (t
))
2336 return call_can_make_abnormal_goto (t
);
2341 /* Return true if T represents a stmt that always transfers control. */
2344 is_ctrl_stmt (gimple t
)
2346 switch (gimple_code (t
))
2360 /* Return true if T is a statement that may alter the flow of control
2361 (e.g., a call to a non-returning function). */
2364 is_ctrl_altering_stmt (gimple t
)
2368 switch (gimple_code (t
))
2372 int flags
= gimple_call_flags (t
);
2374 /* A call alters control flow if it can make an abnormal goto. */
2375 if (call_can_make_abnormal_goto (t
))
2378 /* A call also alters control flow if it does not return. */
2379 if (flags
& ECF_NORETURN
)
2382 /* TM ending statements have backedges out of the transaction.
2383 Return true so we split the basic block containing them.
2384 Note that the TM_BUILTIN test is merely an optimization. */
2385 if ((flags
& ECF_TM_BUILTIN
)
2386 && is_tm_ending_fndecl (gimple_call_fndecl (t
)))
2389 /* BUILT_IN_RETURN call is same as return statement. */
2390 if (gimple_call_builtin_p (t
, BUILT_IN_RETURN
))
2395 case GIMPLE_EH_DISPATCH
:
2396 /* EH_DISPATCH branches to the individual catch handlers at
2397 this level of a try or allowed-exceptions region. It can
2398 fallthru to the next statement as well. */
2402 if (gimple_asm_nlabels (t
) > 0)
2407 /* OpenMP directives alter control flow. */
2410 case GIMPLE_TRANSACTION
:
2411 /* A transaction start alters control flow. */
2418 /* If a statement can throw, it alters control flow. */
2419 return stmt_can_throw_internal (t
);
2423 /* Return true if T is a simple local goto. */
2426 simple_goto_p (gimple t
)
2428 return (gimple_code (t
) == GIMPLE_GOTO
2429 && TREE_CODE (gimple_goto_dest (t
)) == LABEL_DECL
);
2433 /* Return true if STMT should start a new basic block. PREV_STMT is
2434 the statement preceding STMT. It is used when STMT is a label or a
2435 case label. Labels should only start a new basic block if their
2436 previous statement wasn't a label. Otherwise, sequence of labels
2437 would generate unnecessary basic blocks that only contain a single
2441 stmt_starts_bb_p (gimple stmt
, gimple prev_stmt
)
2446 /* Labels start a new basic block only if the preceding statement
2447 wasn't a label of the same type. This prevents the creation of
2448 consecutive blocks that have nothing but a single label. */
2449 if (gimple_code (stmt
) == GIMPLE_LABEL
)
2451 /* Nonlocal and computed GOTO targets always start a new block. */
2452 if (DECL_NONLOCAL (gimple_label_label (stmt
))
2453 || FORCED_LABEL (gimple_label_label (stmt
)))
2456 if (prev_stmt
&& gimple_code (prev_stmt
) == GIMPLE_LABEL
)
2458 if (DECL_NONLOCAL (gimple_label_label (prev_stmt
)))
2461 cfg_stats
.num_merged_labels
++;
2467 else if (gimple_code (stmt
) == GIMPLE_CALL
2468 && gimple_call_flags (stmt
) & ECF_RETURNS_TWICE
)
2469 /* setjmp acts similar to a nonlocal GOTO target and thus should
2470 start a new block. */
2477 /* Return true if T should end a basic block. */
2480 stmt_ends_bb_p (gimple t
)
2482 return is_ctrl_stmt (t
) || is_ctrl_altering_stmt (t
);
2485 /* Remove block annotations and other data structures. */
2488 delete_tree_cfg_annotations (void)
2490 vec_free (label_to_block_map_for_fn (cfun
));
2494 /* Return the first statement in basic block BB. */
2497 first_stmt (basic_block bb
)
2499 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2502 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2510 /* Return the first non-label statement in basic block BB. */
2513 first_non_label_stmt (basic_block bb
)
2515 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2516 while (!gsi_end_p (i
) && gimple_code (gsi_stmt (i
)) == GIMPLE_LABEL
)
2518 return !gsi_end_p (i
) ? gsi_stmt (i
) : NULL
;
2521 /* Return the last statement in basic block BB. */
2524 last_stmt (basic_block bb
)
2526 gimple_stmt_iterator i
= gsi_last_bb (bb
);
2529 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2537 /* Return the last statement of an otherwise empty block. Return NULL
2538 if the block is totally empty, or if it contains more than one
2542 last_and_only_stmt (basic_block bb
)
2544 gimple_stmt_iterator i
= gsi_last_nondebug_bb (bb
);
2550 last
= gsi_stmt (i
);
2551 gsi_prev_nondebug (&i
);
2555 /* Empty statements should no longer appear in the instruction stream.
2556 Everything that might have appeared before should be deleted by
2557 remove_useless_stmts, and the optimizers should just gsi_remove
2558 instead of smashing with build_empty_stmt.
2560 Thus the only thing that should appear here in a block containing
2561 one executable statement is a label. */
2562 prev
= gsi_stmt (i
);
2563 if (gimple_code (prev
) == GIMPLE_LABEL
)
2569 /* Reinstall those PHI arguments queued in OLD_EDGE to NEW_EDGE. */
2572 reinstall_phi_args (edge new_edge
, edge old_edge
)
2574 edge_var_map_vector
*v
;
2577 gimple_stmt_iterator phis
;
2579 v
= redirect_edge_var_map_vector (old_edge
);
2583 for (i
= 0, phis
= gsi_start_phis (new_edge
->dest
);
2584 v
->iterate (i
, &vm
) && !gsi_end_p (phis
);
2585 i
++, gsi_next (&phis
))
2587 gimple phi
= gsi_stmt (phis
);
2588 tree result
= redirect_edge_var_map_result (vm
);
2589 tree arg
= redirect_edge_var_map_def (vm
);
2591 gcc_assert (result
== gimple_phi_result (phi
));
2593 add_phi_arg (phi
, arg
, new_edge
, redirect_edge_var_map_location (vm
));
2596 redirect_edge_var_map_clear (old_edge
);
2599 /* Returns the basic block after which the new basic block created
2600 by splitting edge EDGE_IN should be placed. Tries to keep the new block
2601 near its "logical" location. This is of most help to humans looking
2602 at debugging dumps. */
2605 split_edge_bb_loc (edge edge_in
)
2607 basic_block dest
= edge_in
->dest
;
2608 basic_block dest_prev
= dest
->prev_bb
;
2612 edge e
= find_edge (dest_prev
, dest
);
2613 if (e
&& !(e
->flags
& EDGE_COMPLEX
))
2614 return edge_in
->src
;
2619 /* Split a (typically critical) edge EDGE_IN. Return the new block.
2620 Abort on abnormal edges. */
2623 gimple_split_edge (edge edge_in
)
2625 basic_block new_bb
, after_bb
, dest
;
2628 /* Abnormal edges cannot be split. */
2629 gcc_assert (!(edge_in
->flags
& EDGE_ABNORMAL
));
2631 dest
= edge_in
->dest
;
2633 after_bb
= split_edge_bb_loc (edge_in
);
2635 new_bb
= create_empty_bb (after_bb
);
2636 new_bb
->frequency
= EDGE_FREQUENCY (edge_in
);
2637 new_bb
->count
= edge_in
->count
;
2638 new_edge
= make_edge (new_bb
, dest
, EDGE_FALLTHRU
);
2639 new_edge
->probability
= REG_BR_PROB_BASE
;
2640 new_edge
->count
= edge_in
->count
;
2642 e
= redirect_edge_and_branch (edge_in
, new_bb
);
2643 gcc_assert (e
== edge_in
);
2644 reinstall_phi_args (new_edge
, e
);
2650 /* Verify properties of the address expression T with base object BASE. */
2653 verify_address (tree t
, tree base
)
2656 bool old_side_effects
;
2658 bool new_side_effects
;
2660 old_constant
= TREE_CONSTANT (t
);
2661 old_side_effects
= TREE_SIDE_EFFECTS (t
);
2663 recompute_tree_invariant_for_addr_expr (t
);
2664 new_side_effects
= TREE_SIDE_EFFECTS (t
);
2665 new_constant
= TREE_CONSTANT (t
);
2667 if (old_constant
!= new_constant
)
2669 error ("constant not recomputed when ADDR_EXPR changed");
2672 if (old_side_effects
!= new_side_effects
)
2674 error ("side effects not recomputed when ADDR_EXPR changed");
2678 if (!(TREE_CODE (base
) == VAR_DECL
2679 || TREE_CODE (base
) == PARM_DECL
2680 || TREE_CODE (base
) == RESULT_DECL
))
2683 if (DECL_GIMPLE_REG_P (base
))
2685 error ("DECL_GIMPLE_REG_P set on a variable with address taken");
2692 /* Callback for walk_tree, check that all elements with address taken are
2693 properly noticed as such. The DATA is an int* that is 1 if TP was seen
2694 inside a PHI node. */
2697 verify_expr (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
2704 /* Check operand N for being valid GIMPLE and give error MSG if not. */
2705 #define CHECK_OP(N, MSG) \
2706 do { if (!is_gimple_val (TREE_OPERAND (t, N))) \
2707 { error (MSG); return TREE_OPERAND (t, N); }} while (0)
2709 switch (TREE_CODE (t
))
2712 if (SSA_NAME_IN_FREE_LIST (t
))
2714 error ("SSA name in freelist but still referenced");
2720 error ("INDIRECT_REF in gimple IL");
2724 x
= TREE_OPERAND (t
, 0);
2725 if (!POINTER_TYPE_P (TREE_TYPE (x
))
2726 || !is_gimple_mem_ref_addr (x
))
2728 error ("invalid first operand of MEM_REF");
2731 if (TREE_CODE (TREE_OPERAND (t
, 1)) != INTEGER_CST
2732 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 1))))
2734 error ("invalid offset operand of MEM_REF");
2735 return TREE_OPERAND (t
, 1);
2737 if (TREE_CODE (x
) == ADDR_EXPR
2738 && (x
= verify_address (x
, TREE_OPERAND (x
, 0))))
2744 x
= fold (ASSERT_EXPR_COND (t
));
2745 if (x
== boolean_false_node
)
2747 error ("ASSERT_EXPR with an always-false condition");
2753 error ("MODIFY_EXPR not expected while having tuples");
2760 gcc_assert (is_gimple_address (t
));
2762 /* Skip any references (they will be checked when we recurse down the
2763 tree) and ensure that any variable used as a prefix is marked
2765 for (x
= TREE_OPERAND (t
, 0);
2766 handled_component_p (x
);
2767 x
= TREE_OPERAND (x
, 0))
2770 if ((tem
= verify_address (t
, x
)))
2773 if (!(TREE_CODE (x
) == VAR_DECL
2774 || TREE_CODE (x
) == PARM_DECL
2775 || TREE_CODE (x
) == RESULT_DECL
))
2778 if (!TREE_ADDRESSABLE (x
))
2780 error ("address taken, but ADDRESSABLE bit not set");
2788 x
= COND_EXPR_COND (t
);
2789 if (!INTEGRAL_TYPE_P (TREE_TYPE (x
)))
2791 error ("non-integral used in condition");
2794 if (!is_gimple_condexpr (x
))
2796 error ("invalid conditional operand");
2801 case NON_LVALUE_EXPR
:
2802 case TRUTH_NOT_EXPR
:
2806 case FIX_TRUNC_EXPR
:
2811 CHECK_OP (0, "invalid operand to unary operator");
2817 if (!is_gimple_reg_type (TREE_TYPE (t
)))
2819 error ("non-scalar BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR");
2823 if (TREE_CODE (t
) == BIT_FIELD_REF
)
2825 tree t0
= TREE_OPERAND (t
, 0);
2826 tree t1
= TREE_OPERAND (t
, 1);
2827 tree t2
= TREE_OPERAND (t
, 2);
2828 if (!tree_fits_uhwi_p (t1
)
2829 || !tree_fits_uhwi_p (t2
))
2831 error ("invalid position or size operand to BIT_FIELD_REF");
2834 if (INTEGRAL_TYPE_P (TREE_TYPE (t
))
2835 && (TYPE_PRECISION (TREE_TYPE (t
))
2836 != tree_to_uhwi (t1
)))
2838 error ("integral result type precision does not match "
2839 "field size of BIT_FIELD_REF");
2842 else if (!INTEGRAL_TYPE_P (TREE_TYPE (t
))
2843 && TYPE_MODE (TREE_TYPE (t
)) != BLKmode
2844 && (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (t
)))
2845 != tree_to_uhwi (t1
)))
2847 error ("mode precision of non-integral result does not "
2848 "match field size of BIT_FIELD_REF");
2851 if (!AGGREGATE_TYPE_P (TREE_TYPE (t0
))
2852 && (tree_to_uhwi (t1
) + tree_to_uhwi (t2
)
2853 > tree_to_uhwi (TYPE_SIZE (TREE_TYPE (t0
)))))
2855 error ("position plus size exceeds size of referenced object in "
2860 t
= TREE_OPERAND (t
, 0);
2865 case ARRAY_RANGE_REF
:
2866 case VIEW_CONVERT_EXPR
:
2867 /* We have a nest of references. Verify that each of the operands
2868 that determine where to reference is either a constant or a variable,
2869 verify that the base is valid, and then show we've already checked
2871 while (handled_component_p (t
))
2873 if (TREE_CODE (t
) == COMPONENT_REF
&& TREE_OPERAND (t
, 2))
2874 CHECK_OP (2, "invalid COMPONENT_REF offset operator");
2875 else if (TREE_CODE (t
) == ARRAY_REF
2876 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
2878 CHECK_OP (1, "invalid array index");
2879 if (TREE_OPERAND (t
, 2))
2880 CHECK_OP (2, "invalid array lower bound");
2881 if (TREE_OPERAND (t
, 3))
2882 CHECK_OP (3, "invalid array stride");
2884 else if (TREE_CODE (t
) == BIT_FIELD_REF
2885 || TREE_CODE (t
) == REALPART_EXPR
2886 || TREE_CODE (t
) == IMAGPART_EXPR
)
2888 error ("non-top-level BIT_FIELD_REF, IMAGPART_EXPR or "
2893 t
= TREE_OPERAND (t
, 0);
2896 if (!is_gimple_min_invariant (t
) && !is_gimple_lvalue (t
))
2898 error ("invalid reference prefix");
2905 /* PLUS_EXPR and MINUS_EXPR don't work on pointers, they should be done using
2906 POINTER_PLUS_EXPR. */
2907 if (POINTER_TYPE_P (TREE_TYPE (t
)))
2909 error ("invalid operand to plus/minus, type is a pointer");
2912 CHECK_OP (0, "invalid operand to binary operator");
2913 CHECK_OP (1, "invalid operand to binary operator");
2916 case POINTER_PLUS_EXPR
:
2917 /* Check to make sure the first operand is a pointer or reference type. */
2918 if (!POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 0))))
2920 error ("invalid operand to pointer plus, first operand is not a pointer");
2923 /* Check to make sure the second operand is a ptrofftype. */
2924 if (!ptrofftype_p (TREE_TYPE (TREE_OPERAND (t
, 1))))
2926 error ("invalid operand to pointer plus, second operand is not an "
2927 "integer type of appropriate width");
2937 case UNORDERED_EXPR
:
2946 case TRUNC_DIV_EXPR
:
2948 case FLOOR_DIV_EXPR
:
2949 case ROUND_DIV_EXPR
:
2950 case TRUNC_MOD_EXPR
:
2952 case FLOOR_MOD_EXPR
:
2953 case ROUND_MOD_EXPR
:
2955 case EXACT_DIV_EXPR
:
2965 CHECK_OP (0, "invalid operand to binary operator");
2966 CHECK_OP (1, "invalid operand to binary operator");
2970 if (TREE_CONSTANT (t
) && TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
2974 case CASE_LABEL_EXPR
:
2977 error ("invalid CASE_CHAIN");
2991 /* Verify if EXPR is either a GIMPLE ID or a GIMPLE indirect reference.
2992 Returns true if there is an error, otherwise false. */
2995 verify_types_in_gimple_min_lval (tree expr
)
2999 if (is_gimple_id (expr
))
3002 if (TREE_CODE (expr
) != TARGET_MEM_REF
3003 && TREE_CODE (expr
) != MEM_REF
)
3005 error ("invalid expression for min lvalue");
3009 /* TARGET_MEM_REFs are strange beasts. */
3010 if (TREE_CODE (expr
) == TARGET_MEM_REF
)
3013 op
= TREE_OPERAND (expr
, 0);
3014 if (!is_gimple_val (op
))
3016 error ("invalid operand in indirect reference");
3017 debug_generic_stmt (op
);
3020 /* Memory references now generally can involve a value conversion. */
3025 /* Verify if EXPR is a valid GIMPLE reference expression. If
3026 REQUIRE_LVALUE is true verifies it is an lvalue. Returns true
3027 if there is an error, otherwise false. */
3030 verify_types_in_gimple_reference (tree expr
, bool require_lvalue
)
3032 while (handled_component_p (expr
))
3034 tree op
= TREE_OPERAND (expr
, 0);
3036 if (TREE_CODE (expr
) == ARRAY_REF
3037 || TREE_CODE (expr
) == ARRAY_RANGE_REF
)
3039 if (!is_gimple_val (TREE_OPERAND (expr
, 1))
3040 || (TREE_OPERAND (expr
, 2)
3041 && !is_gimple_val (TREE_OPERAND (expr
, 2)))
3042 || (TREE_OPERAND (expr
, 3)
3043 && !is_gimple_val (TREE_OPERAND (expr
, 3))))
3045 error ("invalid operands to array reference");
3046 debug_generic_stmt (expr
);
3051 /* Verify if the reference array element types are compatible. */
3052 if (TREE_CODE (expr
) == ARRAY_REF
3053 && !useless_type_conversion_p (TREE_TYPE (expr
),
3054 TREE_TYPE (TREE_TYPE (op
))))
3056 error ("type mismatch in array reference");
3057 debug_generic_stmt (TREE_TYPE (expr
));
3058 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3061 if (TREE_CODE (expr
) == ARRAY_RANGE_REF
3062 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr
)),
3063 TREE_TYPE (TREE_TYPE (op
))))
3065 error ("type mismatch in array range reference");
3066 debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr
)));
3067 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3071 if ((TREE_CODE (expr
) == REALPART_EXPR
3072 || TREE_CODE (expr
) == IMAGPART_EXPR
)
3073 && !useless_type_conversion_p (TREE_TYPE (expr
),
3074 TREE_TYPE (TREE_TYPE (op
))))
3076 error ("type mismatch in real/imagpart reference");
3077 debug_generic_stmt (TREE_TYPE (expr
));
3078 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3082 if (TREE_CODE (expr
) == COMPONENT_REF
3083 && !useless_type_conversion_p (TREE_TYPE (expr
),
3084 TREE_TYPE (TREE_OPERAND (expr
, 1))))
3086 error ("type mismatch in component reference");
3087 debug_generic_stmt (TREE_TYPE (expr
));
3088 debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr
, 1)));
3092 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
)
3094 /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
3095 that their operand is not an SSA name or an invariant when
3096 requiring an lvalue (this usually means there is a SRA or IPA-SRA
3097 bug). Otherwise there is nothing to verify, gross mismatches at
3098 most invoke undefined behavior. */
3100 && (TREE_CODE (op
) == SSA_NAME
3101 || is_gimple_min_invariant (op
)))
3103 error ("conversion of an SSA_NAME on the left hand side");
3104 debug_generic_stmt (expr
);
3107 else if (TREE_CODE (op
) == SSA_NAME
3108 && TYPE_SIZE (TREE_TYPE (expr
)) != TYPE_SIZE (TREE_TYPE (op
)))
3110 error ("conversion of register to a different size");
3111 debug_generic_stmt (expr
);
3114 else if (!handled_component_p (op
))
3121 if (TREE_CODE (expr
) == MEM_REF
)
3123 if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr
, 0)))
3125 error ("invalid address operand in MEM_REF");
3126 debug_generic_stmt (expr
);
3129 if (TREE_CODE (TREE_OPERAND (expr
, 1)) != INTEGER_CST
3130 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr
, 1))))
3132 error ("invalid offset operand in MEM_REF");
3133 debug_generic_stmt (expr
);
3137 else if (TREE_CODE (expr
) == TARGET_MEM_REF
)
3139 if (!TMR_BASE (expr
)
3140 || !is_gimple_mem_ref_addr (TMR_BASE (expr
)))
3142 error ("invalid address operand in TARGET_MEM_REF");
3145 if (!TMR_OFFSET (expr
)
3146 || TREE_CODE (TMR_OFFSET (expr
)) != INTEGER_CST
3147 || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr
))))
3149 error ("invalid offset operand in TARGET_MEM_REF");
3150 debug_generic_stmt (expr
);
3155 return ((require_lvalue
|| !is_gimple_min_invariant (expr
))
3156 && verify_types_in_gimple_min_lval (expr
));
3159 /* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
3160 list of pointer-to types that is trivially convertible to DEST. */
3163 one_pointer_to_useless_type_conversion_p (tree dest
, tree src_obj
)
3167 if (!TYPE_POINTER_TO (src_obj
))
3170 for (src
= TYPE_POINTER_TO (src_obj
); src
; src
= TYPE_NEXT_PTR_TO (src
))
3171 if (useless_type_conversion_p (dest
, src
))
3177 /* Return true if TYPE1 is a fixed-point type and if conversions to and
3178 from TYPE2 can be handled by FIXED_CONVERT_EXPR. */
3181 valid_fixed_convert_types_p (tree type1
, tree type2
)
3183 return (FIXED_POINT_TYPE_P (type1
)
3184 && (INTEGRAL_TYPE_P (type2
)
3185 || SCALAR_FLOAT_TYPE_P (type2
)
3186 || FIXED_POINT_TYPE_P (type2
)));
3189 /* Verify the contents of a GIMPLE_CALL STMT. Returns true when there
3190 is a problem, otherwise false. */
3193 verify_gimple_call (gimple stmt
)
3195 tree fn
= gimple_call_fn (stmt
);
3196 tree fntype
, fndecl
;
3199 if (gimple_call_internal_p (stmt
))
3203 error ("gimple call has two targets");
3204 debug_generic_stmt (fn
);
3212 error ("gimple call has no target");
3217 if (fn
&& !is_gimple_call_addr (fn
))
3219 error ("invalid function in gimple call");
3220 debug_generic_stmt (fn
);
3225 && (!POINTER_TYPE_P (TREE_TYPE (fn
))
3226 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != FUNCTION_TYPE
3227 && TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != METHOD_TYPE
)))
3229 error ("non-function in gimple call");
3233 fndecl
= gimple_call_fndecl (stmt
);
3235 && TREE_CODE (fndecl
) == FUNCTION_DECL
3236 && DECL_LOOPING_CONST_OR_PURE_P (fndecl
)
3237 && !DECL_PURE_P (fndecl
)
3238 && !TREE_READONLY (fndecl
))
3240 error ("invalid pure const state for function");
3244 if (gimple_call_lhs (stmt
)
3245 && (!is_gimple_lvalue (gimple_call_lhs (stmt
))
3246 || verify_types_in_gimple_reference (gimple_call_lhs (stmt
), true)))
3248 error ("invalid LHS in gimple call");
3252 if (gimple_call_lhs (stmt
) && gimple_call_noreturn_p (stmt
))
3254 error ("LHS in noreturn call");
3258 fntype
= gimple_call_fntype (stmt
);
3260 && gimple_call_lhs (stmt
)
3261 && !useless_type_conversion_p (TREE_TYPE (gimple_call_lhs (stmt
)),
3263 /* ??? At least C++ misses conversions at assignments from
3264 void * call results.
3265 ??? Java is completely off. Especially with functions
3266 returning java.lang.Object.
3267 For now simply allow arbitrary pointer type conversions. */
3268 && !(POINTER_TYPE_P (TREE_TYPE (gimple_call_lhs (stmt
)))
3269 && POINTER_TYPE_P (TREE_TYPE (fntype
))))
3271 error ("invalid conversion in gimple call");
3272 debug_generic_stmt (TREE_TYPE (gimple_call_lhs (stmt
)));
3273 debug_generic_stmt (TREE_TYPE (fntype
));
3277 if (gimple_call_chain (stmt
)
3278 && !is_gimple_val (gimple_call_chain (stmt
)))
3280 error ("invalid static chain in gimple call");
3281 debug_generic_stmt (gimple_call_chain (stmt
));
3285 /* If there is a static chain argument, this should not be an indirect
3286 call, and the decl should have DECL_STATIC_CHAIN set. */
3287 if (gimple_call_chain (stmt
))
3289 if (!gimple_call_fndecl (stmt
))
3291 error ("static chain in indirect gimple call");
3294 fn
= TREE_OPERAND (fn
, 0);
3296 if (!DECL_STATIC_CHAIN (fn
))
3298 error ("static chain with function that doesn%'t use one");
3303 /* ??? The C frontend passes unpromoted arguments in case it
3304 didn't see a function declaration before the call. So for now
3305 leave the call arguments mostly unverified. Once we gimplify
3306 unit-at-a-time we have a chance to fix this. */
3308 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
3310 tree arg
= gimple_call_arg (stmt
, i
);
3311 if ((is_gimple_reg_type (TREE_TYPE (arg
))
3312 && !is_gimple_val (arg
))
3313 || (!is_gimple_reg_type (TREE_TYPE (arg
))
3314 && !is_gimple_lvalue (arg
)))
3316 error ("invalid argument to gimple call");
3317 debug_generic_expr (arg
);
3325 /* Verifies the gimple comparison with the result type TYPE and
3326 the operands OP0 and OP1. */
3329 verify_gimple_comparison (tree type
, tree op0
, tree op1
)
3331 tree op0_type
= TREE_TYPE (op0
);
3332 tree op1_type
= TREE_TYPE (op1
);
3334 if (!is_gimple_val (op0
) || !is_gimple_val (op1
))
3336 error ("invalid operands in gimple comparison");
3340 /* For comparisons we do not have the operations type as the
3341 effective type the comparison is carried out in. Instead
3342 we require that either the first operand is trivially
3343 convertible into the second, or the other way around.
3344 Because we special-case pointers to void we allow
3345 comparisons of pointers with the same mode as well. */
3346 if (!useless_type_conversion_p (op0_type
, op1_type
)
3347 && !useless_type_conversion_p (op1_type
, op0_type
)
3348 && (!POINTER_TYPE_P (op0_type
)
3349 || !POINTER_TYPE_P (op1_type
)
3350 || TYPE_MODE (op0_type
) != TYPE_MODE (op1_type
)))
3352 error ("mismatching comparison operand types");
3353 debug_generic_expr (op0_type
);
3354 debug_generic_expr (op1_type
);
3358 /* The resulting type of a comparison may be an effective boolean type. */
3359 if (INTEGRAL_TYPE_P (type
)
3360 && (TREE_CODE (type
) == BOOLEAN_TYPE
3361 || TYPE_PRECISION (type
) == 1))
3363 if (TREE_CODE (op0_type
) == VECTOR_TYPE
3364 || TREE_CODE (op1_type
) == VECTOR_TYPE
)
3366 error ("vector comparison returning a boolean");
3367 debug_generic_expr (op0_type
);
3368 debug_generic_expr (op1_type
);
3372 /* Or an integer vector type with the same size and element count
3373 as the comparison operand types. */
3374 else if (TREE_CODE (type
) == VECTOR_TYPE
3375 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
3377 if (TREE_CODE (op0_type
) != VECTOR_TYPE
3378 || TREE_CODE (op1_type
) != VECTOR_TYPE
)
3380 error ("non-vector operands in vector comparison");
3381 debug_generic_expr (op0_type
);
3382 debug_generic_expr (op1_type
);
3386 if (TYPE_VECTOR_SUBPARTS (type
) != TYPE_VECTOR_SUBPARTS (op0_type
)
3387 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (type
)))
3388 != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0_type
))))
3389 /* The result of a vector comparison is of signed
3391 || TYPE_UNSIGNED (TREE_TYPE (type
)))
3393 error ("invalid vector comparison resulting type");
3394 debug_generic_expr (type
);
3400 error ("bogus comparison result type");
3401 debug_generic_expr (type
);
3408 /* Verify a gimple assignment statement STMT with an unary rhs.
3409 Returns true if anything is wrong. */
3412 verify_gimple_assign_unary (gimple stmt
)
3414 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3415 tree lhs
= gimple_assign_lhs (stmt
);
3416 tree lhs_type
= TREE_TYPE (lhs
);
3417 tree rhs1
= gimple_assign_rhs1 (stmt
);
3418 tree rhs1_type
= TREE_TYPE (rhs1
);
3420 if (!is_gimple_reg (lhs
))
3422 error ("non-register as LHS of unary operation");
3426 if (!is_gimple_val (rhs1
))
3428 error ("invalid operand in unary operation");
3432 /* First handle conversions. */
3437 /* Allow conversions from pointer type to integral type only if
3438 there is no sign or zero extension involved.
3439 For targets were the precision of ptrofftype doesn't match that
3440 of pointers we need to allow arbitrary conversions to ptrofftype. */
3441 if ((POINTER_TYPE_P (lhs_type
)
3442 && INTEGRAL_TYPE_P (rhs1_type
))
3443 || (POINTER_TYPE_P (rhs1_type
)
3444 && INTEGRAL_TYPE_P (lhs_type
)
3445 && (TYPE_PRECISION (rhs1_type
) >= TYPE_PRECISION (lhs_type
)
3446 || ptrofftype_p (sizetype
))))
3449 /* Allow conversion from integral to offset type and vice versa. */
3450 if ((TREE_CODE (lhs_type
) == OFFSET_TYPE
3451 && INTEGRAL_TYPE_P (rhs1_type
))
3452 || (INTEGRAL_TYPE_P (lhs_type
)
3453 && TREE_CODE (rhs1_type
) == OFFSET_TYPE
))
3456 /* Otherwise assert we are converting between types of the
3458 if (INTEGRAL_TYPE_P (lhs_type
) != INTEGRAL_TYPE_P (rhs1_type
))
3460 error ("invalid types in nop conversion");
3461 debug_generic_expr (lhs_type
);
3462 debug_generic_expr (rhs1_type
);
3469 case ADDR_SPACE_CONVERT_EXPR
:
3471 if (!POINTER_TYPE_P (rhs1_type
) || !POINTER_TYPE_P (lhs_type
)
3472 || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type
))
3473 == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type
))))
3475 error ("invalid types in address space conversion");
3476 debug_generic_expr (lhs_type
);
3477 debug_generic_expr (rhs1_type
);
3484 case FIXED_CONVERT_EXPR
:
3486 if (!valid_fixed_convert_types_p (lhs_type
, rhs1_type
)
3487 && !valid_fixed_convert_types_p (rhs1_type
, lhs_type
))
3489 error ("invalid types in fixed-point conversion");
3490 debug_generic_expr (lhs_type
);
3491 debug_generic_expr (rhs1_type
);
3500 if ((!INTEGRAL_TYPE_P (rhs1_type
) || !SCALAR_FLOAT_TYPE_P (lhs_type
))
3501 && (!VECTOR_INTEGER_TYPE_P (rhs1_type
)
3502 || !VECTOR_FLOAT_TYPE_P (lhs_type
)))
3504 error ("invalid types in conversion to floating point");
3505 debug_generic_expr (lhs_type
);
3506 debug_generic_expr (rhs1_type
);
3513 case FIX_TRUNC_EXPR
:
3515 if ((!INTEGRAL_TYPE_P (lhs_type
) || !SCALAR_FLOAT_TYPE_P (rhs1_type
))
3516 && (!VECTOR_INTEGER_TYPE_P (lhs_type
)
3517 || !VECTOR_FLOAT_TYPE_P (rhs1_type
)))
3519 error ("invalid types in conversion to integer");
3520 debug_generic_expr (lhs_type
);
3521 debug_generic_expr (rhs1_type
);
3528 case VEC_UNPACK_HI_EXPR
:
3529 case VEC_UNPACK_LO_EXPR
:
3530 case REDUC_MAX_EXPR
:
3531 case REDUC_MIN_EXPR
:
3532 case REDUC_PLUS_EXPR
:
3533 case VEC_UNPACK_FLOAT_HI_EXPR
:
3534 case VEC_UNPACK_FLOAT_LO_EXPR
:
3542 case NON_LVALUE_EXPR
:
3550 /* For the remaining codes assert there is no conversion involved. */
3551 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3553 error ("non-trivial conversion in unary operation");
3554 debug_generic_expr (lhs_type
);
3555 debug_generic_expr (rhs1_type
);
3562 /* Verify a gimple assignment statement STMT with a binary rhs.
3563 Returns true if anything is wrong. */
3566 verify_gimple_assign_binary (gimple stmt
)
3568 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3569 tree lhs
= gimple_assign_lhs (stmt
);
3570 tree lhs_type
= TREE_TYPE (lhs
);
3571 tree rhs1
= gimple_assign_rhs1 (stmt
);
3572 tree rhs1_type
= TREE_TYPE (rhs1
);
3573 tree rhs2
= gimple_assign_rhs2 (stmt
);
3574 tree rhs2_type
= TREE_TYPE (rhs2
);
3576 if (!is_gimple_reg (lhs
))
3578 error ("non-register as LHS of binary operation");
3582 if (!is_gimple_val (rhs1
)
3583 || !is_gimple_val (rhs2
))
3585 error ("invalid operands in binary operation");
3589 /* First handle operations that involve different types. */
3594 if (TREE_CODE (lhs_type
) != COMPLEX_TYPE
3595 || !(INTEGRAL_TYPE_P (rhs1_type
)
3596 || SCALAR_FLOAT_TYPE_P (rhs1_type
))
3597 || !(INTEGRAL_TYPE_P (rhs2_type
)
3598 || SCALAR_FLOAT_TYPE_P (rhs2_type
)))
3600 error ("type mismatch in complex expression");
3601 debug_generic_expr (lhs_type
);
3602 debug_generic_expr (rhs1_type
);
3603 debug_generic_expr (rhs2_type
);
3615 /* Shifts and rotates are ok on integral types, fixed point
3616 types and integer vector types. */
3617 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3618 && !FIXED_POINT_TYPE_P (rhs1_type
)
3619 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3620 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))))
3621 || (!INTEGRAL_TYPE_P (rhs2_type
)
3622 /* Vector shifts of vectors are also ok. */
3623 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3624 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3625 && TREE_CODE (rhs2_type
) == VECTOR_TYPE
3626 && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3627 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3629 error ("type mismatch in shift expression");
3630 debug_generic_expr (lhs_type
);
3631 debug_generic_expr (rhs1_type
);
3632 debug_generic_expr (rhs2_type
);
3639 case VEC_LSHIFT_EXPR
:
3640 case VEC_RSHIFT_EXPR
:
3642 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3643 || !(INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3644 || POINTER_TYPE_P (TREE_TYPE (rhs1_type
))
3645 || FIXED_POINT_TYPE_P (TREE_TYPE (rhs1_type
))
3646 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
)))
3647 || (!INTEGRAL_TYPE_P (rhs2_type
)
3648 && (TREE_CODE (rhs2_type
) != VECTOR_TYPE
3649 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3650 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3652 error ("type mismatch in vector shift expression");
3653 debug_generic_expr (lhs_type
);
3654 debug_generic_expr (rhs1_type
);
3655 debug_generic_expr (rhs2_type
);
3658 /* For shifting a vector of non-integral components we
3659 only allow shifting by a constant multiple of the element size. */
3660 if (!INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3661 && (TREE_CODE (rhs2
) != INTEGER_CST
3662 || !div_if_zero_remainder (rhs2
,
3663 TYPE_SIZE (TREE_TYPE (rhs1_type
)))))
3665 error ("non-element sized vector shift of floating point vector");
3672 case WIDEN_LSHIFT_EXPR
:
3674 if (!INTEGRAL_TYPE_P (lhs_type
)
3675 || !INTEGRAL_TYPE_P (rhs1_type
)
3676 || TREE_CODE (rhs2
) != INTEGER_CST
3677 || (2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)))
3679 error ("type mismatch in widening vector shift expression");
3680 debug_generic_expr (lhs_type
);
3681 debug_generic_expr (rhs1_type
);
3682 debug_generic_expr (rhs2_type
);
3689 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3690 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3692 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3693 || TREE_CODE (lhs_type
) != VECTOR_TYPE
3694 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3695 || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3696 || TREE_CODE (rhs2
) != INTEGER_CST
3697 || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type
))
3698 > TYPE_PRECISION (TREE_TYPE (lhs_type
))))
3700 error ("type mismatch in widening vector shift expression");
3701 debug_generic_expr (lhs_type
);
3702 debug_generic_expr (rhs1_type
);
3703 debug_generic_expr (rhs2_type
);
3713 tree lhs_etype
= lhs_type
;
3714 tree rhs1_etype
= rhs1_type
;
3715 tree rhs2_etype
= rhs2_type
;
3716 if (TREE_CODE (lhs_type
) == VECTOR_TYPE
)
3718 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3719 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
)
3721 error ("invalid non-vector operands to vector valued plus");
3724 lhs_etype
= TREE_TYPE (lhs_type
);
3725 rhs1_etype
= TREE_TYPE (rhs1_type
);
3726 rhs2_etype
= TREE_TYPE (rhs2_type
);
3728 if (POINTER_TYPE_P (lhs_etype
)
3729 || POINTER_TYPE_P (rhs1_etype
)
3730 || POINTER_TYPE_P (rhs2_etype
))
3732 error ("invalid (pointer) operands to plus/minus");
3736 /* Continue with generic binary expression handling. */
3740 case POINTER_PLUS_EXPR
:
3742 if (!POINTER_TYPE_P (rhs1_type
)
3743 || !useless_type_conversion_p (lhs_type
, rhs1_type
)
3744 || !ptrofftype_p (rhs2_type
))
3746 error ("type mismatch in pointer plus expression");
3747 debug_generic_stmt (lhs_type
);
3748 debug_generic_stmt (rhs1_type
);
3749 debug_generic_stmt (rhs2_type
);
3756 case TRUTH_ANDIF_EXPR
:
3757 case TRUTH_ORIF_EXPR
:
3758 case TRUTH_AND_EXPR
:
3760 case TRUTH_XOR_EXPR
:
3770 case UNORDERED_EXPR
:
3778 /* Comparisons are also binary, but the result type is not
3779 connected to the operand types. */
3780 return verify_gimple_comparison (lhs_type
, rhs1
, rhs2
);
3782 case WIDEN_MULT_EXPR
:
3783 if (TREE_CODE (lhs_type
) != INTEGER_TYPE
)
3785 return ((2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
))
3786 || (TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
)));
3788 case WIDEN_SUM_EXPR
:
3789 case VEC_WIDEN_MULT_HI_EXPR
:
3790 case VEC_WIDEN_MULT_LO_EXPR
:
3791 case VEC_WIDEN_MULT_EVEN_EXPR
:
3792 case VEC_WIDEN_MULT_ODD_EXPR
:
3793 case VEC_PACK_TRUNC_EXPR
:
3794 case VEC_PACK_SAT_EXPR
:
3795 case VEC_PACK_FIX_TRUNC_EXPR
:
3800 case MULT_HIGHPART_EXPR
:
3801 case TRUNC_DIV_EXPR
:
3803 case FLOOR_DIV_EXPR
:
3804 case ROUND_DIV_EXPR
:
3805 case TRUNC_MOD_EXPR
:
3807 case FLOOR_MOD_EXPR
:
3808 case ROUND_MOD_EXPR
:
3810 case EXACT_DIV_EXPR
:
3816 /* Continue with generic binary expression handling. */
3823 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3824 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
3826 error ("type mismatch in binary expression");
3827 debug_generic_stmt (lhs_type
);
3828 debug_generic_stmt (rhs1_type
);
3829 debug_generic_stmt (rhs2_type
);
3836 /* Verify a gimple assignment statement STMT with a ternary rhs.
3837 Returns true if anything is wrong. */
3840 verify_gimple_assign_ternary (gimple stmt
)
3842 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3843 tree lhs
= gimple_assign_lhs (stmt
);
3844 tree lhs_type
= TREE_TYPE (lhs
);
3845 tree rhs1
= gimple_assign_rhs1 (stmt
);
3846 tree rhs1_type
= TREE_TYPE (rhs1
);
3847 tree rhs2
= gimple_assign_rhs2 (stmt
);
3848 tree rhs2_type
= TREE_TYPE (rhs2
);
3849 tree rhs3
= gimple_assign_rhs3 (stmt
);
3850 tree rhs3_type
= TREE_TYPE (rhs3
);
3852 if (!is_gimple_reg (lhs
))
3854 error ("non-register as LHS of ternary operation");
3858 if (((rhs_code
== VEC_COND_EXPR
|| rhs_code
== COND_EXPR
)
3859 ? !is_gimple_condexpr (rhs1
) : !is_gimple_val (rhs1
))
3860 || !is_gimple_val (rhs2
)
3861 || !is_gimple_val (rhs3
))
3863 error ("invalid operands in ternary operation");
3867 /* First handle operations that involve different types. */
3870 case WIDEN_MULT_PLUS_EXPR
:
3871 case WIDEN_MULT_MINUS_EXPR
:
3872 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3873 && !FIXED_POINT_TYPE_P (rhs1_type
))
3874 || !useless_type_conversion_p (rhs1_type
, rhs2_type
)
3875 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
3876 || 2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)
3877 || TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
))
3879 error ("type mismatch in widening multiply-accumulate expression");
3880 debug_generic_expr (lhs_type
);
3881 debug_generic_expr (rhs1_type
);
3882 debug_generic_expr (rhs2_type
);
3883 debug_generic_expr (rhs3_type
);
3889 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3890 || !useless_type_conversion_p (lhs_type
, rhs2_type
)
3891 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
3893 error ("type mismatch in fused multiply-add expression");
3894 debug_generic_expr (lhs_type
);
3895 debug_generic_expr (rhs1_type
);
3896 debug_generic_expr (rhs2_type
);
3897 debug_generic_expr (rhs3_type
);
3904 if (!useless_type_conversion_p (lhs_type
, rhs2_type
)
3905 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
3907 error ("type mismatch in conditional expression");
3908 debug_generic_expr (lhs_type
);
3909 debug_generic_expr (rhs2_type
);
3910 debug_generic_expr (rhs3_type
);
3916 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3917 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
3919 error ("type mismatch in vector permute expression");
3920 debug_generic_expr (lhs_type
);
3921 debug_generic_expr (rhs1_type
);
3922 debug_generic_expr (rhs2_type
);
3923 debug_generic_expr (rhs3_type
);
3927 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3928 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
3929 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
3931 error ("vector types expected in vector permute expression");
3932 debug_generic_expr (lhs_type
);
3933 debug_generic_expr (rhs1_type
);
3934 debug_generic_expr (rhs2_type
);
3935 debug_generic_expr (rhs3_type
);
3939 if (TYPE_VECTOR_SUBPARTS (rhs1_type
) != TYPE_VECTOR_SUBPARTS (rhs2_type
)
3940 || TYPE_VECTOR_SUBPARTS (rhs2_type
)
3941 != TYPE_VECTOR_SUBPARTS (rhs3_type
)
3942 || TYPE_VECTOR_SUBPARTS (rhs3_type
)
3943 != TYPE_VECTOR_SUBPARTS (lhs_type
))
3945 error ("vectors with different element number found "
3946 "in vector permute expression");
3947 debug_generic_expr (lhs_type
);
3948 debug_generic_expr (rhs1_type
);
3949 debug_generic_expr (rhs2_type
);
3950 debug_generic_expr (rhs3_type
);
3954 if (TREE_CODE (TREE_TYPE (rhs3_type
)) != INTEGER_TYPE
3955 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs3_type
)))
3956 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type
))))
3958 error ("invalid mask type in vector permute expression");
3959 debug_generic_expr (lhs_type
);
3960 debug_generic_expr (rhs1_type
);
3961 debug_generic_expr (rhs2_type
);
3962 debug_generic_expr (rhs3_type
);
3969 case REALIGN_LOAD_EXPR
:
3979 /* Verify a gimple assignment statement STMT with a single rhs.
3980 Returns true if anything is wrong. */
3983 verify_gimple_assign_single (gimple stmt
)
3985 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3986 tree lhs
= gimple_assign_lhs (stmt
);
3987 tree lhs_type
= TREE_TYPE (lhs
);
3988 tree rhs1
= gimple_assign_rhs1 (stmt
);
3989 tree rhs1_type
= TREE_TYPE (rhs1
);
3992 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3994 error ("non-trivial conversion at assignment");
3995 debug_generic_expr (lhs_type
);
3996 debug_generic_expr (rhs1_type
);
4000 if (gimple_clobber_p (stmt
)
4001 && !(DECL_P (lhs
) || TREE_CODE (lhs
) == MEM_REF
))
4003 error ("non-decl/MEM_REF LHS in clobber statement");
4004 debug_generic_expr (lhs
);
4008 if (handled_component_p (lhs
)
4009 || TREE_CODE (lhs
) == MEM_REF
4010 || TREE_CODE (lhs
) == TARGET_MEM_REF
)
4011 res
|= verify_types_in_gimple_reference (lhs
, true);
4013 /* Special codes we cannot handle via their class. */
4018 tree op
= TREE_OPERAND (rhs1
, 0);
4019 if (!is_gimple_addressable (op
))
4021 error ("invalid operand in unary expression");
4025 /* Technically there is no longer a need for matching types, but
4026 gimple hygiene asks for this check. In LTO we can end up
4027 combining incompatible units and thus end up with addresses
4028 of globals that change their type to a common one. */
4030 && !types_compatible_p (TREE_TYPE (op
),
4031 TREE_TYPE (TREE_TYPE (rhs1
)))
4032 && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1
),
4035 error ("type mismatch in address expression");
4036 debug_generic_stmt (TREE_TYPE (rhs1
));
4037 debug_generic_stmt (TREE_TYPE (op
));
4041 return verify_types_in_gimple_reference (op
, true);
4046 error ("INDIRECT_REF in gimple IL");
4052 case ARRAY_RANGE_REF
:
4053 case VIEW_CONVERT_EXPR
:
4056 case TARGET_MEM_REF
:
4058 if (!is_gimple_reg (lhs
)
4059 && is_gimple_reg_type (TREE_TYPE (lhs
)))
4061 error ("invalid rhs for gimple memory store");
4062 debug_generic_stmt (lhs
);
4063 debug_generic_stmt (rhs1
);
4066 return res
|| verify_types_in_gimple_reference (rhs1
, false);
4078 /* tcc_declaration */
4083 if (!is_gimple_reg (lhs
)
4084 && !is_gimple_reg (rhs1
)
4085 && is_gimple_reg_type (TREE_TYPE (lhs
)))
4087 error ("invalid rhs for gimple memory store");
4088 debug_generic_stmt (lhs
);
4089 debug_generic_stmt (rhs1
);
4095 if (TREE_CODE (rhs1_type
) == VECTOR_TYPE
)
4098 tree elt_i
, elt_v
, elt_t
= NULL_TREE
;
4100 if (CONSTRUCTOR_NELTS (rhs1
) == 0)
4102 /* For vector CONSTRUCTORs we require that either it is empty
4103 CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
4104 (then the element count must be correct to cover the whole
4105 outer vector and index must be NULL on all elements, or it is
4106 a CONSTRUCTOR of scalar elements, where we as an exception allow
4107 smaller number of elements (assuming zero filling) and
4108 consecutive indexes as compared to NULL indexes (such
4109 CONSTRUCTORs can appear in the IL from FEs). */
4110 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1
), i
, elt_i
, elt_v
)
4112 if (elt_t
== NULL_TREE
)
4114 elt_t
= TREE_TYPE (elt_v
);
4115 if (TREE_CODE (elt_t
) == VECTOR_TYPE
)
4117 tree elt_t
= TREE_TYPE (elt_v
);
4118 if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
4121 error ("incorrect type of vector CONSTRUCTOR"
4123 debug_generic_stmt (rhs1
);
4126 else if (CONSTRUCTOR_NELTS (rhs1
)
4127 * TYPE_VECTOR_SUBPARTS (elt_t
)
4128 != TYPE_VECTOR_SUBPARTS (rhs1_type
))
4130 error ("incorrect number of vector CONSTRUCTOR"
4132 debug_generic_stmt (rhs1
);
4136 else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
4139 error ("incorrect type of vector CONSTRUCTOR elements");
4140 debug_generic_stmt (rhs1
);
4143 else if (CONSTRUCTOR_NELTS (rhs1
)
4144 > TYPE_VECTOR_SUBPARTS (rhs1_type
))
4146 error ("incorrect number of vector CONSTRUCTOR elements");
4147 debug_generic_stmt (rhs1
);
4151 else if (!useless_type_conversion_p (elt_t
, TREE_TYPE (elt_v
)))
4153 error ("incorrect type of vector CONSTRUCTOR elements");
4154 debug_generic_stmt (rhs1
);
4157 if (elt_i
!= NULL_TREE
4158 && (TREE_CODE (elt_t
) == VECTOR_TYPE
4159 || TREE_CODE (elt_i
) != INTEGER_CST
4160 || compare_tree_int (elt_i
, i
) != 0))
4162 error ("vector CONSTRUCTOR with non-NULL element index");
4163 debug_generic_stmt (rhs1
);
4171 case WITH_SIZE_EXPR
:
4181 /* Verify the contents of a GIMPLE_ASSIGN STMT. Returns true when there
4182 is a problem, otherwise false. */
4185 verify_gimple_assign (gimple stmt
)
4187 switch (gimple_assign_rhs_class (stmt
))
4189 case GIMPLE_SINGLE_RHS
:
4190 return verify_gimple_assign_single (stmt
);
4192 case GIMPLE_UNARY_RHS
:
4193 return verify_gimple_assign_unary (stmt
);
4195 case GIMPLE_BINARY_RHS
:
4196 return verify_gimple_assign_binary (stmt
);
4198 case GIMPLE_TERNARY_RHS
:
4199 return verify_gimple_assign_ternary (stmt
);
4206 /* Verify the contents of a GIMPLE_RETURN STMT. Returns true when there
4207 is a problem, otherwise false. */
4210 verify_gimple_return (gimple stmt
)
4212 tree op
= gimple_return_retval (stmt
);
4213 tree restype
= TREE_TYPE (TREE_TYPE (cfun
->decl
));
4215 /* We cannot test for present return values as we do not fix up missing
4216 return values from the original source. */
4220 if (!is_gimple_val (op
)
4221 && TREE_CODE (op
) != RESULT_DECL
)
4223 error ("invalid operand in return statement");
4224 debug_generic_stmt (op
);
4228 if ((TREE_CODE (op
) == RESULT_DECL
4229 && DECL_BY_REFERENCE (op
))
4230 || (TREE_CODE (op
) == SSA_NAME
4231 && SSA_NAME_VAR (op
)
4232 && TREE_CODE (SSA_NAME_VAR (op
)) == RESULT_DECL
4233 && DECL_BY_REFERENCE (SSA_NAME_VAR (op
))))
4234 op
= TREE_TYPE (op
);
4236 if (!useless_type_conversion_p (restype
, TREE_TYPE (op
)))
4238 error ("invalid conversion in return statement");
4239 debug_generic_stmt (restype
);
4240 debug_generic_stmt (TREE_TYPE (op
));
4248 /* Verify the contents of a GIMPLE_GOTO STMT. Returns true when there
4249 is a problem, otherwise false. */
4252 verify_gimple_goto (gimple stmt
)
4254 tree dest
= gimple_goto_dest (stmt
);
4256 /* ??? We have two canonical forms of direct goto destinations, a
4257 bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
4258 if (TREE_CODE (dest
) != LABEL_DECL
4259 && (!is_gimple_val (dest
)
4260 || !POINTER_TYPE_P (TREE_TYPE (dest
))))
4262 error ("goto destination is neither a label nor a pointer");
4269 /* Verify the contents of a GIMPLE_SWITCH STMT. Returns true when there
4270 is a problem, otherwise false. */
4273 verify_gimple_switch (gimple stmt
)
4276 tree elt
, prev_upper_bound
= NULL_TREE
;
4277 tree index_type
, elt_type
= NULL_TREE
;
4279 if (!is_gimple_val (gimple_switch_index (stmt
)))
4281 error ("invalid operand to switch statement");
4282 debug_generic_stmt (gimple_switch_index (stmt
));
4286 index_type
= TREE_TYPE (gimple_switch_index (stmt
));
4287 if (! INTEGRAL_TYPE_P (index_type
))
4289 error ("non-integral type switch statement");
4290 debug_generic_expr (index_type
);
4294 elt
= gimple_switch_label (stmt
, 0);
4295 if (CASE_LOW (elt
) != NULL_TREE
|| CASE_HIGH (elt
) != NULL_TREE
)
4297 error ("invalid default case label in switch statement");
4298 debug_generic_expr (elt
);
4302 n
= gimple_switch_num_labels (stmt
);
4303 for (i
= 1; i
< n
; i
++)
4305 elt
= gimple_switch_label (stmt
, i
);
4307 if (! CASE_LOW (elt
))
4309 error ("invalid case label in switch statement");
4310 debug_generic_expr (elt
);
4314 && ! tree_int_cst_lt (CASE_LOW (elt
), CASE_HIGH (elt
)))
4316 error ("invalid case range in switch statement");
4317 debug_generic_expr (elt
);
4323 if (TREE_TYPE (CASE_LOW (elt
)) != elt_type
4324 || (CASE_HIGH (elt
) && TREE_TYPE (CASE_HIGH (elt
)) != elt_type
))
4326 error ("type mismatch for case label in switch statement");
4327 debug_generic_expr (elt
);
4333 elt_type
= TREE_TYPE (CASE_LOW (elt
));
4334 if (TYPE_PRECISION (index_type
) < TYPE_PRECISION (elt_type
))
4336 error ("type precision mismatch in switch statement");
4341 if (prev_upper_bound
)
4343 if (! tree_int_cst_lt (prev_upper_bound
, CASE_LOW (elt
)))
4345 error ("case labels not sorted in switch statement");
4350 prev_upper_bound
= CASE_HIGH (elt
);
4351 if (! prev_upper_bound
)
4352 prev_upper_bound
= CASE_LOW (elt
);
4358 /* Verify a gimple debug statement STMT.
4359 Returns true if anything is wrong. */
4362 verify_gimple_debug (gimple stmt ATTRIBUTE_UNUSED
)
4364 /* There isn't much that could be wrong in a gimple debug stmt. A
4365 gimple debug bind stmt, for example, maps a tree, that's usually
4366 a VAR_DECL or a PARM_DECL, but that could also be some scalarized
4367 component or member of an aggregate type, to another tree, that
4368 can be an arbitrary expression. These stmts expand into debug
4369 insns, and are converted to debug notes by var-tracking.c. */
4373 /* Verify a gimple label statement STMT.
4374 Returns true if anything is wrong. */
4377 verify_gimple_label (gimple stmt
)
4379 tree decl
= gimple_label_label (stmt
);
4383 if (TREE_CODE (decl
) != LABEL_DECL
)
4385 if (!DECL_NONLOCAL (decl
) && !FORCED_LABEL (decl
)
4386 && DECL_CONTEXT (decl
) != current_function_decl
)
4388 error ("label's context is not the current function decl");
4392 uid
= LABEL_DECL_UID (decl
);
4395 || (*label_to_block_map_for_fn (cfun
))[uid
] != gimple_bb (stmt
)))
4397 error ("incorrect entry in label_to_block_map");
4401 uid
= EH_LANDING_PAD_NR (decl
);
4404 eh_landing_pad lp
= get_eh_landing_pad_from_number (uid
);
4405 if (decl
!= lp
->post_landing_pad
)
4407 error ("incorrect setting of landing pad number");
4415 /* Verify the GIMPLE statement STMT. Returns true if there is an
4416 error, otherwise false. */
4419 verify_gimple_stmt (gimple stmt
)
4421 switch (gimple_code (stmt
))
4424 return verify_gimple_assign (stmt
);
4427 return verify_gimple_label (stmt
);
4430 return verify_gimple_call (stmt
);
4433 if (TREE_CODE_CLASS (gimple_cond_code (stmt
)) != tcc_comparison
)
4435 error ("invalid comparison code in gimple cond");
4438 if (!(!gimple_cond_true_label (stmt
)
4439 || TREE_CODE (gimple_cond_true_label (stmt
)) == LABEL_DECL
)
4440 || !(!gimple_cond_false_label (stmt
)
4441 || TREE_CODE (gimple_cond_false_label (stmt
)) == LABEL_DECL
))
4443 error ("invalid labels in gimple cond");
4447 return verify_gimple_comparison (boolean_type_node
,
4448 gimple_cond_lhs (stmt
),
4449 gimple_cond_rhs (stmt
));
4452 return verify_gimple_goto (stmt
);
4455 return verify_gimple_switch (stmt
);
4458 return verify_gimple_return (stmt
);
4463 case GIMPLE_TRANSACTION
:
4464 return verify_gimple_transaction (stmt
);
4466 /* Tuples that do not have tree operands. */
4468 case GIMPLE_PREDICT
:
4470 case GIMPLE_EH_DISPATCH
:
4471 case GIMPLE_EH_MUST_NOT_THROW
:
4475 /* OpenMP directives are validated by the FE and never operated
4476 on by the optimizers. Furthermore, GIMPLE_OMP_FOR may contain
4477 non-gimple expressions when the main index variable has had
4478 its address taken. This does not affect the loop itself
4479 because the header of an GIMPLE_OMP_FOR is merely used to determine
4480 how to setup the parallel iteration. */
4484 return verify_gimple_debug (stmt
);
4491 /* Verify the contents of a GIMPLE_PHI. Returns true if there is a problem,
4492 and false otherwise. */
4495 verify_gimple_phi (gimple phi
)
4499 tree phi_result
= gimple_phi_result (phi
);
4504 error ("invalid PHI result");
4508 virtual_p
= virtual_operand_p (phi_result
);
4509 if (TREE_CODE (phi_result
) != SSA_NAME
4511 && SSA_NAME_VAR (phi_result
) != gimple_vop (cfun
)))
4513 error ("invalid PHI result");
4517 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4519 tree t
= gimple_phi_arg_def (phi
, i
);
4523 error ("missing PHI def");
4527 /* Addressable variables do have SSA_NAMEs but they
4528 are not considered gimple values. */
4529 else if ((TREE_CODE (t
) == SSA_NAME
4530 && virtual_p
!= virtual_operand_p (t
))
4532 && (TREE_CODE (t
) != SSA_NAME
4533 || SSA_NAME_VAR (t
) != gimple_vop (cfun
)))
4535 && !is_gimple_val (t
)))
4537 error ("invalid PHI argument");
4538 debug_generic_expr (t
);
4541 #ifdef ENABLE_TYPES_CHECKING
4542 if (!useless_type_conversion_p (TREE_TYPE (phi_result
), TREE_TYPE (t
)))
4544 error ("incompatible types in PHI argument %u", i
);
4545 debug_generic_stmt (TREE_TYPE (phi_result
));
4546 debug_generic_stmt (TREE_TYPE (t
));
4555 /* Verify the GIMPLE statements inside the sequence STMTS. */
4558 verify_gimple_in_seq_2 (gimple_seq stmts
)
4560 gimple_stmt_iterator ittr
;
4563 for (ittr
= gsi_start (stmts
); !gsi_end_p (ittr
); gsi_next (&ittr
))
4565 gimple stmt
= gsi_stmt (ittr
);
4567 switch (gimple_code (stmt
))
4570 err
|= verify_gimple_in_seq_2 (gimple_bind_body (stmt
));
4574 err
|= verify_gimple_in_seq_2 (gimple_try_eval (stmt
));
4575 err
|= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt
));
4578 case GIMPLE_EH_FILTER
:
4579 err
|= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt
));
4582 case GIMPLE_EH_ELSE
:
4583 err
|= verify_gimple_in_seq_2 (gimple_eh_else_n_body (stmt
));
4584 err
|= verify_gimple_in_seq_2 (gimple_eh_else_e_body (stmt
));
4588 err
|= verify_gimple_in_seq_2 (gimple_catch_handler (stmt
));
4591 case GIMPLE_TRANSACTION
:
4592 err
|= verify_gimple_transaction (stmt
);
4597 bool err2
= verify_gimple_stmt (stmt
);
4599 debug_gimple_stmt (stmt
);
4608 /* Verify the contents of a GIMPLE_TRANSACTION. Returns true if there
4609 is a problem, otherwise false. */
4612 verify_gimple_transaction (gimple stmt
)
4614 tree lab
= gimple_transaction_label (stmt
);
4615 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
4617 return verify_gimple_in_seq_2 (gimple_transaction_body (stmt
));
4621 /* Verify the GIMPLE statements inside the statement list STMTS. */
4624 verify_gimple_in_seq (gimple_seq stmts
)
4626 timevar_push (TV_TREE_STMT_VERIFY
);
4627 if (verify_gimple_in_seq_2 (stmts
))
4628 internal_error ("verify_gimple failed");
4629 timevar_pop (TV_TREE_STMT_VERIFY
);
4632 /* Return true when the T can be shared. */
4635 tree_node_can_be_shared (tree t
)
4637 if (IS_TYPE_OR_DECL_P (t
)
4638 || is_gimple_min_invariant (t
)
4639 || TREE_CODE (t
) == SSA_NAME
4640 || t
== error_mark_node
4641 || TREE_CODE (t
) == IDENTIFIER_NODE
)
4644 if (TREE_CODE (t
) == CASE_LABEL_EXPR
)
4653 /* Called via walk_tree. Verify tree sharing. */
4656 verify_node_sharing_1 (tree
*tp
, int *walk_subtrees
, void *data
)
4658 struct pointer_set_t
*visited
= (struct pointer_set_t
*) data
;
4660 if (tree_node_can_be_shared (*tp
))
4662 *walk_subtrees
= false;
4666 if (pointer_set_insert (visited
, *tp
))
4672 /* Called via walk_gimple_stmt. Verify tree sharing. */
4675 verify_node_sharing (tree
*tp
, int *walk_subtrees
, void *data
)
4677 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4678 return verify_node_sharing_1 (tp
, walk_subtrees
, wi
->info
);
4681 static bool eh_error_found
;
4683 verify_eh_throw_stmt_node (void **slot
, void *data
)
4685 struct throw_stmt_node
*node
= (struct throw_stmt_node
*)*slot
;
4686 struct pointer_set_t
*visited
= (struct pointer_set_t
*) data
;
4688 if (!pointer_set_contains (visited
, node
->stmt
))
4690 error ("dead STMT in EH table");
4691 debug_gimple_stmt (node
->stmt
);
4692 eh_error_found
= true;
4697 /* Verify if the location LOCs block is in BLOCKS. */
4700 verify_location (pointer_set_t
*blocks
, location_t loc
)
4702 tree block
= LOCATION_BLOCK (loc
);
4703 if (block
!= NULL_TREE
4704 && !pointer_set_contains (blocks
, block
))
4706 error ("location references block not in block tree");
4709 if (block
!= NULL_TREE
)
4710 return verify_location (blocks
, BLOCK_SOURCE_LOCATION (block
));
4714 /* Called via walk_tree. Verify that expressions have no blocks. */
4717 verify_expr_no_block (tree
*tp
, int *walk_subtrees
, void *)
4721 *walk_subtrees
= false;
4725 location_t loc
= EXPR_LOCATION (*tp
);
4726 if (LOCATION_BLOCK (loc
) != NULL
)
4732 /* Called via walk_tree. Verify locations of expressions. */
4735 verify_expr_location_1 (tree
*tp
, int *walk_subtrees
, void *data
)
4737 struct pointer_set_t
*blocks
= (struct pointer_set_t
*) data
;
4739 if (TREE_CODE (*tp
) == VAR_DECL
4740 && DECL_HAS_DEBUG_EXPR_P (*tp
))
4742 tree t
= DECL_DEBUG_EXPR (*tp
);
4743 tree addr
= walk_tree (&t
, verify_expr_no_block
, NULL
, NULL
);
4747 if ((TREE_CODE (*tp
) == VAR_DECL
4748 || TREE_CODE (*tp
) == PARM_DECL
4749 || TREE_CODE (*tp
) == RESULT_DECL
)
4750 && DECL_HAS_VALUE_EXPR_P (*tp
))
4752 tree t
= DECL_VALUE_EXPR (*tp
);
4753 tree addr
= walk_tree (&t
, verify_expr_no_block
, NULL
, NULL
);
4760 *walk_subtrees
= false;
4764 location_t loc
= EXPR_LOCATION (*tp
);
4765 if (verify_location (blocks
, loc
))
4771 /* Called via walk_gimple_op. Verify locations of expressions. */
4774 verify_expr_location (tree
*tp
, int *walk_subtrees
, void *data
)
4776 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4777 return verify_expr_location_1 (tp
, walk_subtrees
, wi
->info
);
4780 /* Insert all subblocks of BLOCK into BLOCKS and recurse. */
4783 collect_subblocks (pointer_set_t
*blocks
, tree block
)
4786 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
4788 pointer_set_insert (blocks
, t
);
4789 collect_subblocks (blocks
, t
);
4793 /* Verify the GIMPLE statements in the CFG of FN. */
4796 verify_gimple_in_cfg (struct function
*fn
, bool verify_nothrow
)
4800 struct pointer_set_t
*visited
, *visited_stmts
, *blocks
;
4802 timevar_push (TV_TREE_STMT_VERIFY
);
4803 visited
= pointer_set_create ();
4804 visited_stmts
= pointer_set_create ();
4806 /* Collect all BLOCKs referenced by the BLOCK tree of FN. */
4807 blocks
= pointer_set_create ();
4808 if (DECL_INITIAL (fn
->decl
))
4810 pointer_set_insert (blocks
, DECL_INITIAL (fn
->decl
));
4811 collect_subblocks (blocks
, DECL_INITIAL (fn
->decl
));
4814 FOR_EACH_BB_FN (bb
, fn
)
4816 gimple_stmt_iterator gsi
;
4818 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4820 gimple phi
= gsi_stmt (gsi
);
4824 pointer_set_insert (visited_stmts
, phi
);
4826 if (gimple_bb (phi
) != bb
)
4828 error ("gimple_bb (phi) is set to a wrong basic block");
4832 err2
|= verify_gimple_phi (phi
);
4834 /* Only PHI arguments have locations. */
4835 if (gimple_location (phi
) != UNKNOWN_LOCATION
)
4837 error ("PHI node with location");
4841 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4843 tree arg
= gimple_phi_arg_def (phi
, i
);
4844 tree addr
= walk_tree (&arg
, verify_node_sharing_1
,
4848 error ("incorrect sharing of tree nodes");
4849 debug_generic_expr (addr
);
4852 location_t loc
= gimple_phi_arg_location (phi
, i
);
4853 if (virtual_operand_p (gimple_phi_result (phi
))
4854 && loc
!= UNKNOWN_LOCATION
)
4856 error ("virtual PHI with argument locations");
4859 addr
= walk_tree (&arg
, verify_expr_location_1
, blocks
, NULL
);
4862 debug_generic_expr (addr
);
4865 err2
|= verify_location (blocks
, loc
);
4869 debug_gimple_stmt (phi
);
4873 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4875 gimple stmt
= gsi_stmt (gsi
);
4877 struct walk_stmt_info wi
;
4881 pointer_set_insert (visited_stmts
, stmt
);
4883 if (gimple_bb (stmt
) != bb
)
4885 error ("gimple_bb (stmt) is set to a wrong basic block");
4889 err2
|= verify_gimple_stmt (stmt
);
4890 err2
|= verify_location (blocks
, gimple_location (stmt
));
4892 memset (&wi
, 0, sizeof (wi
));
4893 wi
.info
= (void *) visited
;
4894 addr
= walk_gimple_op (stmt
, verify_node_sharing
, &wi
);
4897 error ("incorrect sharing of tree nodes");
4898 debug_generic_expr (addr
);
4902 memset (&wi
, 0, sizeof (wi
));
4903 wi
.info
= (void *) blocks
;
4904 addr
= walk_gimple_op (stmt
, verify_expr_location
, &wi
);
4907 debug_generic_expr (addr
);
4911 /* ??? Instead of not checking these stmts at all the walker
4912 should know its context via wi. */
4913 if (!is_gimple_debug (stmt
)
4914 && !is_gimple_omp (stmt
))
4916 memset (&wi
, 0, sizeof (wi
));
4917 addr
= walk_gimple_op (stmt
, verify_expr
, &wi
);
4920 debug_generic_expr (addr
);
4921 inform (gimple_location (stmt
), "in statement");
4926 /* If the statement is marked as part of an EH region, then it is
4927 expected that the statement could throw. Verify that when we
4928 have optimizations that simplify statements such that we prove
4929 that they cannot throw, that we update other data structures
4931 lp_nr
= lookup_stmt_eh_lp (stmt
);
4934 if (!stmt_could_throw_p (stmt
))
4938 error ("statement marked for throw, but doesn%'t");
4942 else if (!gsi_one_before_end_p (gsi
))
4944 error ("statement marked for throw in middle of block");
4950 debug_gimple_stmt (stmt
);
4955 eh_error_found
= false;
4956 if (get_eh_throw_stmt_table (cfun
))
4957 htab_traverse (get_eh_throw_stmt_table (cfun
),
4958 verify_eh_throw_stmt_node
,
4961 if (err
|| eh_error_found
)
4962 internal_error ("verify_gimple failed");
4964 pointer_set_destroy (visited
);
4965 pointer_set_destroy (visited_stmts
);
4966 pointer_set_destroy (blocks
);
4967 verify_histograms ();
4968 timevar_pop (TV_TREE_STMT_VERIFY
);
4972 /* Verifies that the flow information is OK. */
4975 gimple_verify_flow_info (void)
4979 gimple_stmt_iterator gsi
;
4984 if (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.seq
4985 || ENTRY_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.phi_nodes
)
4987 error ("ENTRY_BLOCK has IL associated with it");
4991 if (EXIT_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.seq
4992 || EXIT_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.phi_nodes
)
4994 error ("EXIT_BLOCK has IL associated with it");
4998 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
4999 if (e
->flags
& EDGE_FALLTHRU
)
5001 error ("fallthru to exit from bb %d", e
->src
->index
);
5005 FOR_EACH_BB_FN (bb
, cfun
)
5007 bool found_ctrl_stmt
= false;
5011 /* Skip labels on the start of basic block. */
5012 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5015 gimple prev_stmt
= stmt
;
5017 stmt
= gsi_stmt (gsi
);
5019 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5022 label
= gimple_label_label (stmt
);
5023 if (prev_stmt
&& DECL_NONLOCAL (label
))
5025 error ("nonlocal label ");
5026 print_generic_expr (stderr
, label
, 0);
5027 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
5032 if (prev_stmt
&& EH_LANDING_PAD_NR (label
) != 0)
5034 error ("EH landing pad label ");
5035 print_generic_expr (stderr
, label
, 0);
5036 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
5041 if (label_to_block (label
) != bb
)
5044 print_generic_expr (stderr
, label
, 0);
5045 fprintf (stderr
, " to block does not match in bb %d",
5050 if (decl_function_context (label
) != current_function_decl
)
5053 print_generic_expr (stderr
, label
, 0);
5054 fprintf (stderr
, " has incorrect context in bb %d",
5060 /* Verify that body of basic block BB is free of control flow. */
5061 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5063 gimple stmt
= gsi_stmt (gsi
);
5065 if (found_ctrl_stmt
)
5067 error ("control flow in the middle of basic block %d",
5072 if (stmt_ends_bb_p (stmt
))
5073 found_ctrl_stmt
= true;
5075 if (gimple_code (stmt
) == GIMPLE_LABEL
)
5078 print_generic_expr (stderr
, gimple_label_label (stmt
), 0);
5079 fprintf (stderr
, " in the middle of basic block %d", bb
->index
);
5084 gsi
= gsi_last_bb (bb
);
5085 if (gsi_end_p (gsi
))
5088 stmt
= gsi_stmt (gsi
);
5090 if (gimple_code (stmt
) == GIMPLE_LABEL
)
5093 err
|= verify_eh_edges (stmt
);
5095 if (is_ctrl_stmt (stmt
))
5097 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5098 if (e
->flags
& EDGE_FALLTHRU
)
5100 error ("fallthru edge after a control statement in bb %d",
5106 if (gimple_code (stmt
) != GIMPLE_COND
)
5108 /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
5109 after anything else but if statement. */
5110 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5111 if (e
->flags
& (EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
))
5113 error ("true/false edge after a non-GIMPLE_COND in bb %d",
5119 switch (gimple_code (stmt
))
5126 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
5130 || !(true_edge
->flags
& EDGE_TRUE_VALUE
)
5131 || !(false_edge
->flags
& EDGE_FALSE_VALUE
)
5132 || (true_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
5133 || (false_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
5134 || EDGE_COUNT (bb
->succs
) >= 3)
5136 error ("wrong outgoing edge flags at end of bb %d",
5144 if (simple_goto_p (stmt
))
5146 error ("explicit goto at end of bb %d", bb
->index
);
5151 /* FIXME. We should double check that the labels in the
5152 destination blocks have their address taken. */
5153 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5154 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_TRUE_VALUE
5155 | EDGE_FALSE_VALUE
))
5156 || !(e
->flags
& EDGE_ABNORMAL
))
5158 error ("wrong outgoing edge flags at end of bb %d",
5166 if (!gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
))
5168 /* ... fallthru ... */
5170 if (!single_succ_p (bb
)
5171 || (single_succ_edge (bb
)->flags
5172 & (EDGE_FALLTHRU
| EDGE_ABNORMAL
5173 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5175 error ("wrong outgoing edge flags at end of bb %d", bb
->index
);
5178 if (single_succ (bb
) != EXIT_BLOCK_PTR_FOR_FN (cfun
))
5180 error ("return edge does not point to exit in bb %d",
5192 n
= gimple_switch_num_labels (stmt
);
5194 /* Mark all the destination basic blocks. */
5195 for (i
= 0; i
< n
; ++i
)
5197 tree lab
= CASE_LABEL (gimple_switch_label (stmt
, i
));
5198 basic_block label_bb
= label_to_block (lab
);
5199 gcc_assert (!label_bb
->aux
|| label_bb
->aux
== (void *)1);
5200 label_bb
->aux
= (void *)1;
5203 /* Verify that the case labels are sorted. */
5204 prev
= gimple_switch_label (stmt
, 0);
5205 for (i
= 1; i
< n
; ++i
)
5207 tree c
= gimple_switch_label (stmt
, i
);
5210 error ("found default case not at the start of "
5216 && !tree_int_cst_lt (CASE_LOW (prev
), CASE_LOW (c
)))
5218 error ("case labels not sorted: ");
5219 print_generic_expr (stderr
, prev
, 0);
5220 fprintf (stderr
," is greater than ");
5221 print_generic_expr (stderr
, c
, 0);
5222 fprintf (stderr
," but comes before it.\n");
5227 /* VRP will remove the default case if it can prove it will
5228 never be executed. So do not verify there always exists
5229 a default case here. */
5231 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5235 error ("extra outgoing edge %d->%d",
5236 bb
->index
, e
->dest
->index
);
5240 e
->dest
->aux
= (void *)2;
5241 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
5242 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5244 error ("wrong outgoing edge flags at end of bb %d",
5250 /* Check that we have all of them. */
5251 for (i
= 0; i
< n
; ++i
)
5253 tree lab
= CASE_LABEL (gimple_switch_label (stmt
, i
));
5254 basic_block label_bb
= label_to_block (lab
);
5256 if (label_bb
->aux
!= (void *)2)
5258 error ("missing edge %i->%i", bb
->index
, label_bb
->index
);
5263 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5264 e
->dest
->aux
= (void *)0;
5268 case GIMPLE_EH_DISPATCH
:
5269 err
|= verify_eh_dispatch_edge (stmt
);
5277 if (dom_info_state (CDI_DOMINATORS
) >= DOM_NO_FAST_QUERY
)
5278 verify_dominators (CDI_DOMINATORS
);
5284 /* Updates phi nodes after creating a forwarder block joined
5285 by edge FALLTHRU. */
5288 gimple_make_forwarder_block (edge fallthru
)
5292 basic_block dummy
, bb
;
5294 gimple_stmt_iterator gsi
;
5296 dummy
= fallthru
->src
;
5297 bb
= fallthru
->dest
;
5299 if (single_pred_p (bb
))
5302 /* If we redirected a branch we must create new PHI nodes at the
5304 for (gsi
= gsi_start_phis (dummy
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5306 gimple phi
, new_phi
;
5308 phi
= gsi_stmt (gsi
);
5309 var
= gimple_phi_result (phi
);
5310 new_phi
= create_phi_node (var
, bb
);
5311 gimple_phi_set_result (phi
, copy_ssa_name (var
, phi
));
5312 add_phi_arg (new_phi
, gimple_phi_result (phi
), fallthru
,
5316 /* Add the arguments we have stored on edges. */
5317 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
5322 flush_pending_stmts (e
);
5327 /* Return a non-special label in the head of basic block BLOCK.
5328 Create one if it doesn't exist. */
5331 gimple_block_label (basic_block bb
)
5333 gimple_stmt_iterator i
, s
= gsi_start_bb (bb
);
5338 for (i
= s
; !gsi_end_p (i
); first
= false, gsi_next (&i
))
5340 stmt
= gsi_stmt (i
);
5341 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5343 label
= gimple_label_label (stmt
);
5344 if (!DECL_NONLOCAL (label
))
5347 gsi_move_before (&i
, &s
);
5352 label
= create_artificial_label (UNKNOWN_LOCATION
);
5353 stmt
= gimple_build_label (label
);
5354 gsi_insert_before (&s
, stmt
, GSI_NEW_STMT
);
5359 /* Attempt to perform edge redirection by replacing a possibly complex
5360 jump instruction by a goto or by removing the jump completely.
5361 This can apply only if all edges now point to the same block. The
5362 parameters and return values are equivalent to
5363 redirect_edge_and_branch. */
5366 gimple_try_redirect_by_replacing_jump (edge e
, basic_block target
)
5368 basic_block src
= e
->src
;
5369 gimple_stmt_iterator i
;
5372 /* We can replace or remove a complex jump only when we have exactly
5374 if (EDGE_COUNT (src
->succs
) != 2
5375 /* Verify that all targets will be TARGET. Specifically, the
5376 edge that is not E must also go to TARGET. */
5377 || EDGE_SUCC (src
, EDGE_SUCC (src
, 0) == e
)->dest
!= target
)
5380 i
= gsi_last_bb (src
);
5384 stmt
= gsi_stmt (i
);
5386 if (gimple_code (stmt
) == GIMPLE_COND
|| gimple_code (stmt
) == GIMPLE_SWITCH
)
5388 gsi_remove (&i
, true);
5389 e
= ssa_redirect_edge (e
, target
);
5390 e
->flags
= EDGE_FALLTHRU
;
5398 /* Redirect E to DEST. Return NULL on failure. Otherwise, return the
5399 edge representing the redirected branch. */
5402 gimple_redirect_edge_and_branch (edge e
, basic_block dest
)
5404 basic_block bb
= e
->src
;
5405 gimple_stmt_iterator gsi
;
5409 if (e
->flags
& EDGE_ABNORMAL
)
5412 if (e
->dest
== dest
)
5415 if (e
->flags
& EDGE_EH
)
5416 return redirect_eh_edge (e
, dest
);
5418 if (e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
))
5420 ret
= gimple_try_redirect_by_replacing_jump (e
, dest
);
5425 gsi
= gsi_last_bb (bb
);
5426 stmt
= gsi_end_p (gsi
) ? NULL
: gsi_stmt (gsi
);
5428 switch (stmt
? gimple_code (stmt
) : GIMPLE_ERROR_MARK
)
5431 /* For COND_EXPR, we only need to redirect the edge. */
5435 /* No non-abnormal edges should lead from a non-simple goto, and
5436 simple ones should be represented implicitly. */
5441 tree label
= gimple_block_label (dest
);
5442 tree cases
= get_cases_for_edge (e
, stmt
);
5444 /* If we have a list of cases associated with E, then use it
5445 as it's a lot faster than walking the entire case vector. */
5448 edge e2
= find_edge (e
->src
, dest
);
5455 CASE_LABEL (cases
) = label
;
5456 cases
= CASE_CHAIN (cases
);
5459 /* If there was already an edge in the CFG, then we need
5460 to move all the cases associated with E to E2. */
5463 tree cases2
= get_cases_for_edge (e2
, stmt
);
5465 CASE_CHAIN (last
) = CASE_CHAIN (cases2
);
5466 CASE_CHAIN (cases2
) = first
;
5468 bitmap_set_bit (touched_switch_bbs
, gimple_bb (stmt
)->index
);
5472 size_t i
, n
= gimple_switch_num_labels (stmt
);
5474 for (i
= 0; i
< n
; i
++)
5476 tree elt
= gimple_switch_label (stmt
, i
);
5477 if (label_to_block (CASE_LABEL (elt
)) == e
->dest
)
5478 CASE_LABEL (elt
) = label
;
5486 int i
, n
= gimple_asm_nlabels (stmt
);
5489 for (i
= 0; i
< n
; ++i
)
5491 tree cons
= gimple_asm_label_op (stmt
, i
);
5492 if (label_to_block (TREE_VALUE (cons
)) == e
->dest
)
5495 label
= gimple_block_label (dest
);
5496 TREE_VALUE (cons
) = label
;
5500 /* If we didn't find any label matching the former edge in the
5501 asm labels, we must be redirecting the fallthrough
5503 gcc_assert (label
|| (e
->flags
& EDGE_FALLTHRU
));
5508 gsi_remove (&gsi
, true);
5509 e
->flags
|= EDGE_FALLTHRU
;
5512 case GIMPLE_OMP_RETURN
:
5513 case GIMPLE_OMP_CONTINUE
:
5514 case GIMPLE_OMP_SECTIONS_SWITCH
:
5515 case GIMPLE_OMP_FOR
:
5516 /* The edges from OMP constructs can be simply redirected. */
5519 case GIMPLE_EH_DISPATCH
:
5520 if (!(e
->flags
& EDGE_FALLTHRU
))
5521 redirect_eh_dispatch_edge (stmt
, e
, dest
);
5524 case GIMPLE_TRANSACTION
:
5525 /* The ABORT edge has a stored label associated with it, otherwise
5526 the edges are simply redirectable. */
5528 gimple_transaction_set_label (stmt
, gimple_block_label (dest
));
5532 /* Otherwise it must be a fallthru edge, and we don't need to
5533 do anything besides redirecting it. */
5534 gcc_assert (e
->flags
& EDGE_FALLTHRU
);
5538 /* Update/insert PHI nodes as necessary. */
5540 /* Now update the edges in the CFG. */
5541 e
= ssa_redirect_edge (e
, dest
);
5546 /* Returns true if it is possible to remove edge E by redirecting
5547 it to the destination of the other edge from E->src. */
5550 gimple_can_remove_branch_p (const_edge e
)
5552 if (e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
))
5558 /* Simple wrapper, as we can always redirect fallthru edges. */
5561 gimple_redirect_edge_and_branch_force (edge e
, basic_block dest
)
5563 e
= gimple_redirect_edge_and_branch (e
, dest
);
5570 /* Splits basic block BB after statement STMT (but at least after the
5571 labels). If STMT is NULL, BB is split just after the labels. */
5574 gimple_split_block (basic_block bb
, void *stmt
)
5576 gimple_stmt_iterator gsi
;
5577 gimple_stmt_iterator gsi_tgt
;
5584 new_bb
= create_empty_bb (bb
);
5586 /* Redirect the outgoing edges. */
5587 new_bb
->succs
= bb
->succs
;
5589 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
5592 if (stmt
&& gimple_code ((gimple
) stmt
) == GIMPLE_LABEL
)
5595 /* Move everything from GSI to the new basic block. */
5596 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5598 act
= gsi_stmt (gsi
);
5599 if (gimple_code (act
) == GIMPLE_LABEL
)
5612 if (gsi_end_p (gsi
))
5615 /* Split the statement list - avoid re-creating new containers as this
5616 brings ugly quadratic memory consumption in the inliner.
5617 (We are still quadratic since we need to update stmt BB pointers,
5619 gsi_split_seq_before (&gsi
, &list
);
5620 set_bb_seq (new_bb
, list
);
5621 for (gsi_tgt
= gsi_start (list
);
5622 !gsi_end_p (gsi_tgt
); gsi_next (&gsi_tgt
))
5623 gimple_set_bb (gsi_stmt (gsi_tgt
), new_bb
);
5629 /* Moves basic block BB after block AFTER. */
5632 gimple_move_block_after (basic_block bb
, basic_block after
)
5634 if (bb
->prev_bb
== after
)
5638 link_block (bb
, after
);
5644 /* Return TRUE if block BB has no executable statements, otherwise return
5648 gimple_empty_block_p (basic_block bb
)
5650 /* BB must have no executable statements. */
5651 gimple_stmt_iterator gsi
= gsi_after_labels (bb
);
5654 if (gsi_end_p (gsi
))
5656 if (is_gimple_debug (gsi_stmt (gsi
)))
5657 gsi_next_nondebug (&gsi
);
5658 return gsi_end_p (gsi
);
5662 /* Split a basic block if it ends with a conditional branch and if the
5663 other part of the block is not empty. */
5666 gimple_split_block_before_cond_jump (basic_block bb
)
5668 gimple last
, split_point
;
5669 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
5670 if (gsi_end_p (gsi
))
5672 last
= gsi_stmt (gsi
);
5673 if (gimple_code (last
) != GIMPLE_COND
5674 && gimple_code (last
) != GIMPLE_SWITCH
)
5676 gsi_prev_nondebug (&gsi
);
5677 split_point
= gsi_stmt (gsi
);
5678 return split_block (bb
, split_point
)->dest
;
5682 /* Return true if basic_block can be duplicated. */
5685 gimple_can_duplicate_bb_p (const_basic_block bb ATTRIBUTE_UNUSED
)
5690 /* Create a duplicate of the basic block BB. NOTE: This does not
5691 preserve SSA form. */
5694 gimple_duplicate_bb (basic_block bb
)
5697 gimple_stmt_iterator gsi
, gsi_tgt
;
5698 gimple_seq phis
= phi_nodes (bb
);
5699 gimple phi
, stmt
, copy
;
5701 new_bb
= create_empty_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
);
5703 /* Copy the PHI nodes. We ignore PHI node arguments here because
5704 the incoming edges have not been setup yet. */
5705 for (gsi
= gsi_start (phis
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5707 phi
= gsi_stmt (gsi
);
5708 copy
= create_phi_node (NULL_TREE
, new_bb
);
5709 create_new_def_for (gimple_phi_result (phi
), copy
,
5710 gimple_phi_result_ptr (copy
));
5711 gimple_set_uid (copy
, gimple_uid (phi
));
5714 gsi_tgt
= gsi_start_bb (new_bb
);
5715 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5717 def_operand_p def_p
;
5718 ssa_op_iter op_iter
;
5721 stmt
= gsi_stmt (gsi
);
5722 if (gimple_code (stmt
) == GIMPLE_LABEL
)
5725 /* Don't duplicate label debug stmts. */
5726 if (gimple_debug_bind_p (stmt
)
5727 && TREE_CODE (gimple_debug_bind_get_var (stmt
))
5731 /* Create a new copy of STMT and duplicate STMT's virtual
5733 copy
= gimple_copy (stmt
);
5734 gsi_insert_after (&gsi_tgt
, copy
, GSI_NEW_STMT
);
5736 maybe_duplicate_eh_stmt (copy
, stmt
);
5737 gimple_duplicate_stmt_histograms (cfun
, copy
, cfun
, stmt
);
5739 /* When copying around a stmt writing into a local non-user
5740 aggregate, make sure it won't share stack slot with other
5742 lhs
= gimple_get_lhs (stmt
);
5743 if (lhs
&& TREE_CODE (lhs
) != SSA_NAME
)
5745 tree base
= get_base_address (lhs
);
5747 && (TREE_CODE (base
) == VAR_DECL
5748 || TREE_CODE (base
) == RESULT_DECL
)
5749 && DECL_IGNORED_P (base
)
5750 && !TREE_STATIC (base
)
5751 && !DECL_EXTERNAL (base
)
5752 && (TREE_CODE (base
) != VAR_DECL
5753 || !DECL_HAS_VALUE_EXPR_P (base
)))
5754 DECL_NONSHAREABLE (base
) = 1;
5757 /* Create new names for all the definitions created by COPY and
5758 add replacement mappings for each new name. */
5759 FOR_EACH_SSA_DEF_OPERAND (def_p
, copy
, op_iter
, SSA_OP_ALL_DEFS
)
5760 create_new_def_for (DEF_FROM_PTR (def_p
), copy
, def_p
);
5766 /* Adds phi node arguments for edge E_COPY after basic block duplication. */
5769 add_phi_args_after_copy_edge (edge e_copy
)
5771 basic_block bb
, bb_copy
= e_copy
->src
, dest
;
5774 gimple phi
, phi_copy
;
5776 gimple_stmt_iterator psi
, psi_copy
;
5778 if (gimple_seq_empty_p (phi_nodes (e_copy
->dest
)))
5781 bb
= bb_copy
->flags
& BB_DUPLICATED
? get_bb_original (bb_copy
) : bb_copy
;
5783 if (e_copy
->dest
->flags
& BB_DUPLICATED
)
5784 dest
= get_bb_original (e_copy
->dest
);
5786 dest
= e_copy
->dest
;
5788 e
= find_edge (bb
, dest
);
5791 /* During loop unrolling the target of the latch edge is copied.
5792 In this case we are not looking for edge to dest, but to
5793 duplicated block whose original was dest. */
5794 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5796 if ((e
->dest
->flags
& BB_DUPLICATED
)
5797 && get_bb_original (e
->dest
) == dest
)
5801 gcc_assert (e
!= NULL
);
5804 for (psi
= gsi_start_phis (e
->dest
),
5805 psi_copy
= gsi_start_phis (e_copy
->dest
);
5807 gsi_next (&psi
), gsi_next (&psi_copy
))
5809 phi
= gsi_stmt (psi
);
5810 phi_copy
= gsi_stmt (psi_copy
);
5811 def
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
5812 add_phi_arg (phi_copy
, def
, e_copy
,
5813 gimple_phi_arg_location_from_edge (phi
, e
));
5818 /* Basic block BB_COPY was created by code duplication. Add phi node
5819 arguments for edges going out of BB_COPY. The blocks that were
5820 duplicated have BB_DUPLICATED set. */
5823 add_phi_args_after_copy_bb (basic_block bb_copy
)
5828 FOR_EACH_EDGE (e_copy
, ei
, bb_copy
->succs
)
5830 add_phi_args_after_copy_edge (e_copy
);
5834 /* Blocks in REGION_COPY array of length N_REGION were created by
5835 duplication of basic blocks. Add phi node arguments for edges
5836 going from these blocks. If E_COPY is not NULL, also add
5837 phi node arguments for its destination.*/
5840 add_phi_args_after_copy (basic_block
*region_copy
, unsigned n_region
,
5845 for (i
= 0; i
< n_region
; i
++)
5846 region_copy
[i
]->flags
|= BB_DUPLICATED
;
5848 for (i
= 0; i
< n_region
; i
++)
5849 add_phi_args_after_copy_bb (region_copy
[i
]);
5851 add_phi_args_after_copy_edge (e_copy
);
5853 for (i
= 0; i
< n_region
; i
++)
5854 region_copy
[i
]->flags
&= ~BB_DUPLICATED
;
5857 /* Duplicates a REGION (set of N_REGION basic blocks) with just a single
5858 important exit edge EXIT. By important we mean that no SSA name defined
5859 inside region is live over the other exit edges of the region. All entry
5860 edges to the region must go to ENTRY->dest. The edge ENTRY is redirected
5861 to the duplicate of the region. Dominance and loop information is
5862 updated if UPDATE_DOMINANCE is true, but not the SSA web. If
5863 UPDATE_DOMINANCE is false then we assume that the caller will update the
5864 dominance information after calling this function. The new basic
5865 blocks are stored to REGION_COPY in the same order as they had in REGION,
5866 provided that REGION_COPY is not NULL.
5867 The function returns false if it is unable to copy the region,
5871 gimple_duplicate_sese_region (edge entry
, edge exit
,
5872 basic_block
*region
, unsigned n_region
,
5873 basic_block
*region_copy
,
5874 bool update_dominance
)
5877 bool free_region_copy
= false, copying_header
= false;
5878 struct loop
*loop
= entry
->dest
->loop_father
;
5880 vec
<basic_block
> doms
;
5882 int total_freq
= 0, entry_freq
= 0;
5883 gcov_type total_count
= 0, entry_count
= 0;
5885 if (!can_copy_bbs_p (region
, n_region
))
5888 /* Some sanity checking. Note that we do not check for all possible
5889 missuses of the functions. I.e. if you ask to copy something weird,
5890 it will work, but the state of structures probably will not be
5892 for (i
= 0; i
< n_region
; i
++)
5894 /* We do not handle subloops, i.e. all the blocks must belong to the
5896 if (region
[i
]->loop_father
!= loop
)
5899 if (region
[i
] != entry
->dest
5900 && region
[i
] == loop
->header
)
5904 /* In case the function is used for loop header copying (which is the primary
5905 use), ensure that EXIT and its copy will be new latch and entry edges. */
5906 if (loop
->header
== entry
->dest
)
5908 copying_header
= true;
5910 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, exit
->src
))
5913 for (i
= 0; i
< n_region
; i
++)
5914 if (region
[i
] != exit
->src
5915 && dominated_by_p (CDI_DOMINATORS
, region
[i
], exit
->src
))
5919 initialize_original_copy_tables ();
5922 set_loop_copy (loop
, loop_outer (loop
));
5924 set_loop_copy (loop
, loop
);
5928 region_copy
= XNEWVEC (basic_block
, n_region
);
5929 free_region_copy
= true;
5932 /* Record blocks outside the region that are dominated by something
5934 if (update_dominance
)
5937 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
5940 if (entry
->dest
->count
)
5942 total_count
= entry
->dest
->count
;
5943 entry_count
= entry
->count
;
5944 /* Fix up corner cases, to avoid division by zero or creation of negative
5946 if (entry_count
> total_count
)
5947 entry_count
= total_count
;
5951 total_freq
= entry
->dest
->frequency
;
5952 entry_freq
= EDGE_FREQUENCY (entry
);
5953 /* Fix up corner cases, to avoid division by zero or creation of negative
5955 if (total_freq
== 0)
5957 else if (entry_freq
> total_freq
)
5958 entry_freq
= total_freq
;
5961 copy_bbs (region
, n_region
, region_copy
, &exit
, 1, &exit_copy
, loop
,
5962 split_edge_bb_loc (entry
), update_dominance
);
5965 scale_bbs_frequencies_gcov_type (region
, n_region
,
5966 total_count
- entry_count
,
5968 scale_bbs_frequencies_gcov_type (region_copy
, n_region
, entry_count
,
5973 scale_bbs_frequencies_int (region
, n_region
, total_freq
- entry_freq
,
5975 scale_bbs_frequencies_int (region_copy
, n_region
, entry_freq
, total_freq
);
5980 loop
->header
= exit
->dest
;
5981 loop
->latch
= exit
->src
;
5984 /* Redirect the entry and add the phi node arguments. */
5985 redirected
= redirect_edge_and_branch (entry
, get_bb_copy (entry
->dest
));
5986 gcc_assert (redirected
!= NULL
);
5987 flush_pending_stmts (entry
);
5989 /* Concerning updating of dominators: We must recount dominators
5990 for entry block and its copy. Anything that is outside of the
5991 region, but was dominated by something inside needs recounting as
5993 if (update_dominance
)
5995 set_immediate_dominator (CDI_DOMINATORS
, entry
->dest
, entry
->src
);
5996 doms
.safe_push (get_bb_original (entry
->dest
));
5997 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6001 /* Add the other PHI node arguments. */
6002 add_phi_args_after_copy (region_copy
, n_region
, NULL
);
6004 if (free_region_copy
)
6007 free_original_copy_tables ();
6011 /* Checks if BB is part of the region defined by N_REGION BBS. */
6013 bb_part_of_region_p (basic_block bb
, basic_block
* bbs
, unsigned n_region
)
6017 for (n
= 0; n
< n_region
; n
++)
6025 /* Duplicates REGION consisting of N_REGION blocks. The new blocks
6026 are stored to REGION_COPY in the same order in that they appear
6027 in REGION, if REGION_COPY is not NULL. ENTRY is the entry to
6028 the region, EXIT an exit from it. The condition guarding EXIT
6029 is moved to ENTRY. Returns true if duplication succeeds, false
6055 gimple_duplicate_sese_tail (edge entry ATTRIBUTE_UNUSED
, edge exit ATTRIBUTE_UNUSED
,
6056 basic_block
*region ATTRIBUTE_UNUSED
, unsigned n_region ATTRIBUTE_UNUSED
,
6057 basic_block
*region_copy ATTRIBUTE_UNUSED
)
6060 bool free_region_copy
= false;
6061 struct loop
*loop
= exit
->dest
->loop_father
;
6062 struct loop
*orig_loop
= entry
->dest
->loop_father
;
6063 basic_block switch_bb
, entry_bb
, nentry_bb
;
6064 vec
<basic_block
> doms
;
6065 int total_freq
= 0, exit_freq
= 0;
6066 gcov_type total_count
= 0, exit_count
= 0;
6067 edge exits
[2], nexits
[2], e
;
6068 gimple_stmt_iterator gsi
;
6071 basic_block exit_bb
;
6072 gimple_stmt_iterator psi
;
6075 struct loop
*target
, *aloop
, *cloop
;
6077 gcc_assert (EDGE_COUNT (exit
->src
->succs
) == 2);
6079 exits
[1] = EDGE_SUCC (exit
->src
, EDGE_SUCC (exit
->src
, 0) == exit
);
6081 if (!can_copy_bbs_p (region
, n_region
))
6084 initialize_original_copy_tables ();
6085 set_loop_copy (orig_loop
, loop
);
6088 for (aloop
= orig_loop
->inner
; aloop
; aloop
= aloop
->next
)
6090 if (bb_part_of_region_p (aloop
->header
, region
, n_region
))
6092 cloop
= duplicate_loop (aloop
, target
);
6093 duplicate_subloops (aloop
, cloop
);
6099 region_copy
= XNEWVEC (basic_block
, n_region
);
6100 free_region_copy
= true;
6103 gcc_assert (!need_ssa_update_p (cfun
));
6105 /* Record blocks outside the region that are dominated by something
6107 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
6109 if (exit
->src
->count
)
6111 total_count
= exit
->src
->count
;
6112 exit_count
= exit
->count
;
6113 /* Fix up corner cases, to avoid division by zero or creation of negative
6115 if (exit_count
> total_count
)
6116 exit_count
= total_count
;
6120 total_freq
= exit
->src
->frequency
;
6121 exit_freq
= EDGE_FREQUENCY (exit
);
6122 /* Fix up corner cases, to avoid division by zero or creation of negative
6124 if (total_freq
== 0)
6126 if (exit_freq
> total_freq
)
6127 exit_freq
= total_freq
;
6130 copy_bbs (region
, n_region
, region_copy
, exits
, 2, nexits
, orig_loop
,
6131 split_edge_bb_loc (exit
), true);
6134 scale_bbs_frequencies_gcov_type (region
, n_region
,
6135 total_count
- exit_count
,
6137 scale_bbs_frequencies_gcov_type (region_copy
, n_region
, exit_count
,
6142 scale_bbs_frequencies_int (region
, n_region
, total_freq
- exit_freq
,
6144 scale_bbs_frequencies_int (region_copy
, n_region
, exit_freq
, total_freq
);
6147 /* Create the switch block, and put the exit condition to it. */
6148 entry_bb
= entry
->dest
;
6149 nentry_bb
= get_bb_copy (entry_bb
);
6150 if (!last_stmt (entry
->src
)
6151 || !stmt_ends_bb_p (last_stmt (entry
->src
)))
6152 switch_bb
= entry
->src
;
6154 switch_bb
= split_edge (entry
);
6155 set_immediate_dominator (CDI_DOMINATORS
, nentry_bb
, switch_bb
);
6157 gsi
= gsi_last_bb (switch_bb
);
6158 cond_stmt
= last_stmt (exit
->src
);
6159 gcc_assert (gimple_code (cond_stmt
) == GIMPLE_COND
);
6160 cond_stmt
= gimple_copy (cond_stmt
);
6162 gsi_insert_after (&gsi
, cond_stmt
, GSI_NEW_STMT
);
6164 sorig
= single_succ_edge (switch_bb
);
6165 sorig
->flags
= exits
[1]->flags
;
6166 snew
= make_edge (switch_bb
, nentry_bb
, exits
[0]->flags
);
6168 /* Register the new edge from SWITCH_BB in loop exit lists. */
6169 rescan_loop_exit (snew
, true, false);
6171 /* Add the PHI node arguments. */
6172 add_phi_args_after_copy (region_copy
, n_region
, snew
);
6174 /* Get rid of now superfluous conditions and associated edges (and phi node
6176 exit_bb
= exit
->dest
;
6178 e
= redirect_edge_and_branch (exits
[0], exits
[1]->dest
);
6179 PENDING_STMT (e
) = NULL
;
6181 /* The latch of ORIG_LOOP was copied, and so was the backedge
6182 to the original header. We redirect this backedge to EXIT_BB. */
6183 for (i
= 0; i
< n_region
; i
++)
6184 if (get_bb_original (region_copy
[i
]) == orig_loop
->latch
)
6186 gcc_assert (single_succ_edge (region_copy
[i
]));
6187 e
= redirect_edge_and_branch (single_succ_edge (region_copy
[i
]), exit_bb
);
6188 PENDING_STMT (e
) = NULL
;
6189 for (psi
= gsi_start_phis (exit_bb
);
6193 phi
= gsi_stmt (psi
);
6194 def
= PHI_ARG_DEF (phi
, nexits
[0]->dest_idx
);
6195 add_phi_arg (phi
, def
, e
, gimple_phi_arg_location_from_edge (phi
, e
));
6198 e
= redirect_edge_and_branch (nexits
[1], nexits
[0]->dest
);
6199 PENDING_STMT (e
) = NULL
;
6201 /* Anything that is outside of the region, but was dominated by something
6202 inside needs to update dominance info. */
6203 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6205 /* Update the SSA web. */
6206 update_ssa (TODO_update_ssa
);
6208 if (free_region_copy
)
6211 free_original_copy_tables ();
6215 /* Add all the blocks dominated by ENTRY to the array BBS_P. Stop
6216 adding blocks when the dominator traversal reaches EXIT. This
6217 function silently assumes that ENTRY strictly dominates EXIT. */
6220 gather_blocks_in_sese_region (basic_block entry
, basic_block exit
,
6221 vec
<basic_block
> *bbs_p
)
6225 for (son
= first_dom_son (CDI_DOMINATORS
, entry
);
6227 son
= next_dom_son (CDI_DOMINATORS
, son
))
6229 bbs_p
->safe_push (son
);
6231 gather_blocks_in_sese_region (son
, exit
, bbs_p
);
6235 /* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
6236 The duplicates are recorded in VARS_MAP. */
6239 replace_by_duplicate_decl (tree
*tp
, struct pointer_map_t
*vars_map
,
6242 tree t
= *tp
, new_t
;
6243 struct function
*f
= DECL_STRUCT_FUNCTION (to_context
);
6246 if (DECL_CONTEXT (t
) == to_context
)
6249 loc
= pointer_map_contains (vars_map
, t
);
6253 loc
= pointer_map_insert (vars_map
, t
);
6257 new_t
= copy_var_decl (t
, DECL_NAME (t
), TREE_TYPE (t
));
6258 add_local_decl (f
, new_t
);
6262 gcc_assert (TREE_CODE (t
) == CONST_DECL
);
6263 new_t
= copy_node (t
);
6265 DECL_CONTEXT (new_t
) = to_context
;
6270 new_t
= (tree
) *loc
;
6276 /* Creates an ssa name in TO_CONTEXT equivalent to NAME.
6277 VARS_MAP maps old ssa names and var_decls to the new ones. */
6280 replace_ssa_name (tree name
, struct pointer_map_t
*vars_map
,
6286 gcc_assert (!virtual_operand_p (name
));
6288 loc
= pointer_map_contains (vars_map
, name
);
6292 tree decl
= SSA_NAME_VAR (name
);
6295 replace_by_duplicate_decl (&decl
, vars_map
, to_context
);
6296 new_name
= make_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6297 decl
, SSA_NAME_DEF_STMT (name
));
6298 if (SSA_NAME_IS_DEFAULT_DEF (name
))
6299 set_ssa_default_def (DECL_STRUCT_FUNCTION (to_context
),
6303 new_name
= copy_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6304 name
, SSA_NAME_DEF_STMT (name
));
6306 loc
= pointer_map_insert (vars_map
, name
);
6310 new_name
= (tree
) *loc
;
6321 struct pointer_map_t
*vars_map
;
6322 htab_t new_label_map
;
6323 struct pointer_map_t
*eh_map
;
6327 /* Helper for move_block_to_fn. Set TREE_BLOCK in every expression
6328 contained in *TP if it has been ORIG_BLOCK previously and change the
6329 DECL_CONTEXT of every local variable referenced in *TP. */
6332 move_stmt_op (tree
*tp
, int *walk_subtrees
, void *data
)
6334 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
6335 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6340 tree block
= TREE_BLOCK (t
);
6341 if (block
== p
->orig_block
6342 || (p
->orig_block
== NULL_TREE
6343 && block
!= NULL_TREE
))
6344 TREE_SET_BLOCK (t
, p
->new_block
);
6345 #ifdef ENABLE_CHECKING
6346 else if (block
!= NULL_TREE
)
6348 while (block
&& TREE_CODE (block
) == BLOCK
&& block
!= p
->orig_block
)
6349 block
= BLOCK_SUPERCONTEXT (block
);
6350 gcc_assert (block
== p
->orig_block
);
6354 else if (DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
)
6356 if (TREE_CODE (t
) == SSA_NAME
)
6357 *tp
= replace_ssa_name (t
, p
->vars_map
, p
->to_context
);
6358 else if (TREE_CODE (t
) == LABEL_DECL
)
6360 if (p
->new_label_map
)
6362 struct tree_map in
, *out
;
6364 out
= (struct tree_map
*)
6365 htab_find_with_hash (p
->new_label_map
, &in
, DECL_UID (t
));
6370 DECL_CONTEXT (t
) = p
->to_context
;
6372 else if (p
->remap_decls_p
)
6374 /* Replace T with its duplicate. T should no longer appear in the
6375 parent function, so this looks wasteful; however, it may appear
6376 in referenced_vars, and more importantly, as virtual operands of
6377 statements, and in alias lists of other variables. It would be
6378 quite difficult to expunge it from all those places. ??? It might
6379 suffice to do this for addressable variables. */
6380 if ((TREE_CODE (t
) == VAR_DECL
6381 && !is_global_var (t
))
6382 || TREE_CODE (t
) == CONST_DECL
)
6383 replace_by_duplicate_decl (tp
, p
->vars_map
, p
->to_context
);
6387 else if (TYPE_P (t
))
6393 /* Helper for move_stmt_r. Given an EH region number for the source
6394 function, map that to the duplicate EH regio number in the dest. */
6397 move_stmt_eh_region_nr (int old_nr
, struct move_stmt_d
*p
)
6399 eh_region old_r
, new_r
;
6402 old_r
= get_eh_region_from_number (old_nr
);
6403 slot
= pointer_map_contains (p
->eh_map
, old_r
);
6404 new_r
= (eh_region
) *slot
;
6406 return new_r
->index
;
6409 /* Similar, but operate on INTEGER_CSTs. */
6412 move_stmt_eh_region_tree_nr (tree old_t_nr
, struct move_stmt_d
*p
)
6416 old_nr
= tree_to_shwi (old_t_nr
);
6417 new_nr
= move_stmt_eh_region_nr (old_nr
, p
);
6419 return build_int_cst (integer_type_node
, new_nr
);
6422 /* Like move_stmt_op, but for gimple statements.
6424 Helper for move_block_to_fn. Set GIMPLE_BLOCK in every expression
6425 contained in the current statement in *GSI_P and change the
6426 DECL_CONTEXT of every local variable referenced in the current
6430 move_stmt_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
6431 struct walk_stmt_info
*wi
)
6433 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6434 gimple stmt
= gsi_stmt (*gsi_p
);
6435 tree block
= gimple_block (stmt
);
6437 if (block
== p
->orig_block
6438 || (p
->orig_block
== NULL_TREE
6439 && block
!= NULL_TREE
))
6440 gimple_set_block (stmt
, p
->new_block
);
6442 switch (gimple_code (stmt
))
6445 /* Remap the region numbers for __builtin_eh_{pointer,filter}. */
6447 tree r
, fndecl
= gimple_call_fndecl (stmt
);
6448 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
6449 switch (DECL_FUNCTION_CODE (fndecl
))
6451 case BUILT_IN_EH_COPY_VALUES
:
6452 r
= gimple_call_arg (stmt
, 1);
6453 r
= move_stmt_eh_region_tree_nr (r
, p
);
6454 gimple_call_set_arg (stmt
, 1, r
);
6457 case BUILT_IN_EH_POINTER
:
6458 case BUILT_IN_EH_FILTER
:
6459 r
= gimple_call_arg (stmt
, 0);
6460 r
= move_stmt_eh_region_tree_nr (r
, p
);
6461 gimple_call_set_arg (stmt
, 0, r
);
6472 int r
= gimple_resx_region (stmt
);
6473 r
= move_stmt_eh_region_nr (r
, p
);
6474 gimple_resx_set_region (stmt
, r
);
6478 case GIMPLE_EH_DISPATCH
:
6480 int r
= gimple_eh_dispatch_region (stmt
);
6481 r
= move_stmt_eh_region_nr (r
, p
);
6482 gimple_eh_dispatch_set_region (stmt
, r
);
6486 case GIMPLE_OMP_RETURN
:
6487 case GIMPLE_OMP_CONTINUE
:
6490 if (is_gimple_omp (stmt
))
6492 /* Do not remap variables inside OMP directives. Variables
6493 referenced in clauses and directive header belong to the
6494 parent function and should not be moved into the child
6496 bool save_remap_decls_p
= p
->remap_decls_p
;
6497 p
->remap_decls_p
= false;
6498 *handled_ops_p
= true;
6500 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt
), move_stmt_r
,
6503 p
->remap_decls_p
= save_remap_decls_p
;
6511 /* Move basic block BB from function CFUN to function DEST_FN. The
6512 block is moved out of the original linked list and placed after
6513 block AFTER in the new list. Also, the block is removed from the
6514 original array of blocks and placed in DEST_FN's array of blocks.
6515 If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
6516 updated to reflect the moved edges.
6518 The local variables are remapped to new instances, VARS_MAP is used
6519 to record the mapping. */
6522 move_block_to_fn (struct function
*dest_cfun
, basic_block bb
,
6523 basic_block after
, bool update_edge_count_p
,
6524 struct move_stmt_d
*d
)
6526 struct control_flow_graph
*cfg
;
6529 gimple_stmt_iterator si
;
6530 unsigned old_len
, new_len
;
6532 /* Remove BB from dominance structures. */
6533 delete_from_dominance_info (CDI_DOMINATORS
, bb
);
6535 /* Move BB from its current loop to the copy in the new function. */
6538 struct loop
*new_loop
= (struct loop
*)bb
->loop_father
->aux
;
6540 bb
->loop_father
= new_loop
;
6543 /* Link BB to the new linked list. */
6544 move_block_after (bb
, after
);
6546 /* Update the edge count in the corresponding flowgraphs. */
6547 if (update_edge_count_p
)
6548 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6550 cfun
->cfg
->x_n_edges
--;
6551 dest_cfun
->cfg
->x_n_edges
++;
6554 /* Remove BB from the original basic block array. */
6555 (*cfun
->cfg
->x_basic_block_info
)[bb
->index
] = NULL
;
6556 cfun
->cfg
->x_n_basic_blocks
--;
6558 /* Grow DEST_CFUN's basic block array if needed. */
6559 cfg
= dest_cfun
->cfg
;
6560 cfg
->x_n_basic_blocks
++;
6561 if (bb
->index
>= cfg
->x_last_basic_block
)
6562 cfg
->x_last_basic_block
= bb
->index
+ 1;
6564 old_len
= vec_safe_length (cfg
->x_basic_block_info
);
6565 if ((unsigned) cfg
->x_last_basic_block
>= old_len
)
6567 new_len
= cfg
->x_last_basic_block
+ (cfg
->x_last_basic_block
+ 3) / 4;
6568 vec_safe_grow_cleared (cfg
->x_basic_block_info
, new_len
);
6571 (*cfg
->x_basic_block_info
)[bb
->index
] = bb
;
6573 /* Remap the variables in phi nodes. */
6574 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); )
6576 gimple phi
= gsi_stmt (si
);
6578 tree op
= PHI_RESULT (phi
);
6582 if (virtual_operand_p (op
))
6584 /* Remove the phi nodes for virtual operands (alias analysis will be
6585 run for the new function, anyway). */
6586 remove_phi_node (&si
, true);
6590 SET_PHI_RESULT (phi
,
6591 replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
6592 FOR_EACH_PHI_ARG (use
, phi
, oi
, SSA_OP_USE
)
6594 op
= USE_FROM_PTR (use
);
6595 if (TREE_CODE (op
) == SSA_NAME
)
6596 SET_USE (use
, replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
6599 for (i
= 0; i
< EDGE_COUNT (bb
->preds
); i
++)
6601 location_t locus
= gimple_phi_arg_location (phi
, i
);
6602 tree block
= LOCATION_BLOCK (locus
);
6604 if (locus
== UNKNOWN_LOCATION
)
6606 if (d
->orig_block
== NULL_TREE
|| block
== d
->orig_block
)
6608 if (d
->new_block
== NULL_TREE
)
6609 locus
= LOCATION_LOCUS (locus
);
6611 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, d
->new_block
);
6612 gimple_phi_arg_set_location (phi
, i
, locus
);
6619 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6621 gimple stmt
= gsi_stmt (si
);
6622 struct walk_stmt_info wi
;
6624 memset (&wi
, 0, sizeof (wi
));
6626 walk_gimple_stmt (&si
, move_stmt_r
, move_stmt_op
, &wi
);
6628 if (gimple_code (stmt
) == GIMPLE_LABEL
)
6630 tree label
= gimple_label_label (stmt
);
6631 int uid
= LABEL_DECL_UID (label
);
6633 gcc_assert (uid
> -1);
6635 old_len
= vec_safe_length (cfg
->x_label_to_block_map
);
6636 if (old_len
<= (unsigned) uid
)
6638 new_len
= 3 * uid
/ 2 + 1;
6639 vec_safe_grow_cleared (cfg
->x_label_to_block_map
, new_len
);
6642 (*cfg
->x_label_to_block_map
)[uid
] = bb
;
6643 (*cfun
->cfg
->x_label_to_block_map
)[uid
] = NULL
;
6645 gcc_assert (DECL_CONTEXT (label
) == dest_cfun
->decl
);
6647 if (uid
>= dest_cfun
->cfg
->last_label_uid
)
6648 dest_cfun
->cfg
->last_label_uid
= uid
+ 1;
6651 maybe_duplicate_eh_stmt_fn (dest_cfun
, stmt
, cfun
, stmt
, d
->eh_map
, 0);
6652 remove_stmt_from_eh_lp_fn (cfun
, stmt
);
6654 gimple_duplicate_stmt_histograms (dest_cfun
, stmt
, cfun
, stmt
);
6655 gimple_remove_stmt_histograms (cfun
, stmt
);
6657 /* We cannot leave any operands allocated from the operand caches of
6658 the current function. */
6659 free_stmt_operands (cfun
, stmt
);
6660 push_cfun (dest_cfun
);
6665 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6666 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
6668 tree block
= LOCATION_BLOCK (e
->goto_locus
);
6669 if (d
->orig_block
== NULL_TREE
6670 || block
== d
->orig_block
)
6671 e
->goto_locus
= d
->new_block
?
6672 COMBINE_LOCATION_DATA (line_table
, e
->goto_locus
, d
->new_block
) :
6673 LOCATION_LOCUS (e
->goto_locus
);
6677 /* Examine the statements in BB (which is in SRC_CFUN); find and return
6678 the outermost EH region. Use REGION as the incoming base EH region. */
6681 find_outermost_region_in_block (struct function
*src_cfun
,
6682 basic_block bb
, eh_region region
)
6684 gimple_stmt_iterator si
;
6686 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6688 gimple stmt
= gsi_stmt (si
);
6689 eh_region stmt_region
;
6692 lp_nr
= lookup_stmt_eh_lp_fn (src_cfun
, stmt
);
6693 stmt_region
= get_eh_region_from_lp_number_fn (src_cfun
, lp_nr
);
6697 region
= stmt_region
;
6698 else if (stmt_region
!= region
)
6700 region
= eh_region_outermost (src_cfun
, stmt_region
, region
);
6701 gcc_assert (region
!= NULL
);
6710 new_label_mapper (tree decl
, void *data
)
6712 htab_t hash
= (htab_t
) data
;
6716 gcc_assert (TREE_CODE (decl
) == LABEL_DECL
);
6718 m
= XNEW (struct tree_map
);
6719 m
->hash
= DECL_UID (decl
);
6720 m
->base
.from
= decl
;
6721 m
->to
= create_artificial_label (UNKNOWN_LOCATION
);
6722 LABEL_DECL_UID (m
->to
) = LABEL_DECL_UID (decl
);
6723 if (LABEL_DECL_UID (m
->to
) >= cfun
->cfg
->last_label_uid
)
6724 cfun
->cfg
->last_label_uid
= LABEL_DECL_UID (m
->to
) + 1;
6726 slot
= htab_find_slot_with_hash (hash
, m
, m
->hash
, INSERT
);
6727 gcc_assert (*slot
== NULL
);
6734 /* Change DECL_CONTEXT of all BLOCK_VARS in block, including
6738 replace_block_vars_by_duplicates (tree block
, struct pointer_map_t
*vars_map
,
6743 for (tp
= &BLOCK_VARS (block
); *tp
; tp
= &DECL_CHAIN (*tp
))
6746 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != CONST_DECL
)
6748 replace_by_duplicate_decl (&t
, vars_map
, to_context
);
6751 if (TREE_CODE (*tp
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (*tp
))
6753 SET_DECL_VALUE_EXPR (t
, DECL_VALUE_EXPR (*tp
));
6754 DECL_HAS_VALUE_EXPR_P (t
) = 1;
6756 DECL_CHAIN (t
) = DECL_CHAIN (*tp
);
6761 for (block
= BLOCK_SUBBLOCKS (block
); block
; block
= BLOCK_CHAIN (block
))
6762 replace_block_vars_by_duplicates (block
, vars_map
, to_context
);
6765 /* Fixup the loop arrays and numbers after moving LOOP and its subloops
6769 fixup_loop_arrays_after_move (struct function
*fn1
, struct function
*fn2
,
6772 /* Discard it from the old loop array. */
6773 (*get_loops (fn1
))[loop
->num
] = NULL
;
6775 /* Place it in the new loop array, assigning it a new number. */
6776 loop
->num
= number_of_loops (fn2
);
6777 vec_safe_push (loops_for_fn (fn2
)->larray
, loop
);
6779 /* Recurse to children. */
6780 for (loop
= loop
->inner
; loop
; loop
= loop
->next
)
6781 fixup_loop_arrays_after_move (fn1
, fn2
, loop
);
6784 /* Move a single-entry, single-exit region delimited by ENTRY_BB and
6785 EXIT_BB to function DEST_CFUN. The whole region is replaced by a
6786 single basic block in the original CFG and the new basic block is
6787 returned. DEST_CFUN must not have a CFG yet.
6789 Note that the region need not be a pure SESE region. Blocks inside
6790 the region may contain calls to abort/exit. The only restriction
6791 is that ENTRY_BB should be the only entry point and it must
6794 Change TREE_BLOCK of all statements in ORIG_BLOCK to the new
6795 functions outermost BLOCK, move all subblocks of ORIG_BLOCK
6796 to the new function.
6798 All local variables referenced in the region are assumed to be in
6799 the corresponding BLOCK_VARS and unexpanded variable lists
6800 associated with DEST_CFUN. */
6803 move_sese_region_to_fn (struct function
*dest_cfun
, basic_block entry_bb
,
6804 basic_block exit_bb
, tree orig_block
)
6806 vec
<basic_block
> bbs
, dom_bbs
;
6807 basic_block dom_entry
= get_immediate_dominator (CDI_DOMINATORS
, entry_bb
);
6808 basic_block after
, bb
, *entry_pred
, *exit_succ
, abb
;
6809 struct function
*saved_cfun
= cfun
;
6810 int *entry_flag
, *exit_flag
;
6811 unsigned *entry_prob
, *exit_prob
;
6812 unsigned i
, num_entry_edges
, num_exit_edges
, num_nodes
;
6815 htab_t new_label_map
;
6816 struct pointer_map_t
*vars_map
, *eh_map
;
6817 struct loop
*loop
= entry_bb
->loop_father
;
6818 struct loop
*loop0
= get_loop (saved_cfun
, 0);
6819 struct move_stmt_d d
;
6821 /* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
6823 gcc_assert (entry_bb
!= exit_bb
6825 || dominated_by_p (CDI_DOMINATORS
, exit_bb
, entry_bb
)));
6827 /* Collect all the blocks in the region. Manually add ENTRY_BB
6828 because it won't be added by dfs_enumerate_from. */
6830 bbs
.safe_push (entry_bb
);
6831 gather_blocks_in_sese_region (entry_bb
, exit_bb
, &bbs
);
6833 /* The blocks that used to be dominated by something in BBS will now be
6834 dominated by the new block. */
6835 dom_bbs
= get_dominated_by_region (CDI_DOMINATORS
,
6839 /* Detach ENTRY_BB and EXIT_BB from CFUN->CFG. We need to remember
6840 the predecessor edges to ENTRY_BB and the successor edges to
6841 EXIT_BB so that we can re-attach them to the new basic block that
6842 will replace the region. */
6843 num_entry_edges
= EDGE_COUNT (entry_bb
->preds
);
6844 entry_pred
= XNEWVEC (basic_block
, num_entry_edges
);
6845 entry_flag
= XNEWVEC (int, num_entry_edges
);
6846 entry_prob
= XNEWVEC (unsigned, num_entry_edges
);
6848 for (ei
= ei_start (entry_bb
->preds
); (e
= ei_safe_edge (ei
)) != NULL
;)
6850 entry_prob
[i
] = e
->probability
;
6851 entry_flag
[i
] = e
->flags
;
6852 entry_pred
[i
++] = e
->src
;
6858 num_exit_edges
= EDGE_COUNT (exit_bb
->succs
);
6859 exit_succ
= XNEWVEC (basic_block
, num_exit_edges
);
6860 exit_flag
= XNEWVEC (int, num_exit_edges
);
6861 exit_prob
= XNEWVEC (unsigned, num_exit_edges
);
6863 for (ei
= ei_start (exit_bb
->succs
); (e
= ei_safe_edge (ei
)) != NULL
;)
6865 exit_prob
[i
] = e
->probability
;
6866 exit_flag
[i
] = e
->flags
;
6867 exit_succ
[i
++] = e
->dest
;
6879 /* Switch context to the child function to initialize DEST_FN's CFG. */
6880 gcc_assert (dest_cfun
->cfg
== NULL
);
6881 push_cfun (dest_cfun
);
6883 init_empty_tree_cfg ();
6885 /* Initialize EH information for the new function. */
6887 new_label_map
= NULL
;
6890 eh_region region
= NULL
;
6892 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6893 region
= find_outermost_region_in_block (saved_cfun
, bb
, region
);
6895 init_eh_for_function ();
6898 new_label_map
= htab_create (17, tree_map_hash
, tree_map_eq
, free
);
6899 eh_map
= duplicate_eh_regions (saved_cfun
, region
, 0,
6900 new_label_mapper
, new_label_map
);
6904 /* Initialize an empty loop tree. */
6905 struct loops
*loops
= ggc_cleared_alloc
<struct loops
> ();
6906 init_loops_structure (dest_cfun
, loops
, 1);
6907 loops
->state
= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
6908 set_loops_for_fn (dest_cfun
, loops
);
6910 /* Move the outlined loop tree part. */
6911 num_nodes
= bbs
.length ();
6912 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6914 if (bb
->loop_father
->header
== bb
)
6916 struct loop
*this_loop
= bb
->loop_father
;
6917 struct loop
*outer
= loop_outer (this_loop
);
6919 /* If the SESE region contains some bbs ending with
6920 a noreturn call, those are considered to belong
6921 to the outermost loop in saved_cfun, rather than
6922 the entry_bb's loop_father. */
6926 num_nodes
-= this_loop
->num_nodes
;
6927 flow_loop_tree_node_remove (bb
->loop_father
);
6928 flow_loop_tree_node_add (get_loop (dest_cfun
, 0), this_loop
);
6929 fixup_loop_arrays_after_move (saved_cfun
, cfun
, this_loop
);
6932 else if (bb
->loop_father
== loop0
&& loop0
!= loop
)
6935 /* Remove loop exits from the outlined region. */
6936 if (loops_for_fn (saved_cfun
)->exits
)
6937 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6939 void **slot
= htab_find_slot_with_hash
6940 (loops_for_fn (saved_cfun
)->exits
, e
,
6941 htab_hash_pointer (e
), NO_INSERT
);
6943 htab_clear_slot (loops_for_fn (saved_cfun
)->exits
, slot
);
6948 /* Adjust the number of blocks in the tree root of the outlined part. */
6949 get_loop (dest_cfun
, 0)->num_nodes
= bbs
.length () + 2;
6951 /* Setup a mapping to be used by move_block_to_fn. */
6952 loop
->aux
= current_loops
->tree_root
;
6953 loop0
->aux
= current_loops
->tree_root
;
6957 /* Move blocks from BBS into DEST_CFUN. */
6958 gcc_assert (bbs
.length () >= 2);
6959 after
= dest_cfun
->cfg
->x_entry_block_ptr
;
6960 vars_map
= pointer_map_create ();
6962 memset (&d
, 0, sizeof (d
));
6963 d
.orig_block
= orig_block
;
6964 d
.new_block
= DECL_INITIAL (dest_cfun
->decl
);
6965 d
.from_context
= cfun
->decl
;
6966 d
.to_context
= dest_cfun
->decl
;
6967 d
.vars_map
= vars_map
;
6968 d
.new_label_map
= new_label_map
;
6970 d
.remap_decls_p
= true;
6972 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6974 /* No need to update edge counts on the last block. It has
6975 already been updated earlier when we detached the region from
6976 the original CFG. */
6977 move_block_to_fn (dest_cfun
, bb
, after
, bb
!= exit_bb
, &d
);
6983 /* Loop sizes are no longer correct, fix them up. */
6984 loop
->num_nodes
-= num_nodes
;
6985 for (struct loop
*outer
= loop_outer (loop
);
6986 outer
; outer
= loop_outer (outer
))
6987 outer
->num_nodes
-= num_nodes
;
6988 loop0
->num_nodes
-= bbs
.length () - num_nodes
;
6990 if (saved_cfun
->has_simduid_loops
|| saved_cfun
->has_force_vectorize_loops
)
6993 for (i
= 0; vec_safe_iterate (loops
->larray
, i
, &aloop
); i
++)
6998 replace_by_duplicate_decl (&aloop
->simduid
, d
.vars_map
,
7000 dest_cfun
->has_simduid_loops
= true;
7002 if (aloop
->force_vectorize
)
7003 dest_cfun
->has_force_vectorize_loops
= true;
7007 /* Rewire BLOCK_SUBBLOCKS of orig_block. */
7011 gcc_assert (BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
7013 BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
7014 = BLOCK_SUBBLOCKS (orig_block
);
7015 for (block
= BLOCK_SUBBLOCKS (orig_block
);
7016 block
; block
= BLOCK_CHAIN (block
))
7017 BLOCK_SUPERCONTEXT (block
) = DECL_INITIAL (dest_cfun
->decl
);
7018 BLOCK_SUBBLOCKS (orig_block
) = NULL_TREE
;
7021 replace_block_vars_by_duplicates (DECL_INITIAL (dest_cfun
->decl
),
7022 vars_map
, dest_cfun
->decl
);
7025 htab_delete (new_label_map
);
7027 pointer_map_destroy (eh_map
);
7028 pointer_map_destroy (vars_map
);
7030 /* Rewire the entry and exit blocks. The successor to the entry
7031 block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
7032 the child function. Similarly, the predecessor of DEST_FN's
7033 EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR. We
7034 need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
7035 various CFG manipulation function get to the right CFG.
7037 FIXME, this is silly. The CFG ought to become a parameter to
7039 push_cfun (dest_cfun
);
7040 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
), entry_bb
, EDGE_FALLTHRU
);
7042 make_edge (exit_bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
7045 /* Back in the original function, the SESE region has disappeared,
7046 create a new basic block in its place. */
7047 bb
= create_empty_bb (entry_pred
[0]);
7049 add_bb_to_loop (bb
, loop
);
7050 for (i
= 0; i
< num_entry_edges
; i
++)
7052 e
= make_edge (entry_pred
[i
], bb
, entry_flag
[i
]);
7053 e
->probability
= entry_prob
[i
];
7056 for (i
= 0; i
< num_exit_edges
; i
++)
7058 e
= make_edge (bb
, exit_succ
[i
], exit_flag
[i
]);
7059 e
->probability
= exit_prob
[i
];
7062 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom_entry
);
7063 FOR_EACH_VEC_ELT (dom_bbs
, i
, abb
)
7064 set_immediate_dominator (CDI_DOMINATORS
, abb
, bb
);
7082 /* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in dumpfile.h)
7086 dump_function_to_file (tree fndecl
, FILE *file
, int flags
)
7088 tree arg
, var
, old_current_fndecl
= current_function_decl
;
7089 struct function
*dsf
;
7090 bool ignore_topmost_bind
= false, any_var
= false;
7093 bool tmclone
= (TREE_CODE (fndecl
) == FUNCTION_DECL
7094 && decl_is_tm_clone (fndecl
));
7095 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
7097 current_function_decl
= fndecl
;
7098 fprintf (file
, "%s %s(", function_name (fun
), tmclone
? "[tm-clone] " : "");
7100 arg
= DECL_ARGUMENTS (fndecl
);
7103 print_generic_expr (file
, TREE_TYPE (arg
), dump_flags
);
7104 fprintf (file
, " ");
7105 print_generic_expr (file
, arg
, dump_flags
);
7106 if (flags
& TDF_VERBOSE
)
7107 print_node (file
, "", arg
, 4);
7108 if (DECL_CHAIN (arg
))
7109 fprintf (file
, ", ");
7110 arg
= DECL_CHAIN (arg
);
7112 fprintf (file
, ")\n");
7114 if (flags
& TDF_VERBOSE
)
7115 print_node (file
, "", fndecl
, 2);
7117 dsf
= DECL_STRUCT_FUNCTION (fndecl
);
7118 if (dsf
&& (flags
& TDF_EH
))
7119 dump_eh_tree (file
, dsf
);
7121 if (flags
& TDF_RAW
&& !gimple_has_body_p (fndecl
))
7123 dump_node (fndecl
, TDF_SLIM
| flags
, file
);
7124 current_function_decl
= old_current_fndecl
;
7128 /* When GIMPLE is lowered, the variables are no longer available in
7129 BIND_EXPRs, so display them separately. */
7130 if (fun
&& fun
->decl
== fndecl
&& (fun
->curr_properties
& PROP_gimple_lcf
))
7133 ignore_topmost_bind
= true;
7135 fprintf (file
, "{\n");
7136 if (!vec_safe_is_empty (fun
->local_decls
))
7137 FOR_EACH_LOCAL_DECL (fun
, ix
, var
)
7139 print_generic_decl (file
, var
, flags
);
7140 if (flags
& TDF_VERBOSE
)
7141 print_node (file
, "", var
, 4);
7142 fprintf (file
, "\n");
7146 if (gimple_in_ssa_p (cfun
))
7147 for (ix
= 1; ix
< num_ssa_names
; ++ix
)
7149 tree name
= ssa_name (ix
);
7150 if (name
&& !SSA_NAME_VAR (name
))
7152 fprintf (file
, " ");
7153 print_generic_expr (file
, TREE_TYPE (name
), flags
);
7154 fprintf (file
, " ");
7155 print_generic_expr (file
, name
, flags
);
7156 fprintf (file
, ";\n");
7163 if (fun
&& fun
->decl
== fndecl
7165 && basic_block_info_for_fn (fun
))
7167 /* If the CFG has been built, emit a CFG-based dump. */
7168 if (!ignore_topmost_bind
)
7169 fprintf (file
, "{\n");
7171 if (any_var
&& n_basic_blocks_for_fn (fun
))
7172 fprintf (file
, "\n");
7174 FOR_EACH_BB_FN (bb
, fun
)
7175 dump_bb (file
, bb
, 2, flags
| TDF_COMMENT
);
7177 fprintf (file
, "}\n");
7179 else if (DECL_SAVED_TREE (fndecl
) == NULL
)
7181 /* The function is now in GIMPLE form but the CFG has not been
7182 built yet. Emit the single sequence of GIMPLE statements
7183 that make up its body. */
7184 gimple_seq body
= gimple_body (fndecl
);
7186 if (gimple_seq_first_stmt (body
)
7187 && gimple_seq_first_stmt (body
) == gimple_seq_last_stmt (body
)
7188 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
)
7189 print_gimple_seq (file
, body
, 0, flags
);
7192 if (!ignore_topmost_bind
)
7193 fprintf (file
, "{\n");
7196 fprintf (file
, "\n");
7198 print_gimple_seq (file
, body
, 2, flags
);
7199 fprintf (file
, "}\n");
7206 /* Make a tree based dump. */
7207 chain
= DECL_SAVED_TREE (fndecl
);
7208 if (chain
&& TREE_CODE (chain
) == BIND_EXPR
)
7210 if (ignore_topmost_bind
)
7212 chain
= BIND_EXPR_BODY (chain
);
7220 if (!ignore_topmost_bind
)
7221 fprintf (file
, "{\n");
7226 fprintf (file
, "\n");
7228 print_generic_stmt_indented (file
, chain
, flags
, indent
);
7229 if (ignore_topmost_bind
)
7230 fprintf (file
, "}\n");
7233 if (flags
& TDF_ENUMERATE_LOCALS
)
7234 dump_enumerated_decls (file
, flags
);
7235 fprintf (file
, "\n\n");
7237 current_function_decl
= old_current_fndecl
;
7240 /* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h) */
7243 debug_function (tree fn
, int flags
)
7245 dump_function_to_file (fn
, stderr
, flags
);
7249 /* Print on FILE the indexes for the predecessors of basic_block BB. */
7252 print_pred_bbs (FILE *file
, basic_block bb
)
7257 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7258 fprintf (file
, "bb_%d ", e
->src
->index
);
7262 /* Print on FILE the indexes for the successors of basic_block BB. */
7265 print_succ_bbs (FILE *file
, basic_block bb
)
7270 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7271 fprintf (file
, "bb_%d ", e
->dest
->index
);
7274 /* Print to FILE the basic block BB following the VERBOSITY level. */
7277 print_loops_bb (FILE *file
, basic_block bb
, int indent
, int verbosity
)
7279 char *s_indent
= (char *) alloca ((size_t) indent
+ 1);
7280 memset ((void *) s_indent
, ' ', (size_t) indent
);
7281 s_indent
[indent
] = '\0';
7283 /* Print basic_block's header. */
7286 fprintf (file
, "%s bb_%d (preds = {", s_indent
, bb
->index
);
7287 print_pred_bbs (file
, bb
);
7288 fprintf (file
, "}, succs = {");
7289 print_succ_bbs (file
, bb
);
7290 fprintf (file
, "})\n");
7293 /* Print basic_block's body. */
7296 fprintf (file
, "%s {\n", s_indent
);
7297 dump_bb (file
, bb
, indent
+ 4, TDF_VOPS
|TDF_MEMSYMS
);
7298 fprintf (file
, "%s }\n", s_indent
);
7302 static void print_loop_and_siblings (FILE *, struct loop
*, int, int);
7304 /* Pretty print LOOP on FILE, indented INDENT spaces. Following
7305 VERBOSITY level this outputs the contents of the loop, or just its
7309 print_loop (FILE *file
, struct loop
*loop
, int indent
, int verbosity
)
7317 s_indent
= (char *) alloca ((size_t) indent
+ 1);
7318 memset ((void *) s_indent
, ' ', (size_t) indent
);
7319 s_indent
[indent
] = '\0';
7321 /* Print loop's header. */
7322 fprintf (file
, "%sloop_%d (", s_indent
, loop
->num
);
7324 fprintf (file
, "header = %d", loop
->header
->index
);
7327 fprintf (file
, "deleted)\n");
7331 fprintf (file
, ", latch = %d", loop
->latch
->index
);
7333 fprintf (file
, ", multiple latches");
7334 fprintf (file
, ", niter = ");
7335 print_generic_expr (file
, loop
->nb_iterations
, 0);
7337 if (loop
->any_upper_bound
)
7339 fprintf (file
, ", upper_bound = ");
7340 print_decu (loop
->nb_iterations_upper_bound
, file
);
7343 if (loop
->any_estimate
)
7345 fprintf (file
, ", estimate = ");
7346 print_decu (loop
->nb_iterations_estimate
, file
);
7348 fprintf (file
, ")\n");
7350 /* Print loop's body. */
7353 fprintf (file
, "%s{\n", s_indent
);
7354 FOR_EACH_BB_FN (bb
, cfun
)
7355 if (bb
->loop_father
== loop
)
7356 print_loops_bb (file
, bb
, indent
, verbosity
);
7358 print_loop_and_siblings (file
, loop
->inner
, indent
+ 2, verbosity
);
7359 fprintf (file
, "%s}\n", s_indent
);
7363 /* Print the LOOP and its sibling loops on FILE, indented INDENT
7364 spaces. Following VERBOSITY level this outputs the contents of the
7365 loop, or just its structure. */
7368 print_loop_and_siblings (FILE *file
, struct loop
*loop
, int indent
,
7374 print_loop (file
, loop
, indent
, verbosity
);
7375 print_loop_and_siblings (file
, loop
->next
, indent
, verbosity
);
7378 /* Follow a CFG edge from the entry point of the program, and on entry
7379 of a loop, pretty print the loop structure on FILE. */
7382 print_loops (FILE *file
, int verbosity
)
7386 bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
7387 if (bb
&& bb
->loop_father
)
7388 print_loop_and_siblings (file
, bb
->loop_father
, 0, verbosity
);
7394 debug (struct loop
&ref
)
7396 print_loop (stderr
, &ref
, 0, /*verbosity*/0);
7400 debug (struct loop
*ptr
)
7405 fprintf (stderr
, "<nil>\n");
7408 /* Dump a loop verbosely. */
7411 debug_verbose (struct loop
&ref
)
7413 print_loop (stderr
, &ref
, 0, /*verbosity*/3);
7417 debug_verbose (struct loop
*ptr
)
7422 fprintf (stderr
, "<nil>\n");
7426 /* Debugging loops structure at tree level, at some VERBOSITY level. */
7429 debug_loops (int verbosity
)
7431 print_loops (stderr
, verbosity
);
7434 /* Print on stderr the code of LOOP, at some VERBOSITY level. */
7437 debug_loop (struct loop
*loop
, int verbosity
)
7439 print_loop (stderr
, loop
, 0, verbosity
);
7442 /* Print on stderr the code of loop number NUM, at some VERBOSITY
7446 debug_loop_num (unsigned num
, int verbosity
)
7448 debug_loop (get_loop (cfun
, num
), verbosity
);
7451 /* Return true if BB ends with a call, possibly followed by some
7452 instructions that must stay with the call. Return false,
7456 gimple_block_ends_with_call_p (basic_block bb
)
7458 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
7459 return !gsi_end_p (gsi
) && is_gimple_call (gsi_stmt (gsi
));
7463 /* Return true if BB ends with a conditional branch. Return false,
7467 gimple_block_ends_with_condjump_p (const_basic_block bb
)
7469 gimple stmt
= last_stmt (CONST_CAST_BB (bb
));
7470 return (stmt
&& gimple_code (stmt
) == GIMPLE_COND
);
7474 /* Return true if we need to add fake edge to exit at statement T.
7475 Helper function for gimple_flow_call_edges_add. */
7478 need_fake_edge_p (gimple t
)
7480 tree fndecl
= NULL_TREE
;
7483 /* NORETURN and LONGJMP calls already have an edge to exit.
7484 CONST and PURE calls do not need one.
7485 We don't currently check for CONST and PURE here, although
7486 it would be a good idea, because those attributes are
7487 figured out from the RTL in mark_constant_function, and
7488 the counter incrementation code from -fprofile-arcs
7489 leads to different results from -fbranch-probabilities. */
7490 if (is_gimple_call (t
))
7492 fndecl
= gimple_call_fndecl (t
);
7493 call_flags
= gimple_call_flags (t
);
7496 if (is_gimple_call (t
)
7498 && DECL_BUILT_IN (fndecl
)
7499 && (call_flags
& ECF_NOTHROW
)
7500 && !(call_flags
& ECF_RETURNS_TWICE
)
7501 /* fork() doesn't really return twice, but the effect of
7502 wrapping it in __gcov_fork() which calls __gcov_flush()
7503 and clears the counters before forking has the same
7504 effect as returning twice. Force a fake edge. */
7505 && !(DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7506 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FORK
))
7509 if (is_gimple_call (t
))
7515 if (!(call_flags
& ECF_NORETURN
))
7519 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7520 if ((e
->flags
& EDGE_FAKE
) == 0)
7524 if (gimple_code (t
) == GIMPLE_ASM
7525 && (gimple_asm_volatile_p (t
) || gimple_asm_input_p (t
)))
7532 /* Add fake edges to the function exit for any non constant and non
7533 noreturn calls (or noreturn calls with EH/abnormal edges),
7534 volatile inline assembly in the bitmap of blocks specified by BLOCKS
7535 or to the whole CFG if BLOCKS is zero. Return the number of blocks
7538 The goal is to expose cases in which entering a basic block does
7539 not imply that all subsequent instructions must be executed. */
7542 gimple_flow_call_edges_add (sbitmap blocks
)
7545 int blocks_split
= 0;
7546 int last_bb
= last_basic_block_for_fn (cfun
);
7547 bool check_last_block
= false;
7549 if (n_basic_blocks_for_fn (cfun
) == NUM_FIXED_BLOCKS
)
7553 check_last_block
= true;
7555 check_last_block
= bitmap_bit_p (blocks
,
7556 EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
->index
);
7558 /* In the last basic block, before epilogue generation, there will be
7559 a fallthru edge to EXIT. Special care is required if the last insn
7560 of the last basic block is a call because make_edge folds duplicate
7561 edges, which would result in the fallthru edge also being marked
7562 fake, which would result in the fallthru edge being removed by
7563 remove_fake_edges, which would result in an invalid CFG.
7565 Moreover, we can't elide the outgoing fake edge, since the block
7566 profiler needs to take this into account in order to solve the minimal
7567 spanning tree in the case that the call doesn't return.
7569 Handle this by adding a dummy instruction in a new last basic block. */
7570 if (check_last_block
)
7572 basic_block bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
7573 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
7576 if (!gsi_end_p (gsi
))
7579 if (t
&& need_fake_edge_p (t
))
7583 e
= find_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
7586 gsi_insert_on_edge (e
, gimple_build_nop ());
7587 gsi_commit_edge_inserts ();
7592 /* Now add fake edges to the function exit for any non constant
7593 calls since there is no way that we can determine if they will
7595 for (i
= 0; i
< last_bb
; i
++)
7597 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
7598 gimple_stmt_iterator gsi
;
7599 gimple stmt
, last_stmt
;
7604 if (blocks
&& !bitmap_bit_p (blocks
, i
))
7607 gsi
= gsi_last_nondebug_bb (bb
);
7608 if (!gsi_end_p (gsi
))
7610 last_stmt
= gsi_stmt (gsi
);
7613 stmt
= gsi_stmt (gsi
);
7614 if (need_fake_edge_p (stmt
))
7618 /* The handling above of the final block before the
7619 epilogue should be enough to verify that there is
7620 no edge to the exit block in CFG already.
7621 Calling make_edge in such case would cause us to
7622 mark that edge as fake and remove it later. */
7623 #ifdef ENABLE_CHECKING
7624 if (stmt
== last_stmt
)
7626 e
= find_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
7627 gcc_assert (e
== NULL
);
7631 /* Note that the following may create a new basic block
7632 and renumber the existing basic blocks. */
7633 if (stmt
!= last_stmt
)
7635 e
= split_block (bb
, stmt
);
7639 make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FAKE
);
7643 while (!gsi_end_p (gsi
));
7648 verify_flow_info ();
7650 return blocks_split
;
7653 /* Removes edge E and all the blocks dominated by it, and updates dominance
7654 information. The IL in E->src needs to be updated separately.
7655 If dominance info is not available, only the edge E is removed.*/
7658 remove_edge_and_dominated_blocks (edge e
)
7660 vec
<basic_block
> bbs_to_remove
= vNULL
;
7661 vec
<basic_block
> bbs_to_fix_dom
= vNULL
;
7665 bool none_removed
= false;
7667 basic_block bb
, dbb
;
7670 if (!dom_info_available_p (CDI_DOMINATORS
))
7676 /* No updating is needed for edges to exit. */
7677 if (e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
7679 if (cfgcleanup_altered_bbs
)
7680 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
7685 /* First, we find the basic blocks to remove. If E->dest has a predecessor
7686 that is not dominated by E->dest, then this set is empty. Otherwise,
7687 all the basic blocks dominated by E->dest are removed.
7689 Also, to DF_IDOM we store the immediate dominators of the blocks in
7690 the dominance frontier of E (i.e., of the successors of the
7691 removed blocks, if there are any, and of E->dest otherwise). */
7692 FOR_EACH_EDGE (f
, ei
, e
->dest
->preds
)
7697 if (!dominated_by_p (CDI_DOMINATORS
, f
->src
, e
->dest
))
7699 none_removed
= true;
7704 df
= BITMAP_ALLOC (NULL
);
7705 df_idom
= BITMAP_ALLOC (NULL
);
7708 bitmap_set_bit (df_idom
,
7709 get_immediate_dominator (CDI_DOMINATORS
, e
->dest
)->index
);
7712 bbs_to_remove
= get_all_dominated_blocks (CDI_DOMINATORS
, e
->dest
);
7713 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
7715 FOR_EACH_EDGE (f
, ei
, bb
->succs
)
7717 if (f
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
7718 bitmap_set_bit (df
, f
->dest
->index
);
7721 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
7722 bitmap_clear_bit (df
, bb
->index
);
7724 EXECUTE_IF_SET_IN_BITMAP (df
, 0, i
, bi
)
7726 bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
7727 bitmap_set_bit (df_idom
,
7728 get_immediate_dominator (CDI_DOMINATORS
, bb
)->index
);
7732 if (cfgcleanup_altered_bbs
)
7734 /* Record the set of the altered basic blocks. */
7735 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
7736 bitmap_ior_into (cfgcleanup_altered_bbs
, df
);
7739 /* Remove E and the cancelled blocks. */
7744 /* Walk backwards so as to get a chance to substitute all
7745 released DEFs into debug stmts. See
7746 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
7748 for (i
= bbs_to_remove
.length (); i
-- > 0; )
7749 delete_basic_block (bbs_to_remove
[i
]);
7752 /* Update the dominance information. The immediate dominator may change only
7753 for blocks whose immediate dominator belongs to DF_IDOM:
7755 Suppose that idom(X) = Y before removal of E and idom(X) != Y after the
7756 removal. Let Z the arbitrary block such that idom(Z) = Y and
7757 Z dominates X after the removal. Before removal, there exists a path P
7758 from Y to X that avoids Z. Let F be the last edge on P that is
7759 removed, and let W = F->dest. Before removal, idom(W) = Y (since Y
7760 dominates W, and because of P, Z does not dominate W), and W belongs to
7761 the dominance frontier of E. Therefore, Y belongs to DF_IDOM. */
7762 EXECUTE_IF_SET_IN_BITMAP (df_idom
, 0, i
, bi
)
7764 bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
7765 for (dbb
= first_dom_son (CDI_DOMINATORS
, bb
);
7767 dbb
= next_dom_son (CDI_DOMINATORS
, dbb
))
7768 bbs_to_fix_dom
.safe_push (dbb
);
7771 iterate_fix_dominators (CDI_DOMINATORS
, bbs_to_fix_dom
, true);
7774 BITMAP_FREE (df_idom
);
7775 bbs_to_remove
.release ();
7776 bbs_to_fix_dom
.release ();
7779 /* Purge dead EH edges from basic block BB. */
7782 gimple_purge_dead_eh_edges (basic_block bb
)
7784 bool changed
= false;
7787 gimple stmt
= last_stmt (bb
);
7789 if (stmt
&& stmt_can_throw_internal (stmt
))
7792 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
7794 if (e
->flags
& EDGE_EH
)
7796 remove_edge_and_dominated_blocks (e
);
7806 /* Purge dead EH edges from basic block listed in BLOCKS. */
7809 gimple_purge_all_dead_eh_edges (const_bitmap blocks
)
7811 bool changed
= false;
7815 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
7817 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
7819 /* Earlier gimple_purge_dead_eh_edges could have removed
7820 this basic block already. */
7821 gcc_assert (bb
|| changed
);
7823 changed
|= gimple_purge_dead_eh_edges (bb
);
7829 /* Purge dead abnormal call edges from basic block BB. */
7832 gimple_purge_dead_abnormal_call_edges (basic_block bb
)
7834 bool changed
= false;
7837 gimple stmt
= last_stmt (bb
);
7839 if (!cfun
->has_nonlocal_label
7840 && !cfun
->calls_setjmp
)
7843 if (stmt
&& stmt_can_make_abnormal_goto (stmt
))
7846 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
7848 if (e
->flags
& EDGE_ABNORMAL
)
7850 if (e
->flags
& EDGE_FALLTHRU
)
7851 e
->flags
&= ~EDGE_ABNORMAL
;
7853 remove_edge_and_dominated_blocks (e
);
7863 /* Purge dead abnormal call edges from basic block listed in BLOCKS. */
7866 gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks
)
7868 bool changed
= false;
7872 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
7874 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
7876 /* Earlier gimple_purge_dead_abnormal_call_edges could have removed
7877 this basic block already. */
7878 gcc_assert (bb
|| changed
);
7880 changed
|= gimple_purge_dead_abnormal_call_edges (bb
);
7886 /* This function is called whenever a new edge is created or
7890 gimple_execute_on_growing_pred (edge e
)
7892 basic_block bb
= e
->dest
;
7894 if (!gimple_seq_empty_p (phi_nodes (bb
)))
7895 reserve_phi_args_for_new_edge (bb
);
7898 /* This function is called immediately before edge E is removed from
7899 the edge vector E->dest->preds. */
7902 gimple_execute_on_shrinking_pred (edge e
)
7904 if (!gimple_seq_empty_p (phi_nodes (e
->dest
)))
7905 remove_phi_args (e
);
7908 /*---------------------------------------------------------------------------
7909 Helper functions for Loop versioning
7910 ---------------------------------------------------------------------------*/
7912 /* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy
7913 of 'first'. Both of them are dominated by 'new_head' basic block. When
7914 'new_head' was created by 'second's incoming edge it received phi arguments
7915 on the edge by split_edge(). Later, additional edge 'e' was created to
7916 connect 'new_head' and 'first'. Now this routine adds phi args on this
7917 additional edge 'e' that new_head to second edge received as part of edge
7921 gimple_lv_adjust_loop_header_phi (basic_block first
, basic_block second
,
7922 basic_block new_head
, edge e
)
7925 gimple_stmt_iterator psi1
, psi2
;
7927 edge e2
= find_edge (new_head
, second
);
7929 /* Because NEW_HEAD has been created by splitting SECOND's incoming
7930 edge, we should always have an edge from NEW_HEAD to SECOND. */
7931 gcc_assert (e2
!= NULL
);
7933 /* Browse all 'second' basic block phi nodes and add phi args to
7934 edge 'e' for 'first' head. PHI args are always in correct order. */
7936 for (psi2
= gsi_start_phis (second
),
7937 psi1
= gsi_start_phis (first
);
7938 !gsi_end_p (psi2
) && !gsi_end_p (psi1
);
7939 gsi_next (&psi2
), gsi_next (&psi1
))
7941 phi1
= gsi_stmt (psi1
);
7942 phi2
= gsi_stmt (psi2
);
7943 def
= PHI_ARG_DEF (phi2
, e2
->dest_idx
);
7944 add_phi_arg (phi1
, def
, e
, gimple_phi_arg_location_from_edge (phi2
, e2
));
7949 /* Adds a if else statement to COND_BB with condition COND_EXPR.
7950 SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
7951 the destination of the ELSE part. */
7954 gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED
,
7955 basic_block second_head ATTRIBUTE_UNUSED
,
7956 basic_block cond_bb
, void *cond_e
)
7958 gimple_stmt_iterator gsi
;
7959 gimple new_cond_expr
;
7960 tree cond_expr
= (tree
) cond_e
;
7963 /* Build new conditional expr */
7964 new_cond_expr
= gimple_build_cond_from_tree (cond_expr
,
7965 NULL_TREE
, NULL_TREE
);
7967 /* Add new cond in cond_bb. */
7968 gsi
= gsi_last_bb (cond_bb
);
7969 gsi_insert_after (&gsi
, new_cond_expr
, GSI_NEW_STMT
);
7971 /* Adjust edges appropriately to connect new head with first head
7972 as well as second head. */
7973 e0
= single_succ_edge (cond_bb
);
7974 e0
->flags
&= ~EDGE_FALLTHRU
;
7975 e0
->flags
|= EDGE_FALSE_VALUE
;
7979 /* Do book-keeping of basic block BB for the profile consistency checker.
7980 If AFTER_PASS is 0, do pre-pass accounting, or if AFTER_PASS is 1
7981 then do post-pass accounting. Store the counting in RECORD. */
7983 gimple_account_profile_record (basic_block bb
, int after_pass
,
7984 struct profile_record
*record
)
7986 gimple_stmt_iterator i
;
7987 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
7989 record
->size
[after_pass
]
7990 += estimate_num_insns (gsi_stmt (i
), &eni_size_weights
);
7991 if (profile_status_for_fn (cfun
) == PROFILE_READ
)
7992 record
->time
[after_pass
]
7993 += estimate_num_insns (gsi_stmt (i
),
7994 &eni_time_weights
) * bb
->count
;
7995 else if (profile_status_for_fn (cfun
) == PROFILE_GUESSED
)
7996 record
->time
[after_pass
]
7997 += estimate_num_insns (gsi_stmt (i
),
7998 &eni_time_weights
) * bb
->frequency
;
8002 struct cfg_hooks gimple_cfg_hooks
= {
8004 gimple_verify_flow_info
,
8005 gimple_dump_bb
, /* dump_bb */
8006 gimple_dump_bb_for_graph
, /* dump_bb_for_graph */
8007 create_bb
, /* create_basic_block */
8008 gimple_redirect_edge_and_branch
, /* redirect_edge_and_branch */
8009 gimple_redirect_edge_and_branch_force
, /* redirect_edge_and_branch_force */
8010 gimple_can_remove_branch_p
, /* can_remove_branch_p */
8011 remove_bb
, /* delete_basic_block */
8012 gimple_split_block
, /* split_block */
8013 gimple_move_block_after
, /* move_block_after */
8014 gimple_can_merge_blocks_p
, /* can_merge_blocks_p */
8015 gimple_merge_blocks
, /* merge_blocks */
8016 gimple_predict_edge
, /* predict_edge */
8017 gimple_predicted_by_p
, /* predicted_by_p */
8018 gimple_can_duplicate_bb_p
, /* can_duplicate_block_p */
8019 gimple_duplicate_bb
, /* duplicate_block */
8020 gimple_split_edge
, /* split_edge */
8021 gimple_make_forwarder_block
, /* make_forward_block */
8022 NULL
, /* tidy_fallthru_edge */
8023 NULL
, /* force_nonfallthru */
8024 gimple_block_ends_with_call_p
,/* block_ends_with_call_p */
8025 gimple_block_ends_with_condjump_p
, /* block_ends_with_condjump_p */
8026 gimple_flow_call_edges_add
, /* flow_call_edges_add */
8027 gimple_execute_on_growing_pred
, /* execute_on_growing_pred */
8028 gimple_execute_on_shrinking_pred
, /* execute_on_shrinking_pred */
8029 gimple_duplicate_loop_to_header_edge
, /* duplicate loop for trees */
8030 gimple_lv_add_condition_to_bb
, /* lv_add_condition_to_bb */
8031 gimple_lv_adjust_loop_header_phi
, /* lv_adjust_loop_header_phi*/
8032 extract_true_false_edges_from_block
, /* extract_cond_bb_edges */
8033 flush_pending_stmts
, /* flush_pending_stmts */
8034 gimple_empty_block_p
, /* block_empty_p */
8035 gimple_split_block_before_cond_jump
, /* split_block_before_cond_jump */
8036 gimple_account_profile_record
,
8040 /* Split all critical edges. */
8043 split_critical_edges (void)
8049 /* split_edge can redirect edges out of SWITCH_EXPRs, which can get
8050 expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
8051 mappings around the calls to split_edge. */
8052 start_recording_case_labels ();
8053 FOR_ALL_BB_FN (bb
, cfun
)
8055 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8057 if (EDGE_CRITICAL_P (e
) && !(e
->flags
& EDGE_ABNORMAL
))
8059 /* PRE inserts statements to edges and expects that
8060 since split_critical_edges was done beforehand, committing edge
8061 insertions will not split more edges. In addition to critical
8062 edges we must split edges that have multiple successors and
8063 end by control flow statements, such as RESX.
8064 Go ahead and split them too. This matches the logic in
8065 gimple_find_edge_insert_loc. */
8066 else if ((!single_pred_p (e
->dest
)
8067 || !gimple_seq_empty_p (phi_nodes (e
->dest
))
8068 || e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
8069 && e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)
8070 && !(e
->flags
& EDGE_ABNORMAL
))
8072 gimple_stmt_iterator gsi
;
8074 gsi
= gsi_last_bb (e
->src
);
8075 if (!gsi_end_p (gsi
)
8076 && stmt_ends_bb_p (gsi_stmt (gsi
))
8077 && (gimple_code (gsi_stmt (gsi
)) != GIMPLE_RETURN
8078 && !gimple_call_builtin_p (gsi_stmt (gsi
),
8084 end_recording_case_labels ();
8090 const pass_data pass_data_split_crit_edges
=
8092 GIMPLE_PASS
, /* type */
8093 "crited", /* name */
8094 OPTGROUP_NONE
, /* optinfo_flags */
8095 true, /* has_execute */
8096 TV_TREE_SPLIT_EDGES
, /* tv_id */
8097 PROP_cfg
, /* properties_required */
8098 PROP_no_crit_edges
, /* properties_provided */
8099 0, /* properties_destroyed */
8100 0, /* todo_flags_start */
8101 0, /* todo_flags_finish */
8104 class pass_split_crit_edges
: public gimple_opt_pass
8107 pass_split_crit_edges (gcc::context
*ctxt
)
8108 : gimple_opt_pass (pass_data_split_crit_edges
, ctxt
)
8111 /* opt_pass methods: */
8112 virtual unsigned int execute (function
*) { return split_critical_edges (); }
8114 opt_pass
* clone () { return new pass_split_crit_edges (m_ctxt
); }
8115 }; // class pass_split_crit_edges
8120 make_pass_split_crit_edges (gcc::context
*ctxt
)
8122 return new pass_split_crit_edges (ctxt
);
8126 /* Build a ternary operation and gimplify it. Emit code before GSI.
8127 Return the gimple_val holding the result. */
8130 gimplify_build3 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
8131 tree type
, tree a
, tree b
, tree c
)
8134 location_t loc
= gimple_location (gsi_stmt (*gsi
));
8136 ret
= fold_build3_loc (loc
, code
, type
, a
, b
, c
);
8139 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
8143 /* Build a binary operation and gimplify it. Emit code before GSI.
8144 Return the gimple_val holding the result. */
8147 gimplify_build2 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
8148 tree type
, tree a
, tree b
)
8152 ret
= fold_build2_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
, b
);
8155 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
8159 /* Build a unary operation and gimplify it. Emit code before GSI.
8160 Return the gimple_val holding the result. */
8163 gimplify_build1 (gimple_stmt_iterator
*gsi
, enum tree_code code
, tree type
,
8168 ret
= fold_build1_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
);
8171 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
8177 /* Given a basic block B which ends with a conditional and has
8178 precisely two successors, determine which of the edges is taken if
8179 the conditional is true and which is taken if the conditional is
8180 false. Set TRUE_EDGE and FALSE_EDGE appropriately. */
8183 extract_true_false_edges_from_block (basic_block b
,
8187 edge e
= EDGE_SUCC (b
, 0);
8189 if (e
->flags
& EDGE_TRUE_VALUE
)
8192 *false_edge
= EDGE_SUCC (b
, 1);
8197 *true_edge
= EDGE_SUCC (b
, 1);
8201 /* Emit return warnings. */
8205 const pass_data pass_data_warn_function_return
=
8207 GIMPLE_PASS
, /* type */
8208 "*warn_function_return", /* name */
8209 OPTGROUP_NONE
, /* optinfo_flags */
8210 true, /* has_execute */
8211 TV_NONE
, /* tv_id */
8212 PROP_cfg
, /* properties_required */
8213 0, /* properties_provided */
8214 0, /* properties_destroyed */
8215 0, /* todo_flags_start */
8216 0, /* todo_flags_finish */
8219 class pass_warn_function_return
: public gimple_opt_pass
8222 pass_warn_function_return (gcc::context
*ctxt
)
8223 : gimple_opt_pass (pass_data_warn_function_return
, ctxt
)
8226 /* opt_pass methods: */
8227 virtual unsigned int execute (function
*);
8229 }; // class pass_warn_function_return
8232 pass_warn_function_return::execute (function
*fun
)
8234 source_location location
;
8239 if (!targetm
.warn_func_return (fun
->decl
))
8242 /* If we have a path to EXIT, then we do return. */
8243 if (TREE_THIS_VOLATILE (fun
->decl
)
8244 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) > 0)
8246 location
= UNKNOWN_LOCATION
;
8247 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
)
8249 last
= last_stmt (e
->src
);
8250 if ((gimple_code (last
) == GIMPLE_RETURN
8251 || gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
8252 && (location
= gimple_location (last
)) != UNKNOWN_LOCATION
)
8255 if (location
== UNKNOWN_LOCATION
)
8256 location
= cfun
->function_end_locus
;
8257 warning_at (location
, 0, "%<noreturn%> function does return");
8260 /* If we see "return;" in some basic block, then we do reach the end
8261 without returning a value. */
8262 else if (warn_return_type
8263 && !TREE_NO_WARNING (fun
->decl
)
8264 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) > 0
8265 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fun
->decl
))))
8267 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
)
8269 gimple last
= last_stmt (e
->src
);
8270 if (gimple_code (last
) == GIMPLE_RETURN
8271 && gimple_return_retval (last
) == NULL
8272 && !gimple_no_warning_p (last
))
8274 location
= gimple_location (last
);
8275 if (location
== UNKNOWN_LOCATION
)
8276 location
= fun
->function_end_locus
;
8277 warning_at (location
, OPT_Wreturn_type
, "control reaches end of non-void function");
8278 TREE_NO_WARNING (fun
->decl
) = 1;
8289 make_pass_warn_function_return (gcc::context
*ctxt
)
8291 return new pass_warn_function_return (ctxt
);
8294 /* Walk a gimplified function and warn for functions whose return value is
8295 ignored and attribute((warn_unused_result)) is set. This is done before
8296 inlining, so we don't have to worry about that. */
8299 do_warn_unused_result (gimple_seq seq
)
8302 gimple_stmt_iterator i
;
8304 for (i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
8306 gimple g
= gsi_stmt (i
);
8308 switch (gimple_code (g
))
8311 do_warn_unused_result (gimple_bind_body (g
));
8314 do_warn_unused_result (gimple_try_eval (g
));
8315 do_warn_unused_result (gimple_try_cleanup (g
));
8318 do_warn_unused_result (gimple_catch_handler (g
));
8320 case GIMPLE_EH_FILTER
:
8321 do_warn_unused_result (gimple_eh_filter_failure (g
));
8325 if (gimple_call_lhs (g
))
8327 if (gimple_call_internal_p (g
))
8330 /* This is a naked call, as opposed to a GIMPLE_CALL with an
8331 LHS. All calls whose value is ignored should be
8332 represented like this. Look for the attribute. */
8333 fdecl
= gimple_call_fndecl (g
);
8334 ftype
= gimple_call_fntype (g
);
8336 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
8338 location_t loc
= gimple_location (g
);
8341 warning_at (loc
, OPT_Wunused_result
,
8342 "ignoring return value of %qD, "
8343 "declared with attribute warn_unused_result",
8346 warning_at (loc
, OPT_Wunused_result
,
8347 "ignoring return value of function "
8348 "declared with attribute warn_unused_result");
8353 /* Not a container, not a call, or a call whose value is used. */
8361 const pass_data pass_data_warn_unused_result
=
8363 GIMPLE_PASS
, /* type */
8364 "*warn_unused_result", /* name */
8365 OPTGROUP_NONE
, /* optinfo_flags */
8366 true, /* has_execute */
8367 TV_NONE
, /* tv_id */
8368 PROP_gimple_any
, /* properties_required */
8369 0, /* properties_provided */
8370 0, /* properties_destroyed */
8371 0, /* todo_flags_start */
8372 0, /* todo_flags_finish */
8375 class pass_warn_unused_result
: public gimple_opt_pass
8378 pass_warn_unused_result (gcc::context
*ctxt
)
8379 : gimple_opt_pass (pass_data_warn_unused_result
, ctxt
)
8382 /* opt_pass methods: */
8383 virtual bool gate (function
*) { return flag_warn_unused_result
; }
8384 virtual unsigned int execute (function
*)
8386 do_warn_unused_result (gimple_body (current_function_decl
));
8390 }; // class pass_warn_unused_result
8395 make_pass_warn_unused_result (gcc::context
*ctxt
)
8397 return new pass_warn_unused_result (ctxt
);
8400 /* IPA passes, compilation of earlier functions or inlining
8401 might have changed some properties, such as marked functions nothrow,
8402 pure, const or noreturn.
8403 Remove redundant edges and basic blocks, and create new ones if necessary.
8405 This pass can't be executed as stand alone pass from pass manager, because
8406 in between inlining and this fixup the verify_flow_info would fail. */
8409 execute_fixup_cfg (void)
8412 gimple_stmt_iterator gsi
;
8414 gcov_type count_scale
;
8419 = GCOV_COMPUTE_SCALE (cgraph_get_node (current_function_decl
)->count
,
8420 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
);
8422 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
=
8423 cgraph_get_node (current_function_decl
)->count
;
8424 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
=
8425 apply_scale (EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
,
8428 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
)
8429 e
->count
= apply_scale (e
->count
, count_scale
);
8431 FOR_EACH_BB_FN (bb
, cfun
)
8433 bb
->count
= apply_scale (bb
->count
, count_scale
);
8434 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
8436 gimple stmt
= gsi_stmt (gsi
);
8437 tree decl
= is_gimple_call (stmt
)
8438 ? gimple_call_fndecl (stmt
)
8442 int flags
= gimple_call_flags (stmt
);
8443 if (flags
& (ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
))
8445 if (gimple_purge_dead_abnormal_call_edges (bb
))
8446 todo
|= TODO_cleanup_cfg
;
8448 if (gimple_in_ssa_p (cfun
))
8450 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
8455 if (flags
& ECF_NORETURN
8456 && fixup_noreturn_call (stmt
))
8457 todo
|= TODO_cleanup_cfg
;
8460 /* Remove stores to variables we marked write-only.
8461 Keep access when store has side effect, i.e. in case when source
8463 if (gimple_store_p (stmt
)
8464 && !gimple_has_side_effects (stmt
))
8466 tree lhs
= get_base_address (gimple_get_lhs (stmt
));
8468 if (TREE_CODE (lhs
) == VAR_DECL
8469 && (TREE_STATIC (lhs
) || DECL_EXTERNAL (lhs
))
8470 && varpool_get_node (lhs
)->writeonly
)
8472 unlink_stmt_vdef (stmt
);
8473 gsi_remove (&gsi
, true);
8474 release_defs (stmt
);
8475 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
8479 /* For calls we can simply remove LHS when it is known
8480 to be write-only. */
8481 if (is_gimple_call (stmt
)
8482 && gimple_get_lhs (stmt
))
8484 tree lhs
= get_base_address (gimple_get_lhs (stmt
));
8486 if (TREE_CODE (lhs
) == VAR_DECL
8487 && (TREE_STATIC (lhs
) || DECL_EXTERNAL (lhs
))
8488 && varpool_get_node (lhs
)->writeonly
)
8490 gimple_call_set_lhs (stmt
, NULL
);
8492 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
8496 if (maybe_clean_eh_stmt (stmt
)
8497 && gimple_purge_dead_eh_edges (bb
))
8498 todo
|= TODO_cleanup_cfg
;
8502 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8503 e
->count
= apply_scale (e
->count
, count_scale
);
8505 /* If we have a basic block with no successors that does not
8506 end with a control statement or a noreturn call end it with
8507 a call to __builtin_unreachable. This situation can occur
8508 when inlining a noreturn call that does in fact return. */
8509 if (EDGE_COUNT (bb
->succs
) == 0)
8511 gimple stmt
= last_stmt (bb
);
8513 || (!is_ctrl_stmt (stmt
)
8514 && (!is_gimple_call (stmt
)
8515 || (gimple_call_flags (stmt
) & ECF_NORETURN
) == 0)))
8517 stmt
= gimple_build_call
8518 (builtin_decl_implicit (BUILT_IN_UNREACHABLE
), 0);
8519 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
8520 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
8524 if (count_scale
!= REG_BR_PROB_BASE
)
8525 compute_function_frequency ();
8527 /* We just processed all calls. */
8528 if (cfun
->gimple_df
)
8529 vec_free (MODIFIED_NORETURN_CALLS (cfun
));
8531 /* Dump a textual representation of the flowgraph. */
8533 gimple_dump_cfg (dump_file
, dump_flags
);
8536 && (todo
& TODO_cleanup_cfg
))
8537 loops_state_set (LOOPS_NEED_FIXUP
);
8544 const pass_data pass_data_fixup_cfg
=
8546 GIMPLE_PASS
, /* type */
8547 "*free_cfg_annotations", /* name */
8548 OPTGROUP_NONE
, /* optinfo_flags */
8549 true, /* has_execute */
8550 TV_NONE
, /* tv_id */
8551 PROP_cfg
, /* properties_required */
8552 0, /* properties_provided */
8553 0, /* properties_destroyed */
8554 0, /* todo_flags_start */
8555 0, /* todo_flags_finish */
8558 class pass_fixup_cfg
: public gimple_opt_pass
8561 pass_fixup_cfg (gcc::context
*ctxt
)
8562 : gimple_opt_pass (pass_data_fixup_cfg
, ctxt
)
8565 /* opt_pass methods: */
8566 opt_pass
* clone () { return new pass_fixup_cfg (m_ctxt
); }
8567 virtual unsigned int execute (function
*) { return execute_fixup_cfg (); }
8569 }; // class pass_fixup_cfg
8574 make_pass_fixup_cfg (gcc::context
*ctxt
)
8576 return new pass_fixup_cfg (ctxt
);
8579 /* Garbage collection support for edge_def. */
8581 extern void gt_ggc_mx (tree
&);
8582 extern void gt_ggc_mx (gimple
&);
8583 extern void gt_ggc_mx (rtx
&);
8584 extern void gt_ggc_mx (basic_block
&);
8587 gt_ggc_mx (edge_def
*e
)
8589 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8591 gt_ggc_mx (e
->dest
);
8592 if (current_ir_type () == IR_GIMPLE
)
8593 gt_ggc_mx (e
->insns
.g
);
8595 gt_ggc_mx (e
->insns
.r
);
8599 /* PCH support for edge_def. */
8601 extern void gt_pch_nx (tree
&);
8602 extern void gt_pch_nx (gimple
&);
8603 extern void gt_pch_nx (rtx
&);
8604 extern void gt_pch_nx (basic_block
&);
8607 gt_pch_nx (edge_def
*e
)
8609 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8611 gt_pch_nx (e
->dest
);
8612 if (current_ir_type () == IR_GIMPLE
)
8613 gt_pch_nx (e
->insns
.g
);
8615 gt_pch_nx (e
->insns
.r
);
8620 gt_pch_nx (edge_def
*e
, gt_pointer_operator op
, void *cookie
)
8622 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8623 op (&(e
->src
), cookie
);
8624 op (&(e
->dest
), cookie
);
8625 if (current_ir_type () == IR_GIMPLE
)
8626 op (&(e
->insns
.g
), cookie
);
8628 op (&(e
->insns
.r
), cookie
);
8629 op (&(block
), cookie
);