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"
28 #include "trans-mem.h"
29 #include "stor-layout.h"
30 #include "print-tree.h"
32 #include "basic-block.h"
35 #include "gimple-pretty-print.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 hash_map
<edge
, tree
> *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 (gimple_switch
, 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_transaction
);
167 static bool call_can_make_abnormal_goto (gimple
);
169 /* Flowgraph optimization and cleanup. */
170 static void gimple_merge_blocks (basic_block
, basic_block
);
171 static bool gimple_can_merge_blocks_p (basic_block
, basic_block
);
172 static void remove_bb (basic_block
);
173 static edge
find_taken_edge_computed_goto (basic_block
, tree
);
174 static edge
find_taken_edge_cond_expr (basic_block
, tree
);
175 static edge
find_taken_edge_switch_expr (gimple_switch
, basic_block
, tree
);
176 static tree
find_case_label_for_value (gimple_switch
, tree
);
179 init_empty_tree_cfg_for_function (struct function
*fn
)
181 /* Initialize the basic block array. */
183 profile_status_for_fn (fn
) = PROFILE_ABSENT
;
184 n_basic_blocks_for_fn (fn
) = NUM_FIXED_BLOCKS
;
185 last_basic_block_for_fn (fn
) = NUM_FIXED_BLOCKS
;
186 vec_alloc (basic_block_info_for_fn (fn
), initial_cfg_capacity
);
187 vec_safe_grow_cleared (basic_block_info_for_fn (fn
),
188 initial_cfg_capacity
);
190 /* Build a mapping of labels to their associated blocks. */
191 vec_alloc (label_to_block_map_for_fn (fn
), initial_cfg_capacity
);
192 vec_safe_grow_cleared (label_to_block_map_for_fn (fn
),
193 initial_cfg_capacity
);
195 SET_BASIC_BLOCK_FOR_FN (fn
, ENTRY_BLOCK
, ENTRY_BLOCK_PTR_FOR_FN (fn
));
196 SET_BASIC_BLOCK_FOR_FN (fn
, EXIT_BLOCK
, EXIT_BLOCK_PTR_FOR_FN (fn
));
198 ENTRY_BLOCK_PTR_FOR_FN (fn
)->next_bb
199 = EXIT_BLOCK_PTR_FOR_FN (fn
);
200 EXIT_BLOCK_PTR_FOR_FN (fn
)->prev_bb
201 = ENTRY_BLOCK_PTR_FOR_FN (fn
);
205 init_empty_tree_cfg (void)
207 init_empty_tree_cfg_for_function (cfun
);
210 /*---------------------------------------------------------------------------
212 ---------------------------------------------------------------------------*/
214 /* Entry point to the CFG builder for trees. SEQ is the sequence of
215 statements to be added to the flowgraph. */
218 build_gimple_cfg (gimple_seq seq
)
220 /* Register specific gimple functions. */
221 gimple_register_cfg_hooks ();
223 memset ((void *) &cfg_stats
, 0, sizeof (cfg_stats
));
225 init_empty_tree_cfg ();
229 /* Make sure there is always at least one block, even if it's empty. */
230 if (n_basic_blocks_for_fn (cfun
) == NUM_FIXED_BLOCKS
)
231 create_empty_bb (ENTRY_BLOCK_PTR_FOR_FN (cfun
));
233 /* Adjust the size of the array. */
234 if (basic_block_info_for_fn (cfun
)->length ()
235 < (size_t) n_basic_blocks_for_fn (cfun
))
236 vec_safe_grow_cleared (basic_block_info_for_fn (cfun
),
237 n_basic_blocks_for_fn (cfun
));
239 /* To speed up statement iterator walks, we first purge dead labels. */
240 cleanup_dead_labels ();
242 /* Group case nodes to reduce the number of edges.
243 We do this after cleaning up dead labels because otherwise we miss
244 a lot of obvious case merging opportunities. */
245 group_case_labels ();
247 /* Create the edges of the flowgraph. */
248 discriminator_per_locus
= new hash_table
<locus_discrim_hasher
> (13);
250 assign_discriminators ();
251 cleanup_dead_labels ();
252 delete discriminator_per_locus
;
253 discriminator_per_locus
= NULL
;
257 /* Look for ANNOTATE calls with loop annotation kind; if found, remove
258 them and propagate the information to the loop. We assume that the
259 annotations come immediately before the condition of the loop. */
262 replace_loop_annotate ()
266 gimple_stmt_iterator gsi
;
269 FOR_EACH_LOOP (loop
, 0)
271 gsi
= gsi_last_bb (loop
->header
);
272 stmt
= gsi_stmt (gsi
);
273 if (!(stmt
&& gimple_code (stmt
) == GIMPLE_COND
))
275 for (gsi_prev_nondebug (&gsi
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
277 stmt
= gsi_stmt (gsi
);
278 if (gimple_code (stmt
) != GIMPLE_CALL
)
280 if (!gimple_call_internal_p (stmt
)
281 || gimple_call_internal_fn (stmt
) != IFN_ANNOTATE
)
283 switch ((annot_expr_kind
) tree_to_shwi (gimple_call_arg (stmt
, 1)))
285 case annot_expr_ivdep_kind
:
286 loop
->safelen
= INT_MAX
;
288 case annot_expr_no_vector_kind
:
289 loop
->dont_vectorize
= true;
291 case annot_expr_vector_kind
:
292 loop
->force_vectorize
= true;
293 cfun
->has_force_vectorize_loops
= true;
298 stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
299 gimple_call_arg (stmt
, 0));
300 gsi_replace (&gsi
, stmt
, true);
304 /* Remove IFN_ANNOTATE. Safeguard for the case loop->latch == NULL. */
305 FOR_EACH_BB_FN (bb
, cfun
)
307 for (gsi
= gsi_last_bb (bb
); !gsi_end_p (gsi
); gsi_prev (&gsi
))
309 stmt
= gsi_stmt (gsi
);
310 if (gimple_code (stmt
) != GIMPLE_CALL
)
312 if (!gimple_call_internal_p (stmt
)
313 || gimple_call_internal_fn (stmt
) != IFN_ANNOTATE
)
315 switch ((annot_expr_kind
) tree_to_shwi (gimple_call_arg (stmt
, 1)))
317 case annot_expr_ivdep_kind
:
318 case annot_expr_no_vector_kind
:
319 case annot_expr_vector_kind
:
324 warning_at (gimple_location (stmt
), 0, "ignoring loop annotation");
325 stmt
= gimple_build_assign (gimple_call_lhs (stmt
),
326 gimple_call_arg (stmt
, 0));
327 gsi_replace (&gsi
, stmt
, true);
334 execute_build_cfg (void)
336 gimple_seq body
= gimple_body (current_function_decl
);
338 build_gimple_cfg (body
);
339 gimple_set_body (current_function_decl
, NULL
);
340 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
342 fprintf (dump_file
, "Scope blocks:\n");
343 dump_scope_blocks (dump_file
, dump_flags
);
346 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
347 replace_loop_annotate ();
353 const pass_data pass_data_build_cfg
=
355 GIMPLE_PASS
, /* type */
357 OPTGROUP_NONE
, /* optinfo_flags */
358 TV_TREE_CFG
, /* tv_id */
359 PROP_gimple_leh
, /* properties_required */
360 ( PROP_cfg
| PROP_loops
), /* properties_provided */
361 0, /* properties_destroyed */
362 0, /* todo_flags_start */
363 0, /* todo_flags_finish */
366 class pass_build_cfg
: public gimple_opt_pass
369 pass_build_cfg (gcc::context
*ctxt
)
370 : gimple_opt_pass (pass_data_build_cfg
, ctxt
)
373 /* opt_pass methods: */
374 virtual unsigned int execute (function
*) { return execute_build_cfg (); }
376 }; // class pass_build_cfg
381 make_pass_build_cfg (gcc::context
*ctxt
)
383 return new pass_build_cfg (ctxt
);
387 /* Return true if T is a computed goto. */
390 computed_goto_p (gimple t
)
392 return (gimple_code (t
) == GIMPLE_GOTO
393 && TREE_CODE (gimple_goto_dest (t
)) != LABEL_DECL
);
396 /* Returns true for edge E where e->src ends with a GIMPLE_COND and
397 the other edge points to a bb with just __builtin_unreachable ().
398 I.e. return true for C->M edge in:
406 __builtin_unreachable ();
410 assert_unreachable_fallthru_edge_p (edge e
)
412 basic_block pred_bb
= e
->src
;
413 gimple last
= last_stmt (pred_bb
);
414 if (last
&& gimple_code (last
) == GIMPLE_COND
)
416 basic_block other_bb
= EDGE_SUCC (pred_bb
, 0)->dest
;
417 if (other_bb
== e
->dest
)
418 other_bb
= EDGE_SUCC (pred_bb
, 1)->dest
;
419 if (EDGE_COUNT (other_bb
->succs
) == 0)
421 gimple_stmt_iterator gsi
= gsi_after_labels (other_bb
);
426 stmt
= gsi_stmt (gsi
);
427 while (is_gimple_debug (stmt
) || gimple_clobber_p (stmt
))
432 stmt
= gsi_stmt (gsi
);
434 return gimple_call_builtin_p (stmt
, BUILT_IN_UNREACHABLE
);
441 /* Initialize GF_CALL_CTRL_ALTERING flag, which indicates the call
442 could alter control flow except via eh. We initialize the flag at
443 CFG build time and only ever clear it later. */
446 gimple_call_initialize_ctrl_altering (gimple stmt
)
448 int flags
= gimple_call_flags (stmt
);
450 /* A call alters control flow if it can make an abnormal goto. */
451 if (call_can_make_abnormal_goto (stmt
)
452 /* A call also alters control flow if it does not return. */
453 || flags
& ECF_NORETURN
454 /* TM ending statements have backedges out of the transaction.
455 Return true so we split the basic block containing them.
456 Note that the TM_BUILTIN test is merely an optimization. */
457 || ((flags
& ECF_TM_BUILTIN
)
458 && is_tm_ending_fndecl (gimple_call_fndecl (stmt
)))
459 /* BUILT_IN_RETURN call is same as return statement. */
460 || gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
))
461 gimple_call_set_ctrl_altering (stmt
, true);
463 gimple_call_set_ctrl_altering (stmt
, false);
467 /* Build a flowgraph for the sequence of stmts SEQ. */
470 make_blocks (gimple_seq seq
)
472 gimple_stmt_iterator i
= gsi_start (seq
);
474 bool start_new_block
= true;
475 bool first_stmt_of_seq
= true;
476 basic_block bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
478 while (!gsi_end_p (i
))
485 if (stmt
&& is_gimple_call (stmt
))
486 gimple_call_initialize_ctrl_altering (stmt
);
488 /* If the statement starts a new basic block or if we have determined
489 in a previous pass that we need to create a new block for STMT, do
491 if (start_new_block
|| stmt_starts_bb_p (stmt
, prev_stmt
))
493 if (!first_stmt_of_seq
)
494 gsi_split_seq_before (&i
, &seq
);
495 bb
= create_basic_block (seq
, NULL
, bb
);
496 start_new_block
= false;
499 /* Now add STMT to BB and create the subgraphs for special statement
501 gimple_set_bb (stmt
, bb
);
503 /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
505 if (stmt_ends_bb_p (stmt
))
507 /* If the stmt can make abnormal goto use a new temporary
508 for the assignment to the LHS. This makes sure the old value
509 of the LHS is available on the abnormal edge. Otherwise
510 we will end up with overlapping life-ranges for abnormal
512 if (gimple_has_lhs (stmt
)
513 && stmt_can_make_abnormal_goto (stmt
)
514 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt
))))
516 tree lhs
= gimple_get_lhs (stmt
);
517 tree tmp
= create_tmp_var (TREE_TYPE (lhs
), NULL
);
518 gimple s
= gimple_build_assign (lhs
, tmp
);
519 gimple_set_location (s
, gimple_location (stmt
));
520 gimple_set_block (s
, gimple_block (stmt
));
521 gimple_set_lhs (stmt
, tmp
);
522 if (TREE_CODE (TREE_TYPE (tmp
)) == COMPLEX_TYPE
523 || TREE_CODE (TREE_TYPE (tmp
)) == VECTOR_TYPE
)
524 DECL_GIMPLE_REG_P (tmp
) = 1;
525 gsi_insert_after (&i
, s
, GSI_SAME_STMT
);
527 start_new_block
= true;
531 first_stmt_of_seq
= false;
536 /* Create and return a new empty basic block after bb AFTER. */
539 create_bb (void *h
, void *e
, basic_block after
)
545 /* Create and initialize a new basic block. Since alloc_block uses
546 GC allocation that clears memory to allocate a basic block, we do
547 not have to clear the newly allocated basic block here. */
550 bb
->index
= last_basic_block_for_fn (cfun
);
552 set_bb_seq (bb
, h
? (gimple_seq
) h
: NULL
);
554 /* Add the new block to the linked list of blocks. */
555 link_block (bb
, after
);
557 /* Grow the basic block array if needed. */
558 if ((size_t) last_basic_block_for_fn (cfun
)
559 == basic_block_info_for_fn (cfun
)->length ())
562 (last_basic_block_for_fn (cfun
)
563 + (last_basic_block_for_fn (cfun
) + 3) / 4);
564 vec_safe_grow_cleared (basic_block_info_for_fn (cfun
), new_size
);
567 /* Add the newly created block to the array. */
568 SET_BASIC_BLOCK_FOR_FN (cfun
, last_basic_block_for_fn (cfun
), bb
);
570 n_basic_blocks_for_fn (cfun
)++;
571 last_basic_block_for_fn (cfun
)++;
577 /*---------------------------------------------------------------------------
579 ---------------------------------------------------------------------------*/
581 /* Fold COND_EXPR_COND of each COND_EXPR. */
584 fold_cond_expr_cond (void)
588 FOR_EACH_BB_FN (bb
, cfun
)
590 gimple stmt
= last_stmt (bb
);
592 if (stmt
&& gimple_code (stmt
) == GIMPLE_COND
)
594 gimple_cond cond_stmt
= as_a
<gimple_cond
> (stmt
);
595 location_t loc
= gimple_location (stmt
);
599 fold_defer_overflow_warnings ();
600 cond
= fold_binary_loc (loc
, gimple_cond_code (cond_stmt
),
602 gimple_cond_lhs (cond_stmt
),
603 gimple_cond_rhs (cond_stmt
));
606 zerop
= integer_zerop (cond
);
607 onep
= integer_onep (cond
);
610 zerop
= onep
= false;
612 fold_undefer_overflow_warnings (zerop
|| onep
,
614 WARN_STRICT_OVERFLOW_CONDITIONAL
);
616 gimple_cond_make_false (cond_stmt
);
618 gimple_cond_make_true (cond_stmt
);
623 /* If basic block BB has an abnormal edge to a basic block
624 containing IFN_ABNORMAL_DISPATCHER internal call, return
625 that the dispatcher's basic block, otherwise return NULL. */
628 get_abnormal_succ_dispatcher (basic_block bb
)
633 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
634 if ((e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
)) == EDGE_ABNORMAL
)
636 gimple_stmt_iterator gsi
637 = gsi_start_nondebug_after_labels_bb (e
->dest
);
638 gimple g
= gsi_stmt (gsi
);
640 && is_gimple_call (g
)
641 && gimple_call_internal_p (g
)
642 && gimple_call_internal_fn (g
) == IFN_ABNORMAL_DISPATCHER
)
648 /* Helper function for make_edges. Create a basic block with
649 with ABNORMAL_DISPATCHER internal call in it if needed, and
650 create abnormal edges from BBS to it and from it to FOR_BB
651 if COMPUTED_GOTO is false, otherwise factor the computed gotos. */
654 handle_abnormal_edges (basic_block
*dispatcher_bbs
,
655 basic_block for_bb
, int *bb_to_omp_idx
,
656 auto_vec
<basic_block
> *bbs
, bool computed_goto
)
658 basic_block
*dispatcher
= dispatcher_bbs
+ (computed_goto
? 1 : 0);
659 unsigned int idx
= 0;
665 dispatcher
= dispatcher_bbs
+ 2 * bb_to_omp_idx
[for_bb
->index
];
666 if (bb_to_omp_idx
[for_bb
->index
] != 0)
670 /* If the dispatcher has been created already, then there are basic
671 blocks with abnormal edges to it, so just make a new edge to
673 if (*dispatcher
== NULL
)
675 /* Check if there are any basic blocks that need to have
676 abnormal edges to this dispatcher. If there are none, return
678 if (bb_to_omp_idx
== NULL
)
680 if (bbs
->is_empty ())
685 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
686 if (bb_to_omp_idx
[bb
->index
] == bb_to_omp_idx
[for_bb
->index
])
692 /* Create the dispatcher bb. */
693 *dispatcher
= create_basic_block (NULL
, NULL
, for_bb
);
696 /* Factor computed gotos into a common computed goto site. Also
697 record the location of that site so that we can un-factor the
698 gotos after we have converted back to normal form. */
699 gimple_stmt_iterator gsi
= gsi_start_bb (*dispatcher
);
701 /* Create the destination of the factored goto. Each original
702 computed goto will put its desired destination into this
703 variable and jump to the label we create immediately below. */
704 tree var
= create_tmp_var (ptr_type_node
, "gotovar");
706 /* Build a label for the new block which will contain the
707 factored computed goto. */
708 tree factored_label_decl
709 = create_artificial_label (UNKNOWN_LOCATION
);
710 gimple factored_computed_goto_label
711 = gimple_build_label (factored_label_decl
);
712 gsi_insert_after (&gsi
, factored_computed_goto_label
, GSI_NEW_STMT
);
714 /* Build our new computed goto. */
715 gimple factored_computed_goto
= gimple_build_goto (var
);
716 gsi_insert_after (&gsi
, factored_computed_goto
, GSI_NEW_STMT
);
718 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
721 && bb_to_omp_idx
[bb
->index
] != bb_to_omp_idx
[for_bb
->index
])
724 gsi
= gsi_last_bb (bb
);
725 gimple last
= gsi_stmt (gsi
);
727 gcc_assert (computed_goto_p (last
));
729 /* Copy the original computed goto's destination into VAR. */
731 = gimple_build_assign (var
, gimple_goto_dest (last
));
732 gsi_insert_before (&gsi
, assignment
, GSI_SAME_STMT
);
734 edge e
= make_edge (bb
, *dispatcher
, EDGE_FALLTHRU
);
735 e
->goto_locus
= gimple_location (last
);
736 gsi_remove (&gsi
, true);
741 tree arg
= inner
? boolean_true_node
: boolean_false_node
;
742 gimple g
= gimple_build_call_internal (IFN_ABNORMAL_DISPATCHER
,
744 gimple_stmt_iterator gsi
= gsi_after_labels (*dispatcher
);
745 gsi_insert_after (&gsi
, g
, GSI_NEW_STMT
);
747 /* Create predecessor edges of the dispatcher. */
748 FOR_EACH_VEC_ELT (*bbs
, idx
, bb
)
751 && bb_to_omp_idx
[bb
->index
] != bb_to_omp_idx
[for_bb
->index
])
753 make_edge (bb
, *dispatcher
, EDGE_ABNORMAL
);
758 make_edge (*dispatcher
, for_bb
, EDGE_ABNORMAL
);
761 /* Join all the blocks in the flowgraph. */
767 struct omp_region
*cur_region
= NULL
;
768 auto_vec
<basic_block
> ab_edge_goto
;
769 auto_vec
<basic_block
> ab_edge_call
;
770 int *bb_to_omp_idx
= NULL
;
771 int cur_omp_region_idx
= 0;
773 /* Create an edge from entry to the first block with executable
775 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
),
776 BASIC_BLOCK_FOR_FN (cfun
, NUM_FIXED_BLOCKS
),
779 /* Traverse the basic block array placing edges. */
780 FOR_EACH_BB_FN (bb
, cfun
)
782 gimple last
= last_stmt (bb
);
786 bb_to_omp_idx
[bb
->index
] = cur_omp_region_idx
;
790 enum gimple_code code
= gimple_code (last
);
794 if (make_goto_expr_edges (bb
))
795 ab_edge_goto
.safe_push (bb
);
800 edge e
= make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
801 e
->goto_locus
= gimple_location (last
);
806 make_cond_expr_edges (bb
);
810 make_gimple_switch_edges (as_a
<gimple_switch
> (last
), bb
);
814 make_eh_edges (last
);
817 case GIMPLE_EH_DISPATCH
:
819 make_eh_dispatch_edges (as_a
<gimple_eh_dispatch
> (last
));
823 /* If this function receives a nonlocal goto, then we need to
824 make edges from this call site to all the nonlocal goto
826 if (stmt_can_make_abnormal_goto (last
))
827 ab_edge_call
.safe_push (bb
);
829 /* If this statement has reachable exception handlers, then
830 create abnormal edges to them. */
831 make_eh_edges (last
);
833 /* BUILTIN_RETURN is really a return statement. */
834 if (gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
836 make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
839 /* Some calls are known not to return. */
841 fallthru
= !(gimple_call_flags (last
) & ECF_NORETURN
);
845 /* A GIMPLE_ASSIGN may throw internally and thus be considered
847 if (is_ctrl_altering_stmt (last
))
848 make_eh_edges (last
);
853 make_gimple_asm_edges (bb
);
858 fallthru
= make_gimple_omp_edges (bb
, &cur_region
,
859 &cur_omp_region_idx
);
860 if (cur_region
&& bb_to_omp_idx
== NULL
)
861 bb_to_omp_idx
= XCNEWVEC (int, n_basic_blocks_for_fn (cfun
));
864 case GIMPLE_TRANSACTION
:
867 gimple_transaction_label (as_a
<gimple_transaction
> (last
));
869 make_edge (bb
, label_to_block (abort_label
), EDGE_TM_ABORT
);
875 gcc_assert (!stmt_ends_bb_p (last
));
883 make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
886 /* Computed gotos are hell to deal with, especially if there are
887 lots of them with a large number of destinations. So we factor
888 them to a common computed goto location before we build the
889 edge list. After we convert back to normal form, we will un-factor
890 the computed gotos since factoring introduces an unwanted jump.
891 For non-local gotos and abnormal edges from calls to calls that return
892 twice or forced labels, factor the abnormal edges too, by having all
893 abnormal edges from the calls go to a common artificial basic block
894 with ABNORMAL_DISPATCHER internal call and abnormal edges from that
895 basic block to all forced labels and calls returning twice.
896 We do this per-OpenMP structured block, because those regions
897 are guaranteed to be single entry single exit by the standard,
898 so it is not allowed to enter or exit such regions abnormally this way,
899 thus all computed gotos, non-local gotos and setjmp/longjmp calls
900 must not transfer control across SESE region boundaries. */
901 if (!ab_edge_goto
.is_empty () || !ab_edge_call
.is_empty ())
903 gimple_stmt_iterator gsi
;
904 basic_block dispatcher_bb_array
[2] = { NULL
, NULL
};
905 basic_block
*dispatcher_bbs
= dispatcher_bb_array
;
906 int count
= n_basic_blocks_for_fn (cfun
);
909 dispatcher_bbs
= XCNEWVEC (basic_block
, 2 * count
);
911 FOR_EACH_BB_FN (bb
, cfun
)
913 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
915 gimple_label label_stmt
=
916 dyn_cast
<gimple_label
> (gsi_stmt (gsi
));
922 target
= gimple_label_label (label_stmt
);
924 /* Make an edge to every label block that has been marked as a
925 potential target for a computed goto or a non-local goto. */
926 if (FORCED_LABEL (target
))
927 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
928 &ab_edge_goto
, true);
929 if (DECL_NONLOCAL (target
))
931 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
932 &ab_edge_call
, false);
937 if (!gsi_end_p (gsi
) && is_gimple_debug (gsi_stmt (gsi
)))
938 gsi_next_nondebug (&gsi
);
939 if (!gsi_end_p (gsi
))
941 /* Make an edge to every setjmp-like call. */
942 gimple call_stmt
= gsi_stmt (gsi
);
943 if (is_gimple_call (call_stmt
)
944 && ((gimple_call_flags (call_stmt
) & ECF_RETURNS_TWICE
)
945 || gimple_call_builtin_p (call_stmt
,
946 BUILT_IN_SETJMP_RECEIVER
)))
947 handle_abnormal_edges (dispatcher_bbs
, bb
, bb_to_omp_idx
,
948 &ab_edge_call
, false);
953 XDELETE (dispatcher_bbs
);
956 XDELETE (bb_to_omp_idx
);
960 /* Fold COND_EXPR_COND of each COND_EXPR. */
961 fold_cond_expr_cond ();
964 /* Find the next available discriminator value for LOCUS. The
965 discriminator distinguishes among several basic blocks that
966 share a common locus, allowing for more accurate sample-based
970 next_discriminator_for_locus (location_t locus
)
972 struct locus_discrim_map item
;
973 struct locus_discrim_map
**slot
;
976 item
.discriminator
= 0;
977 slot
= discriminator_per_locus
->find_slot_with_hash (
978 &item
, LOCATION_LINE (locus
), INSERT
);
980 if (*slot
== HTAB_EMPTY_ENTRY
)
982 *slot
= XNEW (struct locus_discrim_map
);
984 (*slot
)->locus
= locus
;
985 (*slot
)->discriminator
= 0;
987 (*slot
)->discriminator
++;
988 return (*slot
)->discriminator
;
991 /* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line. */
994 same_line_p (location_t locus1
, location_t locus2
)
996 expanded_location from
, to
;
998 if (locus1
== locus2
)
1001 from
= expand_location (locus1
);
1002 to
= expand_location (locus2
);
1004 if (from
.line
!= to
.line
)
1006 if (from
.file
== to
.file
)
1008 return (from
.file
!= NULL
1010 && filename_cmp (from
.file
, to
.file
) == 0);
1013 /* Assign discriminators to each basic block. */
1016 assign_discriminators (void)
1020 FOR_EACH_BB_FN (bb
, cfun
)
1024 gimple last
= last_stmt (bb
);
1025 location_t locus
= last
? gimple_location (last
) : UNKNOWN_LOCATION
;
1027 if (locus
== UNKNOWN_LOCATION
)
1030 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1032 gimple first
= first_non_label_stmt (e
->dest
);
1033 gimple last
= last_stmt (e
->dest
);
1034 if ((first
&& same_line_p (locus
, gimple_location (first
)))
1035 || (last
&& same_line_p (locus
, gimple_location (last
))))
1037 if (e
->dest
->discriminator
!= 0 && bb
->discriminator
== 0)
1038 bb
->discriminator
= next_discriminator_for_locus (locus
);
1040 e
->dest
->discriminator
= next_discriminator_for_locus (locus
);
1046 /* Create the edges for a GIMPLE_COND starting at block BB. */
1049 make_cond_expr_edges (basic_block bb
)
1051 gimple_cond entry
= as_a
<gimple_cond
> (last_stmt (bb
));
1052 gimple then_stmt
, else_stmt
;
1053 basic_block then_bb
, else_bb
;
1054 tree then_label
, else_label
;
1058 gcc_assert (gimple_code (entry
) == GIMPLE_COND
);
1060 /* Entry basic blocks for each component. */
1061 then_label
= gimple_cond_true_label (entry
);
1062 else_label
= gimple_cond_false_label (entry
);
1063 then_bb
= label_to_block (then_label
);
1064 else_bb
= label_to_block (else_label
);
1065 then_stmt
= first_stmt (then_bb
);
1066 else_stmt
= first_stmt (else_bb
);
1068 e
= make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
1069 e
->goto_locus
= gimple_location (then_stmt
);
1070 e
= make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
1072 e
->goto_locus
= gimple_location (else_stmt
);
1074 /* We do not need the labels anymore. */
1075 gimple_cond_set_true_label (entry
, NULL_TREE
);
1076 gimple_cond_set_false_label (entry
, NULL_TREE
);
1080 /* Called for each element in the hash table (P) as we delete the
1081 edge to cases hash table.
1083 Clear all the TREE_CHAINs to prevent problems with copying of
1084 SWITCH_EXPRs and structure sharing rules, then free the hash table
1088 edge_to_cases_cleanup (edge
const &, tree
const &value
, void *)
1092 for (t
= value
; t
; t
= next
)
1094 next
= CASE_CHAIN (t
);
1095 CASE_CHAIN (t
) = NULL
;
1101 /* Start recording information mapping edges to case labels. */
1104 start_recording_case_labels (void)
1106 gcc_assert (edge_to_cases
== NULL
);
1107 edge_to_cases
= new hash_map
<edge
, tree
>;
1108 touched_switch_bbs
= BITMAP_ALLOC (NULL
);
1111 /* Return nonzero if we are recording information for case labels. */
1114 recording_case_labels_p (void)
1116 return (edge_to_cases
!= NULL
);
1119 /* Stop recording information mapping edges to case labels and
1120 remove any information we have recorded. */
1122 end_recording_case_labels (void)
1126 edge_to_cases
->traverse
<void *, edge_to_cases_cleanup
> (NULL
);
1127 delete edge_to_cases
;
1128 edge_to_cases
= NULL
;
1129 EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs
, 0, i
, bi
)
1131 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
1134 gimple stmt
= last_stmt (bb
);
1135 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1136 group_case_labels_stmt (as_a
<gimple_switch
> (stmt
));
1139 BITMAP_FREE (touched_switch_bbs
);
1142 /* If we are inside a {start,end}_recording_cases block, then return
1143 a chain of CASE_LABEL_EXPRs from T which reference E.
1145 Otherwise return NULL. */
1148 get_cases_for_edge (edge e
, gimple_switch t
)
1153 /* If we are not recording cases, then we do not have CASE_LABEL_EXPR
1154 chains available. Return NULL so the caller can detect this case. */
1155 if (!recording_case_labels_p ())
1158 slot
= edge_to_cases
->get (e
);
1162 /* If we did not find E in the hash table, then this must be the first
1163 time we have been queried for information about E & T. Add all the
1164 elements from T to the hash table then perform the query again. */
1166 n
= gimple_switch_num_labels (t
);
1167 for (i
= 0; i
< n
; i
++)
1169 tree elt
= gimple_switch_label (t
, i
);
1170 tree lab
= CASE_LABEL (elt
);
1171 basic_block label_bb
= label_to_block (lab
);
1172 edge this_edge
= find_edge (e
->src
, label_bb
);
1174 /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
1176 tree
&s
= edge_to_cases
->get_or_insert (this_edge
);
1177 CASE_CHAIN (elt
) = s
;
1181 return *edge_to_cases
->get (e
);
1184 /* Create the edges for a GIMPLE_SWITCH starting at block BB. */
1187 make_gimple_switch_edges (gimple_switch entry
, basic_block bb
)
1191 n
= gimple_switch_num_labels (entry
);
1193 for (i
= 0; i
< n
; ++i
)
1195 tree lab
= CASE_LABEL (gimple_switch_label (entry
, i
));
1196 basic_block label_bb
= label_to_block (lab
);
1197 make_edge (bb
, label_bb
, 0);
1202 /* Return the basic block holding label DEST. */
1205 label_to_block_fn (struct function
*ifun
, tree dest
)
1207 int uid
= LABEL_DECL_UID (dest
);
1209 /* We would die hard when faced by an undefined label. Emit a label to
1210 the very first basic block. This will hopefully make even the dataflow
1211 and undefined variable warnings quite right. */
1212 if (seen_error () && uid
< 0)
1214 gimple_stmt_iterator gsi
=
1215 gsi_start_bb (BASIC_BLOCK_FOR_FN (cfun
, NUM_FIXED_BLOCKS
));
1218 stmt
= gimple_build_label (dest
);
1219 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
1220 uid
= LABEL_DECL_UID (dest
);
1222 if (vec_safe_length (ifun
->cfg
->x_label_to_block_map
) <= (unsigned int) uid
)
1224 return (*ifun
->cfg
->x_label_to_block_map
)[uid
];
1227 /* Create edges for a goto statement at block BB. Returns true
1228 if abnormal edges should be created. */
1231 make_goto_expr_edges (basic_block bb
)
1233 gimple_stmt_iterator last
= gsi_last_bb (bb
);
1234 gimple goto_t
= gsi_stmt (last
);
1236 /* A simple GOTO creates normal edges. */
1237 if (simple_goto_p (goto_t
))
1239 tree dest
= gimple_goto_dest (goto_t
);
1240 basic_block label_bb
= label_to_block (dest
);
1241 edge e
= make_edge (bb
, label_bb
, EDGE_FALLTHRU
);
1242 e
->goto_locus
= gimple_location (goto_t
);
1243 gsi_remove (&last
, true);
1247 /* A computed GOTO creates abnormal edges. */
1251 /* Create edges for an asm statement with labels at block BB. */
1254 make_gimple_asm_edges (basic_block bb
)
1256 gimple_asm stmt
= as_a
<gimple_asm
> (last_stmt (bb
));
1257 int i
, n
= gimple_asm_nlabels (stmt
);
1259 for (i
= 0; i
< n
; ++i
)
1261 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
1262 basic_block label_bb
= label_to_block (label
);
1263 make_edge (bb
, label_bb
, 0);
1267 /*---------------------------------------------------------------------------
1269 ---------------------------------------------------------------------------*/
1271 /* Cleanup useless labels in basic blocks. This is something we wish
1272 to do early because it allows us to group case labels before creating
1273 the edges for the CFG, and it speeds up block statement iterators in
1274 all passes later on.
1275 We rerun this pass after CFG is created, to get rid of the labels that
1276 are no longer referenced. After then we do not run it any more, since
1277 (almost) no new labels should be created. */
1279 /* A map from basic block index to the leading label of that block. */
1280 static struct label_record
1285 /* True if the label is referenced from somewhere. */
1289 /* Given LABEL return the first label in the same basic block. */
1292 main_block_label (tree label
)
1294 basic_block bb
= label_to_block (label
);
1295 tree main_label
= label_for_bb
[bb
->index
].label
;
1297 /* label_to_block possibly inserted undefined label into the chain. */
1300 label_for_bb
[bb
->index
].label
= label
;
1304 label_for_bb
[bb
->index
].used
= true;
1308 /* Clean up redundant labels within the exception tree. */
1311 cleanup_dead_labels_eh (void)
1318 if (cfun
->eh
== NULL
)
1321 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1322 if (lp
&& lp
->post_landing_pad
)
1324 lab
= main_block_label (lp
->post_landing_pad
);
1325 if (lab
!= lp
->post_landing_pad
)
1327 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1328 EH_LANDING_PAD_NR (lab
) = lp
->index
;
1332 FOR_ALL_EH_REGION (r
)
1336 case ERT_MUST_NOT_THROW
:
1342 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
1346 c
->label
= main_block_label (lab
);
1351 case ERT_ALLOWED_EXCEPTIONS
:
1352 lab
= r
->u
.allowed
.label
;
1354 r
->u
.allowed
.label
= main_block_label (lab
);
1360 /* Cleanup redundant labels. This is a three-step process:
1361 1) Find the leading label for each block.
1362 2) Redirect all references to labels to the leading labels.
1363 3) Cleanup all useless labels. */
1366 cleanup_dead_labels (void)
1369 label_for_bb
= XCNEWVEC (struct label_record
, last_basic_block_for_fn (cfun
));
1371 /* Find a suitable label for each block. We use the first user-defined
1372 label if there is one, or otherwise just the first label we see. */
1373 FOR_EACH_BB_FN (bb
, cfun
)
1375 gimple_stmt_iterator i
;
1377 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
1380 gimple_label label_stmt
= dyn_cast
<gimple_label
> (gsi_stmt (i
));
1385 label
= gimple_label_label (label_stmt
);
1387 /* If we have not yet seen a label for the current block,
1388 remember this one and see if there are more labels. */
1389 if (!label_for_bb
[bb
->index
].label
)
1391 label_for_bb
[bb
->index
].label
= label
;
1395 /* If we did see a label for the current block already, but it
1396 is an artificially created label, replace it if the current
1397 label is a user defined label. */
1398 if (!DECL_ARTIFICIAL (label
)
1399 && DECL_ARTIFICIAL (label_for_bb
[bb
->index
].label
))
1401 label_for_bb
[bb
->index
].label
= label
;
1407 /* Now redirect all jumps/branches to the selected label.
1408 First do so for each block ending in a control statement. */
1409 FOR_EACH_BB_FN (bb
, cfun
)
1411 gimple stmt
= last_stmt (bb
);
1412 tree label
, new_label
;
1417 switch (gimple_code (stmt
))
1421 gimple_cond cond_stmt
= as_a
<gimple_cond
> (stmt
);
1422 label
= gimple_cond_true_label (cond_stmt
);
1425 new_label
= main_block_label (label
);
1426 if (new_label
!= label
)
1427 gimple_cond_set_true_label (cond_stmt
, new_label
);
1430 label
= gimple_cond_false_label (cond_stmt
);
1433 new_label
= main_block_label (label
);
1434 if (new_label
!= label
)
1435 gimple_cond_set_false_label (cond_stmt
, new_label
);
1442 gimple_switch switch_stmt
= as_a
<gimple_switch
> (stmt
);
1443 size_t i
, n
= gimple_switch_num_labels (switch_stmt
);
1445 /* Replace all destination labels. */
1446 for (i
= 0; i
< n
; ++i
)
1448 tree case_label
= gimple_switch_label (switch_stmt
, i
);
1449 label
= CASE_LABEL (case_label
);
1450 new_label
= main_block_label (label
);
1451 if (new_label
!= label
)
1452 CASE_LABEL (case_label
) = new_label
;
1459 gimple_asm asm_stmt
= as_a
<gimple_asm
> (stmt
);
1460 int i
, n
= gimple_asm_nlabels (asm_stmt
);
1462 for (i
= 0; i
< n
; ++i
)
1464 tree cons
= gimple_asm_label_op (asm_stmt
, i
);
1465 tree label
= main_block_label (TREE_VALUE (cons
));
1466 TREE_VALUE (cons
) = label
;
1471 /* We have to handle gotos until they're removed, and we don't
1472 remove them until after we've created the CFG edges. */
1474 if (!computed_goto_p (stmt
))
1476 gimple_goto goto_stmt
= as_a
<gimple_goto
> (stmt
);
1477 label
= gimple_goto_dest (goto_stmt
);
1478 new_label
= main_block_label (label
);
1479 if (new_label
!= label
)
1480 gimple_goto_set_dest (goto_stmt
, new_label
);
1484 case GIMPLE_TRANSACTION
:
1486 gimple_transaction trans_stmt
= as_a
<gimple_transaction
> (stmt
);
1487 tree label
= gimple_transaction_label (trans_stmt
);
1490 tree new_label
= main_block_label (label
);
1491 if (new_label
!= label
)
1492 gimple_transaction_set_label (trans_stmt
, new_label
);
1502 /* Do the same for the exception region tree labels. */
1503 cleanup_dead_labels_eh ();
1505 /* Finally, purge dead labels. All user-defined labels and labels that
1506 can be the target of non-local gotos and labels which have their
1507 address taken are preserved. */
1508 FOR_EACH_BB_FN (bb
, cfun
)
1510 gimple_stmt_iterator i
;
1511 tree label_for_this_bb
= label_for_bb
[bb
->index
].label
;
1513 if (!label_for_this_bb
)
1516 /* If the main label of the block is unused, we may still remove it. */
1517 if (!label_for_bb
[bb
->index
].used
)
1518 label_for_this_bb
= NULL
;
1520 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); )
1523 gimple_label label_stmt
= dyn_cast
<gimple_label
> (gsi_stmt (i
));
1528 label
= gimple_label_label (label_stmt
);
1530 if (label
== label_for_this_bb
1531 || !DECL_ARTIFICIAL (label
)
1532 || DECL_NONLOCAL (label
)
1533 || FORCED_LABEL (label
))
1536 gsi_remove (&i
, true);
1540 free (label_for_bb
);
1543 /* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
1544 the ones jumping to the same label.
1545 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
1548 group_case_labels_stmt (gimple_switch stmt
)
1550 int old_size
= gimple_switch_num_labels (stmt
);
1551 int i
, j
, new_size
= old_size
;
1552 basic_block default_bb
= NULL
;
1554 default_bb
= label_to_block (CASE_LABEL (gimple_switch_default_label (stmt
)));
1556 /* Look for possible opportunities to merge cases. */
1558 while (i
< old_size
)
1560 tree base_case
, base_high
;
1561 basic_block base_bb
;
1563 base_case
= gimple_switch_label (stmt
, i
);
1565 gcc_assert (base_case
);
1566 base_bb
= label_to_block (CASE_LABEL (base_case
));
1568 /* Discard cases that have the same destination as the
1570 if (base_bb
== default_bb
)
1572 gimple_switch_set_label (stmt
, i
, NULL_TREE
);
1578 base_high
= CASE_HIGH (base_case
)
1579 ? CASE_HIGH (base_case
)
1580 : CASE_LOW (base_case
);
1583 /* Try to merge case labels. Break out when we reach the end
1584 of the label vector or when we cannot merge the next case
1585 label with the current one. */
1586 while (i
< old_size
)
1588 tree merge_case
= gimple_switch_label (stmt
, i
);
1589 basic_block merge_bb
= label_to_block (CASE_LABEL (merge_case
));
1590 wide_int bhp1
= wi::add (base_high
, 1);
1592 /* Merge the cases if they jump to the same place,
1593 and their ranges are consecutive. */
1594 if (merge_bb
== base_bb
1595 && wi::eq_p (CASE_LOW (merge_case
), bhp1
))
1597 base_high
= CASE_HIGH (merge_case
) ?
1598 CASE_HIGH (merge_case
) : CASE_LOW (merge_case
);
1599 CASE_HIGH (base_case
) = base_high
;
1600 gimple_switch_set_label (stmt
, i
, NULL_TREE
);
1609 /* Compress the case labels in the label vector, and adjust the
1610 length of the vector. */
1611 for (i
= 0, j
= 0; i
< new_size
; i
++)
1613 while (! gimple_switch_label (stmt
, j
))
1615 gimple_switch_set_label (stmt
, i
,
1616 gimple_switch_label (stmt
, j
++));
1619 gcc_assert (new_size
<= old_size
);
1620 gimple_switch_set_num_labels (stmt
, new_size
);
1623 /* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
1624 and scan the sorted vector of cases. Combine the ones jumping to the
1628 group_case_labels (void)
1632 FOR_EACH_BB_FN (bb
, cfun
)
1634 gimple stmt
= last_stmt (bb
);
1635 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1636 group_case_labels_stmt (as_a
<gimple_switch
> (stmt
));
1640 /* Checks whether we can merge block B into block A. */
1643 gimple_can_merge_blocks_p (basic_block a
, basic_block b
)
1646 gimple_stmt_iterator gsi
;
1648 if (!single_succ_p (a
))
1651 if (single_succ_edge (a
)->flags
& EDGE_COMPLEX
)
1654 if (single_succ (a
) != b
)
1657 if (!single_pred_p (b
))
1660 if (b
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
1663 /* If A ends by a statement causing exceptions or something similar, we
1664 cannot merge the blocks. */
1665 stmt
= last_stmt (a
);
1666 if (stmt
&& stmt_ends_bb_p (stmt
))
1669 /* Do not allow a block with only a non-local label to be merged. */
1671 if (gimple_label label_stmt
= dyn_cast
<gimple_label
> (stmt
))
1672 if (DECL_NONLOCAL (gimple_label_label (label_stmt
)))
1675 /* Examine the labels at the beginning of B. */
1676 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1679 gimple_label label_stmt
= dyn_cast
<gimple_label
> (gsi_stmt (gsi
));
1682 lab
= gimple_label_label (label_stmt
);
1684 /* Do not remove user forced labels or for -O0 any user labels. */
1685 if (!DECL_ARTIFICIAL (lab
) && (!optimize
|| FORCED_LABEL (lab
)))
1689 /* Protect the loop latches. */
1690 if (current_loops
&& b
->loop_father
->latch
== b
)
1693 /* It must be possible to eliminate all phi nodes in B. If ssa form
1694 is not up-to-date and a name-mapping is registered, we cannot eliminate
1695 any phis. Symbols marked for renaming are never a problem though. */
1696 for (gsi
= gsi_start_phis (b
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1698 gimple phi
= gsi_stmt (gsi
);
1699 /* Technically only new names matter. */
1700 if (name_registered_for_update_p (PHI_RESULT (phi
)))
1704 /* When not optimizing, don't merge if we'd lose goto_locus. */
1706 && single_succ_edge (a
)->goto_locus
!= UNKNOWN_LOCATION
)
1708 location_t goto_locus
= single_succ_edge (a
)->goto_locus
;
1709 gimple_stmt_iterator prev
, next
;
1710 prev
= gsi_last_nondebug_bb (a
);
1711 next
= gsi_after_labels (b
);
1712 if (!gsi_end_p (next
) && is_gimple_debug (gsi_stmt (next
)))
1713 gsi_next_nondebug (&next
);
1714 if ((gsi_end_p (prev
)
1715 || gimple_location (gsi_stmt (prev
)) != goto_locus
)
1716 && (gsi_end_p (next
)
1717 || gimple_location (gsi_stmt (next
)) != goto_locus
))
1724 /* Replaces all uses of NAME by VAL. */
1727 replace_uses_by (tree name
, tree val
)
1729 imm_use_iterator imm_iter
;
1734 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, name
)
1736 /* Mark the block if we change the last stmt in it. */
1737 if (cfgcleanup_altered_bbs
1738 && stmt_ends_bb_p (stmt
))
1739 bitmap_set_bit (cfgcleanup_altered_bbs
, gimple_bb (stmt
)->index
);
1741 FOR_EACH_IMM_USE_ON_STMT (use
, imm_iter
)
1743 replace_exp (use
, val
);
1745 if (gimple_code (stmt
) == GIMPLE_PHI
)
1747 e
= gimple_phi_arg_edge (as_a
<gimple_phi
> (stmt
),
1748 PHI_ARG_INDEX_FROM_USE (use
));
1749 if (e
->flags
& EDGE_ABNORMAL
)
1751 /* This can only occur for virtual operands, since
1752 for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
1753 would prevent replacement. */
1754 gcc_checking_assert (virtual_operand_p (name
));
1755 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val
) = 1;
1760 if (gimple_code (stmt
) != GIMPLE_PHI
)
1762 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
1763 gimple orig_stmt
= stmt
;
1766 /* FIXME. It shouldn't be required to keep TREE_CONSTANT
1767 on ADDR_EXPRs up-to-date on GIMPLE. Propagation will
1768 only change sth from non-invariant to invariant, and only
1769 when propagating constants. */
1770 if (is_gimple_min_invariant (val
))
1771 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1773 tree op
= gimple_op (stmt
, i
);
1774 /* Operands may be empty here. For example, the labels
1775 of a GIMPLE_COND are nulled out following the creation
1776 of the corresponding CFG edges. */
1777 if (op
&& TREE_CODE (op
) == ADDR_EXPR
)
1778 recompute_tree_invariant_for_addr_expr (op
);
1781 if (fold_stmt (&gsi
))
1782 stmt
= gsi_stmt (gsi
);
1784 if (maybe_clean_or_replace_eh_stmt (orig_stmt
, stmt
))
1785 gimple_purge_dead_eh_edges (gimple_bb (stmt
));
1791 gcc_checking_assert (has_zero_uses (name
));
1793 /* Also update the trees stored in loop structures. */
1798 FOR_EACH_LOOP (loop
, 0)
1800 substitute_in_loop_info (loop
, name
, val
);
1805 /* Merge block B into block A. */
1808 gimple_merge_blocks (basic_block a
, basic_block b
)
1810 gimple_stmt_iterator last
, gsi
, psi
;
1813 fprintf (dump_file
, "Merging blocks %d and %d\n", a
->index
, b
->index
);
1815 /* Remove all single-valued PHI nodes from block B of the form
1816 V_i = PHI <V_j> by propagating V_j to all the uses of V_i. */
1817 gsi
= gsi_last_bb (a
);
1818 for (psi
= gsi_start_phis (b
); !gsi_end_p (psi
); )
1820 gimple phi
= gsi_stmt (psi
);
1821 tree def
= gimple_phi_result (phi
), use
= gimple_phi_arg_def (phi
, 0);
1823 bool may_replace_uses
= (virtual_operand_p (def
)
1824 || may_propagate_copy (def
, use
));
1826 /* In case we maintain loop closed ssa form, do not propagate arguments
1827 of loop exit phi nodes. */
1829 && loops_state_satisfies_p (LOOP_CLOSED_SSA
)
1830 && !virtual_operand_p (def
)
1831 && TREE_CODE (use
) == SSA_NAME
1832 && a
->loop_father
!= b
->loop_father
)
1833 may_replace_uses
= false;
1835 if (!may_replace_uses
)
1837 gcc_assert (!virtual_operand_p (def
));
1839 /* Note that just emitting the copies is fine -- there is no problem
1840 with ordering of phi nodes. This is because A is the single
1841 predecessor of B, therefore results of the phi nodes cannot
1842 appear as arguments of the phi nodes. */
1843 copy
= gimple_build_assign (def
, use
);
1844 gsi_insert_after (&gsi
, copy
, GSI_NEW_STMT
);
1845 remove_phi_node (&psi
, false);
1849 /* If we deal with a PHI for virtual operands, we can simply
1850 propagate these without fussing with folding or updating
1852 if (virtual_operand_p (def
))
1854 imm_use_iterator iter
;
1855 use_operand_p use_p
;
1858 FOR_EACH_IMM_USE_STMT (stmt
, iter
, def
)
1859 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
1860 SET_USE (use_p
, use
);
1862 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
1863 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use
) = 1;
1866 replace_uses_by (def
, use
);
1868 remove_phi_node (&psi
, true);
1872 /* Ensure that B follows A. */
1873 move_block_after (b
, a
);
1875 gcc_assert (single_succ_edge (a
)->flags
& EDGE_FALLTHRU
);
1876 gcc_assert (!last_stmt (a
) || !stmt_ends_bb_p (last_stmt (a
)));
1878 /* Remove labels from B and set gimple_bb to A for other statements. */
1879 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
);)
1881 gimple stmt
= gsi_stmt (gsi
);
1882 if (gimple_label label_stmt
= dyn_cast
<gimple_label
> (stmt
))
1884 tree label
= gimple_label_label (label_stmt
);
1887 gsi_remove (&gsi
, false);
1889 /* Now that we can thread computed gotos, we might have
1890 a situation where we have a forced label in block B
1891 However, the label at the start of block B might still be
1892 used in other ways (think about the runtime checking for
1893 Fortran assigned gotos). So we can not just delete the
1894 label. Instead we move the label to the start of block A. */
1895 if (FORCED_LABEL (label
))
1897 gimple_stmt_iterator dest_gsi
= gsi_start_bb (a
);
1898 gsi_insert_before (&dest_gsi
, stmt
, GSI_NEW_STMT
);
1900 /* Other user labels keep around in a form of a debug stmt. */
1901 else if (!DECL_ARTIFICIAL (label
) && MAY_HAVE_DEBUG_STMTS
)
1903 gimple dbg
= gimple_build_debug_bind (label
,
1906 gimple_debug_bind_reset_value (dbg
);
1907 gsi_insert_before (&gsi
, dbg
, GSI_SAME_STMT
);
1910 lp_nr
= EH_LANDING_PAD_NR (label
);
1913 eh_landing_pad lp
= get_eh_landing_pad_from_number (lp_nr
);
1914 lp
->post_landing_pad
= NULL
;
1919 gimple_set_bb (stmt
, a
);
1924 /* When merging two BBs, if their counts are different, the larger count
1925 is selected as the new bb count. This is to handle inconsistent
1927 if (a
->loop_father
== b
->loop_father
)
1929 a
->count
= MAX (a
->count
, b
->count
);
1930 a
->frequency
= MAX (a
->frequency
, b
->frequency
);
1933 /* Merge the sequences. */
1934 last
= gsi_last_bb (a
);
1935 gsi_insert_seq_after (&last
, bb_seq (b
), GSI_NEW_STMT
);
1936 set_bb_seq (b
, NULL
);
1938 if (cfgcleanup_altered_bbs
)
1939 bitmap_set_bit (cfgcleanup_altered_bbs
, a
->index
);
1943 /* Return the one of two successors of BB that is not reachable by a
1944 complex edge, if there is one. Else, return BB. We use
1945 this in optimizations that use post-dominators for their heuristics,
1946 to catch the cases in C++ where function calls are involved. */
1949 single_noncomplex_succ (basic_block bb
)
1952 if (EDGE_COUNT (bb
->succs
) != 2)
1955 e0
= EDGE_SUCC (bb
, 0);
1956 e1
= EDGE_SUCC (bb
, 1);
1957 if (e0
->flags
& EDGE_COMPLEX
)
1959 if (e1
->flags
& EDGE_COMPLEX
)
1965 /* T is CALL_EXPR. Set current_function_calls_* flags. */
1968 notice_special_calls (gimple_call call
)
1970 int flags
= gimple_call_flags (call
);
1972 if (flags
& ECF_MAY_BE_ALLOCA
)
1973 cfun
->calls_alloca
= true;
1974 if (flags
& ECF_RETURNS_TWICE
)
1975 cfun
->calls_setjmp
= true;
1979 /* Clear flags set by notice_special_calls. Used by dead code removal
1980 to update the flags. */
1983 clear_special_calls (void)
1985 cfun
->calls_alloca
= false;
1986 cfun
->calls_setjmp
= false;
1989 /* Remove PHI nodes associated with basic block BB and all edges out of BB. */
1992 remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb
)
1994 /* Since this block is no longer reachable, we can just delete all
1995 of its PHI nodes. */
1996 remove_phi_nodes (bb
);
1998 /* Remove edges to BB's successors. */
1999 while (EDGE_COUNT (bb
->succs
) > 0)
2000 remove_edge (EDGE_SUCC (bb
, 0));
2004 /* Remove statements of basic block BB. */
2007 remove_bb (basic_block bb
)
2009 gimple_stmt_iterator i
;
2013 fprintf (dump_file
, "Removing basic block %d\n", bb
->index
);
2014 if (dump_flags
& TDF_DETAILS
)
2016 dump_bb (dump_file
, bb
, 0, TDF_BLOCKS
);
2017 fprintf (dump_file
, "\n");
2023 struct loop
*loop
= bb
->loop_father
;
2025 /* If a loop gets removed, clean up the information associated
2027 if (loop
->latch
== bb
2028 || loop
->header
== bb
)
2029 free_numbers_of_iterations_estimates_loop (loop
);
2032 /* Remove all the instructions in the block. */
2033 if (bb_seq (bb
) != NULL
)
2035 /* Walk backwards so as to get a chance to substitute all
2036 released DEFs into debug stmts. See
2037 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
2039 for (i
= gsi_last_bb (bb
); !gsi_end_p (i
);)
2041 gimple stmt
= gsi_stmt (i
);
2042 gimple_label label_stmt
= dyn_cast
<gimple_label
> (stmt
);
2044 && (FORCED_LABEL (gimple_label_label (label_stmt
))
2045 || DECL_NONLOCAL (gimple_label_label (label_stmt
))))
2048 gimple_stmt_iterator new_gsi
;
2050 /* A non-reachable non-local label may still be referenced.
2051 But it no longer needs to carry the extra semantics of
2053 if (DECL_NONLOCAL (gimple_label_label (label_stmt
)))
2055 DECL_NONLOCAL (gimple_label_label (label_stmt
)) = 0;
2056 FORCED_LABEL (gimple_label_label (label_stmt
)) = 1;
2059 new_bb
= bb
->prev_bb
;
2060 new_gsi
= gsi_start_bb (new_bb
);
2061 gsi_remove (&i
, false);
2062 gsi_insert_before (&new_gsi
, stmt
, GSI_NEW_STMT
);
2066 /* Release SSA definitions if we are in SSA. Note that we
2067 may be called when not in SSA. For example,
2068 final_cleanup calls this function via
2069 cleanup_tree_cfg. */
2070 if (gimple_in_ssa_p (cfun
))
2071 release_defs (stmt
);
2073 gsi_remove (&i
, true);
2077 i
= gsi_last_bb (bb
);
2083 remove_phi_nodes_and_edges_for_unreachable_block (bb
);
2084 bb
->il
.gimple
.seq
= NULL
;
2085 bb
->il
.gimple
.phi_nodes
= NULL
;
2089 /* Given a basic block BB ending with COND_EXPR or SWITCH_EXPR, and a
2090 predicate VAL, return the edge that will be taken out of the block.
2091 If VAL does not match a unique edge, NULL is returned. */
2094 find_taken_edge (basic_block bb
, tree val
)
2098 stmt
= last_stmt (bb
);
2101 gcc_assert (is_ctrl_stmt (stmt
));
2106 if (!is_gimple_min_invariant (val
))
2109 if (gimple_code (stmt
) == GIMPLE_COND
)
2110 return find_taken_edge_cond_expr (bb
, val
);
2112 if (gimple_code (stmt
) == GIMPLE_SWITCH
)
2113 return find_taken_edge_switch_expr (as_a
<gimple_switch
> (stmt
), bb
, val
);
2115 if (computed_goto_p (stmt
))
2117 /* Only optimize if the argument is a label, if the argument is
2118 not a label then we can not construct a proper CFG.
2120 It may be the case that we only need to allow the LABEL_REF to
2121 appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
2122 appear inside a LABEL_EXPR just to be safe. */
2123 if ((TREE_CODE (val
) == ADDR_EXPR
|| TREE_CODE (val
) == LABEL_EXPR
)
2124 && TREE_CODE (TREE_OPERAND (val
, 0)) == LABEL_DECL
)
2125 return find_taken_edge_computed_goto (bb
, TREE_OPERAND (val
, 0));
2132 /* Given a constant value VAL and the entry block BB to a GOTO_EXPR
2133 statement, determine which of the outgoing edges will be taken out of the
2134 block. Return NULL if either edge may be taken. */
2137 find_taken_edge_computed_goto (basic_block bb
, tree val
)
2142 dest
= label_to_block (val
);
2145 e
= find_edge (bb
, dest
);
2146 gcc_assert (e
!= NULL
);
2152 /* Given a constant value VAL and the entry block BB to a COND_EXPR
2153 statement, determine which of the two edges will be taken out of the
2154 block. Return NULL if either edge may be taken. */
2157 find_taken_edge_cond_expr (basic_block bb
, tree val
)
2159 edge true_edge
, false_edge
;
2161 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
2163 gcc_assert (TREE_CODE (val
) == INTEGER_CST
);
2164 return (integer_zerop (val
) ? false_edge
: true_edge
);
2167 /* Given an INTEGER_CST VAL and the entry block BB to a SWITCH_EXPR
2168 statement, determine which edge will be taken out of the block. Return
2169 NULL if any edge may be taken. */
2172 find_taken_edge_switch_expr (gimple_switch switch_stmt
, basic_block bb
,
2175 basic_block dest_bb
;
2179 taken_case
= find_case_label_for_value (switch_stmt
, val
);
2180 dest_bb
= label_to_block (CASE_LABEL (taken_case
));
2182 e
= find_edge (bb
, dest_bb
);
2188 /* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
2189 We can make optimal use here of the fact that the case labels are
2190 sorted: We can do a binary search for a case matching VAL. */
2193 find_case_label_for_value (gimple_switch switch_stmt
, tree val
)
2195 size_t low
, high
, n
= gimple_switch_num_labels (switch_stmt
);
2196 tree default_case
= gimple_switch_default_label (switch_stmt
);
2198 for (low
= 0, high
= n
; high
- low
> 1; )
2200 size_t i
= (high
+ low
) / 2;
2201 tree t
= gimple_switch_label (switch_stmt
, i
);
2204 /* Cache the result of comparing CASE_LOW and val. */
2205 cmp
= tree_int_cst_compare (CASE_LOW (t
), val
);
2212 if (CASE_HIGH (t
) == NULL
)
2214 /* A singe-valued case label. */
2220 /* A case range. We can only handle integer ranges. */
2221 if (cmp
<= 0 && tree_int_cst_compare (CASE_HIGH (t
), val
) >= 0)
2226 return default_case
;
2230 /* Dump a basic block on stderr. */
2233 gimple_debug_bb (basic_block bb
)
2235 dump_bb (stderr
, bb
, 0, TDF_VOPS
|TDF_MEMSYMS
|TDF_BLOCKS
);
2239 /* Dump basic block with index N on stderr. */
2242 gimple_debug_bb_n (int n
)
2244 gimple_debug_bb (BASIC_BLOCK_FOR_FN (cfun
, n
));
2245 return BASIC_BLOCK_FOR_FN (cfun
, n
);
2249 /* Dump the CFG on stderr.
2251 FLAGS are the same used by the tree dumping functions
2252 (see TDF_* in dumpfile.h). */
2255 gimple_debug_cfg (int flags
)
2257 gimple_dump_cfg (stderr
, flags
);
2261 /* Dump the program showing basic block boundaries on the given FILE.
2263 FLAGS are the same used by the tree dumping functions (see TDF_* in
2267 gimple_dump_cfg (FILE *file
, int flags
)
2269 if (flags
& TDF_DETAILS
)
2271 dump_function_header (file
, current_function_decl
, flags
);
2272 fprintf (file
, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
2273 n_basic_blocks_for_fn (cfun
), n_edges_for_fn (cfun
),
2274 last_basic_block_for_fn (cfun
));
2276 brief_dump_cfg (file
, flags
| TDF_COMMENT
);
2277 fprintf (file
, "\n");
2280 if (flags
& TDF_STATS
)
2281 dump_cfg_stats (file
);
2283 dump_function_to_file (current_function_decl
, file
, flags
| TDF_BLOCKS
);
2287 /* Dump CFG statistics on FILE. */
2290 dump_cfg_stats (FILE *file
)
2292 static long max_num_merged_labels
= 0;
2293 unsigned long size
, total
= 0;
2296 const char * const fmt_str
= "%-30s%-13s%12s\n";
2297 const char * const fmt_str_1
= "%-30s%13d%11lu%c\n";
2298 const char * const fmt_str_2
= "%-30s%13ld%11lu%c\n";
2299 const char * const fmt_str_3
= "%-43s%11lu%c\n";
2300 const char *funcname
= current_function_name ();
2302 fprintf (file
, "\nCFG Statistics for %s\n\n", funcname
);
2304 fprintf (file
, "---------------------------------------------------------\n");
2305 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
2306 fprintf (file
, fmt_str
, "", " instances ", "used ");
2307 fprintf (file
, "---------------------------------------------------------\n");
2309 size
= n_basic_blocks_for_fn (cfun
) * sizeof (struct basic_block_def
);
2311 fprintf (file
, fmt_str_1
, "Basic blocks", n_basic_blocks_for_fn (cfun
),
2312 SCALE (size
), LABEL (size
));
2315 FOR_EACH_BB_FN (bb
, cfun
)
2316 num_edges
+= EDGE_COUNT (bb
->succs
);
2317 size
= num_edges
* sizeof (struct edge_def
);
2319 fprintf (file
, fmt_str_2
, "Edges", num_edges
, SCALE (size
), LABEL (size
));
2321 fprintf (file
, "---------------------------------------------------------\n");
2322 fprintf (file
, fmt_str_3
, "Total memory used by CFG data", SCALE (total
),
2324 fprintf (file
, "---------------------------------------------------------\n");
2325 fprintf (file
, "\n");
2327 if (cfg_stats
.num_merged_labels
> max_num_merged_labels
)
2328 max_num_merged_labels
= cfg_stats
.num_merged_labels
;
2330 fprintf (file
, "Coalesced label blocks: %ld (Max so far: %ld)\n",
2331 cfg_stats
.num_merged_labels
, max_num_merged_labels
);
2333 fprintf (file
, "\n");
2337 /* Dump CFG statistics on stderr. Keep extern so that it's always
2338 linked in the final executable. */
2341 debug_cfg_stats (void)
2343 dump_cfg_stats (stderr
);
2346 /*---------------------------------------------------------------------------
2347 Miscellaneous helpers
2348 ---------------------------------------------------------------------------*/
2350 /* Return true if T, a GIMPLE_CALL, can make an abnormal transfer of control
2351 flow. Transfers of control flow associated with EH are excluded. */
2354 call_can_make_abnormal_goto (gimple t
)
2356 /* If the function has no non-local labels, then a call cannot make an
2357 abnormal transfer of control. */
2358 if (!cfun
->has_nonlocal_label
2359 && !cfun
->calls_setjmp
)
2362 /* Likewise if the call has no side effects. */
2363 if (!gimple_has_side_effects (t
))
2366 /* Likewise if the called function is leaf. */
2367 if (gimple_call_flags (t
) & ECF_LEAF
)
2374 /* Return true if T can make an abnormal transfer of control flow.
2375 Transfers of control flow associated with EH are excluded. */
2378 stmt_can_make_abnormal_goto (gimple t
)
2380 if (computed_goto_p (t
))
2382 if (is_gimple_call (t
))
2383 return call_can_make_abnormal_goto (t
);
2388 /* Return true if T represents a stmt that always transfers control. */
2391 is_ctrl_stmt (gimple t
)
2393 switch (gimple_code (t
))
2407 /* Return true if T is a statement that may alter the flow of control
2408 (e.g., a call to a non-returning function). */
2411 is_ctrl_altering_stmt (gimple t
)
2415 switch (gimple_code (t
))
2418 /* Per stmt call flag indicates whether the call could alter
2420 if (gimple_call_ctrl_altering_p (t
))
2424 case GIMPLE_EH_DISPATCH
:
2425 /* EH_DISPATCH branches to the individual catch handlers at
2426 this level of a try or allowed-exceptions region. It can
2427 fallthru to the next statement as well. */
2431 if (gimple_asm_nlabels (as_a
<gimple_asm
> (t
)) > 0)
2436 /* OpenMP directives alter control flow. */
2439 case GIMPLE_TRANSACTION
:
2440 /* A transaction start alters control flow. */
2447 /* If a statement can throw, it alters control flow. */
2448 return stmt_can_throw_internal (t
);
2452 /* Return true if T is a simple local goto. */
2455 simple_goto_p (gimple t
)
2457 return (gimple_code (t
) == GIMPLE_GOTO
2458 && TREE_CODE (gimple_goto_dest (t
)) == LABEL_DECL
);
2462 /* Return true if STMT should start a new basic block. PREV_STMT is
2463 the statement preceding STMT. It is used when STMT is a label or a
2464 case label. Labels should only start a new basic block if their
2465 previous statement wasn't a label. Otherwise, sequence of labels
2466 would generate unnecessary basic blocks that only contain a single
2470 stmt_starts_bb_p (gimple stmt
, gimple prev_stmt
)
2475 /* Labels start a new basic block only if the preceding statement
2476 wasn't a label of the same type. This prevents the creation of
2477 consecutive blocks that have nothing but a single label. */
2478 if (gimple_label label_stmt
= dyn_cast
<gimple_label
> (stmt
))
2480 /* Nonlocal and computed GOTO targets always start a new block. */
2481 if (DECL_NONLOCAL (gimple_label_label (label_stmt
))
2482 || FORCED_LABEL (gimple_label_label (label_stmt
)))
2485 if (prev_stmt
&& gimple_code (prev_stmt
) == GIMPLE_LABEL
)
2487 if (DECL_NONLOCAL (gimple_label_label (
2488 as_a
<gimple_label
> (prev_stmt
))))
2491 cfg_stats
.num_merged_labels
++;
2497 else if (gimple_code (stmt
) == GIMPLE_CALL
2498 && gimple_call_flags (stmt
) & ECF_RETURNS_TWICE
)
2499 /* setjmp acts similar to a nonlocal GOTO target and thus should
2500 start a new block. */
2507 /* Return true if T should end a basic block. */
2510 stmt_ends_bb_p (gimple t
)
2512 return is_ctrl_stmt (t
) || is_ctrl_altering_stmt (t
);
2515 /* Remove block annotations and other data structures. */
2518 delete_tree_cfg_annotations (void)
2520 vec_free (label_to_block_map_for_fn (cfun
));
2524 /* Return the first statement in basic block BB. */
2527 first_stmt (basic_block bb
)
2529 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2532 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2540 /* Return the first non-label statement in basic block BB. */
2543 first_non_label_stmt (basic_block bb
)
2545 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2546 while (!gsi_end_p (i
) && gimple_code (gsi_stmt (i
)) == GIMPLE_LABEL
)
2548 return !gsi_end_p (i
) ? gsi_stmt (i
) : NULL
;
2551 /* Return the last statement in basic block BB. */
2554 last_stmt (basic_block bb
)
2556 gimple_stmt_iterator i
= gsi_last_bb (bb
);
2559 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2567 /* Return the last statement of an otherwise empty block. Return NULL
2568 if the block is totally empty, or if it contains more than one
2572 last_and_only_stmt (basic_block bb
)
2574 gimple_stmt_iterator i
= gsi_last_nondebug_bb (bb
);
2580 last
= gsi_stmt (i
);
2581 gsi_prev_nondebug (&i
);
2585 /* Empty statements should no longer appear in the instruction stream.
2586 Everything that might have appeared before should be deleted by
2587 remove_useless_stmts, and the optimizers should just gsi_remove
2588 instead of smashing with build_empty_stmt.
2590 Thus the only thing that should appear here in a block containing
2591 one executable statement is a label. */
2592 prev
= gsi_stmt (i
);
2593 if (gimple_code (prev
) == GIMPLE_LABEL
)
2599 /* Reinstall those PHI arguments queued in OLD_EDGE to NEW_EDGE. */
2602 reinstall_phi_args (edge new_edge
, edge old_edge
)
2606 gimple_phi_iterator phis
;
2608 vec
<edge_var_map
> *v
= redirect_edge_var_map_vector (old_edge
);
2612 for (i
= 0, phis
= gsi_start_phis (new_edge
->dest
);
2613 v
->iterate (i
, &vm
) && !gsi_end_p (phis
);
2614 i
++, gsi_next (&phis
))
2616 gimple_phi phi
= phis
.phi ();
2617 tree result
= redirect_edge_var_map_result (vm
);
2618 tree arg
= redirect_edge_var_map_def (vm
);
2620 gcc_assert (result
== gimple_phi_result (phi
));
2622 add_phi_arg (phi
, arg
, new_edge
, redirect_edge_var_map_location (vm
));
2625 redirect_edge_var_map_clear (old_edge
);
2628 /* Returns the basic block after which the new basic block created
2629 by splitting edge EDGE_IN should be placed. Tries to keep the new block
2630 near its "logical" location. This is of most help to humans looking
2631 at debugging dumps. */
2634 split_edge_bb_loc (edge edge_in
)
2636 basic_block dest
= edge_in
->dest
;
2637 basic_block dest_prev
= dest
->prev_bb
;
2641 edge e
= find_edge (dest_prev
, dest
);
2642 if (e
&& !(e
->flags
& EDGE_COMPLEX
))
2643 return edge_in
->src
;
2648 /* Split a (typically critical) edge EDGE_IN. Return the new block.
2649 Abort on abnormal edges. */
2652 gimple_split_edge (edge edge_in
)
2654 basic_block new_bb
, after_bb
, dest
;
2657 /* Abnormal edges cannot be split. */
2658 gcc_assert (!(edge_in
->flags
& EDGE_ABNORMAL
));
2660 dest
= edge_in
->dest
;
2662 after_bb
= split_edge_bb_loc (edge_in
);
2664 new_bb
= create_empty_bb (after_bb
);
2665 new_bb
->frequency
= EDGE_FREQUENCY (edge_in
);
2666 new_bb
->count
= edge_in
->count
;
2667 new_edge
= make_edge (new_bb
, dest
, EDGE_FALLTHRU
);
2668 new_edge
->probability
= REG_BR_PROB_BASE
;
2669 new_edge
->count
= edge_in
->count
;
2671 e
= redirect_edge_and_branch (edge_in
, new_bb
);
2672 gcc_assert (e
== edge_in
);
2673 reinstall_phi_args (new_edge
, e
);
2679 /* Verify properties of the address expression T with base object BASE. */
2682 verify_address (tree t
, tree base
)
2685 bool old_side_effects
;
2687 bool new_side_effects
;
2689 old_constant
= TREE_CONSTANT (t
);
2690 old_side_effects
= TREE_SIDE_EFFECTS (t
);
2692 recompute_tree_invariant_for_addr_expr (t
);
2693 new_side_effects
= TREE_SIDE_EFFECTS (t
);
2694 new_constant
= TREE_CONSTANT (t
);
2696 if (old_constant
!= new_constant
)
2698 error ("constant not recomputed when ADDR_EXPR changed");
2701 if (old_side_effects
!= new_side_effects
)
2703 error ("side effects not recomputed when ADDR_EXPR changed");
2707 if (!(TREE_CODE (base
) == VAR_DECL
2708 || TREE_CODE (base
) == PARM_DECL
2709 || TREE_CODE (base
) == RESULT_DECL
))
2712 if (DECL_GIMPLE_REG_P (base
))
2714 error ("DECL_GIMPLE_REG_P set on a variable with address taken");
2721 /* Callback for walk_tree, check that all elements with address taken are
2722 properly noticed as such. The DATA is an int* that is 1 if TP was seen
2723 inside a PHI node. */
2726 verify_expr (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
2733 /* Check operand N for being valid GIMPLE and give error MSG if not. */
2734 #define CHECK_OP(N, MSG) \
2735 do { if (!is_gimple_val (TREE_OPERAND (t, N))) \
2736 { error (MSG); return TREE_OPERAND (t, N); }} while (0)
2738 switch (TREE_CODE (t
))
2741 if (SSA_NAME_IN_FREE_LIST (t
))
2743 error ("SSA name in freelist but still referenced");
2749 error ("INDIRECT_REF in gimple IL");
2753 x
= TREE_OPERAND (t
, 0);
2754 if (!POINTER_TYPE_P (TREE_TYPE (x
))
2755 || !is_gimple_mem_ref_addr (x
))
2757 error ("invalid first operand of MEM_REF");
2760 if (TREE_CODE (TREE_OPERAND (t
, 1)) != INTEGER_CST
2761 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 1))))
2763 error ("invalid offset operand of MEM_REF");
2764 return TREE_OPERAND (t
, 1);
2766 if (TREE_CODE (x
) == ADDR_EXPR
2767 && (x
= verify_address (x
, TREE_OPERAND (x
, 0))))
2773 x
= fold (ASSERT_EXPR_COND (t
));
2774 if (x
== boolean_false_node
)
2776 error ("ASSERT_EXPR with an always-false condition");
2782 error ("MODIFY_EXPR not expected while having tuples");
2789 gcc_assert (is_gimple_address (t
));
2791 /* Skip any references (they will be checked when we recurse down the
2792 tree) and ensure that any variable used as a prefix is marked
2794 for (x
= TREE_OPERAND (t
, 0);
2795 handled_component_p (x
);
2796 x
= TREE_OPERAND (x
, 0))
2799 if ((tem
= verify_address (t
, x
)))
2802 if (!(TREE_CODE (x
) == VAR_DECL
2803 || TREE_CODE (x
) == PARM_DECL
2804 || TREE_CODE (x
) == RESULT_DECL
))
2807 if (!TREE_ADDRESSABLE (x
))
2809 error ("address taken, but ADDRESSABLE bit not set");
2817 x
= COND_EXPR_COND (t
);
2818 if (!INTEGRAL_TYPE_P (TREE_TYPE (x
)))
2820 error ("non-integral used in condition");
2823 if (!is_gimple_condexpr (x
))
2825 error ("invalid conditional operand");
2830 case NON_LVALUE_EXPR
:
2831 case TRUTH_NOT_EXPR
:
2835 case FIX_TRUNC_EXPR
:
2840 CHECK_OP (0, "invalid operand to unary operator");
2846 if (!is_gimple_reg_type (TREE_TYPE (t
)))
2848 error ("non-scalar BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR");
2852 if (TREE_CODE (t
) == BIT_FIELD_REF
)
2854 tree t0
= TREE_OPERAND (t
, 0);
2855 tree t1
= TREE_OPERAND (t
, 1);
2856 tree t2
= TREE_OPERAND (t
, 2);
2857 if (!tree_fits_uhwi_p (t1
)
2858 || !tree_fits_uhwi_p (t2
))
2860 error ("invalid position or size operand to BIT_FIELD_REF");
2863 if (INTEGRAL_TYPE_P (TREE_TYPE (t
))
2864 && (TYPE_PRECISION (TREE_TYPE (t
))
2865 != tree_to_uhwi (t1
)))
2867 error ("integral result type precision does not match "
2868 "field size of BIT_FIELD_REF");
2871 else if (!INTEGRAL_TYPE_P (TREE_TYPE (t
))
2872 && TYPE_MODE (TREE_TYPE (t
)) != BLKmode
2873 && (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (t
)))
2874 != tree_to_uhwi (t1
)))
2876 error ("mode precision of non-integral result does not "
2877 "match field size of BIT_FIELD_REF");
2880 if (!AGGREGATE_TYPE_P (TREE_TYPE (t0
))
2881 && (tree_to_uhwi (t1
) + tree_to_uhwi (t2
)
2882 > tree_to_uhwi (TYPE_SIZE (TREE_TYPE (t0
)))))
2884 error ("position plus size exceeds size of referenced object in "
2889 t
= TREE_OPERAND (t
, 0);
2894 case ARRAY_RANGE_REF
:
2895 case VIEW_CONVERT_EXPR
:
2896 /* We have a nest of references. Verify that each of the operands
2897 that determine where to reference is either a constant or a variable,
2898 verify that the base is valid, and then show we've already checked
2900 while (handled_component_p (t
))
2902 if (TREE_CODE (t
) == COMPONENT_REF
&& TREE_OPERAND (t
, 2))
2903 CHECK_OP (2, "invalid COMPONENT_REF offset operator");
2904 else if (TREE_CODE (t
) == ARRAY_REF
2905 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
2907 CHECK_OP (1, "invalid array index");
2908 if (TREE_OPERAND (t
, 2))
2909 CHECK_OP (2, "invalid array lower bound");
2910 if (TREE_OPERAND (t
, 3))
2911 CHECK_OP (3, "invalid array stride");
2913 else if (TREE_CODE (t
) == BIT_FIELD_REF
2914 || TREE_CODE (t
) == REALPART_EXPR
2915 || TREE_CODE (t
) == IMAGPART_EXPR
)
2917 error ("non-top-level BIT_FIELD_REF, IMAGPART_EXPR or "
2922 t
= TREE_OPERAND (t
, 0);
2925 if (!is_gimple_min_invariant (t
) && !is_gimple_lvalue (t
))
2927 error ("invalid reference prefix");
2934 /* PLUS_EXPR and MINUS_EXPR don't work on pointers, they should be done using
2935 POINTER_PLUS_EXPR. */
2936 if (POINTER_TYPE_P (TREE_TYPE (t
)))
2938 error ("invalid operand to plus/minus, type is a pointer");
2941 CHECK_OP (0, "invalid operand to binary operator");
2942 CHECK_OP (1, "invalid operand to binary operator");
2945 case POINTER_PLUS_EXPR
:
2946 /* Check to make sure the first operand is a pointer or reference type. */
2947 if (!POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 0))))
2949 error ("invalid operand to pointer plus, first operand is not a pointer");
2952 /* Check to make sure the second operand is a ptrofftype. */
2953 if (!ptrofftype_p (TREE_TYPE (TREE_OPERAND (t
, 1))))
2955 error ("invalid operand to pointer plus, second operand is not an "
2956 "integer type of appropriate width");
2966 case UNORDERED_EXPR
:
2975 case TRUNC_DIV_EXPR
:
2977 case FLOOR_DIV_EXPR
:
2978 case ROUND_DIV_EXPR
:
2979 case TRUNC_MOD_EXPR
:
2981 case FLOOR_MOD_EXPR
:
2982 case ROUND_MOD_EXPR
:
2984 case EXACT_DIV_EXPR
:
2994 CHECK_OP (0, "invalid operand to binary operator");
2995 CHECK_OP (1, "invalid operand to binary operator");
2999 if (TREE_CONSTANT (t
) && TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
3003 case CASE_LABEL_EXPR
:
3006 error ("invalid CASE_CHAIN");
3020 /* Verify if EXPR is either a GIMPLE ID or a GIMPLE indirect reference.
3021 Returns true if there is an error, otherwise false. */
3024 verify_types_in_gimple_min_lval (tree expr
)
3028 if (is_gimple_id (expr
))
3031 if (TREE_CODE (expr
) != TARGET_MEM_REF
3032 && TREE_CODE (expr
) != MEM_REF
)
3034 error ("invalid expression for min lvalue");
3038 /* TARGET_MEM_REFs are strange beasts. */
3039 if (TREE_CODE (expr
) == TARGET_MEM_REF
)
3042 op
= TREE_OPERAND (expr
, 0);
3043 if (!is_gimple_val (op
))
3045 error ("invalid operand in indirect reference");
3046 debug_generic_stmt (op
);
3049 /* Memory references now generally can involve a value conversion. */
3054 /* Verify if EXPR is a valid GIMPLE reference expression. If
3055 REQUIRE_LVALUE is true verifies it is an lvalue. Returns true
3056 if there is an error, otherwise false. */
3059 verify_types_in_gimple_reference (tree expr
, bool require_lvalue
)
3061 while (handled_component_p (expr
))
3063 tree op
= TREE_OPERAND (expr
, 0);
3065 if (TREE_CODE (expr
) == ARRAY_REF
3066 || TREE_CODE (expr
) == ARRAY_RANGE_REF
)
3068 if (!is_gimple_val (TREE_OPERAND (expr
, 1))
3069 || (TREE_OPERAND (expr
, 2)
3070 && !is_gimple_val (TREE_OPERAND (expr
, 2)))
3071 || (TREE_OPERAND (expr
, 3)
3072 && !is_gimple_val (TREE_OPERAND (expr
, 3))))
3074 error ("invalid operands to array reference");
3075 debug_generic_stmt (expr
);
3080 /* Verify if the reference array element types are compatible. */
3081 if (TREE_CODE (expr
) == ARRAY_REF
3082 && !useless_type_conversion_p (TREE_TYPE (expr
),
3083 TREE_TYPE (TREE_TYPE (op
))))
3085 error ("type mismatch in array reference");
3086 debug_generic_stmt (TREE_TYPE (expr
));
3087 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3090 if (TREE_CODE (expr
) == ARRAY_RANGE_REF
3091 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr
)),
3092 TREE_TYPE (TREE_TYPE (op
))))
3094 error ("type mismatch in array range reference");
3095 debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr
)));
3096 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3100 if ((TREE_CODE (expr
) == REALPART_EXPR
3101 || TREE_CODE (expr
) == IMAGPART_EXPR
)
3102 && !useless_type_conversion_p (TREE_TYPE (expr
),
3103 TREE_TYPE (TREE_TYPE (op
))))
3105 error ("type mismatch in real/imagpart reference");
3106 debug_generic_stmt (TREE_TYPE (expr
));
3107 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
3111 if (TREE_CODE (expr
) == COMPONENT_REF
3112 && !useless_type_conversion_p (TREE_TYPE (expr
),
3113 TREE_TYPE (TREE_OPERAND (expr
, 1))))
3115 error ("type mismatch in component reference");
3116 debug_generic_stmt (TREE_TYPE (expr
));
3117 debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr
, 1)));
3121 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
)
3123 /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
3124 that their operand is not an SSA name or an invariant when
3125 requiring an lvalue (this usually means there is a SRA or IPA-SRA
3126 bug). Otherwise there is nothing to verify, gross mismatches at
3127 most invoke undefined behavior. */
3129 && (TREE_CODE (op
) == SSA_NAME
3130 || is_gimple_min_invariant (op
)))
3132 error ("conversion of an SSA_NAME on the left hand side");
3133 debug_generic_stmt (expr
);
3136 else if (TREE_CODE (op
) == SSA_NAME
3137 && TYPE_SIZE (TREE_TYPE (expr
)) != TYPE_SIZE (TREE_TYPE (op
)))
3139 error ("conversion of register to a different size");
3140 debug_generic_stmt (expr
);
3143 else if (!handled_component_p (op
))
3150 if (TREE_CODE (expr
) == MEM_REF
)
3152 if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr
, 0)))
3154 error ("invalid address operand in MEM_REF");
3155 debug_generic_stmt (expr
);
3158 if (TREE_CODE (TREE_OPERAND (expr
, 1)) != INTEGER_CST
3159 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr
, 1))))
3161 error ("invalid offset operand in MEM_REF");
3162 debug_generic_stmt (expr
);
3166 else if (TREE_CODE (expr
) == TARGET_MEM_REF
)
3168 if (!TMR_BASE (expr
)
3169 || !is_gimple_mem_ref_addr (TMR_BASE (expr
)))
3171 error ("invalid address operand in TARGET_MEM_REF");
3174 if (!TMR_OFFSET (expr
)
3175 || TREE_CODE (TMR_OFFSET (expr
)) != INTEGER_CST
3176 || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr
))))
3178 error ("invalid offset operand in TARGET_MEM_REF");
3179 debug_generic_stmt (expr
);
3184 return ((require_lvalue
|| !is_gimple_min_invariant (expr
))
3185 && verify_types_in_gimple_min_lval (expr
));
3188 /* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
3189 list of pointer-to types that is trivially convertible to DEST. */
3192 one_pointer_to_useless_type_conversion_p (tree dest
, tree src_obj
)
3196 if (!TYPE_POINTER_TO (src_obj
))
3199 for (src
= TYPE_POINTER_TO (src_obj
); src
; src
= TYPE_NEXT_PTR_TO (src
))
3200 if (useless_type_conversion_p (dest
, src
))
3206 /* Return true if TYPE1 is a fixed-point type and if conversions to and
3207 from TYPE2 can be handled by FIXED_CONVERT_EXPR. */
3210 valid_fixed_convert_types_p (tree type1
, tree type2
)
3212 return (FIXED_POINT_TYPE_P (type1
)
3213 && (INTEGRAL_TYPE_P (type2
)
3214 || SCALAR_FLOAT_TYPE_P (type2
)
3215 || FIXED_POINT_TYPE_P (type2
)));
3218 /* Verify the contents of a GIMPLE_CALL STMT. Returns true when there
3219 is a problem, otherwise false. */
3222 verify_gimple_call (gimple_call stmt
)
3224 tree fn
= gimple_call_fn (stmt
);
3225 tree fntype
, fndecl
;
3228 if (gimple_call_internal_p (stmt
))
3232 error ("gimple call has two targets");
3233 debug_generic_stmt (fn
);
3241 error ("gimple call has no target");
3246 if (fn
&& !is_gimple_call_addr (fn
))
3248 error ("invalid function in gimple call");
3249 debug_generic_stmt (fn
);
3254 && (!POINTER_TYPE_P (TREE_TYPE (fn
))
3255 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != FUNCTION_TYPE
3256 && TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != METHOD_TYPE
)))
3258 error ("non-function in gimple call");
3262 fndecl
= gimple_call_fndecl (stmt
);
3264 && TREE_CODE (fndecl
) == FUNCTION_DECL
3265 && DECL_LOOPING_CONST_OR_PURE_P (fndecl
)
3266 && !DECL_PURE_P (fndecl
)
3267 && !TREE_READONLY (fndecl
))
3269 error ("invalid pure const state for function");
3273 if (gimple_call_lhs (stmt
)
3274 && (!is_gimple_lvalue (gimple_call_lhs (stmt
))
3275 || verify_types_in_gimple_reference (gimple_call_lhs (stmt
), true)))
3277 error ("invalid LHS in gimple call");
3281 if (gimple_call_lhs (stmt
) && gimple_call_noreturn_p (stmt
))
3283 error ("LHS in noreturn call");
3287 fntype
= gimple_call_fntype (stmt
);
3289 && gimple_call_lhs (stmt
)
3290 && !useless_type_conversion_p (TREE_TYPE (gimple_call_lhs (stmt
)),
3292 /* ??? At least C++ misses conversions at assignments from
3293 void * call results.
3294 ??? Java is completely off. Especially with functions
3295 returning java.lang.Object.
3296 For now simply allow arbitrary pointer type conversions. */
3297 && !(POINTER_TYPE_P (TREE_TYPE (gimple_call_lhs (stmt
)))
3298 && POINTER_TYPE_P (TREE_TYPE (fntype
))))
3300 error ("invalid conversion in gimple call");
3301 debug_generic_stmt (TREE_TYPE (gimple_call_lhs (stmt
)));
3302 debug_generic_stmt (TREE_TYPE (fntype
));
3306 if (gimple_call_chain (stmt
)
3307 && !is_gimple_val (gimple_call_chain (stmt
)))
3309 error ("invalid static chain in gimple call");
3310 debug_generic_stmt (gimple_call_chain (stmt
));
3314 /* If there is a static chain argument, this should not be an indirect
3315 call, and the decl should have DECL_STATIC_CHAIN set. */
3316 if (gimple_call_chain (stmt
))
3318 if (!gimple_call_fndecl (stmt
))
3320 error ("static chain in indirect gimple call");
3323 fn
= TREE_OPERAND (fn
, 0);
3325 if (!DECL_STATIC_CHAIN (fn
))
3327 error ("static chain with function that doesn%'t use one");
3332 /* ??? The C frontend passes unpromoted arguments in case it
3333 didn't see a function declaration before the call. So for now
3334 leave the call arguments mostly unverified. Once we gimplify
3335 unit-at-a-time we have a chance to fix this. */
3337 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
3339 tree arg
= gimple_call_arg (stmt
, i
);
3340 if ((is_gimple_reg_type (TREE_TYPE (arg
))
3341 && !is_gimple_val (arg
))
3342 || (!is_gimple_reg_type (TREE_TYPE (arg
))
3343 && !is_gimple_lvalue (arg
)))
3345 error ("invalid argument to gimple call");
3346 debug_generic_expr (arg
);
3354 /* Verifies the gimple comparison with the result type TYPE and
3355 the operands OP0 and OP1. */
3358 verify_gimple_comparison (tree type
, tree op0
, tree op1
)
3360 tree op0_type
= TREE_TYPE (op0
);
3361 tree op1_type
= TREE_TYPE (op1
);
3363 if (!is_gimple_val (op0
) || !is_gimple_val (op1
))
3365 error ("invalid operands in gimple comparison");
3369 /* For comparisons we do not have the operations type as the
3370 effective type the comparison is carried out in. Instead
3371 we require that either the first operand is trivially
3372 convertible into the second, or the other way around.
3373 Because we special-case pointers to void we allow
3374 comparisons of pointers with the same mode as well. */
3375 if (!useless_type_conversion_p (op0_type
, op1_type
)
3376 && !useless_type_conversion_p (op1_type
, op0_type
)
3377 && (!POINTER_TYPE_P (op0_type
)
3378 || !POINTER_TYPE_P (op1_type
)
3379 || TYPE_MODE (op0_type
) != TYPE_MODE (op1_type
)))
3381 error ("mismatching comparison operand types");
3382 debug_generic_expr (op0_type
);
3383 debug_generic_expr (op1_type
);
3387 /* The resulting type of a comparison may be an effective boolean type. */
3388 if (INTEGRAL_TYPE_P (type
)
3389 && (TREE_CODE (type
) == BOOLEAN_TYPE
3390 || TYPE_PRECISION (type
) == 1))
3392 if (TREE_CODE (op0_type
) == VECTOR_TYPE
3393 || TREE_CODE (op1_type
) == VECTOR_TYPE
)
3395 error ("vector comparison returning a boolean");
3396 debug_generic_expr (op0_type
);
3397 debug_generic_expr (op1_type
);
3401 /* Or an integer vector type with the same size and element count
3402 as the comparison operand types. */
3403 else if (TREE_CODE (type
) == VECTOR_TYPE
3404 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
3406 if (TREE_CODE (op0_type
) != VECTOR_TYPE
3407 || TREE_CODE (op1_type
) != VECTOR_TYPE
)
3409 error ("non-vector operands in vector comparison");
3410 debug_generic_expr (op0_type
);
3411 debug_generic_expr (op1_type
);
3415 if (TYPE_VECTOR_SUBPARTS (type
) != TYPE_VECTOR_SUBPARTS (op0_type
)
3416 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (type
)))
3417 != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0_type
))))
3418 /* The result of a vector comparison is of signed
3420 || TYPE_UNSIGNED (TREE_TYPE (type
)))
3422 error ("invalid vector comparison resulting type");
3423 debug_generic_expr (type
);
3429 error ("bogus comparison result type");
3430 debug_generic_expr (type
);
3437 /* Verify a gimple assignment statement STMT with an unary rhs.
3438 Returns true if anything is wrong. */
3441 verify_gimple_assign_unary (gimple_assign stmt
)
3443 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3444 tree lhs
= gimple_assign_lhs (stmt
);
3445 tree lhs_type
= TREE_TYPE (lhs
);
3446 tree rhs1
= gimple_assign_rhs1 (stmt
);
3447 tree rhs1_type
= TREE_TYPE (rhs1
);
3449 if (!is_gimple_reg (lhs
))
3451 error ("non-register as LHS of unary operation");
3455 if (!is_gimple_val (rhs1
))
3457 error ("invalid operand in unary operation");
3461 /* First handle conversions. */
3466 /* Allow conversions from pointer type to integral type only if
3467 there is no sign or zero extension involved.
3468 For targets were the precision of ptrofftype doesn't match that
3469 of pointers we need to allow arbitrary conversions to ptrofftype. */
3470 if ((POINTER_TYPE_P (lhs_type
)
3471 && INTEGRAL_TYPE_P (rhs1_type
))
3472 || (POINTER_TYPE_P (rhs1_type
)
3473 && INTEGRAL_TYPE_P (lhs_type
)
3474 && (TYPE_PRECISION (rhs1_type
) >= TYPE_PRECISION (lhs_type
)
3475 || ptrofftype_p (sizetype
))))
3478 /* Allow conversion from integral to offset type and vice versa. */
3479 if ((TREE_CODE (lhs_type
) == OFFSET_TYPE
3480 && INTEGRAL_TYPE_P (rhs1_type
))
3481 || (INTEGRAL_TYPE_P (lhs_type
)
3482 && TREE_CODE (rhs1_type
) == OFFSET_TYPE
))
3485 /* Otherwise assert we are converting between types of the
3487 if (INTEGRAL_TYPE_P (lhs_type
) != INTEGRAL_TYPE_P (rhs1_type
))
3489 error ("invalid types in nop conversion");
3490 debug_generic_expr (lhs_type
);
3491 debug_generic_expr (rhs1_type
);
3498 case ADDR_SPACE_CONVERT_EXPR
:
3500 if (!POINTER_TYPE_P (rhs1_type
) || !POINTER_TYPE_P (lhs_type
)
3501 || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type
))
3502 == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type
))))
3504 error ("invalid types in address space conversion");
3505 debug_generic_expr (lhs_type
);
3506 debug_generic_expr (rhs1_type
);
3513 case FIXED_CONVERT_EXPR
:
3515 if (!valid_fixed_convert_types_p (lhs_type
, rhs1_type
)
3516 && !valid_fixed_convert_types_p (rhs1_type
, lhs_type
))
3518 error ("invalid types in fixed-point conversion");
3519 debug_generic_expr (lhs_type
);
3520 debug_generic_expr (rhs1_type
);
3529 if ((!INTEGRAL_TYPE_P (rhs1_type
) || !SCALAR_FLOAT_TYPE_P (lhs_type
))
3530 && (!VECTOR_INTEGER_TYPE_P (rhs1_type
)
3531 || !VECTOR_FLOAT_TYPE_P (lhs_type
)))
3533 error ("invalid types in conversion to floating point");
3534 debug_generic_expr (lhs_type
);
3535 debug_generic_expr (rhs1_type
);
3542 case FIX_TRUNC_EXPR
:
3544 if ((!INTEGRAL_TYPE_P (lhs_type
) || !SCALAR_FLOAT_TYPE_P (rhs1_type
))
3545 && (!VECTOR_INTEGER_TYPE_P (lhs_type
)
3546 || !VECTOR_FLOAT_TYPE_P (rhs1_type
)))
3548 error ("invalid types in conversion to integer");
3549 debug_generic_expr (lhs_type
);
3550 debug_generic_expr (rhs1_type
);
3557 case VEC_UNPACK_HI_EXPR
:
3558 case VEC_UNPACK_LO_EXPR
:
3559 case REDUC_MAX_EXPR
:
3560 case REDUC_MIN_EXPR
:
3561 case REDUC_PLUS_EXPR
:
3562 case VEC_UNPACK_FLOAT_HI_EXPR
:
3563 case VEC_UNPACK_FLOAT_LO_EXPR
:
3578 /* For the remaining codes assert there is no conversion involved. */
3579 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3581 error ("non-trivial conversion in unary operation");
3582 debug_generic_expr (lhs_type
);
3583 debug_generic_expr (rhs1_type
);
3590 /* Verify a gimple assignment statement STMT with a binary rhs.
3591 Returns true if anything is wrong. */
3594 verify_gimple_assign_binary (gimple_assign stmt
)
3596 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3597 tree lhs
= gimple_assign_lhs (stmt
);
3598 tree lhs_type
= TREE_TYPE (lhs
);
3599 tree rhs1
= gimple_assign_rhs1 (stmt
);
3600 tree rhs1_type
= TREE_TYPE (rhs1
);
3601 tree rhs2
= gimple_assign_rhs2 (stmt
);
3602 tree rhs2_type
= TREE_TYPE (rhs2
);
3604 if (!is_gimple_reg (lhs
))
3606 error ("non-register as LHS of binary operation");
3610 if (!is_gimple_val (rhs1
)
3611 || !is_gimple_val (rhs2
))
3613 error ("invalid operands in binary operation");
3617 /* First handle operations that involve different types. */
3622 if (TREE_CODE (lhs_type
) != COMPLEX_TYPE
3623 || !(INTEGRAL_TYPE_P (rhs1_type
)
3624 || SCALAR_FLOAT_TYPE_P (rhs1_type
))
3625 || !(INTEGRAL_TYPE_P (rhs2_type
)
3626 || SCALAR_FLOAT_TYPE_P (rhs2_type
)))
3628 error ("type mismatch in complex expression");
3629 debug_generic_expr (lhs_type
);
3630 debug_generic_expr (rhs1_type
);
3631 debug_generic_expr (rhs2_type
);
3643 /* Shifts and rotates are ok on integral types, fixed point
3644 types and integer vector types. */
3645 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3646 && !FIXED_POINT_TYPE_P (rhs1_type
)
3647 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3648 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))))
3649 || (!INTEGRAL_TYPE_P (rhs2_type
)
3650 /* Vector shifts of vectors are also ok. */
3651 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3652 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3653 && TREE_CODE (rhs2_type
) == VECTOR_TYPE
3654 && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3655 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3657 error ("type mismatch in shift expression");
3658 debug_generic_expr (lhs_type
);
3659 debug_generic_expr (rhs1_type
);
3660 debug_generic_expr (rhs2_type
);
3667 case VEC_LSHIFT_EXPR
:
3668 case VEC_RSHIFT_EXPR
:
3670 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3671 || !(INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3672 || POINTER_TYPE_P (TREE_TYPE (rhs1_type
))
3673 || FIXED_POINT_TYPE_P (TREE_TYPE (rhs1_type
))
3674 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
)))
3675 || (!INTEGRAL_TYPE_P (rhs2_type
)
3676 && (TREE_CODE (rhs2_type
) != VECTOR_TYPE
3677 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3678 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3680 error ("type mismatch in vector shift expression");
3681 debug_generic_expr (lhs_type
);
3682 debug_generic_expr (rhs1_type
);
3683 debug_generic_expr (rhs2_type
);
3686 /* For shifting a vector of non-integral components we
3687 only allow shifting by a constant multiple of the element size. */
3688 if (!INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3689 && (TREE_CODE (rhs2
) != INTEGER_CST
3690 || !div_if_zero_remainder (rhs2
,
3691 TYPE_SIZE (TREE_TYPE (rhs1_type
)))))
3693 error ("non-element sized vector shift of floating point vector");
3700 case WIDEN_LSHIFT_EXPR
:
3702 if (!INTEGRAL_TYPE_P (lhs_type
)
3703 || !INTEGRAL_TYPE_P (rhs1_type
)
3704 || TREE_CODE (rhs2
) != INTEGER_CST
3705 || (2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)))
3707 error ("type mismatch in widening vector shift expression");
3708 debug_generic_expr (lhs_type
);
3709 debug_generic_expr (rhs1_type
);
3710 debug_generic_expr (rhs2_type
);
3717 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3718 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3720 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3721 || TREE_CODE (lhs_type
) != VECTOR_TYPE
3722 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3723 || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3724 || TREE_CODE (rhs2
) != INTEGER_CST
3725 || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type
))
3726 > TYPE_PRECISION (TREE_TYPE (lhs_type
))))
3728 error ("type mismatch in widening vector shift expression");
3729 debug_generic_expr (lhs_type
);
3730 debug_generic_expr (rhs1_type
);
3731 debug_generic_expr (rhs2_type
);
3741 tree lhs_etype
= lhs_type
;
3742 tree rhs1_etype
= rhs1_type
;
3743 tree rhs2_etype
= rhs2_type
;
3744 if (TREE_CODE (lhs_type
) == VECTOR_TYPE
)
3746 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3747 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
)
3749 error ("invalid non-vector operands to vector valued plus");
3752 lhs_etype
= TREE_TYPE (lhs_type
);
3753 rhs1_etype
= TREE_TYPE (rhs1_type
);
3754 rhs2_etype
= TREE_TYPE (rhs2_type
);
3756 if (POINTER_TYPE_P (lhs_etype
)
3757 || POINTER_TYPE_P (rhs1_etype
)
3758 || POINTER_TYPE_P (rhs2_etype
))
3760 error ("invalid (pointer) operands to plus/minus");
3764 /* Continue with generic binary expression handling. */
3768 case POINTER_PLUS_EXPR
:
3770 if (!POINTER_TYPE_P (rhs1_type
)
3771 || !useless_type_conversion_p (lhs_type
, rhs1_type
)
3772 || !ptrofftype_p (rhs2_type
))
3774 error ("type mismatch in pointer plus expression");
3775 debug_generic_stmt (lhs_type
);
3776 debug_generic_stmt (rhs1_type
);
3777 debug_generic_stmt (rhs2_type
);
3784 case TRUTH_ANDIF_EXPR
:
3785 case TRUTH_ORIF_EXPR
:
3786 case TRUTH_AND_EXPR
:
3788 case TRUTH_XOR_EXPR
:
3798 case UNORDERED_EXPR
:
3806 /* Comparisons are also binary, but the result type is not
3807 connected to the operand types. */
3808 return verify_gimple_comparison (lhs_type
, rhs1
, rhs2
);
3810 case WIDEN_MULT_EXPR
:
3811 if (TREE_CODE (lhs_type
) != INTEGER_TYPE
)
3813 return ((2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
))
3814 || (TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
)));
3816 case WIDEN_SUM_EXPR
:
3817 case VEC_WIDEN_MULT_HI_EXPR
:
3818 case VEC_WIDEN_MULT_LO_EXPR
:
3819 case VEC_WIDEN_MULT_EVEN_EXPR
:
3820 case VEC_WIDEN_MULT_ODD_EXPR
:
3821 case VEC_PACK_TRUNC_EXPR
:
3822 case VEC_PACK_SAT_EXPR
:
3823 case VEC_PACK_FIX_TRUNC_EXPR
:
3828 case MULT_HIGHPART_EXPR
:
3829 case TRUNC_DIV_EXPR
:
3831 case FLOOR_DIV_EXPR
:
3832 case ROUND_DIV_EXPR
:
3833 case TRUNC_MOD_EXPR
:
3835 case FLOOR_MOD_EXPR
:
3836 case ROUND_MOD_EXPR
:
3838 case EXACT_DIV_EXPR
:
3844 /* Continue with generic binary expression handling. */
3851 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3852 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
3854 error ("type mismatch in binary expression");
3855 debug_generic_stmt (lhs_type
);
3856 debug_generic_stmt (rhs1_type
);
3857 debug_generic_stmt (rhs2_type
);
3864 /* Verify a gimple assignment statement STMT with a ternary rhs.
3865 Returns true if anything is wrong. */
3868 verify_gimple_assign_ternary (gimple_assign stmt
)
3870 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3871 tree lhs
= gimple_assign_lhs (stmt
);
3872 tree lhs_type
= TREE_TYPE (lhs
);
3873 tree rhs1
= gimple_assign_rhs1 (stmt
);
3874 tree rhs1_type
= TREE_TYPE (rhs1
);
3875 tree rhs2
= gimple_assign_rhs2 (stmt
);
3876 tree rhs2_type
= TREE_TYPE (rhs2
);
3877 tree rhs3
= gimple_assign_rhs3 (stmt
);
3878 tree rhs3_type
= TREE_TYPE (rhs3
);
3880 if (!is_gimple_reg (lhs
))
3882 error ("non-register as LHS of ternary operation");
3886 if (((rhs_code
== VEC_COND_EXPR
|| rhs_code
== COND_EXPR
)
3887 ? !is_gimple_condexpr (rhs1
) : !is_gimple_val (rhs1
))
3888 || !is_gimple_val (rhs2
)
3889 || !is_gimple_val (rhs3
))
3891 error ("invalid operands in ternary operation");
3895 /* First handle operations that involve different types. */
3898 case WIDEN_MULT_PLUS_EXPR
:
3899 case WIDEN_MULT_MINUS_EXPR
:
3900 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3901 && !FIXED_POINT_TYPE_P (rhs1_type
))
3902 || !useless_type_conversion_p (rhs1_type
, rhs2_type
)
3903 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
3904 || 2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)
3905 || TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
))
3907 error ("type mismatch in widening multiply-accumulate expression");
3908 debug_generic_expr (lhs_type
);
3909 debug_generic_expr (rhs1_type
);
3910 debug_generic_expr (rhs2_type
);
3911 debug_generic_expr (rhs3_type
);
3917 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3918 || !useless_type_conversion_p (lhs_type
, rhs2_type
)
3919 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
3921 error ("type mismatch in fused multiply-add expression");
3922 debug_generic_expr (lhs_type
);
3923 debug_generic_expr (rhs1_type
);
3924 debug_generic_expr (rhs2_type
);
3925 debug_generic_expr (rhs3_type
);
3932 if (!useless_type_conversion_p (lhs_type
, rhs2_type
)
3933 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
3935 error ("type mismatch in conditional expression");
3936 debug_generic_expr (lhs_type
);
3937 debug_generic_expr (rhs2_type
);
3938 debug_generic_expr (rhs3_type
);
3944 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3945 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
3947 error ("type mismatch in vector permute expression");
3948 debug_generic_expr (lhs_type
);
3949 debug_generic_expr (rhs1_type
);
3950 debug_generic_expr (rhs2_type
);
3951 debug_generic_expr (rhs3_type
);
3955 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3956 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
3957 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
3959 error ("vector types expected in vector permute expression");
3960 debug_generic_expr (lhs_type
);
3961 debug_generic_expr (rhs1_type
);
3962 debug_generic_expr (rhs2_type
);
3963 debug_generic_expr (rhs3_type
);
3967 if (TYPE_VECTOR_SUBPARTS (rhs1_type
) != TYPE_VECTOR_SUBPARTS (rhs2_type
)
3968 || TYPE_VECTOR_SUBPARTS (rhs2_type
)
3969 != TYPE_VECTOR_SUBPARTS (rhs3_type
)
3970 || TYPE_VECTOR_SUBPARTS (rhs3_type
)
3971 != TYPE_VECTOR_SUBPARTS (lhs_type
))
3973 error ("vectors with different element number found "
3974 "in vector permute expression");
3975 debug_generic_expr (lhs_type
);
3976 debug_generic_expr (rhs1_type
);
3977 debug_generic_expr (rhs2_type
);
3978 debug_generic_expr (rhs3_type
);
3982 if (TREE_CODE (TREE_TYPE (rhs3_type
)) != INTEGER_TYPE
3983 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs3_type
)))
3984 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type
))))
3986 error ("invalid mask type in vector permute expression");
3987 debug_generic_expr (lhs_type
);
3988 debug_generic_expr (rhs1_type
);
3989 debug_generic_expr (rhs2_type
);
3990 debug_generic_expr (rhs3_type
);
3997 if (!useless_type_conversion_p (rhs1_type
, rhs2_type
)
3998 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
3999 || 2 * GET_MODE_BITSIZE (GET_MODE_INNER
4000 (TYPE_MODE (TREE_TYPE (rhs1_type
))))
4001 > GET_MODE_BITSIZE (GET_MODE_INNER
4002 (TYPE_MODE (TREE_TYPE (lhs_type
)))))
4004 error ("type mismatch in sad expression");
4005 debug_generic_expr (lhs_type
);
4006 debug_generic_expr (rhs1_type
);
4007 debug_generic_expr (rhs2_type
);
4008 debug_generic_expr (rhs3_type
);
4012 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
4013 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
4014 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
4016 error ("vector types expected in sad expression");
4017 debug_generic_expr (lhs_type
);
4018 debug_generic_expr (rhs1_type
);
4019 debug_generic_expr (rhs2_type
);
4020 debug_generic_expr (rhs3_type
);
4027 case REALIGN_LOAD_EXPR
:
4037 /* Verify a gimple assignment statement STMT with a single rhs.
4038 Returns true if anything is wrong. */
4041 verify_gimple_assign_single (gimple_assign stmt
)
4043 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
4044 tree lhs
= gimple_assign_lhs (stmt
);
4045 tree lhs_type
= TREE_TYPE (lhs
);
4046 tree rhs1
= gimple_assign_rhs1 (stmt
);
4047 tree rhs1_type
= TREE_TYPE (rhs1
);
4050 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
4052 error ("non-trivial conversion at assignment");
4053 debug_generic_expr (lhs_type
);
4054 debug_generic_expr (rhs1_type
);
4058 if (gimple_clobber_p (stmt
)
4059 && !(DECL_P (lhs
) || TREE_CODE (lhs
) == MEM_REF
))
4061 error ("non-decl/MEM_REF LHS in clobber statement");
4062 debug_generic_expr (lhs
);
4066 if (handled_component_p (lhs
)
4067 || TREE_CODE (lhs
) == MEM_REF
4068 || TREE_CODE (lhs
) == TARGET_MEM_REF
)
4069 res
|= verify_types_in_gimple_reference (lhs
, true);
4071 /* Special codes we cannot handle via their class. */
4076 tree op
= TREE_OPERAND (rhs1
, 0);
4077 if (!is_gimple_addressable (op
))
4079 error ("invalid operand in unary expression");
4083 /* Technically there is no longer a need for matching types, but
4084 gimple hygiene asks for this check. In LTO we can end up
4085 combining incompatible units and thus end up with addresses
4086 of globals that change their type to a common one. */
4088 && !types_compatible_p (TREE_TYPE (op
),
4089 TREE_TYPE (TREE_TYPE (rhs1
)))
4090 && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1
),
4093 error ("type mismatch in address expression");
4094 debug_generic_stmt (TREE_TYPE (rhs1
));
4095 debug_generic_stmt (TREE_TYPE (op
));
4099 return verify_types_in_gimple_reference (op
, true);
4104 error ("INDIRECT_REF in gimple IL");
4110 case ARRAY_RANGE_REF
:
4111 case VIEW_CONVERT_EXPR
:
4114 case TARGET_MEM_REF
:
4116 if (!is_gimple_reg (lhs
)
4117 && is_gimple_reg_type (TREE_TYPE (lhs
)))
4119 error ("invalid rhs for gimple memory store");
4120 debug_generic_stmt (lhs
);
4121 debug_generic_stmt (rhs1
);
4124 return res
|| verify_types_in_gimple_reference (rhs1
, false);
4136 /* tcc_declaration */
4141 if (!is_gimple_reg (lhs
)
4142 && !is_gimple_reg (rhs1
)
4143 && is_gimple_reg_type (TREE_TYPE (lhs
)))
4145 error ("invalid rhs for gimple memory store");
4146 debug_generic_stmt (lhs
);
4147 debug_generic_stmt (rhs1
);
4153 if (TREE_CODE (rhs1_type
) == VECTOR_TYPE
)
4156 tree elt_i
, elt_v
, elt_t
= NULL_TREE
;
4158 if (CONSTRUCTOR_NELTS (rhs1
) == 0)
4160 /* For vector CONSTRUCTORs we require that either it is empty
4161 CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
4162 (then the element count must be correct to cover the whole
4163 outer vector and index must be NULL on all elements, or it is
4164 a CONSTRUCTOR of scalar elements, where we as an exception allow
4165 smaller number of elements (assuming zero filling) and
4166 consecutive indexes as compared to NULL indexes (such
4167 CONSTRUCTORs can appear in the IL from FEs). */
4168 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1
), i
, elt_i
, elt_v
)
4170 if (elt_t
== NULL_TREE
)
4172 elt_t
= TREE_TYPE (elt_v
);
4173 if (TREE_CODE (elt_t
) == VECTOR_TYPE
)
4175 tree elt_t
= TREE_TYPE (elt_v
);
4176 if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
4179 error ("incorrect type of vector CONSTRUCTOR"
4181 debug_generic_stmt (rhs1
);
4184 else if (CONSTRUCTOR_NELTS (rhs1
)
4185 * TYPE_VECTOR_SUBPARTS (elt_t
)
4186 != TYPE_VECTOR_SUBPARTS (rhs1_type
))
4188 error ("incorrect number of vector CONSTRUCTOR"
4190 debug_generic_stmt (rhs1
);
4194 else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
4197 error ("incorrect type of vector CONSTRUCTOR elements");
4198 debug_generic_stmt (rhs1
);
4201 else if (CONSTRUCTOR_NELTS (rhs1
)
4202 > TYPE_VECTOR_SUBPARTS (rhs1_type
))
4204 error ("incorrect number of vector CONSTRUCTOR elements");
4205 debug_generic_stmt (rhs1
);
4209 else if (!useless_type_conversion_p (elt_t
, TREE_TYPE (elt_v
)))
4211 error ("incorrect type of vector CONSTRUCTOR elements");
4212 debug_generic_stmt (rhs1
);
4215 if (elt_i
!= NULL_TREE
4216 && (TREE_CODE (elt_t
) == VECTOR_TYPE
4217 || TREE_CODE (elt_i
) != INTEGER_CST
4218 || compare_tree_int (elt_i
, i
) != 0))
4220 error ("vector CONSTRUCTOR with non-NULL element index");
4221 debug_generic_stmt (rhs1
);
4224 if (!is_gimple_val (elt_v
))
4226 error ("vector CONSTRUCTOR element is not a GIMPLE value");
4227 debug_generic_stmt (rhs1
);
4232 else if (CONSTRUCTOR_NELTS (rhs1
) != 0)
4234 error ("non-vector CONSTRUCTOR with elements");
4235 debug_generic_stmt (rhs1
);
4241 case WITH_SIZE_EXPR
:
4251 /* Verify the contents of a GIMPLE_ASSIGN STMT. Returns true when there
4252 is a problem, otherwise false. */
4255 verify_gimple_assign (gimple_assign stmt
)
4257 switch (gimple_assign_rhs_class (stmt
))
4259 case GIMPLE_SINGLE_RHS
:
4260 return verify_gimple_assign_single (stmt
);
4262 case GIMPLE_UNARY_RHS
:
4263 return verify_gimple_assign_unary (stmt
);
4265 case GIMPLE_BINARY_RHS
:
4266 return verify_gimple_assign_binary (stmt
);
4268 case GIMPLE_TERNARY_RHS
:
4269 return verify_gimple_assign_ternary (stmt
);
4276 /* Verify the contents of a GIMPLE_RETURN STMT. Returns true when there
4277 is a problem, otherwise false. */
4280 verify_gimple_return (gimple_return stmt
)
4282 tree op
= gimple_return_retval (stmt
);
4283 tree restype
= TREE_TYPE (TREE_TYPE (cfun
->decl
));
4285 /* We cannot test for present return values as we do not fix up missing
4286 return values from the original source. */
4290 if (!is_gimple_val (op
)
4291 && TREE_CODE (op
) != RESULT_DECL
)
4293 error ("invalid operand in return statement");
4294 debug_generic_stmt (op
);
4298 if ((TREE_CODE (op
) == RESULT_DECL
4299 && DECL_BY_REFERENCE (op
))
4300 || (TREE_CODE (op
) == SSA_NAME
4301 && SSA_NAME_VAR (op
)
4302 && TREE_CODE (SSA_NAME_VAR (op
)) == RESULT_DECL
4303 && DECL_BY_REFERENCE (SSA_NAME_VAR (op
))))
4304 op
= TREE_TYPE (op
);
4306 if (!useless_type_conversion_p (restype
, TREE_TYPE (op
)))
4308 error ("invalid conversion in return statement");
4309 debug_generic_stmt (restype
);
4310 debug_generic_stmt (TREE_TYPE (op
));
4318 /* Verify the contents of a GIMPLE_GOTO STMT. Returns true when there
4319 is a problem, otherwise false. */
4322 verify_gimple_goto (gimple_goto stmt
)
4324 tree dest
= gimple_goto_dest (stmt
);
4326 /* ??? We have two canonical forms of direct goto destinations, a
4327 bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
4328 if (TREE_CODE (dest
) != LABEL_DECL
4329 && (!is_gimple_val (dest
)
4330 || !POINTER_TYPE_P (TREE_TYPE (dest
))))
4332 error ("goto destination is neither a label nor a pointer");
4339 /* Verify the contents of a GIMPLE_SWITCH STMT. Returns true when there
4340 is a problem, otherwise false. */
4343 verify_gimple_switch (gimple_switch stmt
)
4346 tree elt
, prev_upper_bound
= NULL_TREE
;
4347 tree index_type
, elt_type
= NULL_TREE
;
4349 if (!is_gimple_val (gimple_switch_index (stmt
)))
4351 error ("invalid operand to switch statement");
4352 debug_generic_stmt (gimple_switch_index (stmt
));
4356 index_type
= TREE_TYPE (gimple_switch_index (stmt
));
4357 if (! INTEGRAL_TYPE_P (index_type
))
4359 error ("non-integral type switch statement");
4360 debug_generic_expr (index_type
);
4364 elt
= gimple_switch_label (stmt
, 0);
4365 if (CASE_LOW (elt
) != NULL_TREE
|| CASE_HIGH (elt
) != NULL_TREE
)
4367 error ("invalid default case label in switch statement");
4368 debug_generic_expr (elt
);
4372 n
= gimple_switch_num_labels (stmt
);
4373 for (i
= 1; i
< n
; i
++)
4375 elt
= gimple_switch_label (stmt
, i
);
4377 if (! CASE_LOW (elt
))
4379 error ("invalid case label in switch statement");
4380 debug_generic_expr (elt
);
4384 && ! tree_int_cst_lt (CASE_LOW (elt
), CASE_HIGH (elt
)))
4386 error ("invalid case range in switch statement");
4387 debug_generic_expr (elt
);
4393 if (TREE_TYPE (CASE_LOW (elt
)) != elt_type
4394 || (CASE_HIGH (elt
) && TREE_TYPE (CASE_HIGH (elt
)) != elt_type
))
4396 error ("type mismatch for case label in switch statement");
4397 debug_generic_expr (elt
);
4403 elt_type
= TREE_TYPE (CASE_LOW (elt
));
4404 if (TYPE_PRECISION (index_type
) < TYPE_PRECISION (elt_type
))
4406 error ("type precision mismatch in switch statement");
4411 if (prev_upper_bound
)
4413 if (! tree_int_cst_lt (prev_upper_bound
, CASE_LOW (elt
)))
4415 error ("case labels not sorted in switch statement");
4420 prev_upper_bound
= CASE_HIGH (elt
);
4421 if (! prev_upper_bound
)
4422 prev_upper_bound
= CASE_LOW (elt
);
4428 /* Verify a gimple debug statement STMT.
4429 Returns true if anything is wrong. */
4432 verify_gimple_debug (gimple stmt ATTRIBUTE_UNUSED
)
4434 /* There isn't much that could be wrong in a gimple debug stmt. A
4435 gimple debug bind stmt, for example, maps a tree, that's usually
4436 a VAR_DECL or a PARM_DECL, but that could also be some scalarized
4437 component or member of an aggregate type, to another tree, that
4438 can be an arbitrary expression. These stmts expand into debug
4439 insns, and are converted to debug notes by var-tracking.c. */
4443 /* Verify a gimple label statement STMT.
4444 Returns true if anything is wrong. */
4447 verify_gimple_label (gimple_label stmt
)
4449 tree decl
= gimple_label_label (stmt
);
4453 if (TREE_CODE (decl
) != LABEL_DECL
)
4455 if (!DECL_NONLOCAL (decl
) && !FORCED_LABEL (decl
)
4456 && DECL_CONTEXT (decl
) != current_function_decl
)
4458 error ("label's context is not the current function decl");
4462 uid
= LABEL_DECL_UID (decl
);
4465 || (*label_to_block_map_for_fn (cfun
))[uid
] != gimple_bb (stmt
)))
4467 error ("incorrect entry in label_to_block_map");
4471 uid
= EH_LANDING_PAD_NR (decl
);
4474 eh_landing_pad lp
= get_eh_landing_pad_from_number (uid
);
4475 if (decl
!= lp
->post_landing_pad
)
4477 error ("incorrect setting of landing pad number");
4485 /* Verify a gimple cond statement STMT.
4486 Returns true if anything is wrong. */
4489 verify_gimple_cond (gimple_cond stmt
)
4491 if (TREE_CODE_CLASS (gimple_cond_code (stmt
)) != tcc_comparison
)
4493 error ("invalid comparison code in gimple cond");
4496 if (!(!gimple_cond_true_label (stmt
)
4497 || TREE_CODE (gimple_cond_true_label (stmt
)) == LABEL_DECL
)
4498 || !(!gimple_cond_false_label (stmt
)
4499 || TREE_CODE (gimple_cond_false_label (stmt
)) == LABEL_DECL
))
4501 error ("invalid labels in gimple cond");
4505 return verify_gimple_comparison (boolean_type_node
,
4506 gimple_cond_lhs (stmt
),
4507 gimple_cond_rhs (stmt
));
4510 /* Verify the GIMPLE statement STMT. Returns true if there is an
4511 error, otherwise false. */
4514 verify_gimple_stmt (gimple stmt
)
4516 switch (gimple_code (stmt
))
4519 return verify_gimple_assign (as_a
<gimple_assign
> (stmt
));
4522 return verify_gimple_label (as_a
<gimple_label
> (stmt
));
4525 return verify_gimple_call (as_a
<gimple_call
> (stmt
));
4528 return verify_gimple_cond (as_a
<gimple_cond
> (stmt
));
4531 return verify_gimple_goto (as_a
<gimple_goto
> (stmt
));
4534 return verify_gimple_switch (as_a
<gimple_switch
> (stmt
));
4537 return verify_gimple_return (as_a
<gimple_return
> (stmt
));
4542 case GIMPLE_TRANSACTION
:
4543 return verify_gimple_transaction (as_a
<gimple_transaction
> (stmt
));
4545 /* Tuples that do not have tree operands. */
4547 case GIMPLE_PREDICT
:
4549 case GIMPLE_EH_DISPATCH
:
4550 case GIMPLE_EH_MUST_NOT_THROW
:
4554 /* OpenMP directives are validated by the FE and never operated
4555 on by the optimizers. Furthermore, GIMPLE_OMP_FOR may contain
4556 non-gimple expressions when the main index variable has had
4557 its address taken. This does not affect the loop itself
4558 because the header of an GIMPLE_OMP_FOR is merely used to determine
4559 how to setup the parallel iteration. */
4563 return verify_gimple_debug (stmt
);
4570 /* Verify the contents of a GIMPLE_PHI. Returns true if there is a problem,
4571 and false otherwise. */
4574 verify_gimple_phi (gimple phi
)
4578 tree phi_result
= gimple_phi_result (phi
);
4583 error ("invalid PHI result");
4587 virtual_p
= virtual_operand_p (phi_result
);
4588 if (TREE_CODE (phi_result
) != SSA_NAME
4590 && SSA_NAME_VAR (phi_result
) != gimple_vop (cfun
)))
4592 error ("invalid PHI result");
4596 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4598 tree t
= gimple_phi_arg_def (phi
, i
);
4602 error ("missing PHI def");
4606 /* Addressable variables do have SSA_NAMEs but they
4607 are not considered gimple values. */
4608 else if ((TREE_CODE (t
) == SSA_NAME
4609 && virtual_p
!= virtual_operand_p (t
))
4611 && (TREE_CODE (t
) != SSA_NAME
4612 || SSA_NAME_VAR (t
) != gimple_vop (cfun
)))
4614 && !is_gimple_val (t
)))
4616 error ("invalid PHI argument");
4617 debug_generic_expr (t
);
4620 #ifdef ENABLE_TYPES_CHECKING
4621 if (!useless_type_conversion_p (TREE_TYPE (phi_result
), TREE_TYPE (t
)))
4623 error ("incompatible types in PHI argument %u", i
);
4624 debug_generic_stmt (TREE_TYPE (phi_result
));
4625 debug_generic_stmt (TREE_TYPE (t
));
4634 /* Verify the GIMPLE statements inside the sequence STMTS. */
4637 verify_gimple_in_seq_2 (gimple_seq stmts
)
4639 gimple_stmt_iterator ittr
;
4642 for (ittr
= gsi_start (stmts
); !gsi_end_p (ittr
); gsi_next (&ittr
))
4644 gimple stmt
= gsi_stmt (ittr
);
4646 switch (gimple_code (stmt
))
4649 err
|= verify_gimple_in_seq_2 (
4650 gimple_bind_body (as_a
<gimple_bind
> (stmt
)));
4654 err
|= verify_gimple_in_seq_2 (gimple_try_eval (stmt
));
4655 err
|= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt
));
4658 case GIMPLE_EH_FILTER
:
4659 err
|= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt
));
4662 case GIMPLE_EH_ELSE
:
4664 gimple_eh_else eh_else
= as_a
<gimple_eh_else
> (stmt
);
4665 err
|= verify_gimple_in_seq_2 (gimple_eh_else_n_body (eh_else
));
4666 err
|= verify_gimple_in_seq_2 (gimple_eh_else_e_body (eh_else
));
4671 err
|= verify_gimple_in_seq_2 (gimple_catch_handler (
4672 as_a
<gimple_catch
> (stmt
)));
4675 case GIMPLE_TRANSACTION
:
4676 err
|= verify_gimple_transaction (as_a
<gimple_transaction
> (stmt
));
4681 bool err2
= verify_gimple_stmt (stmt
);
4683 debug_gimple_stmt (stmt
);
4692 /* Verify the contents of a GIMPLE_TRANSACTION. Returns true if there
4693 is a problem, otherwise false. */
4696 verify_gimple_transaction (gimple_transaction stmt
)
4698 tree lab
= gimple_transaction_label (stmt
);
4699 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
4701 return verify_gimple_in_seq_2 (gimple_transaction_body (stmt
));
4705 /* Verify the GIMPLE statements inside the statement list STMTS. */
4708 verify_gimple_in_seq (gimple_seq stmts
)
4710 timevar_push (TV_TREE_STMT_VERIFY
);
4711 if (verify_gimple_in_seq_2 (stmts
))
4712 internal_error ("verify_gimple failed");
4713 timevar_pop (TV_TREE_STMT_VERIFY
);
4716 /* Return true when the T can be shared. */
4719 tree_node_can_be_shared (tree t
)
4721 if (IS_TYPE_OR_DECL_P (t
)
4722 || is_gimple_min_invariant (t
)
4723 || TREE_CODE (t
) == SSA_NAME
4724 || t
== error_mark_node
4725 || TREE_CODE (t
) == IDENTIFIER_NODE
)
4728 if (TREE_CODE (t
) == CASE_LABEL_EXPR
)
4737 /* Called via walk_tree. Verify tree sharing. */
4740 verify_node_sharing_1 (tree
*tp
, int *walk_subtrees
, void *data
)
4742 hash_set
<void *> *visited
= (hash_set
<void *> *) data
;
4744 if (tree_node_can_be_shared (*tp
))
4746 *walk_subtrees
= false;
4750 if (visited
->add (*tp
))
4756 /* Called via walk_gimple_stmt. Verify tree sharing. */
4759 verify_node_sharing (tree
*tp
, int *walk_subtrees
, void *data
)
4761 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4762 return verify_node_sharing_1 (tp
, walk_subtrees
, wi
->info
);
4765 static bool eh_error_found
;
4767 verify_eh_throw_stmt_node (const gimple
&stmt
, const int &,
4768 hash_set
<gimple
> *visited
)
4770 if (!visited
->contains (stmt
))
4772 error ("dead STMT in EH table");
4773 debug_gimple_stmt (stmt
);
4774 eh_error_found
= true;
4779 /* Verify if the location LOCs block is in BLOCKS. */
4782 verify_location (hash_set
<tree
> *blocks
, location_t loc
)
4784 tree block
= LOCATION_BLOCK (loc
);
4785 if (block
!= NULL_TREE
4786 && !blocks
->contains (block
))
4788 error ("location references block not in block tree");
4791 if (block
!= NULL_TREE
)
4792 return verify_location (blocks
, BLOCK_SOURCE_LOCATION (block
));
4796 /* Called via walk_tree. Verify that expressions have no blocks. */
4799 verify_expr_no_block (tree
*tp
, int *walk_subtrees
, void *)
4803 *walk_subtrees
= false;
4807 location_t loc
= EXPR_LOCATION (*tp
);
4808 if (LOCATION_BLOCK (loc
) != NULL
)
4814 /* Called via walk_tree. Verify locations of expressions. */
4817 verify_expr_location_1 (tree
*tp
, int *walk_subtrees
, void *data
)
4819 hash_set
<tree
> *blocks
= (hash_set
<tree
> *) data
;
4821 if (TREE_CODE (*tp
) == VAR_DECL
4822 && DECL_HAS_DEBUG_EXPR_P (*tp
))
4824 tree t
= DECL_DEBUG_EXPR (*tp
);
4825 tree addr
= walk_tree (&t
, verify_expr_no_block
, NULL
, NULL
);
4829 if ((TREE_CODE (*tp
) == VAR_DECL
4830 || TREE_CODE (*tp
) == PARM_DECL
4831 || TREE_CODE (*tp
) == RESULT_DECL
)
4832 && DECL_HAS_VALUE_EXPR_P (*tp
))
4834 tree t
= DECL_VALUE_EXPR (*tp
);
4835 tree addr
= walk_tree (&t
, verify_expr_no_block
, NULL
, NULL
);
4842 *walk_subtrees
= false;
4846 location_t loc
= EXPR_LOCATION (*tp
);
4847 if (verify_location (blocks
, loc
))
4853 /* Called via walk_gimple_op. Verify locations of expressions. */
4856 verify_expr_location (tree
*tp
, int *walk_subtrees
, void *data
)
4858 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4859 return verify_expr_location_1 (tp
, walk_subtrees
, wi
->info
);
4862 /* Insert all subblocks of BLOCK into BLOCKS and recurse. */
4865 collect_subblocks (hash_set
<tree
> *blocks
, tree block
)
4868 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
4871 collect_subblocks (blocks
, t
);
4875 /* Verify the GIMPLE statements in the CFG of FN. */
4878 verify_gimple_in_cfg (struct function
*fn
, bool verify_nothrow
)
4883 timevar_push (TV_TREE_STMT_VERIFY
);
4884 hash_set
<void *> visited
;
4885 hash_set
<gimple
> visited_stmts
;
4887 /* Collect all BLOCKs referenced by the BLOCK tree of FN. */
4888 hash_set
<tree
> blocks
;
4889 if (DECL_INITIAL (fn
->decl
))
4891 blocks
.add (DECL_INITIAL (fn
->decl
));
4892 collect_subblocks (&blocks
, DECL_INITIAL (fn
->decl
));
4895 FOR_EACH_BB_FN (bb
, fn
)
4897 gimple_stmt_iterator gsi
;
4899 for (gimple_phi_iterator gpi
= gsi_start_phis (bb
);
4903 gimple_phi phi
= gpi
.phi ();
4907 visited_stmts
.add (phi
);
4909 if (gimple_bb (phi
) != bb
)
4911 error ("gimple_bb (phi) is set to a wrong basic block");
4915 err2
|= verify_gimple_phi (phi
);
4917 /* Only PHI arguments have locations. */
4918 if (gimple_location (phi
) != UNKNOWN_LOCATION
)
4920 error ("PHI node with location");
4924 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4926 tree arg
= gimple_phi_arg_def (phi
, i
);
4927 tree addr
= walk_tree (&arg
, verify_node_sharing_1
,
4931 error ("incorrect sharing of tree nodes");
4932 debug_generic_expr (addr
);
4935 location_t loc
= gimple_phi_arg_location (phi
, i
);
4936 if (virtual_operand_p (gimple_phi_result (phi
))
4937 && loc
!= UNKNOWN_LOCATION
)
4939 error ("virtual PHI with argument locations");
4942 addr
= walk_tree (&arg
, verify_expr_location_1
, &blocks
, NULL
);
4945 debug_generic_expr (addr
);
4948 err2
|= verify_location (&blocks
, loc
);
4952 debug_gimple_stmt (phi
);
4956 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4958 gimple stmt
= gsi_stmt (gsi
);
4960 struct walk_stmt_info wi
;
4964 visited_stmts
.add (stmt
);
4966 if (gimple_bb (stmt
) != bb
)
4968 error ("gimple_bb (stmt) is set to a wrong basic block");
4972 err2
|= verify_gimple_stmt (stmt
);
4973 err2
|= verify_location (&blocks
, gimple_location (stmt
));
4975 memset (&wi
, 0, sizeof (wi
));
4976 wi
.info
= (void *) &visited
;
4977 addr
= walk_gimple_op (stmt
, verify_node_sharing
, &wi
);
4980 error ("incorrect sharing of tree nodes");
4981 debug_generic_expr (addr
);
4985 memset (&wi
, 0, sizeof (wi
));
4986 wi
.info
= (void *) &blocks
;
4987 addr
= walk_gimple_op (stmt
, verify_expr_location
, &wi
);
4990 debug_generic_expr (addr
);
4994 /* ??? Instead of not checking these stmts at all the walker
4995 should know its context via wi. */
4996 if (!is_gimple_debug (stmt
)
4997 && !is_gimple_omp (stmt
))
4999 memset (&wi
, 0, sizeof (wi
));
5000 addr
= walk_gimple_op (stmt
, verify_expr
, &wi
);
5003 debug_generic_expr (addr
);
5004 inform (gimple_location (stmt
), "in statement");
5009 /* If the statement is marked as part of an EH region, then it is
5010 expected that the statement could throw. Verify that when we
5011 have optimizations that simplify statements such that we prove
5012 that they cannot throw, that we update other data structures
5014 lp_nr
= lookup_stmt_eh_lp (stmt
);
5017 if (!stmt_could_throw_p (stmt
))
5021 error ("statement marked for throw, but doesn%'t");
5025 else if (!gsi_one_before_end_p (gsi
))
5027 error ("statement marked for throw in middle of block");
5033 debug_gimple_stmt (stmt
);
5038 eh_error_found
= false;
5039 hash_map
<gimple
, int> *eh_table
= get_eh_throw_stmt_table (cfun
);
5041 eh_table
->traverse
<hash_set
<gimple
> *, verify_eh_throw_stmt_node
>
5044 if (err
|| eh_error_found
)
5045 internal_error ("verify_gimple failed");
5047 verify_histograms ();
5048 timevar_pop (TV_TREE_STMT_VERIFY
);
5052 /* Verifies that the flow information is OK. */
5055 gimple_verify_flow_info (void)
5059 gimple_stmt_iterator gsi
;
5064 if (ENTRY_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.seq
5065 || ENTRY_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.phi_nodes
)
5067 error ("ENTRY_BLOCK has IL associated with it");
5071 if (EXIT_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.seq
5072 || EXIT_BLOCK_PTR_FOR_FN (cfun
)->il
.gimple
.phi_nodes
)
5074 error ("EXIT_BLOCK has IL associated with it");
5078 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (cfun
)->preds
)
5079 if (e
->flags
& EDGE_FALLTHRU
)
5081 error ("fallthru to exit from bb %d", e
->src
->index
);
5085 FOR_EACH_BB_FN (bb
, cfun
)
5087 bool found_ctrl_stmt
= false;
5091 /* Skip labels on the start of basic block. */
5092 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5095 gimple prev_stmt
= stmt
;
5097 stmt
= gsi_stmt (gsi
);
5099 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5102 label
= gimple_label_label (as_a
<gimple_label
> (stmt
));
5103 if (prev_stmt
&& DECL_NONLOCAL (label
))
5105 error ("nonlocal label ");
5106 print_generic_expr (stderr
, label
, 0);
5107 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
5112 if (prev_stmt
&& EH_LANDING_PAD_NR (label
) != 0)
5114 error ("EH landing pad label ");
5115 print_generic_expr (stderr
, label
, 0);
5116 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
5121 if (label_to_block (label
) != bb
)
5124 print_generic_expr (stderr
, label
, 0);
5125 fprintf (stderr
, " to block does not match in bb %d",
5130 if (decl_function_context (label
) != current_function_decl
)
5133 print_generic_expr (stderr
, label
, 0);
5134 fprintf (stderr
, " has incorrect context in bb %d",
5140 /* Verify that body of basic block BB is free of control flow. */
5141 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
5143 gimple stmt
= gsi_stmt (gsi
);
5145 if (found_ctrl_stmt
)
5147 error ("control flow in the middle of basic block %d",
5152 if (stmt_ends_bb_p (stmt
))
5153 found_ctrl_stmt
= true;
5155 if (gimple_label label_stmt
= dyn_cast
<gimple_label
> (stmt
))
5158 print_generic_expr (stderr
, gimple_label_label (label_stmt
), 0);
5159 fprintf (stderr
, " in the middle of basic block %d", bb
->index
);
5164 gsi
= gsi_last_bb (bb
);
5165 if (gsi_end_p (gsi
))
5168 stmt
= gsi_stmt (gsi
);
5170 if (gimple_code (stmt
) == GIMPLE_LABEL
)
5173 err
|= verify_eh_edges (stmt
);
5175 if (is_ctrl_stmt (stmt
))
5177 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5178 if (e
->flags
& EDGE_FALLTHRU
)
5180 error ("fallthru edge after a control statement in bb %d",
5186 if (gimple_code (stmt
) != GIMPLE_COND
)
5188 /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
5189 after anything else but if statement. */
5190 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5191 if (e
->flags
& (EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
))
5193 error ("true/false edge after a non-GIMPLE_COND in bb %d",
5199 switch (gimple_code (stmt
))
5206 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
5210 || !(true_edge
->flags
& EDGE_TRUE_VALUE
)
5211 || !(false_edge
->flags
& EDGE_FALSE_VALUE
)
5212 || (true_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
5213 || (false_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
5214 || EDGE_COUNT (bb
->succs
) >= 3)
5216 error ("wrong outgoing edge flags at end of bb %d",
5224 if (simple_goto_p (stmt
))
5226 error ("explicit goto at end of bb %d", bb
->index
);
5231 /* FIXME. We should double check that the labels in the
5232 destination blocks have their address taken. */
5233 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5234 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_TRUE_VALUE
5235 | EDGE_FALSE_VALUE
))
5236 || !(e
->flags
& EDGE_ABNORMAL
))
5238 error ("wrong outgoing edge flags at end of bb %d",
5246 if (!gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
))
5248 /* ... fallthru ... */
5250 if (!single_succ_p (bb
)
5251 || (single_succ_edge (bb
)->flags
5252 & (EDGE_FALLTHRU
| EDGE_ABNORMAL
5253 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5255 error ("wrong outgoing edge flags at end of bb %d", bb
->index
);
5258 if (single_succ (bb
) != EXIT_BLOCK_PTR_FOR_FN (cfun
))
5260 error ("return edge does not point to exit in bb %d",
5268 gimple_switch switch_stmt
= as_a
<gimple_switch
> (stmt
);
5273 n
= gimple_switch_num_labels (switch_stmt
);
5275 /* Mark all the destination basic blocks. */
5276 for (i
= 0; i
< n
; ++i
)
5278 tree lab
= CASE_LABEL (gimple_switch_label (switch_stmt
, i
));
5279 basic_block label_bb
= label_to_block (lab
);
5280 gcc_assert (!label_bb
->aux
|| label_bb
->aux
== (void *)1);
5281 label_bb
->aux
= (void *)1;
5284 /* Verify that the case labels are sorted. */
5285 prev
= gimple_switch_label (switch_stmt
, 0);
5286 for (i
= 1; i
< n
; ++i
)
5288 tree c
= gimple_switch_label (switch_stmt
, i
);
5291 error ("found default case not at the start of "
5297 && !tree_int_cst_lt (CASE_LOW (prev
), CASE_LOW (c
)))
5299 error ("case labels not sorted: ");
5300 print_generic_expr (stderr
, prev
, 0);
5301 fprintf (stderr
," is greater than ");
5302 print_generic_expr (stderr
, c
, 0);
5303 fprintf (stderr
," but comes before it.\n");
5308 /* VRP will remove the default case if it can prove it will
5309 never be executed. So do not verify there always exists
5310 a default case here. */
5312 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5316 error ("extra outgoing edge %d->%d",
5317 bb
->index
, e
->dest
->index
);
5321 e
->dest
->aux
= (void *)2;
5322 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
5323 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5325 error ("wrong outgoing edge flags at end of bb %d",
5331 /* Check that we have all of them. */
5332 for (i
= 0; i
< n
; ++i
)
5334 tree lab
= CASE_LABEL (gimple_switch_label (switch_stmt
, i
));
5335 basic_block label_bb
= label_to_block (lab
);
5337 if (label_bb
->aux
!= (void *)2)
5339 error ("missing edge %i->%i", bb
->index
, label_bb
->index
);
5344 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5345 e
->dest
->aux
= (void *)0;
5349 case GIMPLE_EH_DISPATCH
:
5350 err
|= verify_eh_dispatch_edge (as_a
<gimple_eh_dispatch
> (stmt
));
5358 if (dom_info_state (CDI_DOMINATORS
) >= DOM_NO_FAST_QUERY
)
5359 verify_dominators (CDI_DOMINATORS
);
5365 /* Updates phi nodes after creating a forwarder block joined
5366 by edge FALLTHRU. */
5369 gimple_make_forwarder_block (edge fallthru
)
5373 basic_block dummy
, bb
;
5375 gimple_phi_iterator gsi
;
5377 dummy
= fallthru
->src
;
5378 bb
= fallthru
->dest
;
5380 if (single_pred_p (bb
))
5383 /* If we redirected a branch we must create new PHI nodes at the
5385 for (gsi
= gsi_start_phis (dummy
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5387 gimple_phi phi
, new_phi
;
5390 var
= gimple_phi_result (phi
);
5391 new_phi
= create_phi_node (var
, bb
);
5392 gimple_phi_set_result (phi
, copy_ssa_name (var
, phi
));
5393 add_phi_arg (new_phi
, gimple_phi_result (phi
), fallthru
,
5397 /* Add the arguments we have stored on edges. */
5398 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
5403 flush_pending_stmts (e
);
5408 /* Return a non-special label in the head of basic block BLOCK.
5409 Create one if it doesn't exist. */
5412 gimple_block_label (basic_block bb
)
5414 gimple_stmt_iterator i
, s
= gsi_start_bb (bb
);
5419 for (i
= s
; !gsi_end_p (i
); first
= false, gsi_next (&i
))
5421 stmt
= dyn_cast
<gimple_label
> (gsi_stmt (i
));
5424 label
= gimple_label_label (stmt
);
5425 if (!DECL_NONLOCAL (label
))
5428 gsi_move_before (&i
, &s
);
5433 label
= create_artificial_label (UNKNOWN_LOCATION
);
5434 stmt
= gimple_build_label (label
);
5435 gsi_insert_before (&s
, stmt
, GSI_NEW_STMT
);
5440 /* Attempt to perform edge redirection by replacing a possibly complex
5441 jump instruction by a goto or by removing the jump completely.
5442 This can apply only if all edges now point to the same block. The
5443 parameters and return values are equivalent to
5444 redirect_edge_and_branch. */
5447 gimple_try_redirect_by_replacing_jump (edge e
, basic_block target
)
5449 basic_block src
= e
->src
;
5450 gimple_stmt_iterator i
;
5453 /* We can replace or remove a complex jump only when we have exactly
5455 if (EDGE_COUNT (src
->succs
) != 2
5456 /* Verify that all targets will be TARGET. Specifically, the
5457 edge that is not E must also go to TARGET. */
5458 || EDGE_SUCC (src
, EDGE_SUCC (src
, 0) == e
)->dest
!= target
)
5461 i
= gsi_last_bb (src
);
5465 stmt
= gsi_stmt (i
);
5467 if (gimple_code (stmt
) == GIMPLE_COND
|| gimple_code (stmt
) == GIMPLE_SWITCH
)
5469 gsi_remove (&i
, true);
5470 e
= ssa_redirect_edge (e
, target
);
5471 e
->flags
= EDGE_FALLTHRU
;
5479 /* Redirect E to DEST. Return NULL on failure. Otherwise, return the
5480 edge representing the redirected branch. */
5483 gimple_redirect_edge_and_branch (edge e
, basic_block dest
)
5485 basic_block bb
= e
->src
;
5486 gimple_stmt_iterator gsi
;
5490 if (e
->flags
& EDGE_ABNORMAL
)
5493 if (e
->dest
== dest
)
5496 if (e
->flags
& EDGE_EH
)
5497 return redirect_eh_edge (e
, dest
);
5499 if (e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
))
5501 ret
= gimple_try_redirect_by_replacing_jump (e
, dest
);
5506 gsi
= gsi_last_bb (bb
);
5507 stmt
= gsi_end_p (gsi
) ? NULL
: gsi_stmt (gsi
);
5509 switch (stmt
? gimple_code (stmt
) : GIMPLE_ERROR_MARK
)
5512 /* For COND_EXPR, we only need to redirect the edge. */
5516 /* No non-abnormal edges should lead from a non-simple goto, and
5517 simple ones should be represented implicitly. */
5522 gimple_switch switch_stmt
= as_a
<gimple_switch
> (stmt
);
5523 tree label
= gimple_block_label (dest
);
5524 tree cases
= get_cases_for_edge (e
, switch_stmt
);
5526 /* If we have a list of cases associated with E, then use it
5527 as it's a lot faster than walking the entire case vector. */
5530 edge e2
= find_edge (e
->src
, dest
);
5537 CASE_LABEL (cases
) = label
;
5538 cases
= CASE_CHAIN (cases
);
5541 /* If there was already an edge in the CFG, then we need
5542 to move all the cases associated with E to E2. */
5545 tree cases2
= get_cases_for_edge (e2
, switch_stmt
);
5547 CASE_CHAIN (last
) = CASE_CHAIN (cases2
);
5548 CASE_CHAIN (cases2
) = first
;
5550 bitmap_set_bit (touched_switch_bbs
, gimple_bb (stmt
)->index
);
5554 size_t i
, n
= gimple_switch_num_labels (switch_stmt
);
5556 for (i
= 0; i
< n
; i
++)
5558 tree elt
= gimple_switch_label (switch_stmt
, i
);
5559 if (label_to_block (CASE_LABEL (elt
)) == e
->dest
)
5560 CASE_LABEL (elt
) = label
;
5568 gimple_asm asm_stmt
= as_a
<gimple_asm
> (stmt
);
5569 int i
, n
= gimple_asm_nlabels (asm_stmt
);
5572 for (i
= 0; i
< n
; ++i
)
5574 tree cons
= gimple_asm_label_op (asm_stmt
, i
);
5575 if (label_to_block (TREE_VALUE (cons
)) == e
->dest
)
5578 label
= gimple_block_label (dest
);
5579 TREE_VALUE (cons
) = label
;
5583 /* If we didn't find any label matching the former edge in the
5584 asm labels, we must be redirecting the fallthrough
5586 gcc_assert (label
|| (e
->flags
& EDGE_FALLTHRU
));
5591 gsi_remove (&gsi
, true);
5592 e
->flags
|= EDGE_FALLTHRU
;
5595 case GIMPLE_OMP_RETURN
:
5596 case GIMPLE_OMP_CONTINUE
:
5597 case GIMPLE_OMP_SECTIONS_SWITCH
:
5598 case GIMPLE_OMP_FOR
:
5599 /* The edges from OMP constructs can be simply redirected. */
5602 case GIMPLE_EH_DISPATCH
:
5603 if (!(e
->flags
& EDGE_FALLTHRU
))
5604 redirect_eh_dispatch_edge (as_a
<gimple_eh_dispatch
> (stmt
), e
, dest
);
5607 case GIMPLE_TRANSACTION
:
5608 /* The ABORT edge has a stored label associated with it, otherwise
5609 the edges are simply redirectable. */
5611 gimple_transaction_set_label (as_a
<gimple_transaction
> (stmt
),
5612 gimple_block_label (dest
));
5616 /* Otherwise it must be a fallthru edge, and we don't need to
5617 do anything besides redirecting it. */
5618 gcc_assert (e
->flags
& EDGE_FALLTHRU
);
5622 /* Update/insert PHI nodes as necessary. */
5624 /* Now update the edges in the CFG. */
5625 e
= ssa_redirect_edge (e
, dest
);
5630 /* Returns true if it is possible to remove edge E by redirecting
5631 it to the destination of the other edge from E->src. */
5634 gimple_can_remove_branch_p (const_edge e
)
5636 if (e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
))
5642 /* Simple wrapper, as we can always redirect fallthru edges. */
5645 gimple_redirect_edge_and_branch_force (edge e
, basic_block dest
)
5647 e
= gimple_redirect_edge_and_branch (e
, dest
);
5654 /* Splits basic block BB after statement STMT (but at least after the
5655 labels). If STMT is NULL, BB is split just after the labels. */
5658 gimple_split_block (basic_block bb
, void *stmt
)
5660 gimple_stmt_iterator gsi
;
5661 gimple_stmt_iterator gsi_tgt
;
5668 new_bb
= create_empty_bb (bb
);
5670 /* Redirect the outgoing edges. */
5671 new_bb
->succs
= bb
->succs
;
5673 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
5676 if (stmt
&& gimple_code ((gimple
) stmt
) == GIMPLE_LABEL
)
5679 /* Move everything from GSI to the new basic block. */
5680 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5682 act
= gsi_stmt (gsi
);
5683 if (gimple_code (act
) == GIMPLE_LABEL
)
5696 if (gsi_end_p (gsi
))
5699 /* Split the statement list - avoid re-creating new containers as this
5700 brings ugly quadratic memory consumption in the inliner.
5701 (We are still quadratic since we need to update stmt BB pointers,
5703 gsi_split_seq_before (&gsi
, &list
);
5704 set_bb_seq (new_bb
, list
);
5705 for (gsi_tgt
= gsi_start (list
);
5706 !gsi_end_p (gsi_tgt
); gsi_next (&gsi_tgt
))
5707 gimple_set_bb (gsi_stmt (gsi_tgt
), new_bb
);
5713 /* Moves basic block BB after block AFTER. */
5716 gimple_move_block_after (basic_block bb
, basic_block after
)
5718 if (bb
->prev_bb
== after
)
5722 link_block (bb
, after
);
5728 /* Return TRUE if block BB has no executable statements, otherwise return
5732 gimple_empty_block_p (basic_block bb
)
5734 /* BB must have no executable statements. */
5735 gimple_stmt_iterator gsi
= gsi_after_labels (bb
);
5738 if (gsi_end_p (gsi
))
5740 if (is_gimple_debug (gsi_stmt (gsi
)))
5741 gsi_next_nondebug (&gsi
);
5742 return gsi_end_p (gsi
);
5746 /* Split a basic block if it ends with a conditional branch and if the
5747 other part of the block is not empty. */
5750 gimple_split_block_before_cond_jump (basic_block bb
)
5752 gimple last
, split_point
;
5753 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
5754 if (gsi_end_p (gsi
))
5756 last
= gsi_stmt (gsi
);
5757 if (gimple_code (last
) != GIMPLE_COND
5758 && gimple_code (last
) != GIMPLE_SWITCH
)
5760 gsi_prev_nondebug (&gsi
);
5761 split_point
= gsi_stmt (gsi
);
5762 return split_block (bb
, split_point
)->dest
;
5766 /* Return true if basic_block can be duplicated. */
5769 gimple_can_duplicate_bb_p (const_basic_block bb ATTRIBUTE_UNUSED
)
5774 /* Create a duplicate of the basic block BB. NOTE: This does not
5775 preserve SSA form. */
5778 gimple_duplicate_bb (basic_block bb
)
5781 gimple_stmt_iterator gsi_tgt
;
5783 new_bb
= create_empty_bb (EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
);
5785 /* Copy the PHI nodes. We ignore PHI node arguments here because
5786 the incoming edges have not been setup yet. */
5787 for (gimple_phi_iterator gpi
= gsi_start_phis (bb
);
5791 gimple_phi phi
, copy
;
5793 copy
= create_phi_node (NULL_TREE
, new_bb
);
5794 create_new_def_for (gimple_phi_result (phi
), copy
,
5795 gimple_phi_result_ptr (copy
));
5796 gimple_set_uid (copy
, gimple_uid (phi
));
5799 gsi_tgt
= gsi_start_bb (new_bb
);
5800 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
);
5804 def_operand_p def_p
;
5805 ssa_op_iter op_iter
;
5809 stmt
= gsi_stmt (gsi
);
5810 if (gimple_code (stmt
) == GIMPLE_LABEL
)
5813 /* Don't duplicate label debug stmts. */
5814 if (gimple_debug_bind_p (stmt
)
5815 && TREE_CODE (gimple_debug_bind_get_var (stmt
))
5819 /* Create a new copy of STMT and duplicate STMT's virtual
5821 copy
= gimple_copy (stmt
);
5822 gsi_insert_after (&gsi_tgt
, copy
, GSI_NEW_STMT
);
5824 maybe_duplicate_eh_stmt (copy
, stmt
);
5825 gimple_duplicate_stmt_histograms (cfun
, copy
, cfun
, stmt
);
5827 /* When copying around a stmt writing into a local non-user
5828 aggregate, make sure it won't share stack slot with other
5830 lhs
= gimple_get_lhs (stmt
);
5831 if (lhs
&& TREE_CODE (lhs
) != SSA_NAME
)
5833 tree base
= get_base_address (lhs
);
5835 && (TREE_CODE (base
) == VAR_DECL
5836 || TREE_CODE (base
) == RESULT_DECL
)
5837 && DECL_IGNORED_P (base
)
5838 && !TREE_STATIC (base
)
5839 && !DECL_EXTERNAL (base
)
5840 && (TREE_CODE (base
) != VAR_DECL
5841 || !DECL_HAS_VALUE_EXPR_P (base
)))
5842 DECL_NONSHAREABLE (base
) = 1;
5845 /* Create new names for all the definitions created by COPY and
5846 add replacement mappings for each new name. */
5847 FOR_EACH_SSA_DEF_OPERAND (def_p
, copy
, op_iter
, SSA_OP_ALL_DEFS
)
5848 create_new_def_for (DEF_FROM_PTR (def_p
), copy
, def_p
);
5854 /* Adds phi node arguments for edge E_COPY after basic block duplication. */
5857 add_phi_args_after_copy_edge (edge e_copy
)
5859 basic_block bb
, bb_copy
= e_copy
->src
, dest
;
5862 gimple_phi phi
, phi_copy
;
5864 gimple_phi_iterator psi
, psi_copy
;
5866 if (gimple_seq_empty_p (phi_nodes (e_copy
->dest
)))
5869 bb
= bb_copy
->flags
& BB_DUPLICATED
? get_bb_original (bb_copy
) : bb_copy
;
5871 if (e_copy
->dest
->flags
& BB_DUPLICATED
)
5872 dest
= get_bb_original (e_copy
->dest
);
5874 dest
= e_copy
->dest
;
5876 e
= find_edge (bb
, dest
);
5879 /* During loop unrolling the target of the latch edge is copied.
5880 In this case we are not looking for edge to dest, but to
5881 duplicated block whose original was dest. */
5882 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5884 if ((e
->dest
->flags
& BB_DUPLICATED
)
5885 && get_bb_original (e
->dest
) == dest
)
5889 gcc_assert (e
!= NULL
);
5892 for (psi
= gsi_start_phis (e
->dest
),
5893 psi_copy
= gsi_start_phis (e_copy
->dest
);
5895 gsi_next (&psi
), gsi_next (&psi_copy
))
5898 phi_copy
= psi_copy
.phi ();
5899 def
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
5900 add_phi_arg (phi_copy
, def
, e_copy
,
5901 gimple_phi_arg_location_from_edge (phi
, e
));
5906 /* Basic block BB_COPY was created by code duplication. Add phi node
5907 arguments for edges going out of BB_COPY. The blocks that were
5908 duplicated have BB_DUPLICATED set. */
5911 add_phi_args_after_copy_bb (basic_block bb_copy
)
5916 FOR_EACH_EDGE (e_copy
, ei
, bb_copy
->succs
)
5918 add_phi_args_after_copy_edge (e_copy
);
5922 /* Blocks in REGION_COPY array of length N_REGION were created by
5923 duplication of basic blocks. Add phi node arguments for edges
5924 going from these blocks. If E_COPY is not NULL, also add
5925 phi node arguments for its destination.*/
5928 add_phi_args_after_copy (basic_block
*region_copy
, unsigned n_region
,
5933 for (i
= 0; i
< n_region
; i
++)
5934 region_copy
[i
]->flags
|= BB_DUPLICATED
;
5936 for (i
= 0; i
< n_region
; i
++)
5937 add_phi_args_after_copy_bb (region_copy
[i
]);
5939 add_phi_args_after_copy_edge (e_copy
);
5941 for (i
= 0; i
< n_region
; i
++)
5942 region_copy
[i
]->flags
&= ~BB_DUPLICATED
;
5945 /* Duplicates a REGION (set of N_REGION basic blocks) with just a single
5946 important exit edge EXIT. By important we mean that no SSA name defined
5947 inside region is live over the other exit edges of the region. All entry
5948 edges to the region must go to ENTRY->dest. The edge ENTRY is redirected
5949 to the duplicate of the region. Dominance and loop information is
5950 updated if UPDATE_DOMINANCE is true, but not the SSA web. If
5951 UPDATE_DOMINANCE is false then we assume that the caller will update the
5952 dominance information after calling this function. The new basic
5953 blocks are stored to REGION_COPY in the same order as they had in REGION,
5954 provided that REGION_COPY is not NULL.
5955 The function returns false if it is unable to copy the region,
5959 gimple_duplicate_sese_region (edge entry
, edge exit
,
5960 basic_block
*region
, unsigned n_region
,
5961 basic_block
*region_copy
,
5962 bool update_dominance
)
5965 bool free_region_copy
= false, copying_header
= false;
5966 struct loop
*loop
= entry
->dest
->loop_father
;
5968 vec
<basic_block
> doms
;
5970 int total_freq
= 0, entry_freq
= 0;
5971 gcov_type total_count
= 0, entry_count
= 0;
5973 if (!can_copy_bbs_p (region
, n_region
))
5976 /* Some sanity checking. Note that we do not check for all possible
5977 missuses of the functions. I.e. if you ask to copy something weird,
5978 it will work, but the state of structures probably will not be
5980 for (i
= 0; i
< n_region
; i
++)
5982 /* We do not handle subloops, i.e. all the blocks must belong to the
5984 if (region
[i
]->loop_father
!= loop
)
5987 if (region
[i
] != entry
->dest
5988 && region
[i
] == loop
->header
)
5992 /* In case the function is used for loop header copying (which is the primary
5993 use), ensure that EXIT and its copy will be new latch and entry edges. */
5994 if (loop
->header
== entry
->dest
)
5996 copying_header
= true;
5998 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, exit
->src
))
6001 for (i
= 0; i
< n_region
; i
++)
6002 if (region
[i
] != exit
->src
6003 && dominated_by_p (CDI_DOMINATORS
, region
[i
], exit
->src
))
6007 initialize_original_copy_tables ();
6010 set_loop_copy (loop
, loop_outer (loop
));
6012 set_loop_copy (loop
, loop
);
6016 region_copy
= XNEWVEC (basic_block
, n_region
);
6017 free_region_copy
= true;
6020 /* Record blocks outside the region that are dominated by something
6022 if (update_dominance
)
6025 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
6028 if (entry
->dest
->count
)
6030 total_count
= entry
->dest
->count
;
6031 entry_count
= entry
->count
;
6032 /* Fix up corner cases, to avoid division by zero or creation of negative
6034 if (entry_count
> total_count
)
6035 entry_count
= total_count
;
6039 total_freq
= entry
->dest
->frequency
;
6040 entry_freq
= EDGE_FREQUENCY (entry
);
6041 /* Fix up corner cases, to avoid division by zero or creation of negative
6043 if (total_freq
== 0)
6045 else if (entry_freq
> total_freq
)
6046 entry_freq
= total_freq
;
6049 copy_bbs (region
, n_region
, region_copy
, &exit
, 1, &exit_copy
, loop
,
6050 split_edge_bb_loc (entry
), update_dominance
);
6053 scale_bbs_frequencies_gcov_type (region
, n_region
,
6054 total_count
- entry_count
,
6056 scale_bbs_frequencies_gcov_type (region_copy
, n_region
, entry_count
,
6061 scale_bbs_frequencies_int (region
, n_region
, total_freq
- entry_freq
,
6063 scale_bbs_frequencies_int (region_copy
, n_region
, entry_freq
, total_freq
);
6068 loop
->header
= exit
->dest
;
6069 loop
->latch
= exit
->src
;
6072 /* Redirect the entry and add the phi node arguments. */
6073 redirected
= redirect_edge_and_branch (entry
, get_bb_copy (entry
->dest
));
6074 gcc_assert (redirected
!= NULL
);
6075 flush_pending_stmts (entry
);
6077 /* Concerning updating of dominators: We must recount dominators
6078 for entry block and its copy. Anything that is outside of the
6079 region, but was dominated by something inside needs recounting as
6081 if (update_dominance
)
6083 set_immediate_dominator (CDI_DOMINATORS
, entry
->dest
, entry
->src
);
6084 doms
.safe_push (get_bb_original (entry
->dest
));
6085 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6089 /* Add the other PHI node arguments. */
6090 add_phi_args_after_copy (region_copy
, n_region
, NULL
);
6092 if (free_region_copy
)
6095 free_original_copy_tables ();
6099 /* Checks if BB is part of the region defined by N_REGION BBS. */
6101 bb_part_of_region_p (basic_block bb
, basic_block
* bbs
, unsigned n_region
)
6105 for (n
= 0; n
< n_region
; n
++)
6113 /* Duplicates REGION consisting of N_REGION blocks. The new blocks
6114 are stored to REGION_COPY in the same order in that they appear
6115 in REGION, if REGION_COPY is not NULL. ENTRY is the entry to
6116 the region, EXIT an exit from it. The condition guarding EXIT
6117 is moved to ENTRY. Returns true if duplication succeeds, false
6143 gimple_duplicate_sese_tail (edge entry ATTRIBUTE_UNUSED
, edge exit ATTRIBUTE_UNUSED
,
6144 basic_block
*region ATTRIBUTE_UNUSED
, unsigned n_region ATTRIBUTE_UNUSED
,
6145 basic_block
*region_copy ATTRIBUTE_UNUSED
)
6148 bool free_region_copy
= false;
6149 struct loop
*loop
= exit
->dest
->loop_father
;
6150 struct loop
*orig_loop
= entry
->dest
->loop_father
;
6151 basic_block switch_bb
, entry_bb
, nentry_bb
;
6152 vec
<basic_block
> doms
;
6153 int total_freq
= 0, exit_freq
= 0;
6154 gcov_type total_count
= 0, exit_count
= 0;
6155 edge exits
[2], nexits
[2], e
;
6156 gimple_stmt_iterator gsi
;
6159 basic_block exit_bb
;
6160 gimple_phi_iterator psi
;
6163 struct loop
*target
, *aloop
, *cloop
;
6165 gcc_assert (EDGE_COUNT (exit
->src
->succs
) == 2);
6167 exits
[1] = EDGE_SUCC (exit
->src
, EDGE_SUCC (exit
->src
, 0) == exit
);
6169 if (!can_copy_bbs_p (region
, n_region
))
6172 initialize_original_copy_tables ();
6173 set_loop_copy (orig_loop
, loop
);
6176 for (aloop
= orig_loop
->inner
; aloop
; aloop
= aloop
->next
)
6178 if (bb_part_of_region_p (aloop
->header
, region
, n_region
))
6180 cloop
= duplicate_loop (aloop
, target
);
6181 duplicate_subloops (aloop
, cloop
);
6187 region_copy
= XNEWVEC (basic_block
, n_region
);
6188 free_region_copy
= true;
6191 gcc_assert (!need_ssa_update_p (cfun
));
6193 /* Record blocks outside the region that are dominated by something
6195 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
6197 if (exit
->src
->count
)
6199 total_count
= exit
->src
->count
;
6200 exit_count
= exit
->count
;
6201 /* Fix up corner cases, to avoid division by zero or creation of negative
6203 if (exit_count
> total_count
)
6204 exit_count
= total_count
;
6208 total_freq
= exit
->src
->frequency
;
6209 exit_freq
= EDGE_FREQUENCY (exit
);
6210 /* Fix up corner cases, to avoid division by zero or creation of negative
6212 if (total_freq
== 0)
6214 if (exit_freq
> total_freq
)
6215 exit_freq
= total_freq
;
6218 copy_bbs (region
, n_region
, region_copy
, exits
, 2, nexits
, orig_loop
,
6219 split_edge_bb_loc (exit
), true);
6222 scale_bbs_frequencies_gcov_type (region
, n_region
,
6223 total_count
- exit_count
,
6225 scale_bbs_frequencies_gcov_type (region_copy
, n_region
, exit_count
,
6230 scale_bbs_frequencies_int (region
, n_region
, total_freq
- exit_freq
,
6232 scale_bbs_frequencies_int (region_copy
, n_region
, exit_freq
, total_freq
);
6235 /* Create the switch block, and put the exit condition to it. */
6236 entry_bb
= entry
->dest
;
6237 nentry_bb
= get_bb_copy (entry_bb
);
6238 if (!last_stmt (entry
->src
)
6239 || !stmt_ends_bb_p (last_stmt (entry
->src
)))
6240 switch_bb
= entry
->src
;
6242 switch_bb
= split_edge (entry
);
6243 set_immediate_dominator (CDI_DOMINATORS
, nentry_bb
, switch_bb
);
6245 gsi
= gsi_last_bb (switch_bb
);
6246 cond_stmt
= last_stmt (exit
->src
);
6247 gcc_assert (gimple_code (cond_stmt
) == GIMPLE_COND
);
6248 cond_stmt
= gimple_copy (cond_stmt
);
6250 gsi_insert_after (&gsi
, cond_stmt
, GSI_NEW_STMT
);
6252 sorig
= single_succ_edge (switch_bb
);
6253 sorig
->flags
= exits
[1]->flags
;
6254 snew
= make_edge (switch_bb
, nentry_bb
, exits
[0]->flags
);
6256 /* Register the new edge from SWITCH_BB in loop exit lists. */
6257 rescan_loop_exit (snew
, true, false);
6259 /* Add the PHI node arguments. */
6260 add_phi_args_after_copy (region_copy
, n_region
, snew
);
6262 /* Get rid of now superfluous conditions and associated edges (and phi node
6264 exit_bb
= exit
->dest
;
6266 e
= redirect_edge_and_branch (exits
[0], exits
[1]->dest
);
6267 PENDING_STMT (e
) = NULL
;
6269 /* The latch of ORIG_LOOP was copied, and so was the backedge
6270 to the original header. We redirect this backedge to EXIT_BB. */
6271 for (i
= 0; i
< n_region
; i
++)
6272 if (get_bb_original (region_copy
[i
]) == orig_loop
->latch
)
6274 gcc_assert (single_succ_edge (region_copy
[i
]));
6275 e
= redirect_edge_and_branch (single_succ_edge (region_copy
[i
]), exit_bb
);
6276 PENDING_STMT (e
) = NULL
;
6277 for (psi
= gsi_start_phis (exit_bb
);
6282 def
= PHI_ARG_DEF (phi
, nexits
[0]->dest_idx
);
6283 add_phi_arg (phi
, def
, e
, gimple_phi_arg_location_from_edge (phi
, e
));
6286 e
= redirect_edge_and_branch (nexits
[1], nexits
[0]->dest
);
6287 PENDING_STMT (e
) = NULL
;
6289 /* Anything that is outside of the region, but was dominated by something
6290 inside needs to update dominance info. */
6291 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6293 /* Update the SSA web. */
6294 update_ssa (TODO_update_ssa
);
6296 if (free_region_copy
)
6299 free_original_copy_tables ();
6303 /* Add all the blocks dominated by ENTRY to the array BBS_P. Stop
6304 adding blocks when the dominator traversal reaches EXIT. This
6305 function silently assumes that ENTRY strictly dominates EXIT. */
6308 gather_blocks_in_sese_region (basic_block entry
, basic_block exit
,
6309 vec
<basic_block
> *bbs_p
)
6313 for (son
= first_dom_son (CDI_DOMINATORS
, entry
);
6315 son
= next_dom_son (CDI_DOMINATORS
, son
))
6317 bbs_p
->safe_push (son
);
6319 gather_blocks_in_sese_region (son
, exit
, bbs_p
);
6323 /* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
6324 The duplicates are recorded in VARS_MAP. */
6327 replace_by_duplicate_decl (tree
*tp
, hash_map
<tree
, tree
> *vars_map
,
6330 tree t
= *tp
, new_t
;
6331 struct function
*f
= DECL_STRUCT_FUNCTION (to_context
);
6333 if (DECL_CONTEXT (t
) == to_context
)
6337 tree
&loc
= vars_map
->get_or_insert (t
, &existed
);
6343 new_t
= copy_var_decl (t
, DECL_NAME (t
), TREE_TYPE (t
));
6344 add_local_decl (f
, new_t
);
6348 gcc_assert (TREE_CODE (t
) == CONST_DECL
);
6349 new_t
= copy_node (t
);
6351 DECL_CONTEXT (new_t
) = to_context
;
6362 /* Creates an ssa name in TO_CONTEXT equivalent to NAME.
6363 VARS_MAP maps old ssa names and var_decls to the new ones. */
6366 replace_ssa_name (tree name
, hash_map
<tree
, tree
> *vars_map
,
6371 gcc_assert (!virtual_operand_p (name
));
6373 tree
*loc
= vars_map
->get (name
);
6377 tree decl
= SSA_NAME_VAR (name
);
6380 replace_by_duplicate_decl (&decl
, vars_map
, to_context
);
6381 new_name
= make_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6382 decl
, SSA_NAME_DEF_STMT (name
));
6383 if (SSA_NAME_IS_DEFAULT_DEF (name
))
6384 set_ssa_default_def (DECL_STRUCT_FUNCTION (to_context
),
6388 new_name
= copy_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6389 name
, SSA_NAME_DEF_STMT (name
));
6391 vars_map
->put (name
, new_name
);
6405 hash_map
<tree
, tree
> *vars_map
;
6406 htab_t new_label_map
;
6407 hash_map
<void *, void *> *eh_map
;
6411 /* Helper for move_block_to_fn. Set TREE_BLOCK in every expression
6412 contained in *TP if it has been ORIG_BLOCK previously and change the
6413 DECL_CONTEXT of every local variable referenced in *TP. */
6416 move_stmt_op (tree
*tp
, int *walk_subtrees
, void *data
)
6418 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
6419 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6424 tree block
= TREE_BLOCK (t
);
6425 if (block
== p
->orig_block
6426 || (p
->orig_block
== NULL_TREE
6427 && block
!= NULL_TREE
))
6428 TREE_SET_BLOCK (t
, p
->new_block
);
6429 #ifdef ENABLE_CHECKING
6430 else if (block
!= NULL_TREE
)
6432 while (block
&& TREE_CODE (block
) == BLOCK
&& block
!= p
->orig_block
)
6433 block
= BLOCK_SUPERCONTEXT (block
);
6434 gcc_assert (block
== p
->orig_block
);
6438 else if (DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
)
6440 if (TREE_CODE (t
) == SSA_NAME
)
6441 *tp
= replace_ssa_name (t
, p
->vars_map
, p
->to_context
);
6442 else if (TREE_CODE (t
) == LABEL_DECL
)
6444 if (p
->new_label_map
)
6446 struct tree_map in
, *out
;
6448 out
= (struct tree_map
*)
6449 htab_find_with_hash (p
->new_label_map
, &in
, DECL_UID (t
));
6454 DECL_CONTEXT (t
) = p
->to_context
;
6456 else if (p
->remap_decls_p
)
6458 /* Replace T with its duplicate. T should no longer appear in the
6459 parent function, so this looks wasteful; however, it may appear
6460 in referenced_vars, and more importantly, as virtual operands of
6461 statements, and in alias lists of other variables. It would be
6462 quite difficult to expunge it from all those places. ??? It might
6463 suffice to do this for addressable variables. */
6464 if ((TREE_CODE (t
) == VAR_DECL
6465 && !is_global_var (t
))
6466 || TREE_CODE (t
) == CONST_DECL
)
6467 replace_by_duplicate_decl (tp
, p
->vars_map
, p
->to_context
);
6471 else if (TYPE_P (t
))
6477 /* Helper for move_stmt_r. Given an EH region number for the source
6478 function, map that to the duplicate EH regio number in the dest. */
6481 move_stmt_eh_region_nr (int old_nr
, struct move_stmt_d
*p
)
6483 eh_region old_r
, new_r
;
6485 old_r
= get_eh_region_from_number (old_nr
);
6486 new_r
= static_cast<eh_region
> (*p
->eh_map
->get (old_r
));
6488 return new_r
->index
;
6491 /* Similar, but operate on INTEGER_CSTs. */
6494 move_stmt_eh_region_tree_nr (tree old_t_nr
, struct move_stmt_d
*p
)
6498 old_nr
= tree_to_shwi (old_t_nr
);
6499 new_nr
= move_stmt_eh_region_nr (old_nr
, p
);
6501 return build_int_cst (integer_type_node
, new_nr
);
6504 /* Like move_stmt_op, but for gimple statements.
6506 Helper for move_block_to_fn. Set GIMPLE_BLOCK in every expression
6507 contained in the current statement in *GSI_P and change the
6508 DECL_CONTEXT of every local variable referenced in the current
6512 move_stmt_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
6513 struct walk_stmt_info
*wi
)
6515 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6516 gimple stmt
= gsi_stmt (*gsi_p
);
6517 tree block
= gimple_block (stmt
);
6519 if (block
== p
->orig_block
6520 || (p
->orig_block
== NULL_TREE
6521 && block
!= NULL_TREE
))
6522 gimple_set_block (stmt
, p
->new_block
);
6524 switch (gimple_code (stmt
))
6527 /* Remap the region numbers for __builtin_eh_{pointer,filter}. */
6529 tree r
, fndecl
= gimple_call_fndecl (stmt
);
6530 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
6531 switch (DECL_FUNCTION_CODE (fndecl
))
6533 case BUILT_IN_EH_COPY_VALUES
:
6534 r
= gimple_call_arg (stmt
, 1);
6535 r
= move_stmt_eh_region_tree_nr (r
, p
);
6536 gimple_call_set_arg (stmt
, 1, r
);
6539 case BUILT_IN_EH_POINTER
:
6540 case BUILT_IN_EH_FILTER
:
6541 r
= gimple_call_arg (stmt
, 0);
6542 r
= move_stmt_eh_region_tree_nr (r
, p
);
6543 gimple_call_set_arg (stmt
, 0, r
);
6554 gimple_resx resx_stmt
= as_a
<gimple_resx
> (stmt
);
6555 int r
= gimple_resx_region (resx_stmt
);
6556 r
= move_stmt_eh_region_nr (r
, p
);
6557 gimple_resx_set_region (resx_stmt
, r
);
6561 case GIMPLE_EH_DISPATCH
:
6563 gimple_eh_dispatch eh_dispatch_stmt
= as_a
<gimple_eh_dispatch
> (stmt
);
6564 int r
= gimple_eh_dispatch_region (eh_dispatch_stmt
);
6565 r
= move_stmt_eh_region_nr (r
, p
);
6566 gimple_eh_dispatch_set_region (eh_dispatch_stmt
, r
);
6570 case GIMPLE_OMP_RETURN
:
6571 case GIMPLE_OMP_CONTINUE
:
6574 if (is_gimple_omp (stmt
))
6576 /* Do not remap variables inside OMP directives. Variables
6577 referenced in clauses and directive header belong to the
6578 parent function and should not be moved into the child
6580 bool save_remap_decls_p
= p
->remap_decls_p
;
6581 p
->remap_decls_p
= false;
6582 *handled_ops_p
= true;
6584 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt
), move_stmt_r
,
6587 p
->remap_decls_p
= save_remap_decls_p
;
6595 /* Move basic block BB from function CFUN to function DEST_FN. The
6596 block is moved out of the original linked list and placed after
6597 block AFTER in the new list. Also, the block is removed from the
6598 original array of blocks and placed in DEST_FN's array of blocks.
6599 If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
6600 updated to reflect the moved edges.
6602 The local variables are remapped to new instances, VARS_MAP is used
6603 to record the mapping. */
6606 move_block_to_fn (struct function
*dest_cfun
, basic_block bb
,
6607 basic_block after
, bool update_edge_count_p
,
6608 struct move_stmt_d
*d
)
6610 struct control_flow_graph
*cfg
;
6613 gimple_stmt_iterator si
;
6614 unsigned old_len
, new_len
;
6616 /* Remove BB from dominance structures. */
6617 delete_from_dominance_info (CDI_DOMINATORS
, bb
);
6619 /* Move BB from its current loop to the copy in the new function. */
6622 struct loop
*new_loop
= (struct loop
*)bb
->loop_father
->aux
;
6624 bb
->loop_father
= new_loop
;
6627 /* Link BB to the new linked list. */
6628 move_block_after (bb
, after
);
6630 /* Update the edge count in the corresponding flowgraphs. */
6631 if (update_edge_count_p
)
6632 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6634 cfun
->cfg
->x_n_edges
--;
6635 dest_cfun
->cfg
->x_n_edges
++;
6638 /* Remove BB from the original basic block array. */
6639 (*cfun
->cfg
->x_basic_block_info
)[bb
->index
] = NULL
;
6640 cfun
->cfg
->x_n_basic_blocks
--;
6642 /* Grow DEST_CFUN's basic block array if needed. */
6643 cfg
= dest_cfun
->cfg
;
6644 cfg
->x_n_basic_blocks
++;
6645 if (bb
->index
>= cfg
->x_last_basic_block
)
6646 cfg
->x_last_basic_block
= bb
->index
+ 1;
6648 old_len
= vec_safe_length (cfg
->x_basic_block_info
);
6649 if ((unsigned) cfg
->x_last_basic_block
>= old_len
)
6651 new_len
= cfg
->x_last_basic_block
+ (cfg
->x_last_basic_block
+ 3) / 4;
6652 vec_safe_grow_cleared (cfg
->x_basic_block_info
, new_len
);
6655 (*cfg
->x_basic_block_info
)[bb
->index
] = bb
;
6657 /* Remap the variables in phi nodes. */
6658 for (gimple_phi_iterator psi
= gsi_start_phis (bb
);
6661 gimple_phi phi
= psi
.phi ();
6663 tree op
= PHI_RESULT (phi
);
6667 if (virtual_operand_p (op
))
6669 /* Remove the phi nodes for virtual operands (alias analysis will be
6670 run for the new function, anyway). */
6671 remove_phi_node (&psi
, true);
6675 SET_PHI_RESULT (phi
,
6676 replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
6677 FOR_EACH_PHI_ARG (use
, phi
, oi
, SSA_OP_USE
)
6679 op
= USE_FROM_PTR (use
);
6680 if (TREE_CODE (op
) == SSA_NAME
)
6681 SET_USE (use
, replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
6684 for (i
= 0; i
< EDGE_COUNT (bb
->preds
); i
++)
6686 location_t locus
= gimple_phi_arg_location (phi
, i
);
6687 tree block
= LOCATION_BLOCK (locus
);
6689 if (locus
== UNKNOWN_LOCATION
)
6691 if (d
->orig_block
== NULL_TREE
|| block
== d
->orig_block
)
6693 if (d
->new_block
== NULL_TREE
)
6694 locus
= LOCATION_LOCUS (locus
);
6696 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, d
->new_block
);
6697 gimple_phi_arg_set_location (phi
, i
, locus
);
6704 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6706 gimple stmt
= gsi_stmt (si
);
6707 struct walk_stmt_info wi
;
6709 memset (&wi
, 0, sizeof (wi
));
6711 walk_gimple_stmt (&si
, move_stmt_r
, move_stmt_op
, &wi
);
6713 if (gimple_label label_stmt
= dyn_cast
<gimple_label
> (stmt
))
6715 tree label
= gimple_label_label (label_stmt
);
6716 int uid
= LABEL_DECL_UID (label
);
6718 gcc_assert (uid
> -1);
6720 old_len
= vec_safe_length (cfg
->x_label_to_block_map
);
6721 if (old_len
<= (unsigned) uid
)
6723 new_len
= 3 * uid
/ 2 + 1;
6724 vec_safe_grow_cleared (cfg
->x_label_to_block_map
, new_len
);
6727 (*cfg
->x_label_to_block_map
)[uid
] = bb
;
6728 (*cfun
->cfg
->x_label_to_block_map
)[uid
] = NULL
;
6730 gcc_assert (DECL_CONTEXT (label
) == dest_cfun
->decl
);
6732 if (uid
>= dest_cfun
->cfg
->last_label_uid
)
6733 dest_cfun
->cfg
->last_label_uid
= uid
+ 1;
6736 maybe_duplicate_eh_stmt_fn (dest_cfun
, stmt
, cfun
, stmt
, d
->eh_map
, 0);
6737 remove_stmt_from_eh_lp_fn (cfun
, stmt
);
6739 gimple_duplicate_stmt_histograms (dest_cfun
, stmt
, cfun
, stmt
);
6740 gimple_remove_stmt_histograms (cfun
, stmt
);
6742 /* We cannot leave any operands allocated from the operand caches of
6743 the current function. */
6744 free_stmt_operands (cfun
, stmt
);
6745 push_cfun (dest_cfun
);
6750 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6751 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
6753 tree block
= LOCATION_BLOCK (e
->goto_locus
);
6754 if (d
->orig_block
== NULL_TREE
6755 || block
== d
->orig_block
)
6756 e
->goto_locus
= d
->new_block
?
6757 COMBINE_LOCATION_DATA (line_table
, e
->goto_locus
, d
->new_block
) :
6758 LOCATION_LOCUS (e
->goto_locus
);
6762 /* Examine the statements in BB (which is in SRC_CFUN); find and return
6763 the outermost EH region. Use REGION as the incoming base EH region. */
6766 find_outermost_region_in_block (struct function
*src_cfun
,
6767 basic_block bb
, eh_region region
)
6769 gimple_stmt_iterator si
;
6771 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6773 gimple stmt
= gsi_stmt (si
);
6774 eh_region stmt_region
;
6777 lp_nr
= lookup_stmt_eh_lp_fn (src_cfun
, stmt
);
6778 stmt_region
= get_eh_region_from_lp_number_fn (src_cfun
, lp_nr
);
6782 region
= stmt_region
;
6783 else if (stmt_region
!= region
)
6785 region
= eh_region_outermost (src_cfun
, stmt_region
, region
);
6786 gcc_assert (region
!= NULL
);
6795 new_label_mapper (tree decl
, void *data
)
6797 htab_t hash
= (htab_t
) data
;
6801 gcc_assert (TREE_CODE (decl
) == LABEL_DECL
);
6803 m
= XNEW (struct tree_map
);
6804 m
->hash
= DECL_UID (decl
);
6805 m
->base
.from
= decl
;
6806 m
->to
= create_artificial_label (UNKNOWN_LOCATION
);
6807 LABEL_DECL_UID (m
->to
) = LABEL_DECL_UID (decl
);
6808 if (LABEL_DECL_UID (m
->to
) >= cfun
->cfg
->last_label_uid
)
6809 cfun
->cfg
->last_label_uid
= LABEL_DECL_UID (m
->to
) + 1;
6811 slot
= htab_find_slot_with_hash (hash
, m
, m
->hash
, INSERT
);
6812 gcc_assert (*slot
== NULL
);
6819 /* Change DECL_CONTEXT of all BLOCK_VARS in block, including
6823 replace_block_vars_by_duplicates (tree block
, hash_map
<tree
, tree
> *vars_map
,
6828 for (tp
= &BLOCK_VARS (block
); *tp
; tp
= &DECL_CHAIN (*tp
))
6831 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != CONST_DECL
)
6833 replace_by_duplicate_decl (&t
, vars_map
, to_context
);
6836 if (TREE_CODE (*tp
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (*tp
))
6838 SET_DECL_VALUE_EXPR (t
, DECL_VALUE_EXPR (*tp
));
6839 DECL_HAS_VALUE_EXPR_P (t
) = 1;
6841 DECL_CHAIN (t
) = DECL_CHAIN (*tp
);
6846 for (block
= BLOCK_SUBBLOCKS (block
); block
; block
= BLOCK_CHAIN (block
))
6847 replace_block_vars_by_duplicates (block
, vars_map
, to_context
);
6850 /* Fixup the loop arrays and numbers after moving LOOP and its subloops
6854 fixup_loop_arrays_after_move (struct function
*fn1
, struct function
*fn2
,
6857 /* Discard it from the old loop array. */
6858 (*get_loops (fn1
))[loop
->num
] = NULL
;
6860 /* Place it in the new loop array, assigning it a new number. */
6861 loop
->num
= number_of_loops (fn2
);
6862 vec_safe_push (loops_for_fn (fn2
)->larray
, loop
);
6864 /* Recurse to children. */
6865 for (loop
= loop
->inner
; loop
; loop
= loop
->next
)
6866 fixup_loop_arrays_after_move (fn1
, fn2
, loop
);
6869 /* Move a single-entry, single-exit region delimited by ENTRY_BB and
6870 EXIT_BB to function DEST_CFUN. The whole region is replaced by a
6871 single basic block in the original CFG and the new basic block is
6872 returned. DEST_CFUN must not have a CFG yet.
6874 Note that the region need not be a pure SESE region. Blocks inside
6875 the region may contain calls to abort/exit. The only restriction
6876 is that ENTRY_BB should be the only entry point and it must
6879 Change TREE_BLOCK of all statements in ORIG_BLOCK to the new
6880 functions outermost BLOCK, move all subblocks of ORIG_BLOCK
6881 to the new function.
6883 All local variables referenced in the region are assumed to be in
6884 the corresponding BLOCK_VARS and unexpanded variable lists
6885 associated with DEST_CFUN. */
6888 move_sese_region_to_fn (struct function
*dest_cfun
, basic_block entry_bb
,
6889 basic_block exit_bb
, tree orig_block
)
6891 vec
<basic_block
> bbs
, dom_bbs
;
6892 basic_block dom_entry
= get_immediate_dominator (CDI_DOMINATORS
, entry_bb
);
6893 basic_block after
, bb
, *entry_pred
, *exit_succ
, abb
;
6894 struct function
*saved_cfun
= cfun
;
6895 int *entry_flag
, *exit_flag
;
6896 unsigned *entry_prob
, *exit_prob
;
6897 unsigned i
, num_entry_edges
, num_exit_edges
, num_nodes
;
6900 htab_t new_label_map
;
6901 hash_map
<void *, void *> *eh_map
;
6902 struct loop
*loop
= entry_bb
->loop_father
;
6903 struct loop
*loop0
= get_loop (saved_cfun
, 0);
6904 struct move_stmt_d d
;
6906 /* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
6908 gcc_assert (entry_bb
!= exit_bb
6910 || dominated_by_p (CDI_DOMINATORS
, exit_bb
, entry_bb
)));
6912 /* Collect all the blocks in the region. Manually add ENTRY_BB
6913 because it won't be added by dfs_enumerate_from. */
6915 bbs
.safe_push (entry_bb
);
6916 gather_blocks_in_sese_region (entry_bb
, exit_bb
, &bbs
);
6918 /* The blocks that used to be dominated by something in BBS will now be
6919 dominated by the new block. */
6920 dom_bbs
= get_dominated_by_region (CDI_DOMINATORS
,
6924 /* Detach ENTRY_BB and EXIT_BB from CFUN->CFG. We need to remember
6925 the predecessor edges to ENTRY_BB and the successor edges to
6926 EXIT_BB so that we can re-attach them to the new basic block that
6927 will replace the region. */
6928 num_entry_edges
= EDGE_COUNT (entry_bb
->preds
);
6929 entry_pred
= XNEWVEC (basic_block
, num_entry_edges
);
6930 entry_flag
= XNEWVEC (int, num_entry_edges
);
6931 entry_prob
= XNEWVEC (unsigned, num_entry_edges
);
6933 for (ei
= ei_start (entry_bb
->preds
); (e
= ei_safe_edge (ei
)) != NULL
;)
6935 entry_prob
[i
] = e
->probability
;
6936 entry_flag
[i
] = e
->flags
;
6937 entry_pred
[i
++] = e
->src
;
6943 num_exit_edges
= EDGE_COUNT (exit_bb
->succs
);
6944 exit_succ
= XNEWVEC (basic_block
, num_exit_edges
);
6945 exit_flag
= XNEWVEC (int, num_exit_edges
);
6946 exit_prob
= XNEWVEC (unsigned, num_exit_edges
);
6948 for (ei
= ei_start (exit_bb
->succs
); (e
= ei_safe_edge (ei
)) != NULL
;)
6950 exit_prob
[i
] = e
->probability
;
6951 exit_flag
[i
] = e
->flags
;
6952 exit_succ
[i
++] = e
->dest
;
6964 /* Switch context to the child function to initialize DEST_FN's CFG. */
6965 gcc_assert (dest_cfun
->cfg
== NULL
);
6966 push_cfun (dest_cfun
);
6968 init_empty_tree_cfg ();
6970 /* Initialize EH information for the new function. */
6972 new_label_map
= NULL
;
6975 eh_region region
= NULL
;
6977 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6978 region
= find_outermost_region_in_block (saved_cfun
, bb
, region
);
6980 init_eh_for_function ();
6983 new_label_map
= htab_create (17, tree_map_hash
, tree_map_eq
, free
);
6984 eh_map
= duplicate_eh_regions (saved_cfun
, region
, 0,
6985 new_label_mapper
, new_label_map
);
6989 /* Initialize an empty loop tree. */
6990 struct loops
*loops
= ggc_cleared_alloc
<struct loops
> ();
6991 init_loops_structure (dest_cfun
, loops
, 1);
6992 loops
->state
= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
6993 set_loops_for_fn (dest_cfun
, loops
);
6995 /* Move the outlined loop tree part. */
6996 num_nodes
= bbs
.length ();
6997 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6999 if (bb
->loop_father
->header
== bb
)
7001 struct loop
*this_loop
= bb
->loop_father
;
7002 struct loop
*outer
= loop_outer (this_loop
);
7004 /* If the SESE region contains some bbs ending with
7005 a noreturn call, those are considered to belong
7006 to the outermost loop in saved_cfun, rather than
7007 the entry_bb's loop_father. */
7011 num_nodes
-= this_loop
->num_nodes
;
7012 flow_loop_tree_node_remove (bb
->loop_father
);
7013 flow_loop_tree_node_add (get_loop (dest_cfun
, 0), this_loop
);
7014 fixup_loop_arrays_after_move (saved_cfun
, cfun
, this_loop
);
7017 else if (bb
->loop_father
== loop0
&& loop0
!= loop
)
7020 /* Remove loop exits from the outlined region. */
7021 if (loops_for_fn (saved_cfun
)->exits
)
7022 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7024 struct loops
*l
= loops_for_fn (saved_cfun
);
7026 = l
->exits
->find_slot_with_hash (e
, htab_hash_pointer (e
),
7029 l
->exits
->clear_slot (slot
);
7034 /* Adjust the number of blocks in the tree root of the outlined part. */
7035 get_loop (dest_cfun
, 0)->num_nodes
= bbs
.length () + 2;
7037 /* Setup a mapping to be used by move_block_to_fn. */
7038 loop
->aux
= current_loops
->tree_root
;
7039 loop0
->aux
= current_loops
->tree_root
;
7043 /* Move blocks from BBS into DEST_CFUN. */
7044 gcc_assert (bbs
.length () >= 2);
7045 after
= dest_cfun
->cfg
->x_entry_block_ptr
;
7046 hash_map
<tree
, tree
> vars_map
;
7048 memset (&d
, 0, sizeof (d
));
7049 d
.orig_block
= orig_block
;
7050 d
.new_block
= DECL_INITIAL (dest_cfun
->decl
);
7051 d
.from_context
= cfun
->decl
;
7052 d
.to_context
= dest_cfun
->decl
;
7053 d
.vars_map
= &vars_map
;
7054 d
.new_label_map
= new_label_map
;
7056 d
.remap_decls_p
= true;
7058 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
7060 /* No need to update edge counts on the last block. It has
7061 already been updated earlier when we detached the region from
7062 the original CFG. */
7063 move_block_to_fn (dest_cfun
, bb
, after
, bb
!= exit_bb
, &d
);
7069 /* Loop sizes are no longer correct, fix them up. */
7070 loop
->num_nodes
-= num_nodes
;
7071 for (struct loop
*outer
= loop_outer (loop
);
7072 outer
; outer
= loop_outer (outer
))
7073 outer
->num_nodes
-= num_nodes
;
7074 loop0
->num_nodes
-= bbs
.length () - num_nodes
;
7076 if (saved_cfun
->has_simduid_loops
|| saved_cfun
->has_force_vectorize_loops
)
7079 for (i
= 0; vec_safe_iterate (loops
->larray
, i
, &aloop
); i
++)
7084 replace_by_duplicate_decl (&aloop
->simduid
, d
.vars_map
,
7086 dest_cfun
->has_simduid_loops
= true;
7088 if (aloop
->force_vectorize
)
7089 dest_cfun
->has_force_vectorize_loops
= true;
7093 /* Rewire BLOCK_SUBBLOCKS of orig_block. */
7097 gcc_assert (BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
7099 BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
7100 = BLOCK_SUBBLOCKS (orig_block
);
7101 for (block
= BLOCK_SUBBLOCKS (orig_block
);
7102 block
; block
= BLOCK_CHAIN (block
))
7103 BLOCK_SUPERCONTEXT (block
) = DECL_INITIAL (dest_cfun
->decl
);
7104 BLOCK_SUBBLOCKS (orig_block
) = NULL_TREE
;
7107 replace_block_vars_by_duplicates (DECL_INITIAL (dest_cfun
->decl
),
7108 &vars_map
, dest_cfun
->decl
);
7111 htab_delete (new_label_map
);
7115 /* Rewire the entry and exit blocks. The successor to the entry
7116 block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
7117 the child function. Similarly, the predecessor of DEST_FN's
7118 EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR. We
7119 need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
7120 various CFG manipulation function get to the right CFG.
7122 FIXME, this is silly. The CFG ought to become a parameter to
7124 push_cfun (dest_cfun
);
7125 make_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun
), entry_bb
, EDGE_FALLTHRU
);
7127 make_edge (exit_bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), 0);
7130 /* Back in the original function, the SESE region has disappeared,
7131 create a new basic block in its place. */
7132 bb
= create_empty_bb (entry_pred
[0]);
7134 add_bb_to_loop (bb
, loop
);
7135 for (i
= 0; i
< num_entry_edges
; i
++)
7137 e
= make_edge (entry_pred
[i
], bb
, entry_flag
[i
]);
7138 e
->probability
= entry_prob
[i
];
7141 for (i
= 0; i
< num_exit_edges
; i
++)
7143 e
= make_edge (bb
, exit_succ
[i
], exit_flag
[i
]);
7144 e
->probability
= exit_prob
[i
];
7147 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom_entry
);
7148 FOR_EACH_VEC_ELT (dom_bbs
, i
, abb
)
7149 set_immediate_dominator (CDI_DOMINATORS
, abb
, bb
);
7167 /* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in dumpfile.h)
7171 dump_function_to_file (tree fndecl
, FILE *file
, int flags
)
7173 tree arg
, var
, old_current_fndecl
= current_function_decl
;
7174 struct function
*dsf
;
7175 bool ignore_topmost_bind
= false, any_var
= false;
7178 bool tmclone
= (TREE_CODE (fndecl
) == FUNCTION_DECL
7179 && decl_is_tm_clone (fndecl
));
7180 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
7182 current_function_decl
= fndecl
;
7183 fprintf (file
, "%s %s(", function_name (fun
), tmclone
? "[tm-clone] " : "");
7185 arg
= DECL_ARGUMENTS (fndecl
);
7188 print_generic_expr (file
, TREE_TYPE (arg
), dump_flags
);
7189 fprintf (file
, " ");
7190 print_generic_expr (file
, arg
, dump_flags
);
7191 if (flags
& TDF_VERBOSE
)
7192 print_node (file
, "", arg
, 4);
7193 if (DECL_CHAIN (arg
))
7194 fprintf (file
, ", ");
7195 arg
= DECL_CHAIN (arg
);
7197 fprintf (file
, ")\n");
7199 if (flags
& TDF_VERBOSE
)
7200 print_node (file
, "", fndecl
, 2);
7202 dsf
= DECL_STRUCT_FUNCTION (fndecl
);
7203 if (dsf
&& (flags
& TDF_EH
))
7204 dump_eh_tree (file
, dsf
);
7206 if (flags
& TDF_RAW
&& !gimple_has_body_p (fndecl
))
7208 dump_node (fndecl
, TDF_SLIM
| flags
, file
);
7209 current_function_decl
= old_current_fndecl
;
7213 /* When GIMPLE is lowered, the variables are no longer available in
7214 BIND_EXPRs, so display them separately. */
7215 if (fun
&& fun
->decl
== fndecl
&& (fun
->curr_properties
& PROP_gimple_lcf
))
7218 ignore_topmost_bind
= true;
7220 fprintf (file
, "{\n");
7221 if (!vec_safe_is_empty (fun
->local_decls
))
7222 FOR_EACH_LOCAL_DECL (fun
, ix
, var
)
7224 print_generic_decl (file
, var
, flags
);
7225 if (flags
& TDF_VERBOSE
)
7226 print_node (file
, "", var
, 4);
7227 fprintf (file
, "\n");
7231 if (gimple_in_ssa_p (cfun
))
7232 for (ix
= 1; ix
< num_ssa_names
; ++ix
)
7234 tree name
= ssa_name (ix
);
7235 if (name
&& !SSA_NAME_VAR (name
))
7237 fprintf (file
, " ");
7238 print_generic_expr (file
, TREE_TYPE (name
), flags
);
7239 fprintf (file
, " ");
7240 print_generic_expr (file
, name
, flags
);
7241 fprintf (file
, ";\n");
7248 if (fun
&& fun
->decl
== fndecl
7250 && basic_block_info_for_fn (fun
))
7252 /* If the CFG has been built, emit a CFG-based dump. */
7253 if (!ignore_topmost_bind
)
7254 fprintf (file
, "{\n");
7256 if (any_var
&& n_basic_blocks_for_fn (fun
))
7257 fprintf (file
, "\n");
7259 FOR_EACH_BB_FN (bb
, fun
)
7260 dump_bb (file
, bb
, 2, flags
| TDF_COMMENT
);
7262 fprintf (file
, "}\n");
7264 else if (DECL_SAVED_TREE (fndecl
) == NULL
)
7266 /* The function is now in GIMPLE form but the CFG has not been
7267 built yet. Emit the single sequence of GIMPLE statements
7268 that make up its body. */
7269 gimple_seq body
= gimple_body (fndecl
);
7271 if (gimple_seq_first_stmt (body
)
7272 && gimple_seq_first_stmt (body
) == gimple_seq_last_stmt (body
)
7273 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
)
7274 print_gimple_seq (file
, body
, 0, flags
);
7277 if (!ignore_topmost_bind
)
7278 fprintf (file
, "{\n");
7281 fprintf (file
, "\n");
7283 print_gimple_seq (file
, body
, 2, flags
);
7284 fprintf (file
, "}\n");
7291 /* Make a tree based dump. */
7292 chain
= DECL_SAVED_TREE (fndecl
);
7293 if (chain
&& TREE_CODE (chain
) == BIND_EXPR
)
7295 if (ignore_topmost_bind
)
7297 chain
= BIND_EXPR_BODY (chain
);
7305 if (!ignore_topmost_bind
)
7306 fprintf (file
, "{\n");
7311 fprintf (file
, "\n");
7313 print_generic_stmt_indented (file
, chain
, flags
, indent
);
7314 if (ignore_topmost_bind
)
7315 fprintf (file
, "}\n");
7318 if (flags
& TDF_ENUMERATE_LOCALS
)
7319 dump_enumerated_decls (file
, flags
);
7320 fprintf (file
, "\n\n");
7322 current_function_decl
= old_current_fndecl
;
7325 /* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h) */
7328 debug_function (tree fn
, int flags
)
7330 dump_function_to_file (fn
, stderr
, flags
);
7334 /* Print on FILE the indexes for the predecessors of basic_block BB. */
7337 print_pred_bbs (FILE *file
, basic_block bb
)
7342 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7343 fprintf (file
, "bb_%d ", e
->src
->index
);
7347 /* Print on FILE the indexes for the successors of basic_block BB. */
7350 print_succ_bbs (FILE *file
, basic_block bb
)
7355 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7356 fprintf (file
, "bb_%d ", e
->dest
->index
);
7359 /* Print to FILE the basic block BB following the VERBOSITY level. */
7362 print_loops_bb (FILE *file
, basic_block bb
, int indent
, int verbosity
)
7364 char *s_indent
= (char *) alloca ((size_t) indent
+ 1);
7365 memset ((void *) s_indent
, ' ', (size_t) indent
);
7366 s_indent
[indent
] = '\0';
7368 /* Print basic_block's header. */
7371 fprintf (file
, "%s bb_%d (preds = {", s_indent
, bb
->index
);
7372 print_pred_bbs (file
, bb
);
7373 fprintf (file
, "}, succs = {");
7374 print_succ_bbs (file
, bb
);
7375 fprintf (file
, "})\n");
7378 /* Print basic_block's body. */
7381 fprintf (file
, "%s {\n", s_indent
);
7382 dump_bb (file
, bb
, indent
+ 4, TDF_VOPS
|TDF_MEMSYMS
);
7383 fprintf (file
, "%s }\n", s_indent
);
7387 static void print_loop_and_siblings (FILE *, struct loop
*, int, int);
7389 /* Pretty print LOOP on FILE, indented INDENT spaces. Following
7390 VERBOSITY level this outputs the contents of the loop, or just its
7394 print_loop (FILE *file
, struct loop
*loop
, int indent
, int verbosity
)
7402 s_indent
= (char *) alloca ((size_t) indent
+ 1);
7403 memset ((void *) s_indent
, ' ', (size_t) indent
);
7404 s_indent
[indent
] = '\0';
7406 /* Print loop's header. */
7407 fprintf (file
, "%sloop_%d (", s_indent
, loop
->num
);
7409 fprintf (file
, "header = %d", loop
->header
->index
);
7412 fprintf (file
, "deleted)\n");
7416 fprintf (file
, ", latch = %d", loop
->latch
->index
);
7418 fprintf (file
, ", multiple latches");
7419 fprintf (file
, ", niter = ");
7420 print_generic_expr (file
, loop
->nb_iterations
, 0);
7422 if (loop
->any_upper_bound
)
7424 fprintf (file
, ", upper_bound = ");
7425 print_decu (loop
->nb_iterations_upper_bound
, file
);
7428 if (loop
->any_estimate
)
7430 fprintf (file
, ", estimate = ");
7431 print_decu (loop
->nb_iterations_estimate
, file
);
7433 fprintf (file
, ")\n");
7435 /* Print loop's body. */
7438 fprintf (file
, "%s{\n", s_indent
);
7439 FOR_EACH_BB_FN (bb
, cfun
)
7440 if (bb
->loop_father
== loop
)
7441 print_loops_bb (file
, bb
, indent
, verbosity
);
7443 print_loop_and_siblings (file
, loop
->inner
, indent
+ 2, verbosity
);
7444 fprintf (file
, "%s}\n", s_indent
);
7448 /* Print the LOOP and its sibling loops on FILE, indented INDENT
7449 spaces. Following VERBOSITY level this outputs the contents of the
7450 loop, or just its structure. */
7453 print_loop_and_siblings (FILE *file
, struct loop
*loop
, int indent
,
7459 print_loop (file
, loop
, indent
, verbosity
);
7460 print_loop_and_siblings (file
, loop
->next
, indent
, verbosity
);
7463 /* Follow a CFG edge from the entry point of the program, and on entry
7464 of a loop, pretty print the loop structure on FILE. */
7467 print_loops (FILE *file
, int verbosity
)
7471 bb
= ENTRY_BLOCK_PTR_FOR_FN (cfun
);
7472 if (bb
&& bb
->loop_father
)
7473 print_loop_and_siblings (file
, bb
->loop_father
, 0, verbosity
);
7479 debug (struct loop
&ref
)
7481 print_loop (stderr
, &ref
, 0, /*verbosity*/0);
7485 debug (struct loop
*ptr
)
7490 fprintf (stderr
, "<nil>\n");
7493 /* Dump a loop verbosely. */
7496 debug_verbose (struct loop
&ref
)
7498 print_loop (stderr
, &ref
, 0, /*verbosity*/3);
7502 debug_verbose (struct loop
*ptr
)
7507 fprintf (stderr
, "<nil>\n");
7511 /* Debugging loops structure at tree level, at some VERBOSITY level. */
7514 debug_loops (int verbosity
)
7516 print_loops (stderr
, verbosity
);
7519 /* Print on stderr the code of LOOP, at some VERBOSITY level. */
7522 debug_loop (struct loop
*loop
, int verbosity
)
7524 print_loop (stderr
, loop
, 0, verbosity
);
7527 /* Print on stderr the code of loop number NUM, at some VERBOSITY
7531 debug_loop_num (unsigned num
, int verbosity
)
7533 debug_loop (get_loop (cfun
, num
), verbosity
);
7536 /* Return true if BB ends with a call, possibly followed by some
7537 instructions that must stay with the call. Return false,
7541 gimple_block_ends_with_call_p (basic_block bb
)
7543 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
7544 return !gsi_end_p (gsi
) && is_gimple_call (gsi_stmt (gsi
));
7548 /* Return true if BB ends with a conditional branch. Return false,
7552 gimple_block_ends_with_condjump_p (const_basic_block bb
)
7554 gimple stmt
= last_stmt (CONST_CAST_BB (bb
));
7555 return (stmt
&& gimple_code (stmt
) == GIMPLE_COND
);
7559 /* Return true if we need to add fake edge to exit at statement T.
7560 Helper function for gimple_flow_call_edges_add. */
7563 need_fake_edge_p (gimple t
)
7565 tree fndecl
= NULL_TREE
;
7568 /* NORETURN and LONGJMP calls already have an edge to exit.
7569 CONST and PURE calls do not need one.
7570 We don't currently check for CONST and PURE here, although
7571 it would be a good idea, because those attributes are
7572 figured out from the RTL in mark_constant_function, and
7573 the counter incrementation code from -fprofile-arcs
7574 leads to different results from -fbranch-probabilities. */
7575 if (is_gimple_call (t
))
7577 fndecl
= gimple_call_fndecl (t
);
7578 call_flags
= gimple_call_flags (t
);
7581 if (is_gimple_call (t
)
7583 && DECL_BUILT_IN (fndecl
)
7584 && (call_flags
& ECF_NOTHROW
)
7585 && !(call_flags
& ECF_RETURNS_TWICE
)
7586 /* fork() doesn't really return twice, but the effect of
7587 wrapping it in __gcov_fork() which calls __gcov_flush()
7588 and clears the counters before forking has the same
7589 effect as returning twice. Force a fake edge. */
7590 && !(DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7591 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FORK
))
7594 if (is_gimple_call (t
))
7600 if (!(call_flags
& ECF_NORETURN
))
7604 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7605 if ((e
->flags
& EDGE_FAKE
) == 0)
7609 if (gimple_asm asm_stmt
= dyn_cast
<gimple_asm
> (t
))
7610 if (gimple_asm_volatile_p (asm_stmt
) || gimple_asm_input_p (asm_stmt
))
7617 /* Add fake edges to the function exit for any non constant and non
7618 noreturn calls (or noreturn calls with EH/abnormal edges),
7619 volatile inline assembly in the bitmap of blocks specified by BLOCKS
7620 or to the whole CFG if BLOCKS is zero. Return the number of blocks
7623 The goal is to expose cases in which entering a basic block does
7624 not imply that all subsequent instructions must be executed. */
7627 gimple_flow_call_edges_add (sbitmap blocks
)
7630 int blocks_split
= 0;
7631 int last_bb
= last_basic_block_for_fn (cfun
);
7632 bool check_last_block
= false;
7634 if (n_basic_blocks_for_fn (cfun
) == NUM_FIXED_BLOCKS
)
7638 check_last_block
= true;
7640 check_last_block
= bitmap_bit_p (blocks
,
7641 EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
->index
);
7643 /* In the last basic block, before epilogue generation, there will be
7644 a fallthru edge to EXIT. Special care is required if the last insn
7645 of the last basic block is a call because make_edge folds duplicate
7646 edges, which would result in the fallthru edge also being marked
7647 fake, which would result in the fallthru edge being removed by
7648 remove_fake_edges, which would result in an invalid CFG.
7650 Moreover, we can't elide the outgoing fake edge, since the block
7651 profiler needs to take this into account in order to solve the minimal
7652 spanning tree in the case that the call doesn't return.
7654 Handle this by adding a dummy instruction in a new last basic block. */
7655 if (check_last_block
)
7657 basic_block bb
= EXIT_BLOCK_PTR_FOR_FN (cfun
)->prev_bb
;
7658 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
7661 if (!gsi_end_p (gsi
))
7664 if (t
&& need_fake_edge_p (t
))
7668 e
= find_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
7671 gsi_insert_on_edge (e
, gimple_build_nop ());
7672 gsi_commit_edge_inserts ();
7677 /* Now add fake edges to the function exit for any non constant
7678 calls since there is no way that we can determine if they will
7680 for (i
= 0; i
< last_bb
; i
++)
7682 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
7683 gimple_stmt_iterator gsi
;
7684 gimple stmt
, last_stmt
;
7689 if (blocks
&& !bitmap_bit_p (blocks
, i
))
7692 gsi
= gsi_last_nondebug_bb (bb
);
7693 if (!gsi_end_p (gsi
))
7695 last_stmt
= gsi_stmt (gsi
);
7698 stmt
= gsi_stmt (gsi
);
7699 if (need_fake_edge_p (stmt
))
7703 /* The handling above of the final block before the
7704 epilogue should be enough to verify that there is
7705 no edge to the exit block in CFG already.
7706 Calling make_edge in such case would cause us to
7707 mark that edge as fake and remove it later. */
7708 #ifdef ENABLE_CHECKING
7709 if (stmt
== last_stmt
)
7711 e
= find_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
));
7712 gcc_assert (e
== NULL
);
7716 /* Note that the following may create a new basic block
7717 and renumber the existing basic blocks. */
7718 if (stmt
!= last_stmt
)
7720 e
= split_block (bb
, stmt
);
7724 make_edge (bb
, EXIT_BLOCK_PTR_FOR_FN (cfun
), EDGE_FAKE
);
7728 while (!gsi_end_p (gsi
));
7733 verify_flow_info ();
7735 return blocks_split
;
7738 /* Removes edge E and all the blocks dominated by it, and updates dominance
7739 information. The IL in E->src needs to be updated separately.
7740 If dominance info is not available, only the edge E is removed.*/
7743 remove_edge_and_dominated_blocks (edge e
)
7745 vec
<basic_block
> bbs_to_remove
= vNULL
;
7746 vec
<basic_block
> bbs_to_fix_dom
= vNULL
;
7750 bool none_removed
= false;
7752 basic_block bb
, dbb
;
7755 if (!dom_info_available_p (CDI_DOMINATORS
))
7761 /* No updating is needed for edges to exit. */
7762 if (e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
7764 if (cfgcleanup_altered_bbs
)
7765 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
7770 /* First, we find the basic blocks to remove. If E->dest has a predecessor
7771 that is not dominated by E->dest, then this set is empty. Otherwise,
7772 all the basic blocks dominated by E->dest are removed.
7774 Also, to DF_IDOM we store the immediate dominators of the blocks in
7775 the dominance frontier of E (i.e., of the successors of the
7776 removed blocks, if there are any, and of E->dest otherwise). */
7777 FOR_EACH_EDGE (f
, ei
, e
->dest
->preds
)
7782 if (!dominated_by_p (CDI_DOMINATORS
, f
->src
, e
->dest
))
7784 none_removed
= true;
7789 df
= BITMAP_ALLOC (NULL
);
7790 df_idom
= BITMAP_ALLOC (NULL
);
7793 bitmap_set_bit (df_idom
,
7794 get_immediate_dominator (CDI_DOMINATORS
, e
->dest
)->index
);
7797 bbs_to_remove
= get_all_dominated_blocks (CDI_DOMINATORS
, e
->dest
);
7798 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
7800 FOR_EACH_EDGE (f
, ei
, bb
->succs
)
7802 if (f
->dest
!= EXIT_BLOCK_PTR_FOR_FN (cfun
))
7803 bitmap_set_bit (df
, f
->dest
->index
);
7806 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
7807 bitmap_clear_bit (df
, bb
->index
);
7809 EXECUTE_IF_SET_IN_BITMAP (df
, 0, i
, bi
)
7811 bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
7812 bitmap_set_bit (df_idom
,
7813 get_immediate_dominator (CDI_DOMINATORS
, bb
)->index
);
7817 if (cfgcleanup_altered_bbs
)
7819 /* Record the set of the altered basic blocks. */
7820 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
7821 bitmap_ior_into (cfgcleanup_altered_bbs
, df
);
7824 /* Remove E and the cancelled blocks. */
7829 /* Walk backwards so as to get a chance to substitute all
7830 released DEFs into debug stmts. See
7831 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
7833 for (i
= bbs_to_remove
.length (); i
-- > 0; )
7834 delete_basic_block (bbs_to_remove
[i
]);
7837 /* Update the dominance information. The immediate dominator may change only
7838 for blocks whose immediate dominator belongs to DF_IDOM:
7840 Suppose that idom(X) = Y before removal of E and idom(X) != Y after the
7841 removal. Let Z the arbitrary block such that idom(Z) = Y and
7842 Z dominates X after the removal. Before removal, there exists a path P
7843 from Y to X that avoids Z. Let F be the last edge on P that is
7844 removed, and let W = F->dest. Before removal, idom(W) = Y (since Y
7845 dominates W, and because of P, Z does not dominate W), and W belongs to
7846 the dominance frontier of E. Therefore, Y belongs to DF_IDOM. */
7847 EXECUTE_IF_SET_IN_BITMAP (df_idom
, 0, i
, bi
)
7849 bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
7850 for (dbb
= first_dom_son (CDI_DOMINATORS
, bb
);
7852 dbb
= next_dom_son (CDI_DOMINATORS
, dbb
))
7853 bbs_to_fix_dom
.safe_push (dbb
);
7856 iterate_fix_dominators (CDI_DOMINATORS
, bbs_to_fix_dom
, true);
7859 BITMAP_FREE (df_idom
);
7860 bbs_to_remove
.release ();
7861 bbs_to_fix_dom
.release ();
7864 /* Purge dead EH edges from basic block BB. */
7867 gimple_purge_dead_eh_edges (basic_block bb
)
7869 bool changed
= false;
7872 gimple stmt
= last_stmt (bb
);
7874 if (stmt
&& stmt_can_throw_internal (stmt
))
7877 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
7879 if (e
->flags
& EDGE_EH
)
7881 remove_edge_and_dominated_blocks (e
);
7891 /* Purge dead EH edges from basic block listed in BLOCKS. */
7894 gimple_purge_all_dead_eh_edges (const_bitmap blocks
)
7896 bool changed
= false;
7900 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
7902 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
7904 /* Earlier gimple_purge_dead_eh_edges could have removed
7905 this basic block already. */
7906 gcc_assert (bb
|| changed
);
7908 changed
|= gimple_purge_dead_eh_edges (bb
);
7914 /* Purge dead abnormal call edges from basic block BB. */
7917 gimple_purge_dead_abnormal_call_edges (basic_block bb
)
7919 bool changed
= false;
7922 gimple stmt
= last_stmt (bb
);
7924 if (!cfun
->has_nonlocal_label
7925 && !cfun
->calls_setjmp
)
7928 if (stmt
&& stmt_can_make_abnormal_goto (stmt
))
7931 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
7933 if (e
->flags
& EDGE_ABNORMAL
)
7935 if (e
->flags
& EDGE_FALLTHRU
)
7936 e
->flags
&= ~EDGE_ABNORMAL
;
7938 remove_edge_and_dominated_blocks (e
);
7948 /* Purge dead abnormal call edges from basic block listed in BLOCKS. */
7951 gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks
)
7953 bool changed
= false;
7957 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
7959 basic_block bb
= BASIC_BLOCK_FOR_FN (cfun
, i
);
7961 /* Earlier gimple_purge_dead_abnormal_call_edges could have removed
7962 this basic block already. */
7963 gcc_assert (bb
|| changed
);
7965 changed
|= gimple_purge_dead_abnormal_call_edges (bb
);
7971 /* This function is called whenever a new edge is created or
7975 gimple_execute_on_growing_pred (edge e
)
7977 basic_block bb
= e
->dest
;
7979 if (!gimple_seq_empty_p (phi_nodes (bb
)))
7980 reserve_phi_args_for_new_edge (bb
);
7983 /* This function is called immediately before edge E is removed from
7984 the edge vector E->dest->preds. */
7987 gimple_execute_on_shrinking_pred (edge e
)
7989 if (!gimple_seq_empty_p (phi_nodes (e
->dest
)))
7990 remove_phi_args (e
);
7993 /*---------------------------------------------------------------------------
7994 Helper functions for Loop versioning
7995 ---------------------------------------------------------------------------*/
7997 /* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy
7998 of 'first'. Both of them are dominated by 'new_head' basic block. When
7999 'new_head' was created by 'second's incoming edge it received phi arguments
8000 on the edge by split_edge(). Later, additional edge 'e' was created to
8001 connect 'new_head' and 'first'. Now this routine adds phi args on this
8002 additional edge 'e' that new_head to second edge received as part of edge
8006 gimple_lv_adjust_loop_header_phi (basic_block first
, basic_block second
,
8007 basic_block new_head
, edge e
)
8009 gimple_phi phi1
, phi2
;
8010 gimple_phi_iterator psi1
, psi2
;
8012 edge e2
= find_edge (new_head
, second
);
8014 /* Because NEW_HEAD has been created by splitting SECOND's incoming
8015 edge, we should always have an edge from NEW_HEAD to SECOND. */
8016 gcc_assert (e2
!= NULL
);
8018 /* Browse all 'second' basic block phi nodes and add phi args to
8019 edge 'e' for 'first' head. PHI args are always in correct order. */
8021 for (psi2
= gsi_start_phis (second
),
8022 psi1
= gsi_start_phis (first
);
8023 !gsi_end_p (psi2
) && !gsi_end_p (psi1
);
8024 gsi_next (&psi2
), gsi_next (&psi1
))
8028 def
= PHI_ARG_DEF (phi2
, e2
->dest_idx
);
8029 add_phi_arg (phi1
, def
, e
, gimple_phi_arg_location_from_edge (phi2
, e2
));
8034 /* Adds a if else statement to COND_BB with condition COND_EXPR.
8035 SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
8036 the destination of the ELSE part. */
8039 gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED
,
8040 basic_block second_head ATTRIBUTE_UNUSED
,
8041 basic_block cond_bb
, void *cond_e
)
8043 gimple_stmt_iterator gsi
;
8044 gimple new_cond_expr
;
8045 tree cond_expr
= (tree
) cond_e
;
8048 /* Build new conditional expr */
8049 new_cond_expr
= gimple_build_cond_from_tree (cond_expr
,
8050 NULL_TREE
, NULL_TREE
);
8052 /* Add new cond in cond_bb. */
8053 gsi
= gsi_last_bb (cond_bb
);
8054 gsi_insert_after (&gsi
, new_cond_expr
, GSI_NEW_STMT
);
8056 /* Adjust edges appropriately to connect new head with first head
8057 as well as second head. */
8058 e0
= single_succ_edge (cond_bb
);
8059 e0
->flags
&= ~EDGE_FALLTHRU
;
8060 e0
->flags
|= EDGE_FALSE_VALUE
;
8064 /* Do book-keeping of basic block BB for the profile consistency checker.
8065 If AFTER_PASS is 0, do pre-pass accounting, or if AFTER_PASS is 1
8066 then do post-pass accounting. Store the counting in RECORD. */
8068 gimple_account_profile_record (basic_block bb
, int after_pass
,
8069 struct profile_record
*record
)
8071 gimple_stmt_iterator i
;
8072 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
8074 record
->size
[after_pass
]
8075 += estimate_num_insns (gsi_stmt (i
), &eni_size_weights
);
8076 if (profile_status_for_fn (cfun
) == PROFILE_READ
)
8077 record
->time
[after_pass
]
8078 += estimate_num_insns (gsi_stmt (i
),
8079 &eni_time_weights
) * bb
->count
;
8080 else if (profile_status_for_fn (cfun
) == PROFILE_GUESSED
)
8081 record
->time
[after_pass
]
8082 += estimate_num_insns (gsi_stmt (i
),
8083 &eni_time_weights
) * bb
->frequency
;
8087 struct cfg_hooks gimple_cfg_hooks
= {
8089 gimple_verify_flow_info
,
8090 gimple_dump_bb
, /* dump_bb */
8091 gimple_dump_bb_for_graph
, /* dump_bb_for_graph */
8092 create_bb
, /* create_basic_block */
8093 gimple_redirect_edge_and_branch
, /* redirect_edge_and_branch */
8094 gimple_redirect_edge_and_branch_force
, /* redirect_edge_and_branch_force */
8095 gimple_can_remove_branch_p
, /* can_remove_branch_p */
8096 remove_bb
, /* delete_basic_block */
8097 gimple_split_block
, /* split_block */
8098 gimple_move_block_after
, /* move_block_after */
8099 gimple_can_merge_blocks_p
, /* can_merge_blocks_p */
8100 gimple_merge_blocks
, /* merge_blocks */
8101 gimple_predict_edge
, /* predict_edge */
8102 gimple_predicted_by_p
, /* predicted_by_p */
8103 gimple_can_duplicate_bb_p
, /* can_duplicate_block_p */
8104 gimple_duplicate_bb
, /* duplicate_block */
8105 gimple_split_edge
, /* split_edge */
8106 gimple_make_forwarder_block
, /* make_forward_block */
8107 NULL
, /* tidy_fallthru_edge */
8108 NULL
, /* force_nonfallthru */
8109 gimple_block_ends_with_call_p
,/* block_ends_with_call_p */
8110 gimple_block_ends_with_condjump_p
, /* block_ends_with_condjump_p */
8111 gimple_flow_call_edges_add
, /* flow_call_edges_add */
8112 gimple_execute_on_growing_pred
, /* execute_on_growing_pred */
8113 gimple_execute_on_shrinking_pred
, /* execute_on_shrinking_pred */
8114 gimple_duplicate_loop_to_header_edge
, /* duplicate loop for trees */
8115 gimple_lv_add_condition_to_bb
, /* lv_add_condition_to_bb */
8116 gimple_lv_adjust_loop_header_phi
, /* lv_adjust_loop_header_phi*/
8117 extract_true_false_edges_from_block
, /* extract_cond_bb_edges */
8118 flush_pending_stmts
, /* flush_pending_stmts */
8119 gimple_empty_block_p
, /* block_empty_p */
8120 gimple_split_block_before_cond_jump
, /* split_block_before_cond_jump */
8121 gimple_account_profile_record
,
8125 /* Split all critical edges. */
8128 split_critical_edges (void)
8134 /* split_edge can redirect edges out of SWITCH_EXPRs, which can get
8135 expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
8136 mappings around the calls to split_edge. */
8137 start_recording_case_labels ();
8138 FOR_ALL_BB_FN (bb
, cfun
)
8140 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8142 if (EDGE_CRITICAL_P (e
) && !(e
->flags
& EDGE_ABNORMAL
))
8144 /* PRE inserts statements to edges and expects that
8145 since split_critical_edges was done beforehand, committing edge
8146 insertions will not split more edges. In addition to critical
8147 edges we must split edges that have multiple successors and
8148 end by control flow statements, such as RESX.
8149 Go ahead and split them too. This matches the logic in
8150 gimple_find_edge_insert_loc. */
8151 else if ((!single_pred_p (e
->dest
)
8152 || !gimple_seq_empty_p (phi_nodes (e
->dest
))
8153 || e
->dest
== EXIT_BLOCK_PTR_FOR_FN (cfun
))
8154 && e
->src
!= ENTRY_BLOCK_PTR_FOR_FN (cfun
)
8155 && !(e
->flags
& EDGE_ABNORMAL
))
8157 gimple_stmt_iterator gsi
;
8159 gsi
= gsi_last_bb (e
->src
);
8160 if (!gsi_end_p (gsi
)
8161 && stmt_ends_bb_p (gsi_stmt (gsi
))
8162 && (gimple_code (gsi_stmt (gsi
)) != GIMPLE_RETURN
8163 && !gimple_call_builtin_p (gsi_stmt (gsi
),
8169 end_recording_case_labels ();
8175 const pass_data pass_data_split_crit_edges
=
8177 GIMPLE_PASS
, /* type */
8178 "crited", /* name */
8179 OPTGROUP_NONE
, /* optinfo_flags */
8180 TV_TREE_SPLIT_EDGES
, /* tv_id */
8181 PROP_cfg
, /* properties_required */
8182 PROP_no_crit_edges
, /* properties_provided */
8183 0, /* properties_destroyed */
8184 0, /* todo_flags_start */
8185 0, /* todo_flags_finish */
8188 class pass_split_crit_edges
: public gimple_opt_pass
8191 pass_split_crit_edges (gcc::context
*ctxt
)
8192 : gimple_opt_pass (pass_data_split_crit_edges
, ctxt
)
8195 /* opt_pass methods: */
8196 virtual unsigned int execute (function
*) { return split_critical_edges (); }
8198 opt_pass
* clone () { return new pass_split_crit_edges (m_ctxt
); }
8199 }; // class pass_split_crit_edges
8204 make_pass_split_crit_edges (gcc::context
*ctxt
)
8206 return new pass_split_crit_edges (ctxt
);
8210 /* Build a ternary operation and gimplify it. Emit code before GSI.
8211 Return the gimple_val holding the result. */
8214 gimplify_build3 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
8215 tree type
, tree a
, tree b
, tree c
)
8218 location_t loc
= gimple_location (gsi_stmt (*gsi
));
8220 ret
= fold_build3_loc (loc
, code
, type
, a
, b
, c
);
8223 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
8227 /* Build a binary operation and gimplify it. Emit code before GSI.
8228 Return the gimple_val holding the result. */
8231 gimplify_build2 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
8232 tree type
, tree a
, tree b
)
8236 ret
= fold_build2_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
, b
);
8239 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
8243 /* Build a unary operation and gimplify it. Emit code before GSI.
8244 Return the gimple_val holding the result. */
8247 gimplify_build1 (gimple_stmt_iterator
*gsi
, enum tree_code code
, tree type
,
8252 ret
= fold_build1_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
);
8255 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
8261 /* Given a basic block B which ends with a conditional and has
8262 precisely two successors, determine which of the edges is taken if
8263 the conditional is true and which is taken if the conditional is
8264 false. Set TRUE_EDGE and FALSE_EDGE appropriately. */
8267 extract_true_false_edges_from_block (basic_block b
,
8271 edge e
= EDGE_SUCC (b
, 0);
8273 if (e
->flags
& EDGE_TRUE_VALUE
)
8276 *false_edge
= EDGE_SUCC (b
, 1);
8281 *true_edge
= EDGE_SUCC (b
, 1);
8285 /* Emit return warnings. */
8289 const pass_data pass_data_warn_function_return
=
8291 GIMPLE_PASS
, /* type */
8292 "*warn_function_return", /* name */
8293 OPTGROUP_NONE
, /* optinfo_flags */
8294 TV_NONE
, /* tv_id */
8295 PROP_cfg
, /* properties_required */
8296 0, /* properties_provided */
8297 0, /* properties_destroyed */
8298 0, /* todo_flags_start */
8299 0, /* todo_flags_finish */
8302 class pass_warn_function_return
: public gimple_opt_pass
8305 pass_warn_function_return (gcc::context
*ctxt
)
8306 : gimple_opt_pass (pass_data_warn_function_return
, ctxt
)
8309 /* opt_pass methods: */
8310 virtual unsigned int execute (function
*);
8312 }; // class pass_warn_function_return
8315 pass_warn_function_return::execute (function
*fun
)
8317 source_location location
;
8322 if (!targetm
.warn_func_return (fun
->decl
))
8325 /* If we have a path to EXIT, then we do return. */
8326 if (TREE_THIS_VOLATILE (fun
->decl
)
8327 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) > 0)
8329 location
= UNKNOWN_LOCATION
;
8330 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
)
8332 last
= last_stmt (e
->src
);
8333 if ((gimple_code (last
) == GIMPLE_RETURN
8334 || gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
8335 && (location
= gimple_location (last
)) != UNKNOWN_LOCATION
)
8338 if (location
== UNKNOWN_LOCATION
)
8339 location
= cfun
->function_end_locus
;
8340 warning_at (location
, 0, "%<noreturn%> function does return");
8343 /* If we see "return;" in some basic block, then we do reach the end
8344 without returning a value. */
8345 else if (warn_return_type
8346 && !TREE_NO_WARNING (fun
->decl
)
8347 && EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
) > 0
8348 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fun
->decl
))))
8350 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR_FOR_FN (fun
)->preds
)
8352 gimple last
= last_stmt (e
->src
);
8353 gimple_return return_stmt
= dyn_cast
<gimple_return
> (last
);
8355 && gimple_return_retval (return_stmt
) == NULL
8356 && !gimple_no_warning_p (last
))
8358 location
= gimple_location (last
);
8359 if (location
== UNKNOWN_LOCATION
)
8360 location
= fun
->function_end_locus
;
8361 warning_at (location
, OPT_Wreturn_type
, "control reaches end of non-void function");
8362 TREE_NO_WARNING (fun
->decl
) = 1;
8373 make_pass_warn_function_return (gcc::context
*ctxt
)
8375 return new pass_warn_function_return (ctxt
);
8378 /* Walk a gimplified function and warn for functions whose return value is
8379 ignored and attribute((warn_unused_result)) is set. This is done before
8380 inlining, so we don't have to worry about that. */
8383 do_warn_unused_result (gimple_seq seq
)
8386 gimple_stmt_iterator i
;
8388 for (i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
8390 gimple g
= gsi_stmt (i
);
8392 switch (gimple_code (g
))
8395 do_warn_unused_result (gimple_bind_body (as_a
<gimple_bind
>(g
)));
8398 do_warn_unused_result (gimple_try_eval (g
));
8399 do_warn_unused_result (gimple_try_cleanup (g
));
8402 do_warn_unused_result (gimple_catch_handler (
8403 as_a
<gimple_catch
> (g
)));
8405 case GIMPLE_EH_FILTER
:
8406 do_warn_unused_result (gimple_eh_filter_failure (g
));
8410 if (gimple_call_lhs (g
))
8412 if (gimple_call_internal_p (g
))
8415 /* This is a naked call, as opposed to a GIMPLE_CALL with an
8416 LHS. All calls whose value is ignored should be
8417 represented like this. Look for the attribute. */
8418 fdecl
= gimple_call_fndecl (g
);
8419 ftype
= gimple_call_fntype (g
);
8421 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
8423 location_t loc
= gimple_location (g
);
8426 warning_at (loc
, OPT_Wunused_result
,
8427 "ignoring return value of %qD, "
8428 "declared with attribute warn_unused_result",
8431 warning_at (loc
, OPT_Wunused_result
,
8432 "ignoring return value of function "
8433 "declared with attribute warn_unused_result");
8438 /* Not a container, not a call, or a call whose value is used. */
8446 const pass_data pass_data_warn_unused_result
=
8448 GIMPLE_PASS
, /* type */
8449 "*warn_unused_result", /* name */
8450 OPTGROUP_NONE
, /* optinfo_flags */
8451 TV_NONE
, /* tv_id */
8452 PROP_gimple_any
, /* properties_required */
8453 0, /* properties_provided */
8454 0, /* properties_destroyed */
8455 0, /* todo_flags_start */
8456 0, /* todo_flags_finish */
8459 class pass_warn_unused_result
: public gimple_opt_pass
8462 pass_warn_unused_result (gcc::context
*ctxt
)
8463 : gimple_opt_pass (pass_data_warn_unused_result
, ctxt
)
8466 /* opt_pass methods: */
8467 virtual bool gate (function
*) { return flag_warn_unused_result
; }
8468 virtual unsigned int execute (function
*)
8470 do_warn_unused_result (gimple_body (current_function_decl
));
8474 }; // class pass_warn_unused_result
8479 make_pass_warn_unused_result (gcc::context
*ctxt
)
8481 return new pass_warn_unused_result (ctxt
);
8484 /* IPA passes, compilation of earlier functions or inlining
8485 might have changed some properties, such as marked functions nothrow,
8486 pure, const or noreturn.
8487 Remove redundant edges and basic blocks, and create new ones if necessary.
8489 This pass can't be executed as stand alone pass from pass manager, because
8490 in between inlining and this fixup the verify_flow_info would fail. */
8493 execute_fixup_cfg (void)
8496 gimple_stmt_iterator gsi
;
8498 gcov_type count_scale
;
8503 = GCOV_COMPUTE_SCALE (cgraph_node::get (current_function_decl
)->count
,
8504 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
);
8506 ENTRY_BLOCK_PTR_FOR_FN (cfun
)->count
=
8507 cgraph_node::get (current_function_decl
)->count
;
8508 EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
=
8509 apply_scale (EXIT_BLOCK_PTR_FOR_FN (cfun
)->count
,
8512 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR_FOR_FN (cfun
)->succs
)
8513 e
->count
= apply_scale (e
->count
, count_scale
);
8515 FOR_EACH_BB_FN (bb
, cfun
)
8517 bb
->count
= apply_scale (bb
->count
, count_scale
);
8518 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
);)
8520 gimple stmt
= gsi_stmt (gsi
);
8521 tree decl
= is_gimple_call (stmt
)
8522 ? gimple_call_fndecl (stmt
)
8526 int flags
= gimple_call_flags (stmt
);
8527 if (flags
& (ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
))
8529 if (gimple_purge_dead_abnormal_call_edges (bb
))
8530 todo
|= TODO_cleanup_cfg
;
8532 if (gimple_in_ssa_p (cfun
))
8534 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
8539 if (flags
& ECF_NORETURN
8540 && fixup_noreturn_call (stmt
))
8541 todo
|= TODO_cleanup_cfg
;
8544 /* Remove stores to variables we marked write-only.
8545 Keep access when store has side effect, i.e. in case when source
8547 if (gimple_store_p (stmt
)
8548 && !gimple_has_side_effects (stmt
))
8550 tree lhs
= get_base_address (gimple_get_lhs (stmt
));
8552 if (TREE_CODE (lhs
) == VAR_DECL
8553 && (TREE_STATIC (lhs
) || DECL_EXTERNAL (lhs
))
8554 && varpool_node::get (lhs
)->writeonly
)
8556 unlink_stmt_vdef (stmt
);
8557 gsi_remove (&gsi
, true);
8558 release_defs (stmt
);
8559 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
8563 /* For calls we can simply remove LHS when it is known
8564 to be write-only. */
8565 if (is_gimple_call (stmt
)
8566 && gimple_get_lhs (stmt
))
8568 tree lhs
= get_base_address (gimple_get_lhs (stmt
));
8570 if (TREE_CODE (lhs
) == VAR_DECL
8571 && (TREE_STATIC (lhs
) || DECL_EXTERNAL (lhs
))
8572 && varpool_node::get (lhs
)->writeonly
)
8574 gimple_call_set_lhs (stmt
, NULL
);
8576 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
8580 if (maybe_clean_eh_stmt (stmt
)
8581 && gimple_purge_dead_eh_edges (bb
))
8582 todo
|= TODO_cleanup_cfg
;
8586 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8587 e
->count
= apply_scale (e
->count
, count_scale
);
8589 /* If we have a basic block with no successors that does not
8590 end with a control statement or a noreturn call end it with
8591 a call to __builtin_unreachable. This situation can occur
8592 when inlining a noreturn call that does in fact return. */
8593 if (EDGE_COUNT (bb
->succs
) == 0)
8595 gimple stmt
= last_stmt (bb
);
8597 || (!is_ctrl_stmt (stmt
)
8598 && (!is_gimple_call (stmt
)
8599 || (gimple_call_flags (stmt
) & ECF_NORETURN
) == 0)))
8601 if (stmt
&& is_gimple_call (stmt
))
8602 gimple_call_set_ctrl_altering (stmt
, false);
8603 stmt
= gimple_build_call
8604 (builtin_decl_implicit (BUILT_IN_UNREACHABLE
), 0);
8605 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
8606 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
8610 if (count_scale
!= REG_BR_PROB_BASE
)
8611 compute_function_frequency ();
8613 /* Dump a textual representation of the flowgraph. */
8615 gimple_dump_cfg (dump_file
, dump_flags
);
8618 && (todo
& TODO_cleanup_cfg
))
8619 loops_state_set (LOOPS_NEED_FIXUP
);
8626 const pass_data pass_data_fixup_cfg
=
8628 GIMPLE_PASS
, /* type */
8629 "*free_cfg_annotations", /* name */
8630 OPTGROUP_NONE
, /* optinfo_flags */
8631 TV_NONE
, /* tv_id */
8632 PROP_cfg
, /* properties_required */
8633 0, /* properties_provided */
8634 0, /* properties_destroyed */
8635 0, /* todo_flags_start */
8636 0, /* todo_flags_finish */
8639 class pass_fixup_cfg
: public gimple_opt_pass
8642 pass_fixup_cfg (gcc::context
*ctxt
)
8643 : gimple_opt_pass (pass_data_fixup_cfg
, ctxt
)
8646 /* opt_pass methods: */
8647 opt_pass
* clone () { return new pass_fixup_cfg (m_ctxt
); }
8648 virtual unsigned int execute (function
*) { return execute_fixup_cfg (); }
8650 }; // class pass_fixup_cfg
8655 make_pass_fixup_cfg (gcc::context
*ctxt
)
8657 return new pass_fixup_cfg (ctxt
);
8660 /* Garbage collection support for edge_def. */
8662 extern void gt_ggc_mx (tree
&);
8663 extern void gt_ggc_mx (gimple
&);
8664 extern void gt_ggc_mx (rtx
&);
8665 extern void gt_ggc_mx (basic_block
&);
8668 gt_ggc_mx (rtx_insn
*& x
)
8671 gt_ggc_mx_rtx_def ((void *) x
);
8675 gt_ggc_mx (edge_def
*e
)
8677 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8679 gt_ggc_mx (e
->dest
);
8680 if (current_ir_type () == IR_GIMPLE
)
8681 gt_ggc_mx (e
->insns
.g
);
8683 gt_ggc_mx (e
->insns
.r
);
8687 /* PCH support for edge_def. */
8689 extern void gt_pch_nx (tree
&);
8690 extern void gt_pch_nx (gimple
&);
8691 extern void gt_pch_nx (rtx
&);
8692 extern void gt_pch_nx (basic_block
&);
8695 gt_pch_nx (rtx_insn
*& x
)
8698 gt_pch_nx_rtx_def ((void *) x
);
8702 gt_pch_nx (edge_def
*e
)
8704 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8706 gt_pch_nx (e
->dest
);
8707 if (current_ir_type () == IR_GIMPLE
)
8708 gt_pch_nx (e
->insns
.g
);
8710 gt_pch_nx (e
->insns
.r
);
8715 gt_pch_nx (edge_def
*e
, gt_pointer_operator op
, void *cookie
)
8717 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8718 op (&(e
->src
), cookie
);
8719 op (&(e
->dest
), cookie
);
8720 if (current_ir_type () == IR_GIMPLE
)
8721 op (&(e
->insns
.g
), cookie
);
8723 op (&(e
->insns
.r
), cookie
);
8724 op (&(block
), cookie
);