1 /* Control flow functions for trees.
2 Copyright (C) 2001-2013 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 "basic-block.h"
32 #include "gimple-pretty-print.h"
34 #include "tree-dump.h"
35 #include "tree-pass.h"
36 #include "diagnostic-core.h"
39 #include "tree-ssa-propagate.h"
40 #include "value-prof.h"
41 #include "pointer-set.h"
42 #include "tree-inline.h"
44 #include "tree-ssa-live.h"
46 /* This file contains functions for building the Control Flow Graph (CFG)
47 for a function tree. */
49 /* Local declarations. */
51 /* Initial capacity for the basic block array. */
52 static const int initial_cfg_capacity
= 20;
54 /* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
55 which use a particular edge. The CASE_LABEL_EXPRs are chained together
56 via their CASE_CHAIN field, which we clear after we're done with the
57 hash table to prevent problems with duplication of GIMPLE_SWITCHes.
59 Access to this list of CASE_LABEL_EXPRs allows us to efficiently
60 update the case vector in response to edge redirections.
62 Right now this table is set up and torn down at key points in the
63 compilation process. It would be nice if we could make the table
64 more persistent. The key is getting notification of changes to
65 the CFG (particularly edge removal, creation and redirection). */
67 static struct pointer_map_t
*edge_to_cases
;
69 /* If we record edge_to_cases, this bitmap will hold indexes
70 of basic blocks that end in a GIMPLE_SWITCH which we touched
71 due to edge manipulations. */
73 static bitmap touched_switch_bbs
;
78 long num_merged_labels
;
81 static struct cfg_stats_d cfg_stats
;
83 /* Nonzero if we found a computed goto while building basic blocks. */
84 static bool found_computed_goto
;
86 /* Hash table to store last discriminator assigned for each locus. */
87 struct locus_discrim_map
93 /* Hashtable helpers. */
95 struct locus_discrim_hasher
: typed_free_remove
<locus_discrim_map
>
97 typedef locus_discrim_map value_type
;
98 typedef locus_discrim_map compare_type
;
99 static inline hashval_t
hash (const value_type
*);
100 static inline bool equal (const value_type
*, const compare_type
*);
103 /* Trivial hash function for a location_t. ITEM is a pointer to
104 a hash table entry that maps a location_t to a discriminator. */
107 locus_discrim_hasher::hash (const value_type
*item
)
109 return LOCATION_LINE (item
->locus
);
112 /* Equality function for the locus-to-discriminator map. A and B
113 point to the two hash table entries to compare. */
116 locus_discrim_hasher::equal (const value_type
*a
, const compare_type
*b
)
118 return LOCATION_LINE (a
->locus
) == LOCATION_LINE (b
->locus
);
121 static hash_table
<locus_discrim_hasher
> discriminator_per_locus
;
123 /* Basic blocks and flowgraphs. */
124 static void make_blocks (gimple_seq
);
125 static void factor_computed_gotos (void);
128 static void make_edges (void);
129 static void assign_discriminators (void);
130 static void make_cond_expr_edges (basic_block
);
131 static void make_gimple_switch_edges (basic_block
);
132 static void make_goto_expr_edges (basic_block
);
133 static void make_gimple_asm_edges (basic_block
);
134 static edge
gimple_redirect_edge_and_branch (edge
, basic_block
);
135 static edge
gimple_try_redirect_by_replacing_jump (edge
, basic_block
);
136 static unsigned int split_critical_edges (void);
138 /* Various helpers. */
139 static inline bool stmt_starts_bb_p (gimple
, gimple
);
140 static int gimple_verify_flow_info (void);
141 static void gimple_make_forwarder_block (edge
);
142 static gimple
first_non_label_stmt (basic_block
);
143 static bool verify_gimple_transaction (gimple
);
145 /* Flowgraph optimization and cleanup. */
146 static void gimple_merge_blocks (basic_block
, basic_block
);
147 static bool gimple_can_merge_blocks_p (basic_block
, basic_block
);
148 static void remove_bb (basic_block
);
149 static edge
find_taken_edge_computed_goto (basic_block
, tree
);
150 static edge
find_taken_edge_cond_expr (basic_block
, tree
);
151 static edge
find_taken_edge_switch_expr (basic_block
, tree
);
152 static tree
find_case_label_for_value (gimple
, tree
);
155 init_empty_tree_cfg_for_function (struct function
*fn
)
157 /* Initialize the basic block array. */
159 profile_status_for_function (fn
) = PROFILE_ABSENT
;
160 n_basic_blocks_for_function (fn
) = NUM_FIXED_BLOCKS
;
161 last_basic_block_for_function (fn
) = NUM_FIXED_BLOCKS
;
162 vec_alloc (basic_block_info_for_function (fn
), initial_cfg_capacity
);
163 vec_safe_grow_cleared (basic_block_info_for_function (fn
),
164 initial_cfg_capacity
);
166 /* Build a mapping of labels to their associated blocks. */
167 vec_alloc (label_to_block_map_for_function (fn
), initial_cfg_capacity
);
168 vec_safe_grow_cleared (label_to_block_map_for_function (fn
),
169 initial_cfg_capacity
);
171 SET_BASIC_BLOCK_FOR_FUNCTION (fn
, ENTRY_BLOCK
,
172 ENTRY_BLOCK_PTR_FOR_FUNCTION (fn
));
173 SET_BASIC_BLOCK_FOR_FUNCTION (fn
, EXIT_BLOCK
,
174 EXIT_BLOCK_PTR_FOR_FUNCTION (fn
));
176 ENTRY_BLOCK_PTR_FOR_FUNCTION (fn
)->next_bb
177 = EXIT_BLOCK_PTR_FOR_FUNCTION (fn
);
178 EXIT_BLOCK_PTR_FOR_FUNCTION (fn
)->prev_bb
179 = ENTRY_BLOCK_PTR_FOR_FUNCTION (fn
);
183 init_empty_tree_cfg (void)
185 init_empty_tree_cfg_for_function (cfun
);
188 /*---------------------------------------------------------------------------
190 ---------------------------------------------------------------------------*/
192 /* Entry point to the CFG builder for trees. SEQ is the sequence of
193 statements to be added to the flowgraph. */
196 build_gimple_cfg (gimple_seq seq
)
198 /* Register specific gimple functions. */
199 gimple_register_cfg_hooks ();
201 memset ((void *) &cfg_stats
, 0, sizeof (cfg_stats
));
203 init_empty_tree_cfg ();
205 found_computed_goto
= 0;
208 /* Computed gotos are hell to deal with, especially if there are
209 lots of them with a large number of destinations. So we factor
210 them to a common computed goto location before we build the
211 edge list. After we convert back to normal form, we will un-factor
212 the computed gotos since factoring introduces an unwanted jump. */
213 if (found_computed_goto
)
214 factor_computed_gotos ();
216 /* Make sure there is always at least one block, even if it's empty. */
217 if (n_basic_blocks
== NUM_FIXED_BLOCKS
)
218 create_empty_bb (ENTRY_BLOCK_PTR
);
220 /* Adjust the size of the array. */
221 if (basic_block_info
->length () < (size_t) n_basic_blocks
)
222 vec_safe_grow_cleared (basic_block_info
, n_basic_blocks
);
224 /* To speed up statement iterator walks, we first purge dead labels. */
225 cleanup_dead_labels ();
227 /* Group case nodes to reduce the number of edges.
228 We do this after cleaning up dead labels because otherwise we miss
229 a lot of obvious case merging opportunities. */
230 group_case_labels ();
232 /* Create the edges of the flowgraph. */
233 discriminator_per_locus
.create (13);
235 assign_discriminators ();
236 cleanup_dead_labels ();
237 discriminator_per_locus
.dispose ();
241 execute_build_cfg (void)
243 gimple_seq body
= gimple_body (current_function_decl
);
245 build_gimple_cfg (body
);
246 gimple_set_body (current_function_decl
, NULL
);
247 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
249 fprintf (dump_file
, "Scope blocks:\n");
250 dump_scope_blocks (dump_file
, dump_flags
);
253 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
259 const pass_data pass_data_build_cfg
=
261 GIMPLE_PASS
, /* type */
263 OPTGROUP_NONE
, /* optinfo_flags */
264 false, /* has_gate */
265 true, /* has_execute */
266 TV_TREE_CFG
, /* tv_id */
267 PROP_gimple_leh
, /* properties_required */
268 ( PROP_cfg
| PROP_loops
), /* properties_provided */
269 0, /* properties_destroyed */
270 0, /* todo_flags_start */
271 TODO_verify_stmts
, /* todo_flags_finish */
274 class pass_build_cfg
: public gimple_opt_pass
277 pass_build_cfg (gcc::context
*ctxt
)
278 : gimple_opt_pass (pass_data_build_cfg
, ctxt
)
281 /* opt_pass methods: */
282 unsigned int execute () { return execute_build_cfg (); }
284 }; // class pass_build_cfg
289 make_pass_build_cfg (gcc::context
*ctxt
)
291 return new pass_build_cfg (ctxt
);
295 /* Return true if T is a computed goto. */
298 computed_goto_p (gimple t
)
300 return (gimple_code (t
) == GIMPLE_GOTO
301 && TREE_CODE (gimple_goto_dest (t
)) != LABEL_DECL
);
305 /* Search the CFG for any computed gotos. If found, factor them to a
306 common computed goto site. Also record the location of that site so
307 that we can un-factor the gotos after we have converted back to
311 factor_computed_gotos (void)
314 tree factored_label_decl
= NULL
;
316 gimple factored_computed_goto_label
= NULL
;
317 gimple factored_computed_goto
= NULL
;
319 /* We know there are one or more computed gotos in this function.
320 Examine the last statement in each basic block to see if the block
321 ends with a computed goto. */
325 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
331 last
= gsi_stmt (gsi
);
333 /* Ignore the computed goto we create when we factor the original
335 if (last
== factored_computed_goto
)
338 /* If the last statement is a computed goto, factor it. */
339 if (computed_goto_p (last
))
343 /* The first time we find a computed goto we need to create
344 the factored goto block and the variable each original
345 computed goto will use for their goto destination. */
346 if (!factored_computed_goto
)
348 basic_block new_bb
= create_empty_bb (bb
);
349 gimple_stmt_iterator new_gsi
= gsi_start_bb (new_bb
);
351 /* Create the destination of the factored goto. Each original
352 computed goto will put its desired destination into this
353 variable and jump to the label we create immediately
355 var
= create_tmp_var (ptr_type_node
, "gotovar");
357 /* Build a label for the new block which will contain the
358 factored computed goto. */
359 factored_label_decl
= create_artificial_label (UNKNOWN_LOCATION
);
360 factored_computed_goto_label
361 = gimple_build_label (factored_label_decl
);
362 gsi_insert_after (&new_gsi
, factored_computed_goto_label
,
365 /* Build our new computed goto. */
366 factored_computed_goto
= gimple_build_goto (var
);
367 gsi_insert_after (&new_gsi
, factored_computed_goto
, GSI_NEW_STMT
);
370 /* Copy the original computed goto's destination into VAR. */
371 assignment
= gimple_build_assign (var
, gimple_goto_dest (last
));
372 gsi_insert_before (&gsi
, assignment
, GSI_SAME_STMT
);
374 /* And re-vector the computed goto to the new destination. */
375 gimple_goto_set_dest (last
, factored_label_decl
);
381 /* Build a flowgraph for the sequence of stmts SEQ. */
384 make_blocks (gimple_seq seq
)
386 gimple_stmt_iterator i
= gsi_start (seq
);
388 bool start_new_block
= true;
389 bool first_stmt_of_seq
= true;
390 basic_block bb
= ENTRY_BLOCK_PTR
;
392 while (!gsi_end_p (i
))
399 /* If the statement starts a new basic block or if we have determined
400 in a previous pass that we need to create a new block for STMT, do
402 if (start_new_block
|| stmt_starts_bb_p (stmt
, prev_stmt
))
404 if (!first_stmt_of_seq
)
405 gsi_split_seq_before (&i
, &seq
);
406 bb
= create_basic_block (seq
, NULL
, bb
);
407 start_new_block
= false;
410 /* Now add STMT to BB and create the subgraphs for special statement
412 gimple_set_bb (stmt
, bb
);
414 if (computed_goto_p (stmt
))
415 found_computed_goto
= true;
417 /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
419 if (stmt_ends_bb_p (stmt
))
421 /* If the stmt can make abnormal goto use a new temporary
422 for the assignment to the LHS. This makes sure the old value
423 of the LHS is available on the abnormal edge. Otherwise
424 we will end up with overlapping life-ranges for abnormal
426 if (gimple_has_lhs (stmt
)
427 && stmt_can_make_abnormal_goto (stmt
)
428 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt
))))
430 tree lhs
= gimple_get_lhs (stmt
);
431 tree tmp
= create_tmp_var (TREE_TYPE (lhs
), NULL
);
432 gimple s
= gimple_build_assign (lhs
, tmp
);
433 gimple_set_location (s
, gimple_location (stmt
));
434 gimple_set_block (s
, gimple_block (stmt
));
435 gimple_set_lhs (stmt
, tmp
);
436 if (TREE_CODE (TREE_TYPE (tmp
)) == COMPLEX_TYPE
437 || TREE_CODE (TREE_TYPE (tmp
)) == VECTOR_TYPE
)
438 DECL_GIMPLE_REG_P (tmp
) = 1;
439 gsi_insert_after (&i
, s
, GSI_SAME_STMT
);
441 start_new_block
= true;
445 first_stmt_of_seq
= false;
450 /* Create and return a new empty basic block after bb AFTER. */
453 create_bb (void *h
, void *e
, basic_block after
)
459 /* Create and initialize a new basic block. Since alloc_block uses
460 GC allocation that clears memory to allocate a basic block, we do
461 not have to clear the newly allocated basic block here. */
464 bb
->index
= last_basic_block
;
466 set_bb_seq (bb
, h
? (gimple_seq
) h
: NULL
);
468 /* Add the new block to the linked list of blocks. */
469 link_block (bb
, after
);
471 /* Grow the basic block array if needed. */
472 if ((size_t) last_basic_block
== basic_block_info
->length ())
474 size_t new_size
= last_basic_block
+ (last_basic_block
+ 3) / 4;
475 vec_safe_grow_cleared (basic_block_info
, new_size
);
478 /* Add the newly created block to the array. */
479 SET_BASIC_BLOCK (last_basic_block
, bb
);
488 /*---------------------------------------------------------------------------
490 ---------------------------------------------------------------------------*/
492 /* Fold COND_EXPR_COND of each COND_EXPR. */
495 fold_cond_expr_cond (void)
501 gimple stmt
= last_stmt (bb
);
503 if (stmt
&& gimple_code (stmt
) == GIMPLE_COND
)
505 location_t loc
= gimple_location (stmt
);
509 fold_defer_overflow_warnings ();
510 cond
= fold_binary_loc (loc
, gimple_cond_code (stmt
), boolean_type_node
,
511 gimple_cond_lhs (stmt
), gimple_cond_rhs (stmt
));
514 zerop
= integer_zerop (cond
);
515 onep
= integer_onep (cond
);
518 zerop
= onep
= false;
520 fold_undefer_overflow_warnings (zerop
|| onep
,
522 WARN_STRICT_OVERFLOW_CONDITIONAL
);
524 gimple_cond_make_false (stmt
);
526 gimple_cond_make_true (stmt
);
531 /* Join all the blocks in the flowgraph. */
537 struct omp_region
*cur_region
= NULL
;
539 /* Create an edge from entry to the first block with executable
541 make_edge (ENTRY_BLOCK_PTR
, BASIC_BLOCK (NUM_FIXED_BLOCKS
), EDGE_FALLTHRU
);
543 /* Traverse the basic block array placing edges. */
546 gimple last
= last_stmt (bb
);
551 enum gimple_code code
= gimple_code (last
);
555 make_goto_expr_edges (bb
);
559 make_edge (bb
, EXIT_BLOCK_PTR
, 0);
563 make_cond_expr_edges (bb
);
567 make_gimple_switch_edges (bb
);
571 make_eh_edges (last
);
574 case GIMPLE_EH_DISPATCH
:
575 fallthru
= make_eh_dispatch_edges (last
);
579 /* If this function receives a nonlocal goto, then we need to
580 make edges from this call site to all the nonlocal goto
582 if (stmt_can_make_abnormal_goto (last
))
583 make_abnormal_goto_edges (bb
, true);
585 /* If this statement has reachable exception handlers, then
586 create abnormal edges to them. */
587 make_eh_edges (last
);
589 /* BUILTIN_RETURN is really a return statement. */
590 if (gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
591 make_edge (bb
, EXIT_BLOCK_PTR
, 0), fallthru
= false;
592 /* Some calls are known not to return. */
594 fallthru
= !(gimple_call_flags (last
) & ECF_NORETURN
);
598 /* A GIMPLE_ASSIGN may throw internally and thus be considered
600 if (is_ctrl_altering_stmt (last
))
601 make_eh_edges (last
);
606 make_gimple_asm_edges (bb
);
610 case GIMPLE_OMP_PARALLEL
:
611 case GIMPLE_OMP_TASK
:
613 case GIMPLE_OMP_SINGLE
:
614 case GIMPLE_OMP_MASTER
:
615 case GIMPLE_OMP_ORDERED
:
616 case GIMPLE_OMP_CRITICAL
:
617 case GIMPLE_OMP_SECTION
:
618 cur_region
= new_omp_region (bb
, code
, cur_region
);
622 case GIMPLE_OMP_SECTIONS
:
623 cur_region
= new_omp_region (bb
, code
, cur_region
);
627 case GIMPLE_OMP_SECTIONS_SWITCH
:
631 case GIMPLE_OMP_ATOMIC_LOAD
:
632 case GIMPLE_OMP_ATOMIC_STORE
:
636 case GIMPLE_OMP_RETURN
:
637 /* In the case of a GIMPLE_OMP_SECTION, the edge will go
638 somewhere other than the next block. This will be
640 cur_region
->exit
= bb
;
641 fallthru
= cur_region
->type
!= GIMPLE_OMP_SECTION
;
642 cur_region
= cur_region
->outer
;
645 case GIMPLE_OMP_CONTINUE
:
646 cur_region
->cont
= bb
;
647 switch (cur_region
->type
)
650 /* Mark all GIMPLE_OMP_FOR and GIMPLE_OMP_CONTINUE
651 succs edges as abnormal to prevent splitting
653 single_succ_edge (cur_region
->entry
)->flags
|= EDGE_ABNORMAL
;
654 /* Make the loopback edge. */
655 make_edge (bb
, single_succ (cur_region
->entry
),
658 /* Create an edge from GIMPLE_OMP_FOR to exit, which
659 corresponds to the case that the body of the loop
660 is not executed at all. */
661 make_edge (cur_region
->entry
, bb
->next_bb
, EDGE_ABNORMAL
);
662 make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
| EDGE_ABNORMAL
);
666 case GIMPLE_OMP_SECTIONS
:
667 /* Wire up the edges into and out of the nested sections. */
669 basic_block switch_bb
= single_succ (cur_region
->entry
);
671 struct omp_region
*i
;
672 for (i
= cur_region
->inner
; i
; i
= i
->next
)
674 gcc_assert (i
->type
== GIMPLE_OMP_SECTION
);
675 make_edge (switch_bb
, i
->entry
, 0);
676 make_edge (i
->exit
, bb
, EDGE_FALLTHRU
);
679 /* Make the loopback edge to the block with
680 GIMPLE_OMP_SECTIONS_SWITCH. */
681 make_edge (bb
, switch_bb
, 0);
683 /* Make the edge from the switch to exit. */
684 make_edge (switch_bb
, bb
->next_bb
, 0);
694 case GIMPLE_TRANSACTION
:
696 tree abort_label
= gimple_transaction_label (last
);
698 make_edge (bb
, label_to_block (abort_label
), EDGE_TM_ABORT
);
704 gcc_assert (!stmt_ends_bb_p (last
));
712 make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
718 /* Fold COND_EXPR_COND of each COND_EXPR. */
719 fold_cond_expr_cond ();
722 /* Find the next available discriminator value for LOCUS. The
723 discriminator distinguishes among several basic blocks that
724 share a common locus, allowing for more accurate sample-based
728 next_discriminator_for_locus (location_t locus
)
730 struct locus_discrim_map item
;
731 struct locus_discrim_map
**slot
;
734 item
.discriminator
= 0;
735 slot
= discriminator_per_locus
.find_slot_with_hash (
736 &item
, LOCATION_LINE (locus
), INSERT
);
738 if (*slot
== HTAB_EMPTY_ENTRY
)
740 *slot
= XNEW (struct locus_discrim_map
);
742 (*slot
)->locus
= locus
;
743 (*slot
)->discriminator
= 0;
745 (*slot
)->discriminator
++;
746 return (*slot
)->discriminator
;
749 /* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line. */
752 same_line_p (location_t locus1
, location_t locus2
)
754 expanded_location from
, to
;
756 if (locus1
== locus2
)
759 from
= expand_location (locus1
);
760 to
= expand_location (locus2
);
762 if (from
.line
!= to
.line
)
764 if (from
.file
== to
.file
)
766 return (from
.file
!= NULL
768 && filename_cmp (from
.file
, to
.file
) == 0);
771 /* Assign discriminators to each basic block. */
774 assign_discriminators (void)
782 gimple last
= last_stmt (bb
);
783 location_t locus
= last
? gimple_location (last
) : UNKNOWN_LOCATION
;
785 if (locus
== UNKNOWN_LOCATION
)
788 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
790 gimple first
= first_non_label_stmt (e
->dest
);
791 gimple last
= last_stmt (e
->dest
);
792 if ((first
&& same_line_p (locus
, gimple_location (first
)))
793 || (last
&& same_line_p (locus
, gimple_location (last
))))
795 if (e
->dest
->discriminator
!= 0 && bb
->discriminator
== 0)
796 bb
->discriminator
= next_discriminator_for_locus (locus
);
798 e
->dest
->discriminator
= next_discriminator_for_locus (locus
);
804 /* Create the edges for a GIMPLE_COND starting at block BB. */
807 make_cond_expr_edges (basic_block bb
)
809 gimple entry
= last_stmt (bb
);
810 gimple then_stmt
, else_stmt
;
811 basic_block then_bb
, else_bb
;
812 tree then_label
, else_label
;
816 gcc_assert (gimple_code (entry
) == GIMPLE_COND
);
818 /* Entry basic blocks for each component. */
819 then_label
= gimple_cond_true_label (entry
);
820 else_label
= gimple_cond_false_label (entry
);
821 then_bb
= label_to_block (then_label
);
822 else_bb
= label_to_block (else_label
);
823 then_stmt
= first_stmt (then_bb
);
824 else_stmt
= first_stmt (else_bb
);
826 e
= make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
827 e
->goto_locus
= gimple_location (then_stmt
);
828 e
= make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
830 e
->goto_locus
= gimple_location (else_stmt
);
832 /* We do not need the labels anymore. */
833 gimple_cond_set_true_label (entry
, NULL_TREE
);
834 gimple_cond_set_false_label (entry
, NULL_TREE
);
838 /* Called for each element in the hash table (P) as we delete the
839 edge to cases hash table.
841 Clear all the TREE_CHAINs to prevent problems with copying of
842 SWITCH_EXPRs and structure sharing rules, then free the hash table
846 edge_to_cases_cleanup (const void *key ATTRIBUTE_UNUSED
, void **value
,
847 void *data ATTRIBUTE_UNUSED
)
851 for (t
= (tree
) *value
; t
; t
= next
)
853 next
= CASE_CHAIN (t
);
854 CASE_CHAIN (t
) = NULL
;
861 /* Start recording information mapping edges to case labels. */
864 start_recording_case_labels (void)
866 gcc_assert (edge_to_cases
== NULL
);
867 edge_to_cases
= pointer_map_create ();
868 touched_switch_bbs
= BITMAP_ALLOC (NULL
);
871 /* Return nonzero if we are recording information for case labels. */
874 recording_case_labels_p (void)
876 return (edge_to_cases
!= NULL
);
879 /* Stop recording information mapping edges to case labels and
880 remove any information we have recorded. */
882 end_recording_case_labels (void)
886 pointer_map_traverse (edge_to_cases
, edge_to_cases_cleanup
, NULL
);
887 pointer_map_destroy (edge_to_cases
);
888 edge_to_cases
= NULL
;
889 EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs
, 0, i
, bi
)
891 basic_block bb
= BASIC_BLOCK (i
);
894 gimple stmt
= last_stmt (bb
);
895 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
896 group_case_labels_stmt (stmt
);
899 BITMAP_FREE (touched_switch_bbs
);
902 /* If we are inside a {start,end}_recording_cases block, then return
903 a chain of CASE_LABEL_EXPRs from T which reference E.
905 Otherwise return NULL. */
908 get_cases_for_edge (edge e
, gimple t
)
913 /* If we are not recording cases, then we do not have CASE_LABEL_EXPR
914 chains available. Return NULL so the caller can detect this case. */
915 if (!recording_case_labels_p ())
918 slot
= pointer_map_contains (edge_to_cases
, e
);
922 /* If we did not find E in the hash table, then this must be the first
923 time we have been queried for information about E & T. Add all the
924 elements from T to the hash table then perform the query again. */
926 n
= gimple_switch_num_labels (t
);
927 for (i
= 0; i
< n
; i
++)
929 tree elt
= gimple_switch_label (t
, i
);
930 tree lab
= CASE_LABEL (elt
);
931 basic_block label_bb
= label_to_block (lab
);
932 edge this_edge
= find_edge (e
->src
, label_bb
);
934 /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
936 slot
= pointer_map_insert (edge_to_cases
, this_edge
);
937 CASE_CHAIN (elt
) = (tree
) *slot
;
941 return (tree
) *pointer_map_contains (edge_to_cases
, e
);
944 /* Create the edges for a GIMPLE_SWITCH starting at block BB. */
947 make_gimple_switch_edges (basic_block bb
)
949 gimple entry
= last_stmt (bb
);
952 n
= gimple_switch_num_labels (entry
);
954 for (i
= 0; i
< n
; ++i
)
956 tree lab
= CASE_LABEL (gimple_switch_label (entry
, i
));
957 basic_block label_bb
= label_to_block (lab
);
958 make_edge (bb
, label_bb
, 0);
963 /* Return the basic block holding label DEST. */
966 label_to_block_fn (struct function
*ifun
, tree dest
)
968 int uid
= LABEL_DECL_UID (dest
);
970 /* We would die hard when faced by an undefined label. Emit a label to
971 the very first basic block. This will hopefully make even the dataflow
972 and undefined variable warnings quite right. */
973 if (seen_error () && uid
< 0)
975 gimple_stmt_iterator gsi
= gsi_start_bb (BASIC_BLOCK (NUM_FIXED_BLOCKS
));
978 stmt
= gimple_build_label (dest
);
979 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
980 uid
= LABEL_DECL_UID (dest
);
982 if (vec_safe_length (ifun
->cfg
->x_label_to_block_map
) <= (unsigned int) uid
)
984 return (*ifun
->cfg
->x_label_to_block_map
)[uid
];
987 /* Create edges for an abnormal goto statement at block BB. If FOR_CALL
988 is true, the source statement is a CALL_EXPR instead of a GOTO_EXPR. */
991 make_abnormal_goto_edges (basic_block bb
, bool for_call
)
993 basic_block target_bb
;
994 gimple_stmt_iterator gsi
;
996 FOR_EACH_BB (target_bb
)
998 for (gsi
= gsi_start_bb (target_bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1000 gimple label_stmt
= gsi_stmt (gsi
);
1003 if (gimple_code (label_stmt
) != GIMPLE_LABEL
)
1006 target
= gimple_label_label (label_stmt
);
1008 /* Make an edge to every label block that has been marked as a
1009 potential target for a computed goto or a non-local goto. */
1010 if ((FORCED_LABEL (target
) && !for_call
)
1011 || (DECL_NONLOCAL (target
) && for_call
))
1013 make_edge (bb
, target_bb
, EDGE_ABNORMAL
);
1017 if (!gsi_end_p (gsi
)
1018 && is_gimple_debug (gsi_stmt (gsi
)))
1019 gsi_next_nondebug (&gsi
);
1020 if (!gsi_end_p (gsi
))
1022 /* Make an edge to every setjmp-like call. */
1023 gimple call_stmt
= gsi_stmt (gsi
);
1024 if (is_gimple_call (call_stmt
)
1025 && (gimple_call_flags (call_stmt
) & ECF_RETURNS_TWICE
))
1026 make_edge (bb
, target_bb
, EDGE_ABNORMAL
);
1031 /* Create edges for a goto statement at block BB. */
1034 make_goto_expr_edges (basic_block bb
)
1036 gimple_stmt_iterator last
= gsi_last_bb (bb
);
1037 gimple goto_t
= gsi_stmt (last
);
1039 /* A simple GOTO creates normal edges. */
1040 if (simple_goto_p (goto_t
))
1042 tree dest
= gimple_goto_dest (goto_t
);
1043 basic_block label_bb
= label_to_block (dest
);
1044 edge e
= make_edge (bb
, label_bb
, EDGE_FALLTHRU
);
1045 e
->goto_locus
= gimple_location (goto_t
);
1046 gsi_remove (&last
, true);
1050 /* A computed GOTO creates abnormal edges. */
1051 make_abnormal_goto_edges (bb
, false);
1054 /* Create edges for an asm statement with labels at block BB. */
1057 make_gimple_asm_edges (basic_block bb
)
1059 gimple stmt
= last_stmt (bb
);
1060 int i
, n
= gimple_asm_nlabels (stmt
);
1062 for (i
= 0; i
< n
; ++i
)
1064 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
1065 basic_block label_bb
= label_to_block (label
);
1066 make_edge (bb
, label_bb
, 0);
1070 /*---------------------------------------------------------------------------
1072 ---------------------------------------------------------------------------*/
1074 /* Cleanup useless labels in basic blocks. This is something we wish
1075 to do early because it allows us to group case labels before creating
1076 the edges for the CFG, and it speeds up block statement iterators in
1077 all passes later on.
1078 We rerun this pass after CFG is created, to get rid of the labels that
1079 are no longer referenced. After then we do not run it any more, since
1080 (almost) no new labels should be created. */
1082 /* A map from basic block index to the leading label of that block. */
1083 static struct label_record
1088 /* True if the label is referenced from somewhere. */
1092 /* Given LABEL return the first label in the same basic block. */
1095 main_block_label (tree label
)
1097 basic_block bb
= label_to_block (label
);
1098 tree main_label
= label_for_bb
[bb
->index
].label
;
1100 /* label_to_block possibly inserted undefined label into the chain. */
1103 label_for_bb
[bb
->index
].label
= label
;
1107 label_for_bb
[bb
->index
].used
= true;
1111 /* Clean up redundant labels within the exception tree. */
1114 cleanup_dead_labels_eh (void)
1121 if (cfun
->eh
== NULL
)
1124 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1125 if (lp
&& lp
->post_landing_pad
)
1127 lab
= main_block_label (lp
->post_landing_pad
);
1128 if (lab
!= lp
->post_landing_pad
)
1130 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1131 EH_LANDING_PAD_NR (lab
) = lp
->index
;
1135 FOR_ALL_EH_REGION (r
)
1139 case ERT_MUST_NOT_THROW
:
1145 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
1149 c
->label
= main_block_label (lab
);
1154 case ERT_ALLOWED_EXCEPTIONS
:
1155 lab
= r
->u
.allowed
.label
;
1157 r
->u
.allowed
.label
= main_block_label (lab
);
1163 /* Cleanup redundant labels. This is a three-step process:
1164 1) Find the leading label for each block.
1165 2) Redirect all references to labels to the leading labels.
1166 3) Cleanup all useless labels. */
1169 cleanup_dead_labels (void)
1172 label_for_bb
= XCNEWVEC (struct label_record
, last_basic_block
);
1174 /* Find a suitable label for each block. We use the first user-defined
1175 label if there is one, or otherwise just the first label we see. */
1178 gimple_stmt_iterator i
;
1180 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
1183 gimple stmt
= gsi_stmt (i
);
1185 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1188 label
= gimple_label_label (stmt
);
1190 /* If we have not yet seen a label for the current block,
1191 remember this one and see if there are more labels. */
1192 if (!label_for_bb
[bb
->index
].label
)
1194 label_for_bb
[bb
->index
].label
= label
;
1198 /* If we did see a label for the current block already, but it
1199 is an artificially created label, replace it if the current
1200 label is a user defined label. */
1201 if (!DECL_ARTIFICIAL (label
)
1202 && DECL_ARTIFICIAL (label_for_bb
[bb
->index
].label
))
1204 label_for_bb
[bb
->index
].label
= label
;
1210 /* Now redirect all jumps/branches to the selected label.
1211 First do so for each block ending in a control statement. */
1214 gimple stmt
= last_stmt (bb
);
1215 tree label
, new_label
;
1220 switch (gimple_code (stmt
))
1223 label
= gimple_cond_true_label (stmt
);
1226 new_label
= main_block_label (label
);
1227 if (new_label
!= label
)
1228 gimple_cond_set_true_label (stmt
, new_label
);
1231 label
= gimple_cond_false_label (stmt
);
1234 new_label
= main_block_label (label
);
1235 if (new_label
!= label
)
1236 gimple_cond_set_false_label (stmt
, new_label
);
1242 size_t i
, n
= gimple_switch_num_labels (stmt
);
1244 /* Replace all destination labels. */
1245 for (i
= 0; i
< n
; ++i
)
1247 tree case_label
= gimple_switch_label (stmt
, i
);
1248 label
= CASE_LABEL (case_label
);
1249 new_label
= main_block_label (label
);
1250 if (new_label
!= label
)
1251 CASE_LABEL (case_label
) = new_label
;
1258 int i
, n
= gimple_asm_nlabels (stmt
);
1260 for (i
= 0; i
< n
; ++i
)
1262 tree cons
= gimple_asm_label_op (stmt
, i
);
1263 tree label
= main_block_label (TREE_VALUE (cons
));
1264 TREE_VALUE (cons
) = label
;
1269 /* We have to handle gotos until they're removed, and we don't
1270 remove them until after we've created the CFG edges. */
1272 if (!computed_goto_p (stmt
))
1274 label
= gimple_goto_dest (stmt
);
1275 new_label
= main_block_label (label
);
1276 if (new_label
!= label
)
1277 gimple_goto_set_dest (stmt
, new_label
);
1281 case GIMPLE_TRANSACTION
:
1283 tree label
= gimple_transaction_label (stmt
);
1286 tree new_label
= main_block_label (label
);
1287 if (new_label
!= label
)
1288 gimple_transaction_set_label (stmt
, new_label
);
1298 /* Do the same for the exception region tree labels. */
1299 cleanup_dead_labels_eh ();
1301 /* Finally, purge dead labels. All user-defined labels and labels that
1302 can be the target of non-local gotos and labels which have their
1303 address taken are preserved. */
1306 gimple_stmt_iterator i
;
1307 tree label_for_this_bb
= label_for_bb
[bb
->index
].label
;
1309 if (!label_for_this_bb
)
1312 /* If the main label of the block is unused, we may still remove it. */
1313 if (!label_for_bb
[bb
->index
].used
)
1314 label_for_this_bb
= NULL
;
1316 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); )
1319 gimple stmt
= gsi_stmt (i
);
1321 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1324 label
= gimple_label_label (stmt
);
1326 if (label
== label_for_this_bb
1327 || !DECL_ARTIFICIAL (label
)
1328 || DECL_NONLOCAL (label
)
1329 || FORCED_LABEL (label
))
1332 gsi_remove (&i
, true);
1336 free (label_for_bb
);
1339 /* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
1340 the ones jumping to the same label.
1341 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
1344 group_case_labels_stmt (gimple stmt
)
1346 int old_size
= gimple_switch_num_labels (stmt
);
1347 int i
, j
, new_size
= old_size
;
1348 basic_block default_bb
= NULL
;
1350 default_bb
= label_to_block (CASE_LABEL (gimple_switch_default_label (stmt
)));
1352 /* Look for possible opportunities to merge cases. */
1354 while (i
< old_size
)
1356 tree base_case
, base_high
;
1357 basic_block base_bb
;
1359 base_case
= gimple_switch_label (stmt
, i
);
1361 gcc_assert (base_case
);
1362 base_bb
= label_to_block (CASE_LABEL (base_case
));
1364 /* Discard cases that have the same destination as the
1366 if (base_bb
== default_bb
)
1368 gimple_switch_set_label (stmt
, i
, NULL_TREE
);
1374 base_high
= CASE_HIGH (base_case
)
1375 ? CASE_HIGH (base_case
)
1376 : CASE_LOW (base_case
);
1379 /* Try to merge case labels. Break out when we reach the end
1380 of the label vector or when we cannot merge the next case
1381 label with the current one. */
1382 while (i
< old_size
)
1384 tree merge_case
= gimple_switch_label (stmt
, i
);
1385 basic_block merge_bb
= label_to_block (CASE_LABEL (merge_case
));
1386 double_int bhp1
= tree_to_double_int (base_high
) + double_int_one
;
1388 /* Merge the cases if they jump to the same place,
1389 and their ranges are consecutive. */
1390 if (merge_bb
== base_bb
1391 && tree_to_double_int (CASE_LOW (merge_case
)) == bhp1
)
1393 base_high
= CASE_HIGH (merge_case
) ?
1394 CASE_HIGH (merge_case
) : CASE_LOW (merge_case
);
1395 CASE_HIGH (base_case
) = base_high
;
1396 gimple_switch_set_label (stmt
, i
, NULL_TREE
);
1405 /* Compress the case labels in the label vector, and adjust the
1406 length of the vector. */
1407 for (i
= 0, j
= 0; i
< new_size
; i
++)
1409 while (! gimple_switch_label (stmt
, j
))
1411 gimple_switch_set_label (stmt
, i
,
1412 gimple_switch_label (stmt
, j
++));
1415 gcc_assert (new_size
<= old_size
);
1416 gimple_switch_set_num_labels (stmt
, new_size
);
1419 /* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
1420 and scan the sorted vector of cases. Combine the ones jumping to the
1424 group_case_labels (void)
1430 gimple stmt
= last_stmt (bb
);
1431 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1432 group_case_labels_stmt (stmt
);
1436 /* Checks whether we can merge block B into block A. */
1439 gimple_can_merge_blocks_p (basic_block a
, basic_block b
)
1442 gimple_stmt_iterator gsi
;
1444 if (!single_succ_p (a
))
1447 if (single_succ_edge (a
)->flags
& EDGE_COMPLEX
)
1450 if (single_succ (a
) != b
)
1453 if (!single_pred_p (b
))
1456 if (b
== EXIT_BLOCK_PTR
)
1459 /* If A ends by a statement causing exceptions or something similar, we
1460 cannot merge the blocks. */
1461 stmt
= last_stmt (a
);
1462 if (stmt
&& stmt_ends_bb_p (stmt
))
1465 /* Do not allow a block with only a non-local label to be merged. */
1467 && gimple_code (stmt
) == GIMPLE_LABEL
1468 && DECL_NONLOCAL (gimple_label_label (stmt
)))
1471 /* Examine the labels at the beginning of B. */
1472 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1475 stmt
= gsi_stmt (gsi
);
1476 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1478 lab
= gimple_label_label (stmt
);
1480 /* Do not remove user forced labels or for -O0 any user labels. */
1481 if (!DECL_ARTIFICIAL (lab
) && (!optimize
|| FORCED_LABEL (lab
)))
1485 /* Protect the loop latches. */
1486 if (current_loops
&& b
->loop_father
->latch
== b
)
1489 /* It must be possible to eliminate all phi nodes in B. If ssa form
1490 is not up-to-date and a name-mapping is registered, we cannot eliminate
1491 any phis. Symbols marked for renaming are never a problem though. */
1492 for (gsi
= gsi_start_phis (b
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1494 gimple phi
= gsi_stmt (gsi
);
1495 /* Technically only new names matter. */
1496 if (name_registered_for_update_p (PHI_RESULT (phi
)))
1500 /* When not optimizing, don't merge if we'd lose goto_locus. */
1502 && single_succ_edge (a
)->goto_locus
!= UNKNOWN_LOCATION
)
1504 location_t goto_locus
= single_succ_edge (a
)->goto_locus
;
1505 gimple_stmt_iterator prev
, next
;
1506 prev
= gsi_last_nondebug_bb (a
);
1507 next
= gsi_after_labels (b
);
1508 if (!gsi_end_p (next
) && is_gimple_debug (gsi_stmt (next
)))
1509 gsi_next_nondebug (&next
);
1510 if ((gsi_end_p (prev
)
1511 || gimple_location (gsi_stmt (prev
)) != goto_locus
)
1512 && (gsi_end_p (next
)
1513 || gimple_location (gsi_stmt (next
)) != goto_locus
))
1520 /* Replaces all uses of NAME by VAL. */
1523 replace_uses_by (tree name
, tree val
)
1525 imm_use_iterator imm_iter
;
1530 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, name
)
1532 FOR_EACH_IMM_USE_ON_STMT (use
, imm_iter
)
1534 replace_exp (use
, val
);
1536 if (gimple_code (stmt
) == GIMPLE_PHI
)
1538 e
= gimple_phi_arg_edge (stmt
, PHI_ARG_INDEX_FROM_USE (use
));
1539 if (e
->flags
& EDGE_ABNORMAL
)
1541 /* This can only occur for virtual operands, since
1542 for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
1543 would prevent replacement. */
1544 gcc_checking_assert (virtual_operand_p (name
));
1545 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val
) = 1;
1550 if (gimple_code (stmt
) != GIMPLE_PHI
)
1552 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
1553 gimple orig_stmt
= stmt
;
1556 /* Mark the block if we changed the last stmt in it. */
1557 if (cfgcleanup_altered_bbs
1558 && stmt_ends_bb_p (stmt
))
1559 bitmap_set_bit (cfgcleanup_altered_bbs
, gimple_bb (stmt
)->index
);
1561 /* FIXME. It shouldn't be required to keep TREE_CONSTANT
1562 on ADDR_EXPRs up-to-date on GIMPLE. Propagation will
1563 only change sth from non-invariant to invariant, and only
1564 when propagating constants. */
1565 if (is_gimple_min_invariant (val
))
1566 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1568 tree op
= gimple_op (stmt
, i
);
1569 /* Operands may be empty here. For example, the labels
1570 of a GIMPLE_COND are nulled out following the creation
1571 of the corresponding CFG edges. */
1572 if (op
&& TREE_CODE (op
) == ADDR_EXPR
)
1573 recompute_tree_invariant_for_addr_expr (op
);
1576 if (fold_stmt (&gsi
))
1577 stmt
= gsi_stmt (gsi
);
1579 if (maybe_clean_or_replace_eh_stmt (orig_stmt
, stmt
))
1580 gimple_purge_dead_eh_edges (gimple_bb (stmt
));
1586 gcc_checking_assert (has_zero_uses (name
));
1588 /* Also update the trees stored in loop structures. */
1594 FOR_EACH_LOOP (li
, loop
, 0)
1596 substitute_in_loop_info (loop
, name
, val
);
1601 /* Merge block B into block A. */
1604 gimple_merge_blocks (basic_block a
, basic_block b
)
1606 gimple_stmt_iterator last
, gsi
, psi
;
1609 fprintf (dump_file
, "Merging blocks %d and %d\n", a
->index
, b
->index
);
1611 /* Remove all single-valued PHI nodes from block B of the form
1612 V_i = PHI <V_j> by propagating V_j to all the uses of V_i. */
1613 gsi
= gsi_last_bb (a
);
1614 for (psi
= gsi_start_phis (b
); !gsi_end_p (psi
); )
1616 gimple phi
= gsi_stmt (psi
);
1617 tree def
= gimple_phi_result (phi
), use
= gimple_phi_arg_def (phi
, 0);
1619 bool may_replace_uses
= (virtual_operand_p (def
)
1620 || may_propagate_copy (def
, use
));
1622 /* In case we maintain loop closed ssa form, do not propagate arguments
1623 of loop exit phi nodes. */
1625 && loops_state_satisfies_p (LOOP_CLOSED_SSA
)
1626 && !virtual_operand_p (def
)
1627 && TREE_CODE (use
) == SSA_NAME
1628 && a
->loop_father
!= b
->loop_father
)
1629 may_replace_uses
= false;
1631 if (!may_replace_uses
)
1633 gcc_assert (!virtual_operand_p (def
));
1635 /* Note that just emitting the copies is fine -- there is no problem
1636 with ordering of phi nodes. This is because A is the single
1637 predecessor of B, therefore results of the phi nodes cannot
1638 appear as arguments of the phi nodes. */
1639 copy
= gimple_build_assign (def
, use
);
1640 gsi_insert_after (&gsi
, copy
, GSI_NEW_STMT
);
1641 remove_phi_node (&psi
, false);
1645 /* If we deal with a PHI for virtual operands, we can simply
1646 propagate these without fussing with folding or updating
1648 if (virtual_operand_p (def
))
1650 imm_use_iterator iter
;
1651 use_operand_p use_p
;
1654 FOR_EACH_IMM_USE_STMT (stmt
, iter
, def
)
1655 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
1656 SET_USE (use_p
, use
);
1658 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
1659 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use
) = 1;
1662 replace_uses_by (def
, use
);
1664 remove_phi_node (&psi
, true);
1668 /* Ensure that B follows A. */
1669 move_block_after (b
, a
);
1671 gcc_assert (single_succ_edge (a
)->flags
& EDGE_FALLTHRU
);
1672 gcc_assert (!last_stmt (a
) || !stmt_ends_bb_p (last_stmt (a
)));
1674 /* Remove labels from B and set gimple_bb to A for other statements. */
1675 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
);)
1677 gimple stmt
= gsi_stmt (gsi
);
1678 if (gimple_code (stmt
) == GIMPLE_LABEL
)
1680 tree label
= gimple_label_label (stmt
);
1683 gsi_remove (&gsi
, false);
1685 /* Now that we can thread computed gotos, we might have
1686 a situation where we have a forced label in block B
1687 However, the label at the start of block B might still be
1688 used in other ways (think about the runtime checking for
1689 Fortran assigned gotos). So we can not just delete the
1690 label. Instead we move the label to the start of block A. */
1691 if (FORCED_LABEL (label
))
1693 gimple_stmt_iterator dest_gsi
= gsi_start_bb (a
);
1694 gsi_insert_before (&dest_gsi
, stmt
, GSI_NEW_STMT
);
1696 /* Other user labels keep around in a form of a debug stmt. */
1697 else if (!DECL_ARTIFICIAL (label
) && MAY_HAVE_DEBUG_STMTS
)
1699 gimple dbg
= gimple_build_debug_bind (label
,
1702 gimple_debug_bind_reset_value (dbg
);
1703 gsi_insert_before (&gsi
, dbg
, GSI_SAME_STMT
);
1706 lp_nr
= EH_LANDING_PAD_NR (label
);
1709 eh_landing_pad lp
= get_eh_landing_pad_from_number (lp_nr
);
1710 lp
->post_landing_pad
= NULL
;
1715 gimple_set_bb (stmt
, a
);
1720 /* Merge the sequences. */
1721 last
= gsi_last_bb (a
);
1722 gsi_insert_seq_after (&last
, bb_seq (b
), GSI_NEW_STMT
);
1723 set_bb_seq (b
, NULL
);
1725 if (cfgcleanup_altered_bbs
)
1726 bitmap_set_bit (cfgcleanup_altered_bbs
, a
->index
);
1730 /* Return the one of two successors of BB that is not reachable by a
1731 complex edge, if there is one. Else, return BB. We use
1732 this in optimizations that use post-dominators for their heuristics,
1733 to catch the cases in C++ where function calls are involved. */
1736 single_noncomplex_succ (basic_block bb
)
1739 if (EDGE_COUNT (bb
->succs
) != 2)
1742 e0
= EDGE_SUCC (bb
, 0);
1743 e1
= EDGE_SUCC (bb
, 1);
1744 if (e0
->flags
& EDGE_COMPLEX
)
1746 if (e1
->flags
& EDGE_COMPLEX
)
1752 /* T is CALL_EXPR. Set current_function_calls_* flags. */
1755 notice_special_calls (gimple call
)
1757 int flags
= gimple_call_flags (call
);
1759 if (flags
& ECF_MAY_BE_ALLOCA
)
1760 cfun
->calls_alloca
= true;
1761 if (flags
& ECF_RETURNS_TWICE
)
1762 cfun
->calls_setjmp
= true;
1766 /* Clear flags set by notice_special_calls. Used by dead code removal
1767 to update the flags. */
1770 clear_special_calls (void)
1772 cfun
->calls_alloca
= false;
1773 cfun
->calls_setjmp
= false;
1776 /* Remove PHI nodes associated with basic block BB and all edges out of BB. */
1779 remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb
)
1781 /* Since this block is no longer reachable, we can just delete all
1782 of its PHI nodes. */
1783 remove_phi_nodes (bb
);
1785 /* Remove edges to BB's successors. */
1786 while (EDGE_COUNT (bb
->succs
) > 0)
1787 remove_edge (EDGE_SUCC (bb
, 0));
1791 /* Remove statements of basic block BB. */
1794 remove_bb (basic_block bb
)
1796 gimple_stmt_iterator i
;
1800 fprintf (dump_file
, "Removing basic block %d\n", bb
->index
);
1801 if (dump_flags
& TDF_DETAILS
)
1803 dump_bb (dump_file
, bb
, 0, dump_flags
);
1804 fprintf (dump_file
, "\n");
1810 struct loop
*loop
= bb
->loop_father
;
1812 /* If a loop gets removed, clean up the information associated
1814 if (loop
->latch
== bb
1815 || loop
->header
== bb
)
1816 free_numbers_of_iterations_estimates_loop (loop
);
1819 /* Remove all the instructions in the block. */
1820 if (bb_seq (bb
) != NULL
)
1822 /* Walk backwards so as to get a chance to substitute all
1823 released DEFs into debug stmts. See
1824 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
1826 for (i
= gsi_last_bb (bb
); !gsi_end_p (i
);)
1828 gimple stmt
= gsi_stmt (i
);
1829 if (gimple_code (stmt
) == GIMPLE_LABEL
1830 && (FORCED_LABEL (gimple_label_label (stmt
))
1831 || DECL_NONLOCAL (gimple_label_label (stmt
))))
1834 gimple_stmt_iterator new_gsi
;
1836 /* A non-reachable non-local label may still be referenced.
1837 But it no longer needs to carry the extra semantics of
1839 if (DECL_NONLOCAL (gimple_label_label (stmt
)))
1841 DECL_NONLOCAL (gimple_label_label (stmt
)) = 0;
1842 FORCED_LABEL (gimple_label_label (stmt
)) = 1;
1845 new_bb
= bb
->prev_bb
;
1846 new_gsi
= gsi_start_bb (new_bb
);
1847 gsi_remove (&i
, false);
1848 gsi_insert_before (&new_gsi
, stmt
, GSI_NEW_STMT
);
1852 /* Release SSA definitions if we are in SSA. Note that we
1853 may be called when not in SSA. For example,
1854 final_cleanup calls this function via
1855 cleanup_tree_cfg. */
1856 if (gimple_in_ssa_p (cfun
))
1857 release_defs (stmt
);
1859 gsi_remove (&i
, true);
1863 i
= gsi_last_bb (bb
);
1869 remove_phi_nodes_and_edges_for_unreachable_block (bb
);
1870 bb
->il
.gimple
.seq
= NULL
;
1871 bb
->il
.gimple
.phi_nodes
= NULL
;
1875 /* Given a basic block BB ending with COND_EXPR or SWITCH_EXPR, and a
1876 predicate VAL, return the edge that will be taken out of the block.
1877 If VAL does not match a unique edge, NULL is returned. */
1880 find_taken_edge (basic_block bb
, tree val
)
1884 stmt
= last_stmt (bb
);
1887 gcc_assert (is_ctrl_stmt (stmt
));
1892 if (!is_gimple_min_invariant (val
))
1895 if (gimple_code (stmt
) == GIMPLE_COND
)
1896 return find_taken_edge_cond_expr (bb
, val
);
1898 if (gimple_code (stmt
) == GIMPLE_SWITCH
)
1899 return find_taken_edge_switch_expr (bb
, val
);
1901 if (computed_goto_p (stmt
))
1903 /* Only optimize if the argument is a label, if the argument is
1904 not a label then we can not construct a proper CFG.
1906 It may be the case that we only need to allow the LABEL_REF to
1907 appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
1908 appear inside a LABEL_EXPR just to be safe. */
1909 if ((TREE_CODE (val
) == ADDR_EXPR
|| TREE_CODE (val
) == LABEL_EXPR
)
1910 && TREE_CODE (TREE_OPERAND (val
, 0)) == LABEL_DECL
)
1911 return find_taken_edge_computed_goto (bb
, TREE_OPERAND (val
, 0));
1918 /* Given a constant value VAL and the entry block BB to a GOTO_EXPR
1919 statement, determine which of the outgoing edges will be taken out of the
1920 block. Return NULL if either edge may be taken. */
1923 find_taken_edge_computed_goto (basic_block bb
, tree val
)
1928 dest
= label_to_block (val
);
1931 e
= find_edge (bb
, dest
);
1932 gcc_assert (e
!= NULL
);
1938 /* Given a constant value VAL and the entry block BB to a COND_EXPR
1939 statement, determine which of the two edges will be taken out of the
1940 block. Return NULL if either edge may be taken. */
1943 find_taken_edge_cond_expr (basic_block bb
, tree val
)
1945 edge true_edge
, false_edge
;
1947 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
1949 gcc_assert (TREE_CODE (val
) == INTEGER_CST
);
1950 return (integer_zerop (val
) ? false_edge
: true_edge
);
1953 /* Given an INTEGER_CST VAL and the entry block BB to a SWITCH_EXPR
1954 statement, determine which edge will be taken out of the block. Return
1955 NULL if any edge may be taken. */
1958 find_taken_edge_switch_expr (basic_block bb
, tree val
)
1960 basic_block dest_bb
;
1965 switch_stmt
= last_stmt (bb
);
1966 taken_case
= find_case_label_for_value (switch_stmt
, val
);
1967 dest_bb
= label_to_block (CASE_LABEL (taken_case
));
1969 e
= find_edge (bb
, dest_bb
);
1975 /* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
1976 We can make optimal use here of the fact that the case labels are
1977 sorted: We can do a binary search for a case matching VAL. */
1980 find_case_label_for_value (gimple switch_stmt
, tree val
)
1982 size_t low
, high
, n
= gimple_switch_num_labels (switch_stmt
);
1983 tree default_case
= gimple_switch_default_label (switch_stmt
);
1985 for (low
= 0, high
= n
; high
- low
> 1; )
1987 size_t i
= (high
+ low
) / 2;
1988 tree t
= gimple_switch_label (switch_stmt
, i
);
1991 /* Cache the result of comparing CASE_LOW and val. */
1992 cmp
= tree_int_cst_compare (CASE_LOW (t
), val
);
1999 if (CASE_HIGH (t
) == NULL
)
2001 /* A singe-valued case label. */
2007 /* A case range. We can only handle integer ranges. */
2008 if (cmp
<= 0 && tree_int_cst_compare (CASE_HIGH (t
), val
) >= 0)
2013 return default_case
;
2017 /* Dump a basic block on stderr. */
2020 gimple_debug_bb (basic_block bb
)
2022 dump_bb (stderr
, bb
, 0, TDF_VOPS
|TDF_MEMSYMS
|TDF_BLOCKS
);
2026 /* Dump basic block with index N on stderr. */
2029 gimple_debug_bb_n (int n
)
2031 gimple_debug_bb (BASIC_BLOCK (n
));
2032 return BASIC_BLOCK (n
);
2036 /* Dump the CFG on stderr.
2038 FLAGS are the same used by the tree dumping functions
2039 (see TDF_* in dumpfile.h). */
2042 gimple_debug_cfg (int flags
)
2044 gimple_dump_cfg (stderr
, flags
);
2048 /* Dump the program showing basic block boundaries on the given FILE.
2050 FLAGS are the same used by the tree dumping functions (see TDF_* in
2054 gimple_dump_cfg (FILE *file
, int flags
)
2056 if (flags
& TDF_DETAILS
)
2058 dump_function_header (file
, current_function_decl
, flags
);
2059 fprintf (file
, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
2060 n_basic_blocks
, n_edges
, last_basic_block
);
2062 brief_dump_cfg (file
, flags
| TDF_COMMENT
);
2063 fprintf (file
, "\n");
2066 if (flags
& TDF_STATS
)
2067 dump_cfg_stats (file
);
2069 dump_function_to_file (current_function_decl
, file
, flags
| TDF_BLOCKS
);
2073 /* Dump CFG statistics on FILE. */
2076 dump_cfg_stats (FILE *file
)
2078 static long max_num_merged_labels
= 0;
2079 unsigned long size
, total
= 0;
2082 const char * const fmt_str
= "%-30s%-13s%12s\n";
2083 const char * const fmt_str_1
= "%-30s%13d%11lu%c\n";
2084 const char * const fmt_str_2
= "%-30s%13ld%11lu%c\n";
2085 const char * const fmt_str_3
= "%-43s%11lu%c\n";
2086 const char *funcname
= current_function_name ();
2088 fprintf (file
, "\nCFG Statistics for %s\n\n", funcname
);
2090 fprintf (file
, "---------------------------------------------------------\n");
2091 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
2092 fprintf (file
, fmt_str
, "", " instances ", "used ");
2093 fprintf (file
, "---------------------------------------------------------\n");
2095 size
= n_basic_blocks
* sizeof (struct basic_block_def
);
2097 fprintf (file
, fmt_str_1
, "Basic blocks", n_basic_blocks
,
2098 SCALE (size
), LABEL (size
));
2102 num_edges
+= EDGE_COUNT (bb
->succs
);
2103 size
= num_edges
* sizeof (struct edge_def
);
2105 fprintf (file
, fmt_str_2
, "Edges", num_edges
, SCALE (size
), LABEL (size
));
2107 fprintf (file
, "---------------------------------------------------------\n");
2108 fprintf (file
, fmt_str_3
, "Total memory used by CFG data", SCALE (total
),
2110 fprintf (file
, "---------------------------------------------------------\n");
2111 fprintf (file
, "\n");
2113 if (cfg_stats
.num_merged_labels
> max_num_merged_labels
)
2114 max_num_merged_labels
= cfg_stats
.num_merged_labels
;
2116 fprintf (file
, "Coalesced label blocks: %ld (Max so far: %ld)\n",
2117 cfg_stats
.num_merged_labels
, max_num_merged_labels
);
2119 fprintf (file
, "\n");
2123 /* Dump CFG statistics on stderr. Keep extern so that it's always
2124 linked in the final executable. */
2127 debug_cfg_stats (void)
2129 dump_cfg_stats (stderr
);
2132 /*---------------------------------------------------------------------------
2133 Miscellaneous helpers
2134 ---------------------------------------------------------------------------*/
2136 /* Return true if T, a GIMPLE_CALL, can make an abnormal transfer of control
2137 flow. Transfers of control flow associated with EH are excluded. */
2140 call_can_make_abnormal_goto (gimple t
)
2142 /* If the function has no non-local labels, then a call cannot make an
2143 abnormal transfer of control. */
2144 if (!cfun
->has_nonlocal_label
2145 && !cfun
->calls_setjmp
)
2148 /* Likewise if the call has no side effects. */
2149 if (!gimple_has_side_effects (t
))
2152 /* Likewise if the called function is leaf. */
2153 if (gimple_call_flags (t
) & ECF_LEAF
)
2160 /* Return true if T can make an abnormal transfer of control flow.
2161 Transfers of control flow associated with EH are excluded. */
2164 stmt_can_make_abnormal_goto (gimple t
)
2166 if (computed_goto_p (t
))
2168 if (is_gimple_call (t
))
2169 return call_can_make_abnormal_goto (t
);
2174 /* Return true if T represents a stmt that always transfers control. */
2177 is_ctrl_stmt (gimple t
)
2179 switch (gimple_code (t
))
2193 /* Return true if T is a statement that may alter the flow of control
2194 (e.g., a call to a non-returning function). */
2197 is_ctrl_altering_stmt (gimple t
)
2201 switch (gimple_code (t
))
2205 int flags
= gimple_call_flags (t
);
2207 /* A call alters control flow if it can make an abnormal goto. */
2208 if (call_can_make_abnormal_goto (t
))
2211 /* A call also alters control flow if it does not return. */
2212 if (flags
& ECF_NORETURN
)
2215 /* TM ending statements have backedges out of the transaction.
2216 Return true so we split the basic block containing them.
2217 Note that the TM_BUILTIN test is merely an optimization. */
2218 if ((flags
& ECF_TM_BUILTIN
)
2219 && is_tm_ending_fndecl (gimple_call_fndecl (t
)))
2222 /* BUILT_IN_RETURN call is same as return statement. */
2223 if (gimple_call_builtin_p (t
, BUILT_IN_RETURN
))
2228 case GIMPLE_EH_DISPATCH
:
2229 /* EH_DISPATCH branches to the individual catch handlers at
2230 this level of a try or allowed-exceptions region. It can
2231 fallthru to the next statement as well. */
2235 if (gimple_asm_nlabels (t
) > 0)
2240 /* OpenMP directives alter control flow. */
2243 case GIMPLE_TRANSACTION
:
2244 /* A transaction start alters control flow. */
2251 /* If a statement can throw, it alters control flow. */
2252 return stmt_can_throw_internal (t
);
2256 /* Return true if T is a simple local goto. */
2259 simple_goto_p (gimple t
)
2261 return (gimple_code (t
) == GIMPLE_GOTO
2262 && TREE_CODE (gimple_goto_dest (t
)) == LABEL_DECL
);
2266 /* Return true if STMT should start a new basic block. PREV_STMT is
2267 the statement preceding STMT. It is used when STMT is a label or a
2268 case label. Labels should only start a new basic block if their
2269 previous statement wasn't a label. Otherwise, sequence of labels
2270 would generate unnecessary basic blocks that only contain a single
2274 stmt_starts_bb_p (gimple stmt
, gimple prev_stmt
)
2279 /* Labels start a new basic block only if the preceding statement
2280 wasn't a label of the same type. This prevents the creation of
2281 consecutive blocks that have nothing but a single label. */
2282 if (gimple_code (stmt
) == GIMPLE_LABEL
)
2284 /* Nonlocal and computed GOTO targets always start a new block. */
2285 if (DECL_NONLOCAL (gimple_label_label (stmt
))
2286 || FORCED_LABEL (gimple_label_label (stmt
)))
2289 if (prev_stmt
&& gimple_code (prev_stmt
) == GIMPLE_LABEL
)
2291 if (DECL_NONLOCAL (gimple_label_label (prev_stmt
)))
2294 cfg_stats
.num_merged_labels
++;
2300 else if (gimple_code (stmt
) == GIMPLE_CALL
2301 && gimple_call_flags (stmt
) & ECF_RETURNS_TWICE
)
2302 /* setjmp acts similar to a nonlocal GOTO target and thus should
2303 start a new block. */
2310 /* Return true if T should end a basic block. */
2313 stmt_ends_bb_p (gimple t
)
2315 return is_ctrl_stmt (t
) || is_ctrl_altering_stmt (t
);
2318 /* Remove block annotations and other data structures. */
2321 delete_tree_cfg_annotations (void)
2323 vec_free (label_to_block_map
);
2327 /* Return the first statement in basic block BB. */
2330 first_stmt (basic_block bb
)
2332 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2335 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2343 /* Return the first non-label statement in basic block BB. */
2346 first_non_label_stmt (basic_block bb
)
2348 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2349 while (!gsi_end_p (i
) && gimple_code (gsi_stmt (i
)) == GIMPLE_LABEL
)
2351 return !gsi_end_p (i
) ? gsi_stmt (i
) : NULL
;
2354 /* Return the last statement in basic block BB. */
2357 last_stmt (basic_block bb
)
2359 gimple_stmt_iterator i
= gsi_last_bb (bb
);
2362 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2370 /* Return the last statement of an otherwise empty block. Return NULL
2371 if the block is totally empty, or if it contains more than one
2375 last_and_only_stmt (basic_block bb
)
2377 gimple_stmt_iterator i
= gsi_last_nondebug_bb (bb
);
2383 last
= gsi_stmt (i
);
2384 gsi_prev_nondebug (&i
);
2388 /* Empty statements should no longer appear in the instruction stream.
2389 Everything that might have appeared before should be deleted by
2390 remove_useless_stmts, and the optimizers should just gsi_remove
2391 instead of smashing with build_empty_stmt.
2393 Thus the only thing that should appear here in a block containing
2394 one executable statement is a label. */
2395 prev
= gsi_stmt (i
);
2396 if (gimple_code (prev
) == GIMPLE_LABEL
)
2402 /* Reinstall those PHI arguments queued in OLD_EDGE to NEW_EDGE. */
2405 reinstall_phi_args (edge new_edge
, edge old_edge
)
2407 edge_var_map_vector
*v
;
2410 gimple_stmt_iterator phis
;
2412 v
= redirect_edge_var_map_vector (old_edge
);
2416 for (i
= 0, phis
= gsi_start_phis (new_edge
->dest
);
2417 v
->iterate (i
, &vm
) && !gsi_end_p (phis
);
2418 i
++, gsi_next (&phis
))
2420 gimple phi
= gsi_stmt (phis
);
2421 tree result
= redirect_edge_var_map_result (vm
);
2422 tree arg
= redirect_edge_var_map_def (vm
);
2424 gcc_assert (result
== gimple_phi_result (phi
));
2426 add_phi_arg (phi
, arg
, new_edge
, redirect_edge_var_map_location (vm
));
2429 redirect_edge_var_map_clear (old_edge
);
2432 /* Returns the basic block after which the new basic block created
2433 by splitting edge EDGE_IN should be placed. Tries to keep the new block
2434 near its "logical" location. This is of most help to humans looking
2435 at debugging dumps. */
2438 split_edge_bb_loc (edge edge_in
)
2440 basic_block dest
= edge_in
->dest
;
2441 basic_block dest_prev
= dest
->prev_bb
;
2445 edge e
= find_edge (dest_prev
, dest
);
2446 if (e
&& !(e
->flags
& EDGE_COMPLEX
))
2447 return edge_in
->src
;
2452 /* Split a (typically critical) edge EDGE_IN. Return the new block.
2453 Abort on abnormal edges. */
2456 gimple_split_edge (edge edge_in
)
2458 basic_block new_bb
, after_bb
, dest
;
2461 /* Abnormal edges cannot be split. */
2462 gcc_assert (!(edge_in
->flags
& EDGE_ABNORMAL
));
2464 dest
= edge_in
->dest
;
2466 after_bb
= split_edge_bb_loc (edge_in
);
2468 new_bb
= create_empty_bb (after_bb
);
2469 new_bb
->frequency
= EDGE_FREQUENCY (edge_in
);
2470 new_bb
->count
= edge_in
->count
;
2471 new_edge
= make_edge (new_bb
, dest
, EDGE_FALLTHRU
);
2472 new_edge
->probability
= REG_BR_PROB_BASE
;
2473 new_edge
->count
= edge_in
->count
;
2475 e
= redirect_edge_and_branch (edge_in
, new_bb
);
2476 gcc_assert (e
== edge_in
);
2477 reinstall_phi_args (new_edge
, e
);
2483 /* Verify properties of the address expression T with base object BASE. */
2486 verify_address (tree t
, tree base
)
2489 bool old_side_effects
;
2491 bool new_side_effects
;
2493 old_constant
= TREE_CONSTANT (t
);
2494 old_side_effects
= TREE_SIDE_EFFECTS (t
);
2496 recompute_tree_invariant_for_addr_expr (t
);
2497 new_side_effects
= TREE_SIDE_EFFECTS (t
);
2498 new_constant
= TREE_CONSTANT (t
);
2500 if (old_constant
!= new_constant
)
2502 error ("constant not recomputed when ADDR_EXPR changed");
2505 if (old_side_effects
!= new_side_effects
)
2507 error ("side effects not recomputed when ADDR_EXPR changed");
2511 if (!(TREE_CODE (base
) == VAR_DECL
2512 || TREE_CODE (base
) == PARM_DECL
2513 || TREE_CODE (base
) == RESULT_DECL
))
2516 if (DECL_GIMPLE_REG_P (base
))
2518 error ("DECL_GIMPLE_REG_P set on a variable with address taken");
2525 /* Callback for walk_tree, check that all elements with address taken are
2526 properly noticed as such. The DATA is an int* that is 1 if TP was seen
2527 inside a PHI node. */
2530 verify_expr (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
2537 /* Check operand N for being valid GIMPLE and give error MSG if not. */
2538 #define CHECK_OP(N, MSG) \
2539 do { if (!is_gimple_val (TREE_OPERAND (t, N))) \
2540 { error (MSG); return TREE_OPERAND (t, N); }} while (0)
2542 switch (TREE_CODE (t
))
2545 if (SSA_NAME_IN_FREE_LIST (t
))
2547 error ("SSA name in freelist but still referenced");
2553 error ("INDIRECT_REF in gimple IL");
2557 x
= TREE_OPERAND (t
, 0);
2558 if (!POINTER_TYPE_P (TREE_TYPE (x
))
2559 || !is_gimple_mem_ref_addr (x
))
2561 error ("invalid first operand of MEM_REF");
2564 if (TREE_CODE (TREE_OPERAND (t
, 1)) != INTEGER_CST
2565 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 1))))
2567 error ("invalid offset operand of MEM_REF");
2568 return TREE_OPERAND (t
, 1);
2570 if (TREE_CODE (x
) == ADDR_EXPR
2571 && (x
= verify_address (x
, TREE_OPERAND (x
, 0))))
2577 x
= fold (ASSERT_EXPR_COND (t
));
2578 if (x
== boolean_false_node
)
2580 error ("ASSERT_EXPR with an always-false condition");
2586 error ("MODIFY_EXPR not expected while having tuples");
2593 gcc_assert (is_gimple_address (t
));
2595 /* Skip any references (they will be checked when we recurse down the
2596 tree) and ensure that any variable used as a prefix is marked
2598 for (x
= TREE_OPERAND (t
, 0);
2599 handled_component_p (x
);
2600 x
= TREE_OPERAND (x
, 0))
2603 if ((tem
= verify_address (t
, x
)))
2606 if (!(TREE_CODE (x
) == VAR_DECL
2607 || TREE_CODE (x
) == PARM_DECL
2608 || TREE_CODE (x
) == RESULT_DECL
))
2611 if (!TREE_ADDRESSABLE (x
))
2613 error ("address taken, but ADDRESSABLE bit not set");
2621 x
= COND_EXPR_COND (t
);
2622 if (!INTEGRAL_TYPE_P (TREE_TYPE (x
)))
2624 error ("non-integral used in condition");
2627 if (!is_gimple_condexpr (x
))
2629 error ("invalid conditional operand");
2634 case NON_LVALUE_EXPR
:
2635 case TRUTH_NOT_EXPR
:
2639 case FIX_TRUNC_EXPR
:
2644 CHECK_OP (0, "invalid operand to unary operator");
2650 if (!is_gimple_reg_type (TREE_TYPE (t
)))
2652 error ("non-scalar BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR");
2656 if (TREE_CODE (t
) == BIT_FIELD_REF
)
2658 if (!host_integerp (TREE_OPERAND (t
, 1), 1)
2659 || !host_integerp (TREE_OPERAND (t
, 2), 1))
2661 error ("invalid position or size operand to BIT_FIELD_REF");
2664 if (INTEGRAL_TYPE_P (TREE_TYPE (t
))
2665 && (TYPE_PRECISION (TREE_TYPE (t
))
2666 != TREE_INT_CST_LOW (TREE_OPERAND (t
, 1))))
2668 error ("integral result type precision does not match "
2669 "field size of BIT_FIELD_REF");
2672 else if (!INTEGRAL_TYPE_P (TREE_TYPE (t
))
2673 && TYPE_MODE (TREE_TYPE (t
)) != BLKmode
2674 && (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (t
)))
2675 != TREE_INT_CST_LOW (TREE_OPERAND (t
, 1))))
2677 error ("mode precision of non-integral result does not "
2678 "match field size of BIT_FIELD_REF");
2682 t
= TREE_OPERAND (t
, 0);
2687 case ARRAY_RANGE_REF
:
2688 case VIEW_CONVERT_EXPR
:
2689 /* We have a nest of references. Verify that each of the operands
2690 that determine where to reference is either a constant or a variable,
2691 verify that the base is valid, and then show we've already checked
2693 while (handled_component_p (t
))
2695 if (TREE_CODE (t
) == COMPONENT_REF
&& TREE_OPERAND (t
, 2))
2696 CHECK_OP (2, "invalid COMPONENT_REF offset operator");
2697 else if (TREE_CODE (t
) == ARRAY_REF
2698 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
2700 CHECK_OP (1, "invalid array index");
2701 if (TREE_OPERAND (t
, 2))
2702 CHECK_OP (2, "invalid array lower bound");
2703 if (TREE_OPERAND (t
, 3))
2704 CHECK_OP (3, "invalid array stride");
2706 else if (TREE_CODE (t
) == BIT_FIELD_REF
2707 || TREE_CODE (t
) == REALPART_EXPR
2708 || TREE_CODE (t
) == IMAGPART_EXPR
)
2710 error ("non-top-level BIT_FIELD_REF, IMAGPART_EXPR or "
2715 t
= TREE_OPERAND (t
, 0);
2718 if (!is_gimple_min_invariant (t
) && !is_gimple_lvalue (t
))
2720 error ("invalid reference prefix");
2727 /* PLUS_EXPR and MINUS_EXPR don't work on pointers, they should be done using
2728 POINTER_PLUS_EXPR. */
2729 if (POINTER_TYPE_P (TREE_TYPE (t
)))
2731 error ("invalid operand to plus/minus, type is a pointer");
2734 CHECK_OP (0, "invalid operand to binary operator");
2735 CHECK_OP (1, "invalid operand to binary operator");
2738 case POINTER_PLUS_EXPR
:
2739 /* Check to make sure the first operand is a pointer or reference type. */
2740 if (!POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 0))))
2742 error ("invalid operand to pointer plus, first operand is not a pointer");
2745 /* Check to make sure the second operand is a ptrofftype. */
2746 if (!ptrofftype_p (TREE_TYPE (TREE_OPERAND (t
, 1))))
2748 error ("invalid operand to pointer plus, second operand is not an "
2749 "integer type of appropriate width");
2759 case UNORDERED_EXPR
:
2768 case TRUNC_DIV_EXPR
:
2770 case FLOOR_DIV_EXPR
:
2771 case ROUND_DIV_EXPR
:
2772 case TRUNC_MOD_EXPR
:
2774 case FLOOR_MOD_EXPR
:
2775 case ROUND_MOD_EXPR
:
2777 case EXACT_DIV_EXPR
:
2787 CHECK_OP (0, "invalid operand to binary operator");
2788 CHECK_OP (1, "invalid operand to binary operator");
2792 if (TREE_CONSTANT (t
) && TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
2796 case CASE_LABEL_EXPR
:
2799 error ("invalid CASE_CHAIN");
2813 /* Verify if EXPR is either a GIMPLE ID or a GIMPLE indirect reference.
2814 Returns true if there is an error, otherwise false. */
2817 verify_types_in_gimple_min_lval (tree expr
)
2821 if (is_gimple_id (expr
))
2824 if (TREE_CODE (expr
) != TARGET_MEM_REF
2825 && TREE_CODE (expr
) != MEM_REF
)
2827 error ("invalid expression for min lvalue");
2831 /* TARGET_MEM_REFs are strange beasts. */
2832 if (TREE_CODE (expr
) == TARGET_MEM_REF
)
2835 op
= TREE_OPERAND (expr
, 0);
2836 if (!is_gimple_val (op
))
2838 error ("invalid operand in indirect reference");
2839 debug_generic_stmt (op
);
2842 /* Memory references now generally can involve a value conversion. */
2847 /* Verify if EXPR is a valid GIMPLE reference expression. If
2848 REQUIRE_LVALUE is true verifies it is an lvalue. Returns true
2849 if there is an error, otherwise false. */
2852 verify_types_in_gimple_reference (tree expr
, bool require_lvalue
)
2854 while (handled_component_p (expr
))
2856 tree op
= TREE_OPERAND (expr
, 0);
2858 if (TREE_CODE (expr
) == ARRAY_REF
2859 || TREE_CODE (expr
) == ARRAY_RANGE_REF
)
2861 if (!is_gimple_val (TREE_OPERAND (expr
, 1))
2862 || (TREE_OPERAND (expr
, 2)
2863 && !is_gimple_val (TREE_OPERAND (expr
, 2)))
2864 || (TREE_OPERAND (expr
, 3)
2865 && !is_gimple_val (TREE_OPERAND (expr
, 3))))
2867 error ("invalid operands to array reference");
2868 debug_generic_stmt (expr
);
2873 /* Verify if the reference array element types are compatible. */
2874 if (TREE_CODE (expr
) == ARRAY_REF
2875 && !useless_type_conversion_p (TREE_TYPE (expr
),
2876 TREE_TYPE (TREE_TYPE (op
))))
2878 error ("type mismatch in array reference");
2879 debug_generic_stmt (TREE_TYPE (expr
));
2880 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
2883 if (TREE_CODE (expr
) == ARRAY_RANGE_REF
2884 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr
)),
2885 TREE_TYPE (TREE_TYPE (op
))))
2887 error ("type mismatch in array range reference");
2888 debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr
)));
2889 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
2893 if ((TREE_CODE (expr
) == REALPART_EXPR
2894 || TREE_CODE (expr
) == IMAGPART_EXPR
)
2895 && !useless_type_conversion_p (TREE_TYPE (expr
),
2896 TREE_TYPE (TREE_TYPE (op
))))
2898 error ("type mismatch in real/imagpart reference");
2899 debug_generic_stmt (TREE_TYPE (expr
));
2900 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
2904 if (TREE_CODE (expr
) == COMPONENT_REF
2905 && !useless_type_conversion_p (TREE_TYPE (expr
),
2906 TREE_TYPE (TREE_OPERAND (expr
, 1))))
2908 error ("type mismatch in component reference");
2909 debug_generic_stmt (TREE_TYPE (expr
));
2910 debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr
, 1)));
2914 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
)
2916 /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
2917 that their operand is not an SSA name or an invariant when
2918 requiring an lvalue (this usually means there is a SRA or IPA-SRA
2919 bug). Otherwise there is nothing to verify, gross mismatches at
2920 most invoke undefined behavior. */
2922 && (TREE_CODE (op
) == SSA_NAME
2923 || is_gimple_min_invariant (op
)))
2925 error ("conversion of an SSA_NAME on the left hand side");
2926 debug_generic_stmt (expr
);
2929 else if (TREE_CODE (op
) == SSA_NAME
2930 && TYPE_SIZE (TREE_TYPE (expr
)) != TYPE_SIZE (TREE_TYPE (op
)))
2932 error ("conversion of register to a different size");
2933 debug_generic_stmt (expr
);
2936 else if (!handled_component_p (op
))
2943 if (TREE_CODE (expr
) == MEM_REF
)
2945 if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr
, 0)))
2947 error ("invalid address operand in MEM_REF");
2948 debug_generic_stmt (expr
);
2951 if (TREE_CODE (TREE_OPERAND (expr
, 1)) != INTEGER_CST
2952 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr
, 1))))
2954 error ("invalid offset operand in MEM_REF");
2955 debug_generic_stmt (expr
);
2959 else if (TREE_CODE (expr
) == TARGET_MEM_REF
)
2961 if (!TMR_BASE (expr
)
2962 || !is_gimple_mem_ref_addr (TMR_BASE (expr
)))
2964 error ("invalid address operand in TARGET_MEM_REF");
2967 if (!TMR_OFFSET (expr
)
2968 || TREE_CODE (TMR_OFFSET (expr
)) != INTEGER_CST
2969 || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr
))))
2971 error ("invalid offset operand in TARGET_MEM_REF");
2972 debug_generic_stmt (expr
);
2977 return ((require_lvalue
|| !is_gimple_min_invariant (expr
))
2978 && verify_types_in_gimple_min_lval (expr
));
2981 /* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
2982 list of pointer-to types that is trivially convertible to DEST. */
2985 one_pointer_to_useless_type_conversion_p (tree dest
, tree src_obj
)
2989 if (!TYPE_POINTER_TO (src_obj
))
2992 for (src
= TYPE_POINTER_TO (src_obj
); src
; src
= TYPE_NEXT_PTR_TO (src
))
2993 if (useless_type_conversion_p (dest
, src
))
2999 /* Return true if TYPE1 is a fixed-point type and if conversions to and
3000 from TYPE2 can be handled by FIXED_CONVERT_EXPR. */
3003 valid_fixed_convert_types_p (tree type1
, tree type2
)
3005 return (FIXED_POINT_TYPE_P (type1
)
3006 && (INTEGRAL_TYPE_P (type2
)
3007 || SCALAR_FLOAT_TYPE_P (type2
)
3008 || FIXED_POINT_TYPE_P (type2
)));
3011 /* Verify the contents of a GIMPLE_CALL STMT. Returns true when there
3012 is a problem, otherwise false. */
3015 verify_gimple_call (gimple stmt
)
3017 tree fn
= gimple_call_fn (stmt
);
3018 tree fntype
, fndecl
;
3021 if (gimple_call_internal_p (stmt
))
3025 error ("gimple call has two targets");
3026 debug_generic_stmt (fn
);
3034 error ("gimple call has no target");
3039 if (fn
&& !is_gimple_call_addr (fn
))
3041 error ("invalid function in gimple call");
3042 debug_generic_stmt (fn
);
3047 && (!POINTER_TYPE_P (TREE_TYPE (fn
))
3048 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != FUNCTION_TYPE
3049 && TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != METHOD_TYPE
)))
3051 error ("non-function in gimple call");
3055 fndecl
= gimple_call_fndecl (stmt
);
3057 && TREE_CODE (fndecl
) == FUNCTION_DECL
3058 && DECL_LOOPING_CONST_OR_PURE_P (fndecl
)
3059 && !DECL_PURE_P (fndecl
)
3060 && !TREE_READONLY (fndecl
))
3062 error ("invalid pure const state for function");
3066 if (gimple_call_lhs (stmt
)
3067 && (!is_gimple_lvalue (gimple_call_lhs (stmt
))
3068 || verify_types_in_gimple_reference (gimple_call_lhs (stmt
), true)))
3070 error ("invalid LHS in gimple call");
3074 if (gimple_call_lhs (stmt
) && gimple_call_noreturn_p (stmt
))
3076 error ("LHS in noreturn call");
3080 fntype
= gimple_call_fntype (stmt
);
3082 && gimple_call_lhs (stmt
)
3083 && !useless_type_conversion_p (TREE_TYPE (gimple_call_lhs (stmt
)),
3085 /* ??? At least C++ misses conversions at assignments from
3086 void * call results.
3087 ??? Java is completely off. Especially with functions
3088 returning java.lang.Object.
3089 For now simply allow arbitrary pointer type conversions. */
3090 && !(POINTER_TYPE_P (TREE_TYPE (gimple_call_lhs (stmt
)))
3091 && POINTER_TYPE_P (TREE_TYPE (fntype
))))
3093 error ("invalid conversion in gimple call");
3094 debug_generic_stmt (TREE_TYPE (gimple_call_lhs (stmt
)));
3095 debug_generic_stmt (TREE_TYPE (fntype
));
3099 if (gimple_call_chain (stmt
)
3100 && !is_gimple_val (gimple_call_chain (stmt
)))
3102 error ("invalid static chain in gimple call");
3103 debug_generic_stmt (gimple_call_chain (stmt
));
3107 /* If there is a static chain argument, this should not be an indirect
3108 call, and the decl should have DECL_STATIC_CHAIN set. */
3109 if (gimple_call_chain (stmt
))
3111 if (!gimple_call_fndecl (stmt
))
3113 error ("static chain in indirect gimple call");
3116 fn
= TREE_OPERAND (fn
, 0);
3118 if (!DECL_STATIC_CHAIN (fn
))
3120 error ("static chain with function that doesn%'t use one");
3125 /* ??? The C frontend passes unpromoted arguments in case it
3126 didn't see a function declaration before the call. So for now
3127 leave the call arguments mostly unverified. Once we gimplify
3128 unit-at-a-time we have a chance to fix this. */
3130 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
3132 tree arg
= gimple_call_arg (stmt
, i
);
3133 if ((is_gimple_reg_type (TREE_TYPE (arg
))
3134 && !is_gimple_val (arg
))
3135 || (!is_gimple_reg_type (TREE_TYPE (arg
))
3136 && !is_gimple_lvalue (arg
)))
3138 error ("invalid argument to gimple call");
3139 debug_generic_expr (arg
);
3147 /* Verifies the gimple comparison with the result type TYPE and
3148 the operands OP0 and OP1. */
3151 verify_gimple_comparison (tree type
, tree op0
, tree op1
)
3153 tree op0_type
= TREE_TYPE (op0
);
3154 tree op1_type
= TREE_TYPE (op1
);
3156 if (!is_gimple_val (op0
) || !is_gimple_val (op1
))
3158 error ("invalid operands in gimple comparison");
3162 /* For comparisons we do not have the operations type as the
3163 effective type the comparison is carried out in. Instead
3164 we require that either the first operand is trivially
3165 convertible into the second, or the other way around.
3166 Because we special-case pointers to void we allow
3167 comparisons of pointers with the same mode as well. */
3168 if (!useless_type_conversion_p (op0_type
, op1_type
)
3169 && !useless_type_conversion_p (op1_type
, op0_type
)
3170 && (!POINTER_TYPE_P (op0_type
)
3171 || !POINTER_TYPE_P (op1_type
)
3172 || TYPE_MODE (op0_type
) != TYPE_MODE (op1_type
)))
3174 error ("mismatching comparison operand types");
3175 debug_generic_expr (op0_type
);
3176 debug_generic_expr (op1_type
);
3180 /* The resulting type of a comparison may be an effective boolean type. */
3181 if (INTEGRAL_TYPE_P (type
)
3182 && (TREE_CODE (type
) == BOOLEAN_TYPE
3183 || TYPE_PRECISION (type
) == 1))
3185 if (TREE_CODE (op0_type
) == VECTOR_TYPE
3186 || TREE_CODE (op1_type
) == VECTOR_TYPE
)
3188 error ("vector comparison returning a boolean");
3189 debug_generic_expr (op0_type
);
3190 debug_generic_expr (op1_type
);
3194 /* Or an integer vector type with the same size and element count
3195 as the comparison operand types. */
3196 else if (TREE_CODE (type
) == VECTOR_TYPE
3197 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
3199 if (TREE_CODE (op0_type
) != VECTOR_TYPE
3200 || TREE_CODE (op1_type
) != VECTOR_TYPE
)
3202 error ("non-vector operands in vector comparison");
3203 debug_generic_expr (op0_type
);
3204 debug_generic_expr (op1_type
);
3208 if (TYPE_VECTOR_SUBPARTS (type
) != TYPE_VECTOR_SUBPARTS (op0_type
)
3209 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (type
)))
3210 != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0_type
))))
3211 /* The result of a vector comparison is of signed
3213 || TYPE_UNSIGNED (TREE_TYPE (type
)))
3215 error ("invalid vector comparison resulting type");
3216 debug_generic_expr (type
);
3222 error ("bogus comparison result type");
3223 debug_generic_expr (type
);
3230 /* Verify a gimple assignment statement STMT with an unary rhs.
3231 Returns true if anything is wrong. */
3234 verify_gimple_assign_unary (gimple stmt
)
3236 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3237 tree lhs
= gimple_assign_lhs (stmt
);
3238 tree lhs_type
= TREE_TYPE (lhs
);
3239 tree rhs1
= gimple_assign_rhs1 (stmt
);
3240 tree rhs1_type
= TREE_TYPE (rhs1
);
3242 if (!is_gimple_reg (lhs
))
3244 error ("non-register as LHS of unary operation");
3248 if (!is_gimple_val (rhs1
))
3250 error ("invalid operand in unary operation");
3254 /* First handle conversions. */
3259 /* Allow conversions from pointer type to integral type only if
3260 there is no sign or zero extension involved.
3261 For targets were the precision of ptrofftype doesn't match that
3262 of pointers we need to allow arbitrary conversions to ptrofftype. */
3263 if ((POINTER_TYPE_P (lhs_type
)
3264 && INTEGRAL_TYPE_P (rhs1_type
))
3265 || (POINTER_TYPE_P (rhs1_type
)
3266 && INTEGRAL_TYPE_P (lhs_type
)
3267 && (TYPE_PRECISION (rhs1_type
) >= TYPE_PRECISION (lhs_type
)
3268 || ptrofftype_p (sizetype
))))
3271 /* Allow conversion from integral to offset type and vice versa. */
3272 if ((TREE_CODE (lhs_type
) == OFFSET_TYPE
3273 && INTEGRAL_TYPE_P (rhs1_type
))
3274 || (INTEGRAL_TYPE_P (lhs_type
)
3275 && TREE_CODE (rhs1_type
) == OFFSET_TYPE
))
3278 /* Otherwise assert we are converting between types of the
3280 if (INTEGRAL_TYPE_P (lhs_type
) != INTEGRAL_TYPE_P (rhs1_type
))
3282 error ("invalid types in nop conversion");
3283 debug_generic_expr (lhs_type
);
3284 debug_generic_expr (rhs1_type
);
3291 case ADDR_SPACE_CONVERT_EXPR
:
3293 if (!POINTER_TYPE_P (rhs1_type
) || !POINTER_TYPE_P (lhs_type
)
3294 || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type
))
3295 == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type
))))
3297 error ("invalid types in address space conversion");
3298 debug_generic_expr (lhs_type
);
3299 debug_generic_expr (rhs1_type
);
3306 case FIXED_CONVERT_EXPR
:
3308 if (!valid_fixed_convert_types_p (lhs_type
, rhs1_type
)
3309 && !valid_fixed_convert_types_p (rhs1_type
, lhs_type
))
3311 error ("invalid types in fixed-point conversion");
3312 debug_generic_expr (lhs_type
);
3313 debug_generic_expr (rhs1_type
);
3322 if ((!INTEGRAL_TYPE_P (rhs1_type
) || !SCALAR_FLOAT_TYPE_P (lhs_type
))
3323 && (!VECTOR_INTEGER_TYPE_P (rhs1_type
)
3324 || !VECTOR_FLOAT_TYPE_P (lhs_type
)))
3326 error ("invalid types in conversion to floating point");
3327 debug_generic_expr (lhs_type
);
3328 debug_generic_expr (rhs1_type
);
3335 case FIX_TRUNC_EXPR
:
3337 if ((!INTEGRAL_TYPE_P (lhs_type
) || !SCALAR_FLOAT_TYPE_P (rhs1_type
))
3338 && (!VECTOR_INTEGER_TYPE_P (lhs_type
)
3339 || !VECTOR_FLOAT_TYPE_P (rhs1_type
)))
3341 error ("invalid types in conversion to integer");
3342 debug_generic_expr (lhs_type
);
3343 debug_generic_expr (rhs1_type
);
3350 case VEC_UNPACK_HI_EXPR
:
3351 case VEC_UNPACK_LO_EXPR
:
3352 case REDUC_MAX_EXPR
:
3353 case REDUC_MIN_EXPR
:
3354 case REDUC_PLUS_EXPR
:
3355 case VEC_UNPACK_FLOAT_HI_EXPR
:
3356 case VEC_UNPACK_FLOAT_LO_EXPR
:
3364 case NON_LVALUE_EXPR
:
3372 /* For the remaining codes assert there is no conversion involved. */
3373 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3375 error ("non-trivial conversion in unary operation");
3376 debug_generic_expr (lhs_type
);
3377 debug_generic_expr (rhs1_type
);
3384 /* Verify a gimple assignment statement STMT with a binary rhs.
3385 Returns true if anything is wrong. */
3388 verify_gimple_assign_binary (gimple stmt
)
3390 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3391 tree lhs
= gimple_assign_lhs (stmt
);
3392 tree lhs_type
= TREE_TYPE (lhs
);
3393 tree rhs1
= gimple_assign_rhs1 (stmt
);
3394 tree rhs1_type
= TREE_TYPE (rhs1
);
3395 tree rhs2
= gimple_assign_rhs2 (stmt
);
3396 tree rhs2_type
= TREE_TYPE (rhs2
);
3398 if (!is_gimple_reg (lhs
))
3400 error ("non-register as LHS of binary operation");
3404 if (!is_gimple_val (rhs1
)
3405 || !is_gimple_val (rhs2
))
3407 error ("invalid operands in binary operation");
3411 /* First handle operations that involve different types. */
3416 if (TREE_CODE (lhs_type
) != COMPLEX_TYPE
3417 || !(INTEGRAL_TYPE_P (rhs1_type
)
3418 || SCALAR_FLOAT_TYPE_P (rhs1_type
))
3419 || !(INTEGRAL_TYPE_P (rhs2_type
)
3420 || SCALAR_FLOAT_TYPE_P (rhs2_type
)))
3422 error ("type mismatch in complex expression");
3423 debug_generic_expr (lhs_type
);
3424 debug_generic_expr (rhs1_type
);
3425 debug_generic_expr (rhs2_type
);
3437 /* Shifts and rotates are ok on integral types, fixed point
3438 types and integer vector types. */
3439 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3440 && !FIXED_POINT_TYPE_P (rhs1_type
)
3441 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3442 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))))
3443 || (!INTEGRAL_TYPE_P (rhs2_type
)
3444 /* Vector shifts of vectors are also ok. */
3445 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3446 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3447 && TREE_CODE (rhs2_type
) == VECTOR_TYPE
3448 && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3449 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3451 error ("type mismatch in shift expression");
3452 debug_generic_expr (lhs_type
);
3453 debug_generic_expr (rhs1_type
);
3454 debug_generic_expr (rhs2_type
);
3461 case VEC_LSHIFT_EXPR
:
3462 case VEC_RSHIFT_EXPR
:
3464 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3465 || !(INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3466 || POINTER_TYPE_P (TREE_TYPE (rhs1_type
))
3467 || FIXED_POINT_TYPE_P (TREE_TYPE (rhs1_type
))
3468 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
)))
3469 || (!INTEGRAL_TYPE_P (rhs2_type
)
3470 && (TREE_CODE (rhs2_type
) != VECTOR_TYPE
3471 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3472 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3474 error ("type mismatch in vector shift expression");
3475 debug_generic_expr (lhs_type
);
3476 debug_generic_expr (rhs1_type
);
3477 debug_generic_expr (rhs2_type
);
3480 /* For shifting a vector of non-integral components we
3481 only allow shifting by a constant multiple of the element size. */
3482 if (!INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3483 && (TREE_CODE (rhs2
) != INTEGER_CST
3484 || !div_if_zero_remainder (EXACT_DIV_EXPR
, rhs2
,
3485 TYPE_SIZE (TREE_TYPE (rhs1_type
)))))
3487 error ("non-element sized vector shift of floating point vector");
3494 case WIDEN_LSHIFT_EXPR
:
3496 if (!INTEGRAL_TYPE_P (lhs_type
)
3497 || !INTEGRAL_TYPE_P (rhs1_type
)
3498 || TREE_CODE (rhs2
) != INTEGER_CST
3499 || (2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)))
3501 error ("type mismatch in widening vector shift expression");
3502 debug_generic_expr (lhs_type
);
3503 debug_generic_expr (rhs1_type
);
3504 debug_generic_expr (rhs2_type
);
3511 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3512 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3514 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3515 || TREE_CODE (lhs_type
) != VECTOR_TYPE
3516 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3517 || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3518 || TREE_CODE (rhs2
) != INTEGER_CST
3519 || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type
))
3520 > TYPE_PRECISION (TREE_TYPE (lhs_type
))))
3522 error ("type mismatch in widening vector shift expression");
3523 debug_generic_expr (lhs_type
);
3524 debug_generic_expr (rhs1_type
);
3525 debug_generic_expr (rhs2_type
);
3535 tree lhs_etype
= lhs_type
;
3536 tree rhs1_etype
= rhs1_type
;
3537 tree rhs2_etype
= rhs2_type
;
3538 if (TREE_CODE (lhs_type
) == VECTOR_TYPE
)
3540 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3541 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
)
3543 error ("invalid non-vector operands to vector valued plus");
3546 lhs_etype
= TREE_TYPE (lhs_type
);
3547 rhs1_etype
= TREE_TYPE (rhs1_type
);
3548 rhs2_etype
= TREE_TYPE (rhs2_type
);
3550 if (POINTER_TYPE_P (lhs_etype
)
3551 || POINTER_TYPE_P (rhs1_etype
)
3552 || POINTER_TYPE_P (rhs2_etype
))
3554 error ("invalid (pointer) operands to plus/minus");
3558 /* Continue with generic binary expression handling. */
3562 case POINTER_PLUS_EXPR
:
3564 if (!POINTER_TYPE_P (rhs1_type
)
3565 || !useless_type_conversion_p (lhs_type
, rhs1_type
)
3566 || !ptrofftype_p (rhs2_type
))
3568 error ("type mismatch in pointer plus expression");
3569 debug_generic_stmt (lhs_type
);
3570 debug_generic_stmt (rhs1_type
);
3571 debug_generic_stmt (rhs2_type
);
3578 case TRUTH_ANDIF_EXPR
:
3579 case TRUTH_ORIF_EXPR
:
3580 case TRUTH_AND_EXPR
:
3582 case TRUTH_XOR_EXPR
:
3592 case UNORDERED_EXPR
:
3600 /* Comparisons are also binary, but the result type is not
3601 connected to the operand types. */
3602 return verify_gimple_comparison (lhs_type
, rhs1
, rhs2
);
3604 case WIDEN_MULT_EXPR
:
3605 if (TREE_CODE (lhs_type
) != INTEGER_TYPE
)
3607 return ((2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
))
3608 || (TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
)));
3610 case WIDEN_SUM_EXPR
:
3611 case VEC_WIDEN_MULT_HI_EXPR
:
3612 case VEC_WIDEN_MULT_LO_EXPR
:
3613 case VEC_WIDEN_MULT_EVEN_EXPR
:
3614 case VEC_WIDEN_MULT_ODD_EXPR
:
3615 case VEC_PACK_TRUNC_EXPR
:
3616 case VEC_PACK_SAT_EXPR
:
3617 case VEC_PACK_FIX_TRUNC_EXPR
:
3622 case MULT_HIGHPART_EXPR
:
3623 case TRUNC_DIV_EXPR
:
3625 case FLOOR_DIV_EXPR
:
3626 case ROUND_DIV_EXPR
:
3627 case TRUNC_MOD_EXPR
:
3629 case FLOOR_MOD_EXPR
:
3630 case ROUND_MOD_EXPR
:
3632 case EXACT_DIV_EXPR
:
3638 /* Continue with generic binary expression handling. */
3645 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3646 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
3648 error ("type mismatch in binary expression");
3649 debug_generic_stmt (lhs_type
);
3650 debug_generic_stmt (rhs1_type
);
3651 debug_generic_stmt (rhs2_type
);
3658 /* Verify a gimple assignment statement STMT with a ternary rhs.
3659 Returns true if anything is wrong. */
3662 verify_gimple_assign_ternary (gimple stmt
)
3664 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3665 tree lhs
= gimple_assign_lhs (stmt
);
3666 tree lhs_type
= TREE_TYPE (lhs
);
3667 tree rhs1
= gimple_assign_rhs1 (stmt
);
3668 tree rhs1_type
= TREE_TYPE (rhs1
);
3669 tree rhs2
= gimple_assign_rhs2 (stmt
);
3670 tree rhs2_type
= TREE_TYPE (rhs2
);
3671 tree rhs3
= gimple_assign_rhs3 (stmt
);
3672 tree rhs3_type
= TREE_TYPE (rhs3
);
3674 if (!is_gimple_reg (lhs
))
3676 error ("non-register as LHS of ternary operation");
3680 if (((rhs_code
== VEC_COND_EXPR
|| rhs_code
== COND_EXPR
)
3681 ? !is_gimple_condexpr (rhs1
) : !is_gimple_val (rhs1
))
3682 || !is_gimple_val (rhs2
)
3683 || !is_gimple_val (rhs3
))
3685 error ("invalid operands in ternary operation");
3689 /* First handle operations that involve different types. */
3692 case WIDEN_MULT_PLUS_EXPR
:
3693 case WIDEN_MULT_MINUS_EXPR
:
3694 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3695 && !FIXED_POINT_TYPE_P (rhs1_type
))
3696 || !useless_type_conversion_p (rhs1_type
, rhs2_type
)
3697 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
3698 || 2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)
3699 || TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
))
3701 error ("type mismatch in widening multiply-accumulate expression");
3702 debug_generic_expr (lhs_type
);
3703 debug_generic_expr (rhs1_type
);
3704 debug_generic_expr (rhs2_type
);
3705 debug_generic_expr (rhs3_type
);
3711 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3712 || !useless_type_conversion_p (lhs_type
, rhs2_type
)
3713 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
3715 error ("type mismatch in fused multiply-add expression");
3716 debug_generic_expr (lhs_type
);
3717 debug_generic_expr (rhs1_type
);
3718 debug_generic_expr (rhs2_type
);
3719 debug_generic_expr (rhs3_type
);
3726 if (!useless_type_conversion_p (lhs_type
, rhs2_type
)
3727 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
3729 error ("type mismatch in conditional expression");
3730 debug_generic_expr (lhs_type
);
3731 debug_generic_expr (rhs2_type
);
3732 debug_generic_expr (rhs3_type
);
3738 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3739 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
3741 error ("type mismatch in vector permute expression");
3742 debug_generic_expr (lhs_type
);
3743 debug_generic_expr (rhs1_type
);
3744 debug_generic_expr (rhs2_type
);
3745 debug_generic_expr (rhs3_type
);
3749 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3750 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
3751 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
3753 error ("vector types expected in vector permute expression");
3754 debug_generic_expr (lhs_type
);
3755 debug_generic_expr (rhs1_type
);
3756 debug_generic_expr (rhs2_type
);
3757 debug_generic_expr (rhs3_type
);
3761 if (TYPE_VECTOR_SUBPARTS (rhs1_type
) != TYPE_VECTOR_SUBPARTS (rhs2_type
)
3762 || TYPE_VECTOR_SUBPARTS (rhs2_type
)
3763 != TYPE_VECTOR_SUBPARTS (rhs3_type
)
3764 || TYPE_VECTOR_SUBPARTS (rhs3_type
)
3765 != TYPE_VECTOR_SUBPARTS (lhs_type
))
3767 error ("vectors with different element number found "
3768 "in vector permute expression");
3769 debug_generic_expr (lhs_type
);
3770 debug_generic_expr (rhs1_type
);
3771 debug_generic_expr (rhs2_type
);
3772 debug_generic_expr (rhs3_type
);
3776 if (TREE_CODE (TREE_TYPE (rhs3_type
)) != INTEGER_TYPE
3777 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs3_type
)))
3778 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type
))))
3780 error ("invalid mask type in vector permute expression");
3781 debug_generic_expr (lhs_type
);
3782 debug_generic_expr (rhs1_type
);
3783 debug_generic_expr (rhs2_type
);
3784 debug_generic_expr (rhs3_type
);
3791 case REALIGN_LOAD_EXPR
:
3801 /* Verify a gimple assignment statement STMT with a single rhs.
3802 Returns true if anything is wrong. */
3805 verify_gimple_assign_single (gimple stmt
)
3807 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3808 tree lhs
= gimple_assign_lhs (stmt
);
3809 tree lhs_type
= TREE_TYPE (lhs
);
3810 tree rhs1
= gimple_assign_rhs1 (stmt
);
3811 tree rhs1_type
= TREE_TYPE (rhs1
);
3814 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3816 error ("non-trivial conversion at assignment");
3817 debug_generic_expr (lhs_type
);
3818 debug_generic_expr (rhs1_type
);
3822 if (gimple_clobber_p (stmt
)
3823 && !(DECL_P (lhs
) || TREE_CODE (lhs
) == MEM_REF
))
3825 error ("non-decl/MEM_REF LHS in clobber statement");
3826 debug_generic_expr (lhs
);
3830 if (handled_component_p (lhs
))
3831 res
|= verify_types_in_gimple_reference (lhs
, true);
3833 /* Special codes we cannot handle via their class. */
3838 tree op
= TREE_OPERAND (rhs1
, 0);
3839 if (!is_gimple_addressable (op
))
3841 error ("invalid operand in unary expression");
3845 /* Technically there is no longer a need for matching types, but
3846 gimple hygiene asks for this check. In LTO we can end up
3847 combining incompatible units and thus end up with addresses
3848 of globals that change their type to a common one. */
3850 && !types_compatible_p (TREE_TYPE (op
),
3851 TREE_TYPE (TREE_TYPE (rhs1
)))
3852 && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1
),
3855 error ("type mismatch in address expression");
3856 debug_generic_stmt (TREE_TYPE (rhs1
));
3857 debug_generic_stmt (TREE_TYPE (op
));
3861 return verify_types_in_gimple_reference (op
, true);
3866 error ("INDIRECT_REF in gimple IL");
3872 case ARRAY_RANGE_REF
:
3873 case VIEW_CONVERT_EXPR
:
3876 case TARGET_MEM_REF
:
3878 if (!is_gimple_reg (lhs
)
3879 && is_gimple_reg_type (TREE_TYPE (lhs
)))
3881 error ("invalid rhs for gimple memory store");
3882 debug_generic_stmt (lhs
);
3883 debug_generic_stmt (rhs1
);
3886 return res
|| verify_types_in_gimple_reference (rhs1
, false);
3898 /* tcc_declaration */
3903 if (!is_gimple_reg (lhs
)
3904 && !is_gimple_reg (rhs1
)
3905 && is_gimple_reg_type (TREE_TYPE (lhs
)))
3907 error ("invalid rhs for gimple memory store");
3908 debug_generic_stmt (lhs
);
3909 debug_generic_stmt (rhs1
);
3915 if (TREE_CODE (rhs1_type
) == VECTOR_TYPE
)
3918 tree elt_i
, elt_v
, elt_t
= NULL_TREE
;
3920 if (CONSTRUCTOR_NELTS (rhs1
) == 0)
3922 /* For vector CONSTRUCTORs we require that either it is empty
3923 CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
3924 (then the element count must be correct to cover the whole
3925 outer vector and index must be NULL on all elements, or it is
3926 a CONSTRUCTOR of scalar elements, where we as an exception allow
3927 smaller number of elements (assuming zero filling) and
3928 consecutive indexes as compared to NULL indexes (such
3929 CONSTRUCTORs can appear in the IL from FEs). */
3930 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1
), i
, elt_i
, elt_v
)
3932 if (elt_t
== NULL_TREE
)
3934 elt_t
= TREE_TYPE (elt_v
);
3935 if (TREE_CODE (elt_t
) == VECTOR_TYPE
)
3937 tree elt_t
= TREE_TYPE (elt_v
);
3938 if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
3941 error ("incorrect type of vector CONSTRUCTOR"
3943 debug_generic_stmt (rhs1
);
3946 else if (CONSTRUCTOR_NELTS (rhs1
)
3947 * TYPE_VECTOR_SUBPARTS (elt_t
)
3948 != TYPE_VECTOR_SUBPARTS (rhs1_type
))
3950 error ("incorrect number of vector CONSTRUCTOR"
3952 debug_generic_stmt (rhs1
);
3956 else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
3959 error ("incorrect type of vector CONSTRUCTOR elements");
3960 debug_generic_stmt (rhs1
);
3963 else if (CONSTRUCTOR_NELTS (rhs1
)
3964 > TYPE_VECTOR_SUBPARTS (rhs1_type
))
3966 error ("incorrect number of vector CONSTRUCTOR elements");
3967 debug_generic_stmt (rhs1
);
3971 else if (!useless_type_conversion_p (elt_t
, TREE_TYPE (elt_v
)))
3973 error ("incorrect type of vector CONSTRUCTOR elements");
3974 debug_generic_stmt (rhs1
);
3977 if (elt_i
!= NULL_TREE
3978 && (TREE_CODE (elt_t
) == VECTOR_TYPE
3979 || TREE_CODE (elt_i
) != INTEGER_CST
3980 || compare_tree_int (elt_i
, i
) != 0))
3982 error ("vector CONSTRUCTOR with non-NULL element index");
3983 debug_generic_stmt (rhs1
);
3991 case WITH_SIZE_EXPR
:
4001 /* Verify the contents of a GIMPLE_ASSIGN STMT. Returns true when there
4002 is a problem, otherwise false. */
4005 verify_gimple_assign (gimple stmt
)
4007 switch (gimple_assign_rhs_class (stmt
))
4009 case GIMPLE_SINGLE_RHS
:
4010 return verify_gimple_assign_single (stmt
);
4012 case GIMPLE_UNARY_RHS
:
4013 return verify_gimple_assign_unary (stmt
);
4015 case GIMPLE_BINARY_RHS
:
4016 return verify_gimple_assign_binary (stmt
);
4018 case GIMPLE_TERNARY_RHS
:
4019 return verify_gimple_assign_ternary (stmt
);
4026 /* Verify the contents of a GIMPLE_RETURN STMT. Returns true when there
4027 is a problem, otherwise false. */
4030 verify_gimple_return (gimple stmt
)
4032 tree op
= gimple_return_retval (stmt
);
4033 tree restype
= TREE_TYPE (TREE_TYPE (cfun
->decl
));
4035 /* We cannot test for present return values as we do not fix up missing
4036 return values from the original source. */
4040 if (!is_gimple_val (op
)
4041 && TREE_CODE (op
) != RESULT_DECL
)
4043 error ("invalid operand in return statement");
4044 debug_generic_stmt (op
);
4048 if ((TREE_CODE (op
) == RESULT_DECL
4049 && DECL_BY_REFERENCE (op
))
4050 || (TREE_CODE (op
) == SSA_NAME
4051 && SSA_NAME_VAR (op
)
4052 && TREE_CODE (SSA_NAME_VAR (op
)) == RESULT_DECL
4053 && DECL_BY_REFERENCE (SSA_NAME_VAR (op
))))
4054 op
= TREE_TYPE (op
);
4056 if (!useless_type_conversion_p (restype
, TREE_TYPE (op
)))
4058 error ("invalid conversion in return statement");
4059 debug_generic_stmt (restype
);
4060 debug_generic_stmt (TREE_TYPE (op
));
4068 /* Verify the contents of a GIMPLE_GOTO STMT. Returns true when there
4069 is a problem, otherwise false. */
4072 verify_gimple_goto (gimple stmt
)
4074 tree dest
= gimple_goto_dest (stmt
);
4076 /* ??? We have two canonical forms of direct goto destinations, a
4077 bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
4078 if (TREE_CODE (dest
) != LABEL_DECL
4079 && (!is_gimple_val (dest
)
4080 || !POINTER_TYPE_P (TREE_TYPE (dest
))))
4082 error ("goto destination is neither a label nor a pointer");
4089 /* Verify the contents of a GIMPLE_SWITCH STMT. Returns true when there
4090 is a problem, otherwise false. */
4093 verify_gimple_switch (gimple stmt
)
4096 tree elt
, prev_upper_bound
= NULL_TREE
;
4097 tree index_type
, elt_type
= NULL_TREE
;
4099 if (!is_gimple_val (gimple_switch_index (stmt
)))
4101 error ("invalid operand to switch statement");
4102 debug_generic_stmt (gimple_switch_index (stmt
));
4106 index_type
= TREE_TYPE (gimple_switch_index (stmt
));
4107 if (! INTEGRAL_TYPE_P (index_type
))
4109 error ("non-integral type switch statement");
4110 debug_generic_expr (index_type
);
4114 elt
= gimple_switch_label (stmt
, 0);
4115 if (CASE_LOW (elt
) != NULL_TREE
|| CASE_HIGH (elt
) != NULL_TREE
)
4117 error ("invalid default case label in switch statement");
4118 debug_generic_expr (elt
);
4122 n
= gimple_switch_num_labels (stmt
);
4123 for (i
= 1; i
< n
; i
++)
4125 elt
= gimple_switch_label (stmt
, i
);
4127 if (! CASE_LOW (elt
))
4129 error ("invalid case label in switch statement");
4130 debug_generic_expr (elt
);
4134 && ! tree_int_cst_lt (CASE_LOW (elt
), CASE_HIGH (elt
)))
4136 error ("invalid case range in switch statement");
4137 debug_generic_expr (elt
);
4143 if (TREE_TYPE (CASE_LOW (elt
)) != elt_type
4144 || (CASE_HIGH (elt
) && TREE_TYPE (CASE_HIGH (elt
)) != elt_type
))
4146 error ("type mismatch for case label in switch statement");
4147 debug_generic_expr (elt
);
4153 elt_type
= TREE_TYPE (CASE_LOW (elt
));
4154 if (TYPE_PRECISION (index_type
) < TYPE_PRECISION (elt_type
))
4156 error ("type precision mismatch in switch statement");
4161 if (prev_upper_bound
)
4163 if (! tree_int_cst_lt (prev_upper_bound
, CASE_LOW (elt
)))
4165 error ("case labels not sorted in switch statement");
4170 prev_upper_bound
= CASE_HIGH (elt
);
4171 if (! prev_upper_bound
)
4172 prev_upper_bound
= CASE_LOW (elt
);
4178 /* Verify a gimple debug statement STMT.
4179 Returns true if anything is wrong. */
4182 verify_gimple_debug (gimple stmt ATTRIBUTE_UNUSED
)
4184 /* There isn't much that could be wrong in a gimple debug stmt. A
4185 gimple debug bind stmt, for example, maps a tree, that's usually
4186 a VAR_DECL or a PARM_DECL, but that could also be some scalarized
4187 component or member of an aggregate type, to another tree, that
4188 can be an arbitrary expression. These stmts expand into debug
4189 insns, and are converted to debug notes by var-tracking.c. */
4193 /* Verify a gimple label statement STMT.
4194 Returns true if anything is wrong. */
4197 verify_gimple_label (gimple stmt
)
4199 tree decl
= gimple_label_label (stmt
);
4203 if (TREE_CODE (decl
) != LABEL_DECL
)
4205 if (!DECL_NONLOCAL (decl
) && !FORCED_LABEL (decl
)
4206 && DECL_CONTEXT (decl
) != current_function_decl
)
4208 error ("label's context is not the current function decl");
4212 uid
= LABEL_DECL_UID (decl
);
4214 && (uid
== -1 || (*label_to_block_map
)[uid
] != gimple_bb (stmt
)))
4216 error ("incorrect entry in label_to_block_map");
4220 uid
= EH_LANDING_PAD_NR (decl
);
4223 eh_landing_pad lp
= get_eh_landing_pad_from_number (uid
);
4224 if (decl
!= lp
->post_landing_pad
)
4226 error ("incorrect setting of landing pad number");
4234 /* Verify the GIMPLE statement STMT. Returns true if there is an
4235 error, otherwise false. */
4238 verify_gimple_stmt (gimple stmt
)
4240 switch (gimple_code (stmt
))
4243 return verify_gimple_assign (stmt
);
4246 return verify_gimple_label (stmt
);
4249 return verify_gimple_call (stmt
);
4252 if (TREE_CODE_CLASS (gimple_cond_code (stmt
)) != tcc_comparison
)
4254 error ("invalid comparison code in gimple cond");
4257 if (!(!gimple_cond_true_label (stmt
)
4258 || TREE_CODE (gimple_cond_true_label (stmt
)) == LABEL_DECL
)
4259 || !(!gimple_cond_false_label (stmt
)
4260 || TREE_CODE (gimple_cond_false_label (stmt
)) == LABEL_DECL
))
4262 error ("invalid labels in gimple cond");
4266 return verify_gimple_comparison (boolean_type_node
,
4267 gimple_cond_lhs (stmt
),
4268 gimple_cond_rhs (stmt
));
4271 return verify_gimple_goto (stmt
);
4274 return verify_gimple_switch (stmt
);
4277 return verify_gimple_return (stmt
);
4282 case GIMPLE_TRANSACTION
:
4283 return verify_gimple_transaction (stmt
);
4285 /* Tuples that do not have tree operands. */
4287 case GIMPLE_PREDICT
:
4289 case GIMPLE_EH_DISPATCH
:
4290 case GIMPLE_EH_MUST_NOT_THROW
:
4294 /* OpenMP directives are validated by the FE and never operated
4295 on by the optimizers. Furthermore, GIMPLE_OMP_FOR may contain
4296 non-gimple expressions when the main index variable has had
4297 its address taken. This does not affect the loop itself
4298 because the header of an GIMPLE_OMP_FOR is merely used to determine
4299 how to setup the parallel iteration. */
4303 return verify_gimple_debug (stmt
);
4310 /* Verify the contents of a GIMPLE_PHI. Returns true if there is a problem,
4311 and false otherwise. */
4314 verify_gimple_phi (gimple phi
)
4318 tree phi_result
= gimple_phi_result (phi
);
4323 error ("invalid PHI result");
4327 virtual_p
= virtual_operand_p (phi_result
);
4328 if (TREE_CODE (phi_result
) != SSA_NAME
4330 && SSA_NAME_VAR (phi_result
) != gimple_vop (cfun
)))
4332 error ("invalid PHI result");
4336 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4338 tree t
= gimple_phi_arg_def (phi
, i
);
4342 error ("missing PHI def");
4346 /* Addressable variables do have SSA_NAMEs but they
4347 are not considered gimple values. */
4348 else if ((TREE_CODE (t
) == SSA_NAME
4349 && virtual_p
!= virtual_operand_p (t
))
4351 && (TREE_CODE (t
) != SSA_NAME
4352 || SSA_NAME_VAR (t
) != gimple_vop (cfun
)))
4354 && !is_gimple_val (t
)))
4356 error ("invalid PHI argument");
4357 debug_generic_expr (t
);
4360 #ifdef ENABLE_TYPES_CHECKING
4361 if (!useless_type_conversion_p (TREE_TYPE (phi_result
), TREE_TYPE (t
)))
4363 error ("incompatible types in PHI argument %u", i
);
4364 debug_generic_stmt (TREE_TYPE (phi_result
));
4365 debug_generic_stmt (TREE_TYPE (t
));
4374 /* Verify the GIMPLE statements inside the sequence STMTS. */
4377 verify_gimple_in_seq_2 (gimple_seq stmts
)
4379 gimple_stmt_iterator ittr
;
4382 for (ittr
= gsi_start (stmts
); !gsi_end_p (ittr
); gsi_next (&ittr
))
4384 gimple stmt
= gsi_stmt (ittr
);
4386 switch (gimple_code (stmt
))
4389 err
|= verify_gimple_in_seq_2 (gimple_bind_body (stmt
));
4393 err
|= verify_gimple_in_seq_2 (gimple_try_eval (stmt
));
4394 err
|= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt
));
4397 case GIMPLE_EH_FILTER
:
4398 err
|= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt
));
4401 case GIMPLE_EH_ELSE
:
4402 err
|= verify_gimple_in_seq_2 (gimple_eh_else_n_body (stmt
));
4403 err
|= verify_gimple_in_seq_2 (gimple_eh_else_e_body (stmt
));
4407 err
|= verify_gimple_in_seq_2 (gimple_catch_handler (stmt
));
4410 case GIMPLE_TRANSACTION
:
4411 err
|= verify_gimple_transaction (stmt
);
4416 bool err2
= verify_gimple_stmt (stmt
);
4418 debug_gimple_stmt (stmt
);
4427 /* Verify the contents of a GIMPLE_TRANSACTION. Returns true if there
4428 is a problem, otherwise false. */
4431 verify_gimple_transaction (gimple stmt
)
4433 tree lab
= gimple_transaction_label (stmt
);
4434 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
4436 return verify_gimple_in_seq_2 (gimple_transaction_body (stmt
));
4440 /* Verify the GIMPLE statements inside the statement list STMTS. */
4443 verify_gimple_in_seq (gimple_seq stmts
)
4445 timevar_push (TV_TREE_STMT_VERIFY
);
4446 if (verify_gimple_in_seq_2 (stmts
))
4447 internal_error ("verify_gimple failed");
4448 timevar_pop (TV_TREE_STMT_VERIFY
);
4451 /* Return true when the T can be shared. */
4454 tree_node_can_be_shared (tree t
)
4456 if (IS_TYPE_OR_DECL_P (t
)
4457 || is_gimple_min_invariant (t
)
4458 || TREE_CODE (t
) == SSA_NAME
4459 || t
== error_mark_node
4460 || TREE_CODE (t
) == IDENTIFIER_NODE
)
4463 if (TREE_CODE (t
) == CASE_LABEL_EXPR
)
4472 /* Called via walk_tree. Verify tree sharing. */
4475 verify_node_sharing_1 (tree
*tp
, int *walk_subtrees
, void *data
)
4477 struct pointer_set_t
*visited
= (struct pointer_set_t
*) data
;
4479 if (tree_node_can_be_shared (*tp
))
4481 *walk_subtrees
= false;
4485 if (pointer_set_insert (visited
, *tp
))
4491 /* Called via walk_gimple_stmt. Verify tree sharing. */
4494 verify_node_sharing (tree
*tp
, int *walk_subtrees
, void *data
)
4496 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4497 return verify_node_sharing_1 (tp
, walk_subtrees
, wi
->info
);
4500 static bool eh_error_found
;
4502 verify_eh_throw_stmt_node (void **slot
, void *data
)
4504 struct throw_stmt_node
*node
= (struct throw_stmt_node
*)*slot
;
4505 struct pointer_set_t
*visited
= (struct pointer_set_t
*) data
;
4507 if (!pointer_set_contains (visited
, node
->stmt
))
4509 error ("dead STMT in EH table");
4510 debug_gimple_stmt (node
->stmt
);
4511 eh_error_found
= true;
4516 /* Verify if the location LOCs block is in BLOCKS. */
4519 verify_location (pointer_set_t
*blocks
, location_t loc
)
4521 tree block
= LOCATION_BLOCK (loc
);
4522 if (block
!= NULL_TREE
4523 && !pointer_set_contains (blocks
, block
))
4525 error ("location references block not in block tree");
4528 if (block
!= NULL_TREE
)
4529 return verify_location (blocks
, BLOCK_SOURCE_LOCATION (block
));
4533 /* Called via walk_tree. Verify that expressions have no blocks. */
4536 verify_expr_no_block (tree
*tp
, int *walk_subtrees
, void *)
4540 *walk_subtrees
= false;
4544 location_t loc
= EXPR_LOCATION (*tp
);
4545 if (LOCATION_BLOCK (loc
) != NULL
)
4551 /* Called via walk_tree. Verify locations of expressions. */
4554 verify_expr_location_1 (tree
*tp
, int *walk_subtrees
, void *data
)
4556 struct pointer_set_t
*blocks
= (struct pointer_set_t
*) data
;
4558 if (TREE_CODE (*tp
) == VAR_DECL
4559 && DECL_HAS_DEBUG_EXPR_P (*tp
))
4561 tree t
= DECL_DEBUG_EXPR (*tp
);
4562 tree addr
= walk_tree (&t
, verify_expr_no_block
, NULL
, NULL
);
4566 if ((TREE_CODE (*tp
) == VAR_DECL
4567 || TREE_CODE (*tp
) == PARM_DECL
4568 || TREE_CODE (*tp
) == RESULT_DECL
)
4569 && DECL_HAS_VALUE_EXPR_P (*tp
))
4571 tree t
= DECL_VALUE_EXPR (*tp
);
4572 tree addr
= walk_tree (&t
, verify_expr_no_block
, NULL
, NULL
);
4579 *walk_subtrees
= false;
4583 location_t loc
= EXPR_LOCATION (*tp
);
4584 if (verify_location (blocks
, loc
))
4590 /* Called via walk_gimple_op. Verify locations of expressions. */
4593 verify_expr_location (tree
*tp
, int *walk_subtrees
, void *data
)
4595 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4596 return verify_expr_location_1 (tp
, walk_subtrees
, wi
->info
);
4599 /* Insert all subblocks of BLOCK into BLOCKS and recurse. */
4602 collect_subblocks (pointer_set_t
*blocks
, tree block
)
4605 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
4607 pointer_set_insert (blocks
, t
);
4608 collect_subblocks (blocks
, t
);
4612 /* Verify the GIMPLE statements in the CFG of FN. */
4615 verify_gimple_in_cfg (struct function
*fn
)
4619 struct pointer_set_t
*visited
, *visited_stmts
, *blocks
;
4621 timevar_push (TV_TREE_STMT_VERIFY
);
4622 visited
= pointer_set_create ();
4623 visited_stmts
= pointer_set_create ();
4625 /* Collect all BLOCKs referenced by the BLOCK tree of FN. */
4626 blocks
= pointer_set_create ();
4627 if (DECL_INITIAL (fn
->decl
))
4629 pointer_set_insert (blocks
, DECL_INITIAL (fn
->decl
));
4630 collect_subblocks (blocks
, DECL_INITIAL (fn
->decl
));
4633 FOR_EACH_BB_FN (bb
, fn
)
4635 gimple_stmt_iterator gsi
;
4637 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4639 gimple phi
= gsi_stmt (gsi
);
4643 pointer_set_insert (visited_stmts
, phi
);
4645 if (gimple_bb (phi
) != bb
)
4647 error ("gimple_bb (phi) is set to a wrong basic block");
4651 err2
|= verify_gimple_phi (phi
);
4653 /* Only PHI arguments have locations. */
4654 if (gimple_location (phi
) != UNKNOWN_LOCATION
)
4656 error ("PHI node with location");
4660 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4662 tree arg
= gimple_phi_arg_def (phi
, i
);
4663 tree addr
= walk_tree (&arg
, verify_node_sharing_1
,
4667 error ("incorrect sharing of tree nodes");
4668 debug_generic_expr (addr
);
4671 location_t loc
= gimple_phi_arg_location (phi
, i
);
4672 if (virtual_operand_p (gimple_phi_result (phi
))
4673 && loc
!= UNKNOWN_LOCATION
)
4675 error ("virtual PHI with argument locations");
4678 addr
= walk_tree (&arg
, verify_expr_location_1
, blocks
, NULL
);
4681 debug_generic_expr (addr
);
4684 err2
|= verify_location (blocks
, loc
);
4688 debug_gimple_stmt (phi
);
4692 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4694 gimple stmt
= gsi_stmt (gsi
);
4696 struct walk_stmt_info wi
;
4700 pointer_set_insert (visited_stmts
, stmt
);
4702 if (gimple_bb (stmt
) != bb
)
4704 error ("gimple_bb (stmt) is set to a wrong basic block");
4708 err2
|= verify_gimple_stmt (stmt
);
4709 err2
|= verify_location (blocks
, gimple_location (stmt
));
4711 memset (&wi
, 0, sizeof (wi
));
4712 wi
.info
= (void *) visited
;
4713 addr
= walk_gimple_op (stmt
, verify_node_sharing
, &wi
);
4716 error ("incorrect sharing of tree nodes");
4717 debug_generic_expr (addr
);
4721 memset (&wi
, 0, sizeof (wi
));
4722 wi
.info
= (void *) blocks
;
4723 addr
= walk_gimple_op (stmt
, verify_expr_location
, &wi
);
4726 debug_generic_expr (addr
);
4730 /* ??? Instead of not checking these stmts at all the walker
4731 should know its context via wi. */
4732 if (!is_gimple_debug (stmt
)
4733 && !is_gimple_omp (stmt
))
4735 memset (&wi
, 0, sizeof (wi
));
4736 addr
= walk_gimple_op (stmt
, verify_expr
, &wi
);
4739 debug_generic_expr (addr
);
4740 inform (gimple_location (stmt
), "in statement");
4745 /* If the statement is marked as part of an EH region, then it is
4746 expected that the statement could throw. Verify that when we
4747 have optimizations that simplify statements such that we prove
4748 that they cannot throw, that we update other data structures
4750 lp_nr
= lookup_stmt_eh_lp (stmt
);
4753 if (!stmt_could_throw_p (stmt
))
4755 error ("statement marked for throw, but doesn%'t");
4759 && !gsi_one_before_end_p (gsi
)
4760 && stmt_can_throw_internal (stmt
))
4762 error ("statement marked for throw in middle of block");
4768 debug_gimple_stmt (stmt
);
4773 eh_error_found
= false;
4774 if (get_eh_throw_stmt_table (cfun
))
4775 htab_traverse (get_eh_throw_stmt_table (cfun
),
4776 verify_eh_throw_stmt_node
,
4779 if (err
|| eh_error_found
)
4780 internal_error ("verify_gimple failed");
4782 pointer_set_destroy (visited
);
4783 pointer_set_destroy (visited_stmts
);
4784 pointer_set_destroy (blocks
);
4785 verify_histograms ();
4786 timevar_pop (TV_TREE_STMT_VERIFY
);
4790 /* Verifies that the flow information is OK. */
4793 gimple_verify_flow_info (void)
4797 gimple_stmt_iterator gsi
;
4802 if (ENTRY_BLOCK_PTR
->il
.gimple
.seq
|| ENTRY_BLOCK_PTR
->il
.gimple
.phi_nodes
)
4804 error ("ENTRY_BLOCK has IL associated with it");
4808 if (EXIT_BLOCK_PTR
->il
.gimple
.seq
|| EXIT_BLOCK_PTR
->il
.gimple
.phi_nodes
)
4810 error ("EXIT_BLOCK has IL associated with it");
4814 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
4815 if (e
->flags
& EDGE_FALLTHRU
)
4817 error ("fallthru to exit from bb %d", e
->src
->index
);
4823 bool found_ctrl_stmt
= false;
4827 /* Skip labels on the start of basic block. */
4828 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4831 gimple prev_stmt
= stmt
;
4833 stmt
= gsi_stmt (gsi
);
4835 if (gimple_code (stmt
) != GIMPLE_LABEL
)
4838 label
= gimple_label_label (stmt
);
4839 if (prev_stmt
&& DECL_NONLOCAL (label
))
4841 error ("nonlocal label ");
4842 print_generic_expr (stderr
, label
, 0);
4843 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
4848 if (prev_stmt
&& EH_LANDING_PAD_NR (label
) != 0)
4850 error ("EH landing pad label ");
4851 print_generic_expr (stderr
, label
, 0);
4852 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
4857 if (label_to_block (label
) != bb
)
4860 print_generic_expr (stderr
, label
, 0);
4861 fprintf (stderr
, " to block does not match in bb %d",
4866 if (decl_function_context (label
) != current_function_decl
)
4869 print_generic_expr (stderr
, label
, 0);
4870 fprintf (stderr
, " has incorrect context in bb %d",
4876 /* Verify that body of basic block BB is free of control flow. */
4877 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
4879 gimple stmt
= gsi_stmt (gsi
);
4881 if (found_ctrl_stmt
)
4883 error ("control flow in the middle of basic block %d",
4888 if (stmt_ends_bb_p (stmt
))
4889 found_ctrl_stmt
= true;
4891 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4894 print_generic_expr (stderr
, gimple_label_label (stmt
), 0);
4895 fprintf (stderr
, " in the middle of basic block %d", bb
->index
);
4900 gsi
= gsi_last_bb (bb
);
4901 if (gsi_end_p (gsi
))
4904 stmt
= gsi_stmt (gsi
);
4906 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4909 err
|= verify_eh_edges (stmt
);
4911 if (is_ctrl_stmt (stmt
))
4913 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4914 if (e
->flags
& EDGE_FALLTHRU
)
4916 error ("fallthru edge after a control statement in bb %d",
4922 if (gimple_code (stmt
) != GIMPLE_COND
)
4924 /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
4925 after anything else but if statement. */
4926 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4927 if (e
->flags
& (EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
))
4929 error ("true/false edge after a non-GIMPLE_COND in bb %d",
4935 switch (gimple_code (stmt
))
4942 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
4946 || !(true_edge
->flags
& EDGE_TRUE_VALUE
)
4947 || !(false_edge
->flags
& EDGE_FALSE_VALUE
)
4948 || (true_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
4949 || (false_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
4950 || EDGE_COUNT (bb
->succs
) >= 3)
4952 error ("wrong outgoing edge flags at end of bb %d",
4960 if (simple_goto_p (stmt
))
4962 error ("explicit goto at end of bb %d", bb
->index
);
4967 /* FIXME. We should double check that the labels in the
4968 destination blocks have their address taken. */
4969 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4970 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_TRUE_VALUE
4971 | EDGE_FALSE_VALUE
))
4972 || !(e
->flags
& EDGE_ABNORMAL
))
4974 error ("wrong outgoing edge flags at end of bb %d",
4982 if (!gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
))
4984 /* ... fallthru ... */
4986 if (!single_succ_p (bb
)
4987 || (single_succ_edge (bb
)->flags
4988 & (EDGE_FALLTHRU
| EDGE_ABNORMAL
4989 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
4991 error ("wrong outgoing edge flags at end of bb %d", bb
->index
);
4994 if (single_succ (bb
) != EXIT_BLOCK_PTR
)
4996 error ("return edge does not point to exit in bb %d",
5008 n
= gimple_switch_num_labels (stmt
);
5010 /* Mark all the destination basic blocks. */
5011 for (i
= 0; i
< n
; ++i
)
5013 tree lab
= CASE_LABEL (gimple_switch_label (stmt
, i
));
5014 basic_block label_bb
= label_to_block (lab
);
5015 gcc_assert (!label_bb
->aux
|| label_bb
->aux
== (void *)1);
5016 label_bb
->aux
= (void *)1;
5019 /* Verify that the case labels are sorted. */
5020 prev
= gimple_switch_label (stmt
, 0);
5021 for (i
= 1; i
< n
; ++i
)
5023 tree c
= gimple_switch_label (stmt
, i
);
5026 error ("found default case not at the start of "
5032 && !tree_int_cst_lt (CASE_LOW (prev
), CASE_LOW (c
)))
5034 error ("case labels not sorted: ");
5035 print_generic_expr (stderr
, prev
, 0);
5036 fprintf (stderr
," is greater than ");
5037 print_generic_expr (stderr
, c
, 0);
5038 fprintf (stderr
," but comes before it.\n");
5043 /* VRP will remove the default case if it can prove it will
5044 never be executed. So do not verify there always exists
5045 a default case here. */
5047 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5051 error ("extra outgoing edge %d->%d",
5052 bb
->index
, e
->dest
->index
);
5056 e
->dest
->aux
= (void *)2;
5057 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
5058 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5060 error ("wrong outgoing edge flags at end of bb %d",
5066 /* Check that we have all of them. */
5067 for (i
= 0; i
< n
; ++i
)
5069 tree lab
= CASE_LABEL (gimple_switch_label (stmt
, i
));
5070 basic_block label_bb
= label_to_block (lab
);
5072 if (label_bb
->aux
!= (void *)2)
5074 error ("missing edge %i->%i", bb
->index
, label_bb
->index
);
5079 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5080 e
->dest
->aux
= (void *)0;
5084 case GIMPLE_EH_DISPATCH
:
5085 err
|= verify_eh_dispatch_edge (stmt
);
5093 if (dom_info_state (CDI_DOMINATORS
) >= DOM_NO_FAST_QUERY
)
5094 verify_dominators (CDI_DOMINATORS
);
5100 /* Updates phi nodes after creating a forwarder block joined
5101 by edge FALLTHRU. */
5104 gimple_make_forwarder_block (edge fallthru
)
5108 basic_block dummy
, bb
;
5110 gimple_stmt_iterator gsi
;
5112 dummy
= fallthru
->src
;
5113 bb
= fallthru
->dest
;
5115 if (single_pred_p (bb
))
5118 /* If we redirected a branch we must create new PHI nodes at the
5120 for (gsi
= gsi_start_phis (dummy
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5122 gimple phi
, new_phi
;
5124 phi
= gsi_stmt (gsi
);
5125 var
= gimple_phi_result (phi
);
5126 new_phi
= create_phi_node (var
, bb
);
5127 gimple_phi_set_result (phi
, copy_ssa_name (var
, phi
));
5128 add_phi_arg (new_phi
, gimple_phi_result (phi
), fallthru
,
5132 /* Add the arguments we have stored on edges. */
5133 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
5138 flush_pending_stmts (e
);
5143 /* Return a non-special label in the head of basic block BLOCK.
5144 Create one if it doesn't exist. */
5147 gimple_block_label (basic_block bb
)
5149 gimple_stmt_iterator i
, s
= gsi_start_bb (bb
);
5154 for (i
= s
; !gsi_end_p (i
); first
= false, gsi_next (&i
))
5156 stmt
= gsi_stmt (i
);
5157 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5159 label
= gimple_label_label (stmt
);
5160 if (!DECL_NONLOCAL (label
))
5163 gsi_move_before (&i
, &s
);
5168 label
= create_artificial_label (UNKNOWN_LOCATION
);
5169 stmt
= gimple_build_label (label
);
5170 gsi_insert_before (&s
, stmt
, GSI_NEW_STMT
);
5175 /* Attempt to perform edge redirection by replacing a possibly complex
5176 jump instruction by a goto or by removing the jump completely.
5177 This can apply only if all edges now point to the same block. The
5178 parameters and return values are equivalent to
5179 redirect_edge_and_branch. */
5182 gimple_try_redirect_by_replacing_jump (edge e
, basic_block target
)
5184 basic_block src
= e
->src
;
5185 gimple_stmt_iterator i
;
5188 /* We can replace or remove a complex jump only when we have exactly
5190 if (EDGE_COUNT (src
->succs
) != 2
5191 /* Verify that all targets will be TARGET. Specifically, the
5192 edge that is not E must also go to TARGET. */
5193 || EDGE_SUCC (src
, EDGE_SUCC (src
, 0) == e
)->dest
!= target
)
5196 i
= gsi_last_bb (src
);
5200 stmt
= gsi_stmt (i
);
5202 if (gimple_code (stmt
) == GIMPLE_COND
|| gimple_code (stmt
) == GIMPLE_SWITCH
)
5204 gsi_remove (&i
, true);
5205 e
= ssa_redirect_edge (e
, target
);
5206 e
->flags
= EDGE_FALLTHRU
;
5214 /* Redirect E to DEST. Return NULL on failure. Otherwise, return the
5215 edge representing the redirected branch. */
5218 gimple_redirect_edge_and_branch (edge e
, basic_block dest
)
5220 basic_block bb
= e
->src
;
5221 gimple_stmt_iterator gsi
;
5225 if (e
->flags
& EDGE_ABNORMAL
)
5228 if (e
->dest
== dest
)
5231 if (e
->flags
& EDGE_EH
)
5232 return redirect_eh_edge (e
, dest
);
5234 if (e
->src
!= ENTRY_BLOCK_PTR
)
5236 ret
= gimple_try_redirect_by_replacing_jump (e
, dest
);
5241 gsi
= gsi_last_bb (bb
);
5242 stmt
= gsi_end_p (gsi
) ? NULL
: gsi_stmt (gsi
);
5244 switch (stmt
? gimple_code (stmt
) : GIMPLE_ERROR_MARK
)
5247 /* For COND_EXPR, we only need to redirect the edge. */
5251 /* No non-abnormal edges should lead from a non-simple goto, and
5252 simple ones should be represented implicitly. */
5257 tree label
= gimple_block_label (dest
);
5258 tree cases
= get_cases_for_edge (e
, stmt
);
5260 /* If we have a list of cases associated with E, then use it
5261 as it's a lot faster than walking the entire case vector. */
5264 edge e2
= find_edge (e
->src
, dest
);
5271 CASE_LABEL (cases
) = label
;
5272 cases
= CASE_CHAIN (cases
);
5275 /* If there was already an edge in the CFG, then we need
5276 to move all the cases associated with E to E2. */
5279 tree cases2
= get_cases_for_edge (e2
, stmt
);
5281 CASE_CHAIN (last
) = CASE_CHAIN (cases2
);
5282 CASE_CHAIN (cases2
) = first
;
5284 bitmap_set_bit (touched_switch_bbs
, gimple_bb (stmt
)->index
);
5288 size_t i
, n
= gimple_switch_num_labels (stmt
);
5290 for (i
= 0; i
< n
; i
++)
5292 tree elt
= gimple_switch_label (stmt
, i
);
5293 if (label_to_block (CASE_LABEL (elt
)) == e
->dest
)
5294 CASE_LABEL (elt
) = label
;
5302 int i
, n
= gimple_asm_nlabels (stmt
);
5305 for (i
= 0; i
< n
; ++i
)
5307 tree cons
= gimple_asm_label_op (stmt
, i
);
5308 if (label_to_block (TREE_VALUE (cons
)) == e
->dest
)
5311 label
= gimple_block_label (dest
);
5312 TREE_VALUE (cons
) = label
;
5316 /* If we didn't find any label matching the former edge in the
5317 asm labels, we must be redirecting the fallthrough
5319 gcc_assert (label
|| (e
->flags
& EDGE_FALLTHRU
));
5324 gsi_remove (&gsi
, true);
5325 e
->flags
|= EDGE_FALLTHRU
;
5328 case GIMPLE_OMP_RETURN
:
5329 case GIMPLE_OMP_CONTINUE
:
5330 case GIMPLE_OMP_SECTIONS_SWITCH
:
5331 case GIMPLE_OMP_FOR
:
5332 /* The edges from OMP constructs can be simply redirected. */
5335 case GIMPLE_EH_DISPATCH
:
5336 if (!(e
->flags
& EDGE_FALLTHRU
))
5337 redirect_eh_dispatch_edge (stmt
, e
, dest
);
5340 case GIMPLE_TRANSACTION
:
5341 /* The ABORT edge has a stored label associated with it, otherwise
5342 the edges are simply redirectable. */
5344 gimple_transaction_set_label (stmt
, gimple_block_label (dest
));
5348 /* Otherwise it must be a fallthru edge, and we don't need to
5349 do anything besides redirecting it. */
5350 gcc_assert (e
->flags
& EDGE_FALLTHRU
);
5354 /* Update/insert PHI nodes as necessary. */
5356 /* Now update the edges in the CFG. */
5357 e
= ssa_redirect_edge (e
, dest
);
5362 /* Returns true if it is possible to remove edge E by redirecting
5363 it to the destination of the other edge from E->src. */
5366 gimple_can_remove_branch_p (const_edge e
)
5368 if (e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
))
5374 /* Simple wrapper, as we can always redirect fallthru edges. */
5377 gimple_redirect_edge_and_branch_force (edge e
, basic_block dest
)
5379 e
= gimple_redirect_edge_and_branch (e
, dest
);
5386 /* Splits basic block BB after statement STMT (but at least after the
5387 labels). If STMT is NULL, BB is split just after the labels. */
5390 gimple_split_block (basic_block bb
, void *stmt
)
5392 gimple_stmt_iterator gsi
;
5393 gimple_stmt_iterator gsi_tgt
;
5400 new_bb
= create_empty_bb (bb
);
5402 /* Redirect the outgoing edges. */
5403 new_bb
->succs
= bb
->succs
;
5405 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
5408 if (stmt
&& gimple_code ((gimple
) stmt
) == GIMPLE_LABEL
)
5411 /* Move everything from GSI to the new basic block. */
5412 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5414 act
= gsi_stmt (gsi
);
5415 if (gimple_code (act
) == GIMPLE_LABEL
)
5428 if (gsi_end_p (gsi
))
5431 /* Split the statement list - avoid re-creating new containers as this
5432 brings ugly quadratic memory consumption in the inliner.
5433 (We are still quadratic since we need to update stmt BB pointers,
5435 gsi_split_seq_before (&gsi
, &list
);
5436 set_bb_seq (new_bb
, list
);
5437 for (gsi_tgt
= gsi_start (list
);
5438 !gsi_end_p (gsi_tgt
); gsi_next (&gsi_tgt
))
5439 gimple_set_bb (gsi_stmt (gsi_tgt
), new_bb
);
5445 /* Moves basic block BB after block AFTER. */
5448 gimple_move_block_after (basic_block bb
, basic_block after
)
5450 if (bb
->prev_bb
== after
)
5454 link_block (bb
, after
);
5460 /* Return TRUE if block BB has no executable statements, otherwise return
5464 gimple_empty_block_p (basic_block bb
)
5466 /* BB must have no executable statements. */
5467 gimple_stmt_iterator gsi
= gsi_after_labels (bb
);
5470 if (gsi_end_p (gsi
))
5472 if (is_gimple_debug (gsi_stmt (gsi
)))
5473 gsi_next_nondebug (&gsi
);
5474 return gsi_end_p (gsi
);
5478 /* Split a basic block if it ends with a conditional branch and if the
5479 other part of the block is not empty. */
5482 gimple_split_block_before_cond_jump (basic_block bb
)
5484 gimple last
, split_point
;
5485 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
5486 if (gsi_end_p (gsi
))
5488 last
= gsi_stmt (gsi
);
5489 if (gimple_code (last
) != GIMPLE_COND
5490 && gimple_code (last
) != GIMPLE_SWITCH
)
5492 gsi_prev_nondebug (&gsi
);
5493 split_point
= gsi_stmt (gsi
);
5494 return split_block (bb
, split_point
)->dest
;
5498 /* Return true if basic_block can be duplicated. */
5501 gimple_can_duplicate_bb_p (const_basic_block bb ATTRIBUTE_UNUSED
)
5506 /* Create a duplicate of the basic block BB. NOTE: This does not
5507 preserve SSA form. */
5510 gimple_duplicate_bb (basic_block bb
)
5513 gimple_stmt_iterator gsi
, gsi_tgt
;
5514 gimple_seq phis
= phi_nodes (bb
);
5515 gimple phi
, stmt
, copy
;
5517 new_bb
= create_empty_bb (EXIT_BLOCK_PTR
->prev_bb
);
5519 /* Copy the PHI nodes. We ignore PHI node arguments here because
5520 the incoming edges have not been setup yet. */
5521 for (gsi
= gsi_start (phis
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5523 phi
= gsi_stmt (gsi
);
5524 copy
= create_phi_node (NULL_TREE
, new_bb
);
5525 create_new_def_for (gimple_phi_result (phi
), copy
,
5526 gimple_phi_result_ptr (copy
));
5527 gimple_set_uid (copy
, gimple_uid (phi
));
5530 gsi_tgt
= gsi_start_bb (new_bb
);
5531 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5533 def_operand_p def_p
;
5534 ssa_op_iter op_iter
;
5537 stmt
= gsi_stmt (gsi
);
5538 if (gimple_code (stmt
) == GIMPLE_LABEL
)
5541 /* Don't duplicate label debug stmts. */
5542 if (gimple_debug_bind_p (stmt
)
5543 && TREE_CODE (gimple_debug_bind_get_var (stmt
))
5547 /* Create a new copy of STMT and duplicate STMT's virtual
5549 copy
= gimple_copy (stmt
);
5550 gsi_insert_after (&gsi_tgt
, copy
, GSI_NEW_STMT
);
5552 maybe_duplicate_eh_stmt (copy
, stmt
);
5553 gimple_duplicate_stmt_histograms (cfun
, copy
, cfun
, stmt
);
5555 /* When copying around a stmt writing into a local non-user
5556 aggregate, make sure it won't share stack slot with other
5558 lhs
= gimple_get_lhs (stmt
);
5559 if (lhs
&& TREE_CODE (lhs
) != SSA_NAME
)
5561 tree base
= get_base_address (lhs
);
5563 && (TREE_CODE (base
) == VAR_DECL
5564 || TREE_CODE (base
) == RESULT_DECL
)
5565 && DECL_IGNORED_P (base
)
5566 && !TREE_STATIC (base
)
5567 && !DECL_EXTERNAL (base
)
5568 && (TREE_CODE (base
) != VAR_DECL
5569 || !DECL_HAS_VALUE_EXPR_P (base
)))
5570 DECL_NONSHAREABLE (base
) = 1;
5573 /* Create new names for all the definitions created by COPY and
5574 add replacement mappings for each new name. */
5575 FOR_EACH_SSA_DEF_OPERAND (def_p
, copy
, op_iter
, SSA_OP_ALL_DEFS
)
5576 create_new_def_for (DEF_FROM_PTR (def_p
), copy
, def_p
);
5582 /* Adds phi node arguments for edge E_COPY after basic block duplication. */
5585 add_phi_args_after_copy_edge (edge e_copy
)
5587 basic_block bb
, bb_copy
= e_copy
->src
, dest
;
5590 gimple phi
, phi_copy
;
5592 gimple_stmt_iterator psi
, psi_copy
;
5594 if (gimple_seq_empty_p (phi_nodes (e_copy
->dest
)))
5597 bb
= bb_copy
->flags
& BB_DUPLICATED
? get_bb_original (bb_copy
) : bb_copy
;
5599 if (e_copy
->dest
->flags
& BB_DUPLICATED
)
5600 dest
= get_bb_original (e_copy
->dest
);
5602 dest
= e_copy
->dest
;
5604 e
= find_edge (bb
, dest
);
5607 /* During loop unrolling the target of the latch edge is copied.
5608 In this case we are not looking for edge to dest, but to
5609 duplicated block whose original was dest. */
5610 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5612 if ((e
->dest
->flags
& BB_DUPLICATED
)
5613 && get_bb_original (e
->dest
) == dest
)
5617 gcc_assert (e
!= NULL
);
5620 for (psi
= gsi_start_phis (e
->dest
),
5621 psi_copy
= gsi_start_phis (e_copy
->dest
);
5623 gsi_next (&psi
), gsi_next (&psi_copy
))
5625 phi
= gsi_stmt (psi
);
5626 phi_copy
= gsi_stmt (psi_copy
);
5627 def
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
5628 add_phi_arg (phi_copy
, def
, e_copy
,
5629 gimple_phi_arg_location_from_edge (phi
, e
));
5634 /* Basic block BB_COPY was created by code duplication. Add phi node
5635 arguments for edges going out of BB_COPY. The blocks that were
5636 duplicated have BB_DUPLICATED set. */
5639 add_phi_args_after_copy_bb (basic_block bb_copy
)
5644 FOR_EACH_EDGE (e_copy
, ei
, bb_copy
->succs
)
5646 add_phi_args_after_copy_edge (e_copy
);
5650 /* Blocks in REGION_COPY array of length N_REGION were created by
5651 duplication of basic blocks. Add phi node arguments for edges
5652 going from these blocks. If E_COPY is not NULL, also add
5653 phi node arguments for its destination.*/
5656 add_phi_args_after_copy (basic_block
*region_copy
, unsigned n_region
,
5661 for (i
= 0; i
< n_region
; i
++)
5662 region_copy
[i
]->flags
|= BB_DUPLICATED
;
5664 for (i
= 0; i
< n_region
; i
++)
5665 add_phi_args_after_copy_bb (region_copy
[i
]);
5667 add_phi_args_after_copy_edge (e_copy
);
5669 for (i
= 0; i
< n_region
; i
++)
5670 region_copy
[i
]->flags
&= ~BB_DUPLICATED
;
5673 /* Duplicates a REGION (set of N_REGION basic blocks) with just a single
5674 important exit edge EXIT. By important we mean that no SSA name defined
5675 inside region is live over the other exit edges of the region. All entry
5676 edges to the region must go to ENTRY->dest. The edge ENTRY is redirected
5677 to the duplicate of the region. Dominance and loop information is
5678 updated if UPDATE_DOMINANCE is true, but not the SSA web. If
5679 UPDATE_DOMINANCE is false then we assume that the caller will update the
5680 dominance information after calling this function. The new basic
5681 blocks are stored to REGION_COPY in the same order as they had in REGION,
5682 provided that REGION_COPY is not NULL.
5683 The function returns false if it is unable to copy the region,
5687 gimple_duplicate_sese_region (edge entry
, edge exit
,
5688 basic_block
*region
, unsigned n_region
,
5689 basic_block
*region_copy
,
5690 bool update_dominance
)
5693 bool free_region_copy
= false, copying_header
= false;
5694 struct loop
*loop
= entry
->dest
->loop_father
;
5696 vec
<basic_block
> doms
;
5698 int total_freq
= 0, entry_freq
= 0;
5699 gcov_type total_count
= 0, entry_count
= 0;
5701 if (!can_copy_bbs_p (region
, n_region
))
5704 /* Some sanity checking. Note that we do not check for all possible
5705 missuses of the functions. I.e. if you ask to copy something weird,
5706 it will work, but the state of structures probably will not be
5708 for (i
= 0; i
< n_region
; i
++)
5710 /* We do not handle subloops, i.e. all the blocks must belong to the
5712 if (region
[i
]->loop_father
!= loop
)
5715 if (region
[i
] != entry
->dest
5716 && region
[i
] == loop
->header
)
5720 set_loop_copy (loop
, loop
);
5722 /* In case the function is used for loop header copying (which is the primary
5723 use), ensure that EXIT and its copy will be new latch and entry edges. */
5724 if (loop
->header
== entry
->dest
)
5726 copying_header
= true;
5727 set_loop_copy (loop
, loop_outer (loop
));
5729 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, exit
->src
))
5732 for (i
= 0; i
< n_region
; i
++)
5733 if (region
[i
] != exit
->src
5734 && dominated_by_p (CDI_DOMINATORS
, region
[i
], exit
->src
))
5740 region_copy
= XNEWVEC (basic_block
, n_region
);
5741 free_region_copy
= true;
5744 initialize_original_copy_tables ();
5746 /* Record blocks outside the region that are dominated by something
5748 if (update_dominance
)
5751 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
5754 if (entry
->dest
->count
)
5756 total_count
= entry
->dest
->count
;
5757 entry_count
= entry
->count
;
5758 /* Fix up corner cases, to avoid division by zero or creation of negative
5760 if (entry_count
> total_count
)
5761 entry_count
= total_count
;
5765 total_freq
= entry
->dest
->frequency
;
5766 entry_freq
= EDGE_FREQUENCY (entry
);
5767 /* Fix up corner cases, to avoid division by zero or creation of negative
5769 if (total_freq
== 0)
5771 else if (entry_freq
> total_freq
)
5772 entry_freq
= total_freq
;
5775 copy_bbs (region
, n_region
, region_copy
, &exit
, 1, &exit_copy
, loop
,
5776 split_edge_bb_loc (entry
), update_dominance
);
5779 scale_bbs_frequencies_gcov_type (region
, n_region
,
5780 total_count
- entry_count
,
5782 scale_bbs_frequencies_gcov_type (region_copy
, n_region
, entry_count
,
5787 scale_bbs_frequencies_int (region
, n_region
, total_freq
- entry_freq
,
5789 scale_bbs_frequencies_int (region_copy
, n_region
, entry_freq
, total_freq
);
5794 loop
->header
= exit
->dest
;
5795 loop
->latch
= exit
->src
;
5798 /* Redirect the entry and add the phi node arguments. */
5799 redirected
= redirect_edge_and_branch (entry
, get_bb_copy (entry
->dest
));
5800 gcc_assert (redirected
!= NULL
);
5801 flush_pending_stmts (entry
);
5803 /* Concerning updating of dominators: We must recount dominators
5804 for entry block and its copy. Anything that is outside of the
5805 region, but was dominated by something inside needs recounting as
5807 if (update_dominance
)
5809 set_immediate_dominator (CDI_DOMINATORS
, entry
->dest
, entry
->src
);
5810 doms
.safe_push (get_bb_original (entry
->dest
));
5811 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
5815 /* Add the other PHI node arguments. */
5816 add_phi_args_after_copy (region_copy
, n_region
, NULL
);
5818 if (free_region_copy
)
5821 free_original_copy_tables ();
5825 /* Checks if BB is part of the region defined by N_REGION BBS. */
5827 bb_part_of_region_p (basic_block bb
, basic_block
* bbs
, unsigned n_region
)
5831 for (n
= 0; n
< n_region
; n
++)
5839 /* Duplicates REGION consisting of N_REGION blocks. The new blocks
5840 are stored to REGION_COPY in the same order in that they appear
5841 in REGION, if REGION_COPY is not NULL. ENTRY is the entry to
5842 the region, EXIT an exit from it. The condition guarding EXIT
5843 is moved to ENTRY. Returns true if duplication succeeds, false
5869 gimple_duplicate_sese_tail (edge entry ATTRIBUTE_UNUSED
, edge exit ATTRIBUTE_UNUSED
,
5870 basic_block
*region ATTRIBUTE_UNUSED
, unsigned n_region ATTRIBUTE_UNUSED
,
5871 basic_block
*region_copy ATTRIBUTE_UNUSED
)
5874 bool free_region_copy
= false;
5875 struct loop
*loop
= exit
->dest
->loop_father
;
5876 struct loop
*orig_loop
= entry
->dest
->loop_father
;
5877 basic_block switch_bb
, entry_bb
, nentry_bb
;
5878 vec
<basic_block
> doms
;
5879 int total_freq
= 0, exit_freq
= 0;
5880 gcov_type total_count
= 0, exit_count
= 0;
5881 edge exits
[2], nexits
[2], e
;
5882 gimple_stmt_iterator gsi
;
5885 basic_block exit_bb
;
5886 gimple_stmt_iterator psi
;
5889 struct loop
*target
, *aloop
, *cloop
;
5891 gcc_assert (EDGE_COUNT (exit
->src
->succs
) == 2);
5893 exits
[1] = EDGE_SUCC (exit
->src
, EDGE_SUCC (exit
->src
, 0) == exit
);
5895 if (!can_copy_bbs_p (region
, n_region
))
5898 initialize_original_copy_tables ();
5899 set_loop_copy (orig_loop
, loop
);
5902 for (aloop
= orig_loop
->inner
; aloop
; aloop
= aloop
->next
)
5904 if (bb_part_of_region_p (aloop
->header
, region
, n_region
))
5906 cloop
= duplicate_loop (aloop
, target
);
5907 duplicate_subloops (aloop
, cloop
);
5913 region_copy
= XNEWVEC (basic_block
, n_region
);
5914 free_region_copy
= true;
5917 gcc_assert (!need_ssa_update_p (cfun
));
5919 /* Record blocks outside the region that are dominated by something
5921 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
5923 if (exit
->src
->count
)
5925 total_count
= exit
->src
->count
;
5926 exit_count
= exit
->count
;
5927 /* Fix up corner cases, to avoid division by zero or creation of negative
5929 if (exit_count
> total_count
)
5930 exit_count
= total_count
;
5934 total_freq
= exit
->src
->frequency
;
5935 exit_freq
= EDGE_FREQUENCY (exit
);
5936 /* Fix up corner cases, to avoid division by zero or creation of negative
5938 if (total_freq
== 0)
5940 if (exit_freq
> total_freq
)
5941 exit_freq
= total_freq
;
5944 copy_bbs (region
, n_region
, region_copy
, exits
, 2, nexits
, orig_loop
,
5945 split_edge_bb_loc (exit
), true);
5948 scale_bbs_frequencies_gcov_type (region
, n_region
,
5949 total_count
- exit_count
,
5951 scale_bbs_frequencies_gcov_type (region_copy
, n_region
, exit_count
,
5956 scale_bbs_frequencies_int (region
, n_region
, total_freq
- exit_freq
,
5958 scale_bbs_frequencies_int (region_copy
, n_region
, exit_freq
, total_freq
);
5961 /* Create the switch block, and put the exit condition to it. */
5962 entry_bb
= entry
->dest
;
5963 nentry_bb
= get_bb_copy (entry_bb
);
5964 if (!last_stmt (entry
->src
)
5965 || !stmt_ends_bb_p (last_stmt (entry
->src
)))
5966 switch_bb
= entry
->src
;
5968 switch_bb
= split_edge (entry
);
5969 set_immediate_dominator (CDI_DOMINATORS
, nentry_bb
, switch_bb
);
5971 gsi
= gsi_last_bb (switch_bb
);
5972 cond_stmt
= last_stmt (exit
->src
);
5973 gcc_assert (gimple_code (cond_stmt
) == GIMPLE_COND
);
5974 cond_stmt
= gimple_copy (cond_stmt
);
5976 gsi_insert_after (&gsi
, cond_stmt
, GSI_NEW_STMT
);
5978 sorig
= single_succ_edge (switch_bb
);
5979 sorig
->flags
= exits
[1]->flags
;
5980 snew
= make_edge (switch_bb
, nentry_bb
, exits
[0]->flags
);
5982 /* Register the new edge from SWITCH_BB in loop exit lists. */
5983 rescan_loop_exit (snew
, true, false);
5985 /* Add the PHI node arguments. */
5986 add_phi_args_after_copy (region_copy
, n_region
, snew
);
5988 /* Get rid of now superfluous conditions and associated edges (and phi node
5990 exit_bb
= exit
->dest
;
5992 e
= redirect_edge_and_branch (exits
[0], exits
[1]->dest
);
5993 PENDING_STMT (e
) = NULL
;
5995 /* The latch of ORIG_LOOP was copied, and so was the backedge
5996 to the original header. We redirect this backedge to EXIT_BB. */
5997 for (i
= 0; i
< n_region
; i
++)
5998 if (get_bb_original (region_copy
[i
]) == orig_loop
->latch
)
6000 gcc_assert (single_succ_edge (region_copy
[i
]));
6001 e
= redirect_edge_and_branch (single_succ_edge (region_copy
[i
]), exit_bb
);
6002 PENDING_STMT (e
) = NULL
;
6003 for (psi
= gsi_start_phis (exit_bb
);
6007 phi
= gsi_stmt (psi
);
6008 def
= PHI_ARG_DEF (phi
, nexits
[0]->dest_idx
);
6009 add_phi_arg (phi
, def
, e
, gimple_phi_arg_location_from_edge (phi
, e
));
6012 e
= redirect_edge_and_branch (nexits
[1], nexits
[0]->dest
);
6013 PENDING_STMT (e
) = NULL
;
6015 /* Anything that is outside of the region, but was dominated by something
6016 inside needs to update dominance info. */
6017 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6019 /* Update the SSA web. */
6020 update_ssa (TODO_update_ssa
);
6022 if (free_region_copy
)
6025 free_original_copy_tables ();
6029 /* Add all the blocks dominated by ENTRY to the array BBS_P. Stop
6030 adding blocks when the dominator traversal reaches EXIT. This
6031 function silently assumes that ENTRY strictly dominates EXIT. */
6034 gather_blocks_in_sese_region (basic_block entry
, basic_block exit
,
6035 vec
<basic_block
> *bbs_p
)
6039 for (son
= first_dom_son (CDI_DOMINATORS
, entry
);
6041 son
= next_dom_son (CDI_DOMINATORS
, son
))
6043 bbs_p
->safe_push (son
);
6045 gather_blocks_in_sese_region (son
, exit
, bbs_p
);
6049 /* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
6050 The duplicates are recorded in VARS_MAP. */
6053 replace_by_duplicate_decl (tree
*tp
, struct pointer_map_t
*vars_map
,
6056 tree t
= *tp
, new_t
;
6057 struct function
*f
= DECL_STRUCT_FUNCTION (to_context
);
6060 if (DECL_CONTEXT (t
) == to_context
)
6063 loc
= pointer_map_contains (vars_map
, t
);
6067 loc
= pointer_map_insert (vars_map
, t
);
6071 new_t
= copy_var_decl (t
, DECL_NAME (t
), TREE_TYPE (t
));
6072 add_local_decl (f
, new_t
);
6076 gcc_assert (TREE_CODE (t
) == CONST_DECL
);
6077 new_t
= copy_node (t
);
6079 DECL_CONTEXT (new_t
) = to_context
;
6084 new_t
= (tree
) *loc
;
6090 /* Creates an ssa name in TO_CONTEXT equivalent to NAME.
6091 VARS_MAP maps old ssa names and var_decls to the new ones. */
6094 replace_ssa_name (tree name
, struct pointer_map_t
*vars_map
,
6100 gcc_assert (!virtual_operand_p (name
));
6102 loc
= pointer_map_contains (vars_map
, name
);
6106 tree decl
= SSA_NAME_VAR (name
);
6109 replace_by_duplicate_decl (&decl
, vars_map
, to_context
);
6110 new_name
= make_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6111 decl
, SSA_NAME_DEF_STMT (name
));
6112 if (SSA_NAME_IS_DEFAULT_DEF (name
))
6113 set_ssa_default_def (DECL_STRUCT_FUNCTION (to_context
),
6117 new_name
= copy_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6118 name
, SSA_NAME_DEF_STMT (name
));
6120 loc
= pointer_map_insert (vars_map
, name
);
6124 new_name
= (tree
) *loc
;
6135 struct pointer_map_t
*vars_map
;
6136 htab_t new_label_map
;
6137 struct pointer_map_t
*eh_map
;
6141 /* Helper for move_block_to_fn. Set TREE_BLOCK in every expression
6142 contained in *TP if it has been ORIG_BLOCK previously and change the
6143 DECL_CONTEXT of every local variable referenced in *TP. */
6146 move_stmt_op (tree
*tp
, int *walk_subtrees
, void *data
)
6148 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
6149 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6154 tree block
= TREE_BLOCK (t
);
6155 if (block
== p
->orig_block
6156 || (p
->orig_block
== NULL_TREE
6157 && block
!= NULL_TREE
))
6158 TREE_SET_BLOCK (t
, p
->new_block
);
6159 #ifdef ENABLE_CHECKING
6160 else if (block
!= NULL_TREE
)
6162 while (block
&& TREE_CODE (block
) == BLOCK
&& block
!= p
->orig_block
)
6163 block
= BLOCK_SUPERCONTEXT (block
);
6164 gcc_assert (block
== p
->orig_block
);
6168 else if (DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
)
6170 if (TREE_CODE (t
) == SSA_NAME
)
6171 *tp
= replace_ssa_name (t
, p
->vars_map
, p
->to_context
);
6172 else if (TREE_CODE (t
) == LABEL_DECL
)
6174 if (p
->new_label_map
)
6176 struct tree_map in
, *out
;
6178 out
= (struct tree_map
*)
6179 htab_find_with_hash (p
->new_label_map
, &in
, DECL_UID (t
));
6184 DECL_CONTEXT (t
) = p
->to_context
;
6186 else if (p
->remap_decls_p
)
6188 /* Replace T with its duplicate. T should no longer appear in the
6189 parent function, so this looks wasteful; however, it may appear
6190 in referenced_vars, and more importantly, as virtual operands of
6191 statements, and in alias lists of other variables. It would be
6192 quite difficult to expunge it from all those places. ??? It might
6193 suffice to do this for addressable variables. */
6194 if ((TREE_CODE (t
) == VAR_DECL
6195 && !is_global_var (t
))
6196 || TREE_CODE (t
) == CONST_DECL
)
6197 replace_by_duplicate_decl (tp
, p
->vars_map
, p
->to_context
);
6201 else if (TYPE_P (t
))
6207 /* Helper for move_stmt_r. Given an EH region number for the source
6208 function, map that to the duplicate EH regio number in the dest. */
6211 move_stmt_eh_region_nr (int old_nr
, struct move_stmt_d
*p
)
6213 eh_region old_r
, new_r
;
6216 old_r
= get_eh_region_from_number (old_nr
);
6217 slot
= pointer_map_contains (p
->eh_map
, old_r
);
6218 new_r
= (eh_region
) *slot
;
6220 return new_r
->index
;
6223 /* Similar, but operate on INTEGER_CSTs. */
6226 move_stmt_eh_region_tree_nr (tree old_t_nr
, struct move_stmt_d
*p
)
6230 old_nr
= tree_low_cst (old_t_nr
, 0);
6231 new_nr
= move_stmt_eh_region_nr (old_nr
, p
);
6233 return build_int_cst (integer_type_node
, new_nr
);
6236 /* Like move_stmt_op, but for gimple statements.
6238 Helper for move_block_to_fn. Set GIMPLE_BLOCK in every expression
6239 contained in the current statement in *GSI_P and change the
6240 DECL_CONTEXT of every local variable referenced in the current
6244 move_stmt_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
6245 struct walk_stmt_info
*wi
)
6247 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6248 gimple stmt
= gsi_stmt (*gsi_p
);
6249 tree block
= gimple_block (stmt
);
6251 if (block
== p
->orig_block
6252 || (p
->orig_block
== NULL_TREE
6253 && block
!= NULL_TREE
))
6254 gimple_set_block (stmt
, p
->new_block
);
6256 switch (gimple_code (stmt
))
6259 /* Remap the region numbers for __builtin_eh_{pointer,filter}. */
6261 tree r
, fndecl
= gimple_call_fndecl (stmt
);
6262 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
6263 switch (DECL_FUNCTION_CODE (fndecl
))
6265 case BUILT_IN_EH_COPY_VALUES
:
6266 r
= gimple_call_arg (stmt
, 1);
6267 r
= move_stmt_eh_region_tree_nr (r
, p
);
6268 gimple_call_set_arg (stmt
, 1, r
);
6271 case BUILT_IN_EH_POINTER
:
6272 case BUILT_IN_EH_FILTER
:
6273 r
= gimple_call_arg (stmt
, 0);
6274 r
= move_stmt_eh_region_tree_nr (r
, p
);
6275 gimple_call_set_arg (stmt
, 0, r
);
6286 int r
= gimple_resx_region (stmt
);
6287 r
= move_stmt_eh_region_nr (r
, p
);
6288 gimple_resx_set_region (stmt
, r
);
6292 case GIMPLE_EH_DISPATCH
:
6294 int r
= gimple_eh_dispatch_region (stmt
);
6295 r
= move_stmt_eh_region_nr (r
, p
);
6296 gimple_eh_dispatch_set_region (stmt
, r
);
6300 case GIMPLE_OMP_RETURN
:
6301 case GIMPLE_OMP_CONTINUE
:
6304 if (is_gimple_omp (stmt
))
6306 /* Do not remap variables inside OMP directives. Variables
6307 referenced in clauses and directive header belong to the
6308 parent function and should not be moved into the child
6310 bool save_remap_decls_p
= p
->remap_decls_p
;
6311 p
->remap_decls_p
= false;
6312 *handled_ops_p
= true;
6314 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt
), move_stmt_r
,
6317 p
->remap_decls_p
= save_remap_decls_p
;
6325 /* Move basic block BB from function CFUN to function DEST_FN. The
6326 block is moved out of the original linked list and placed after
6327 block AFTER in the new list. Also, the block is removed from the
6328 original array of blocks and placed in DEST_FN's array of blocks.
6329 If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
6330 updated to reflect the moved edges.
6332 The local variables are remapped to new instances, VARS_MAP is used
6333 to record the mapping. */
6336 move_block_to_fn (struct function
*dest_cfun
, basic_block bb
,
6337 basic_block after
, bool update_edge_count_p
,
6338 struct move_stmt_d
*d
)
6340 struct control_flow_graph
*cfg
;
6343 gimple_stmt_iterator si
;
6344 unsigned old_len
, new_len
;
6346 /* Remove BB from dominance structures. */
6347 delete_from_dominance_info (CDI_DOMINATORS
, bb
);
6349 /* Move BB from its current loop to the copy in the new function. */
6352 struct loop
*new_loop
= (struct loop
*)bb
->loop_father
->aux
;
6354 bb
->loop_father
= new_loop
;
6357 /* Link BB to the new linked list. */
6358 move_block_after (bb
, after
);
6360 /* Update the edge count in the corresponding flowgraphs. */
6361 if (update_edge_count_p
)
6362 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6364 cfun
->cfg
->x_n_edges
--;
6365 dest_cfun
->cfg
->x_n_edges
++;
6368 /* Remove BB from the original basic block array. */
6369 (*cfun
->cfg
->x_basic_block_info
)[bb
->index
] = NULL
;
6370 cfun
->cfg
->x_n_basic_blocks
--;
6372 /* Grow DEST_CFUN's basic block array if needed. */
6373 cfg
= dest_cfun
->cfg
;
6374 cfg
->x_n_basic_blocks
++;
6375 if (bb
->index
>= cfg
->x_last_basic_block
)
6376 cfg
->x_last_basic_block
= bb
->index
+ 1;
6378 old_len
= vec_safe_length (cfg
->x_basic_block_info
);
6379 if ((unsigned) cfg
->x_last_basic_block
>= old_len
)
6381 new_len
= cfg
->x_last_basic_block
+ (cfg
->x_last_basic_block
+ 3) / 4;
6382 vec_safe_grow_cleared (cfg
->x_basic_block_info
, new_len
);
6385 (*cfg
->x_basic_block_info
)[bb
->index
] = bb
;
6387 /* Remap the variables in phi nodes. */
6388 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); )
6390 gimple phi
= gsi_stmt (si
);
6392 tree op
= PHI_RESULT (phi
);
6396 if (virtual_operand_p (op
))
6398 /* Remove the phi nodes for virtual operands (alias analysis will be
6399 run for the new function, anyway). */
6400 remove_phi_node (&si
, true);
6404 SET_PHI_RESULT (phi
,
6405 replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
6406 FOR_EACH_PHI_ARG (use
, phi
, oi
, SSA_OP_USE
)
6408 op
= USE_FROM_PTR (use
);
6409 if (TREE_CODE (op
) == SSA_NAME
)
6410 SET_USE (use
, replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
6413 for (i
= 0; i
< EDGE_COUNT (bb
->preds
); i
++)
6415 location_t locus
= gimple_phi_arg_location (phi
, i
);
6416 tree block
= LOCATION_BLOCK (locus
);
6418 if (locus
== UNKNOWN_LOCATION
)
6420 if (d
->orig_block
== NULL_TREE
|| block
== d
->orig_block
)
6422 if (d
->new_block
== NULL_TREE
)
6423 locus
= LOCATION_LOCUS (locus
);
6425 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, d
->new_block
);
6426 gimple_phi_arg_set_location (phi
, i
, locus
);
6433 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6435 gimple stmt
= gsi_stmt (si
);
6436 struct walk_stmt_info wi
;
6438 memset (&wi
, 0, sizeof (wi
));
6440 walk_gimple_stmt (&si
, move_stmt_r
, move_stmt_op
, &wi
);
6442 if (gimple_code (stmt
) == GIMPLE_LABEL
)
6444 tree label
= gimple_label_label (stmt
);
6445 int uid
= LABEL_DECL_UID (label
);
6447 gcc_assert (uid
> -1);
6449 old_len
= vec_safe_length (cfg
->x_label_to_block_map
);
6450 if (old_len
<= (unsigned) uid
)
6452 new_len
= 3 * uid
/ 2 + 1;
6453 vec_safe_grow_cleared (cfg
->x_label_to_block_map
, new_len
);
6456 (*cfg
->x_label_to_block_map
)[uid
] = bb
;
6457 (*cfun
->cfg
->x_label_to_block_map
)[uid
] = NULL
;
6459 gcc_assert (DECL_CONTEXT (label
) == dest_cfun
->decl
);
6461 if (uid
>= dest_cfun
->cfg
->last_label_uid
)
6462 dest_cfun
->cfg
->last_label_uid
= uid
+ 1;
6465 maybe_duplicate_eh_stmt_fn (dest_cfun
, stmt
, cfun
, stmt
, d
->eh_map
, 0);
6466 remove_stmt_from_eh_lp_fn (cfun
, stmt
);
6468 gimple_duplicate_stmt_histograms (dest_cfun
, stmt
, cfun
, stmt
);
6469 gimple_remove_stmt_histograms (cfun
, stmt
);
6471 /* We cannot leave any operands allocated from the operand caches of
6472 the current function. */
6473 free_stmt_operands (stmt
);
6474 push_cfun (dest_cfun
);
6479 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6480 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
6482 tree block
= LOCATION_BLOCK (e
->goto_locus
);
6483 if (d
->orig_block
== NULL_TREE
6484 || block
== d
->orig_block
)
6485 e
->goto_locus
= d
->new_block
?
6486 COMBINE_LOCATION_DATA (line_table
, e
->goto_locus
, d
->new_block
) :
6487 LOCATION_LOCUS (e
->goto_locus
);
6491 /* Examine the statements in BB (which is in SRC_CFUN); find and return
6492 the outermost EH region. Use REGION as the incoming base EH region. */
6495 find_outermost_region_in_block (struct function
*src_cfun
,
6496 basic_block bb
, eh_region region
)
6498 gimple_stmt_iterator si
;
6500 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6502 gimple stmt
= gsi_stmt (si
);
6503 eh_region stmt_region
;
6506 lp_nr
= lookup_stmt_eh_lp_fn (src_cfun
, stmt
);
6507 stmt_region
= get_eh_region_from_lp_number_fn (src_cfun
, lp_nr
);
6511 region
= stmt_region
;
6512 else if (stmt_region
!= region
)
6514 region
= eh_region_outermost (src_cfun
, stmt_region
, region
);
6515 gcc_assert (region
!= NULL
);
6524 new_label_mapper (tree decl
, void *data
)
6526 htab_t hash
= (htab_t
) data
;
6530 gcc_assert (TREE_CODE (decl
) == LABEL_DECL
);
6532 m
= XNEW (struct tree_map
);
6533 m
->hash
= DECL_UID (decl
);
6534 m
->base
.from
= decl
;
6535 m
->to
= create_artificial_label (UNKNOWN_LOCATION
);
6536 LABEL_DECL_UID (m
->to
) = LABEL_DECL_UID (decl
);
6537 if (LABEL_DECL_UID (m
->to
) >= cfun
->cfg
->last_label_uid
)
6538 cfun
->cfg
->last_label_uid
= LABEL_DECL_UID (m
->to
) + 1;
6540 slot
= htab_find_slot_with_hash (hash
, m
, m
->hash
, INSERT
);
6541 gcc_assert (*slot
== NULL
);
6548 /* Change DECL_CONTEXT of all BLOCK_VARS in block, including
6552 replace_block_vars_by_duplicates (tree block
, struct pointer_map_t
*vars_map
,
6557 for (tp
= &BLOCK_VARS (block
); *tp
; tp
= &DECL_CHAIN (*tp
))
6560 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != CONST_DECL
)
6562 replace_by_duplicate_decl (&t
, vars_map
, to_context
);
6565 if (TREE_CODE (*tp
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (*tp
))
6567 SET_DECL_VALUE_EXPR (t
, DECL_VALUE_EXPR (*tp
));
6568 DECL_HAS_VALUE_EXPR_P (t
) = 1;
6570 DECL_CHAIN (t
) = DECL_CHAIN (*tp
);
6575 for (block
= BLOCK_SUBBLOCKS (block
); block
; block
= BLOCK_CHAIN (block
))
6576 replace_block_vars_by_duplicates (block
, vars_map
, to_context
);
6579 /* Fixup the loop arrays and numbers after moving LOOP and its subloops
6583 fixup_loop_arrays_after_move (struct function
*fn1
, struct function
*fn2
,
6586 /* Discard it from the old loop array. */
6587 (*get_loops (fn1
))[loop
->num
] = NULL
;
6589 /* Place it in the new loop array, assigning it a new number. */
6590 loop
->num
= number_of_loops (fn2
);
6591 vec_safe_push (loops_for_fn (fn2
)->larray
, loop
);
6593 /* Recurse to children. */
6594 for (loop
= loop
->inner
; loop
; loop
= loop
->next
)
6595 fixup_loop_arrays_after_move (fn1
, fn2
, loop
);
6598 /* Move a single-entry, single-exit region delimited by ENTRY_BB and
6599 EXIT_BB to function DEST_CFUN. The whole region is replaced by a
6600 single basic block in the original CFG and the new basic block is
6601 returned. DEST_CFUN must not have a CFG yet.
6603 Note that the region need not be a pure SESE region. Blocks inside
6604 the region may contain calls to abort/exit. The only restriction
6605 is that ENTRY_BB should be the only entry point and it must
6608 Change TREE_BLOCK of all statements in ORIG_BLOCK to the new
6609 functions outermost BLOCK, move all subblocks of ORIG_BLOCK
6610 to the new function.
6612 All local variables referenced in the region are assumed to be in
6613 the corresponding BLOCK_VARS and unexpanded variable lists
6614 associated with DEST_CFUN. */
6617 move_sese_region_to_fn (struct function
*dest_cfun
, basic_block entry_bb
,
6618 basic_block exit_bb
, tree orig_block
)
6620 vec
<basic_block
> bbs
, dom_bbs
;
6621 basic_block dom_entry
= get_immediate_dominator (CDI_DOMINATORS
, entry_bb
);
6622 basic_block after
, bb
, *entry_pred
, *exit_succ
, abb
;
6623 struct function
*saved_cfun
= cfun
;
6624 int *entry_flag
, *exit_flag
;
6625 unsigned *entry_prob
, *exit_prob
;
6626 unsigned i
, num_entry_edges
, num_exit_edges
, num_nodes
;
6629 htab_t new_label_map
;
6630 struct pointer_map_t
*vars_map
, *eh_map
;
6631 struct loop
*loop
= entry_bb
->loop_father
;
6632 struct loop
*loop0
= get_loop (saved_cfun
, 0);
6633 struct move_stmt_d d
;
6635 /* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
6637 gcc_assert (entry_bb
!= exit_bb
6639 || dominated_by_p (CDI_DOMINATORS
, exit_bb
, entry_bb
)));
6641 /* Collect all the blocks in the region. Manually add ENTRY_BB
6642 because it won't be added by dfs_enumerate_from. */
6644 bbs
.safe_push (entry_bb
);
6645 gather_blocks_in_sese_region (entry_bb
, exit_bb
, &bbs
);
6647 /* The blocks that used to be dominated by something in BBS will now be
6648 dominated by the new block. */
6649 dom_bbs
= get_dominated_by_region (CDI_DOMINATORS
,
6653 /* Detach ENTRY_BB and EXIT_BB from CFUN->CFG. We need to remember
6654 the predecessor edges to ENTRY_BB and the successor edges to
6655 EXIT_BB so that we can re-attach them to the new basic block that
6656 will replace the region. */
6657 num_entry_edges
= EDGE_COUNT (entry_bb
->preds
);
6658 entry_pred
= XNEWVEC (basic_block
, num_entry_edges
);
6659 entry_flag
= XNEWVEC (int, num_entry_edges
);
6660 entry_prob
= XNEWVEC (unsigned, num_entry_edges
);
6662 for (ei
= ei_start (entry_bb
->preds
); (e
= ei_safe_edge (ei
)) != NULL
;)
6664 entry_prob
[i
] = e
->probability
;
6665 entry_flag
[i
] = e
->flags
;
6666 entry_pred
[i
++] = e
->src
;
6672 num_exit_edges
= EDGE_COUNT (exit_bb
->succs
);
6673 exit_succ
= XNEWVEC (basic_block
, num_exit_edges
);
6674 exit_flag
= XNEWVEC (int, num_exit_edges
);
6675 exit_prob
= XNEWVEC (unsigned, num_exit_edges
);
6677 for (ei
= ei_start (exit_bb
->succs
); (e
= ei_safe_edge (ei
)) != NULL
;)
6679 exit_prob
[i
] = e
->probability
;
6680 exit_flag
[i
] = e
->flags
;
6681 exit_succ
[i
++] = e
->dest
;
6693 /* Switch context to the child function to initialize DEST_FN's CFG. */
6694 gcc_assert (dest_cfun
->cfg
== NULL
);
6695 push_cfun (dest_cfun
);
6697 init_empty_tree_cfg ();
6699 /* Initialize EH information for the new function. */
6701 new_label_map
= NULL
;
6704 eh_region region
= NULL
;
6706 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6707 region
= find_outermost_region_in_block (saved_cfun
, bb
, region
);
6709 init_eh_for_function ();
6712 new_label_map
= htab_create (17, tree_map_hash
, tree_map_eq
, free
);
6713 eh_map
= duplicate_eh_regions (saved_cfun
, region
, 0,
6714 new_label_mapper
, new_label_map
);
6718 /* Initialize an empty loop tree. */
6719 struct loops
*loops
= ggc_alloc_cleared_loops ();
6720 init_loops_structure (dest_cfun
, loops
, 1);
6721 loops
->state
= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
6722 set_loops_for_fn (dest_cfun
, loops
);
6724 /* Move the outlined loop tree part. */
6725 num_nodes
= bbs
.length ();
6726 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6728 if (bb
->loop_father
->header
== bb
)
6730 struct loop
*this_loop
= bb
->loop_father
;
6731 struct loop
*outer
= loop_outer (this_loop
);
6733 /* If the SESE region contains some bbs ending with
6734 a noreturn call, those are considered to belong
6735 to the outermost loop in saved_cfun, rather than
6736 the entry_bb's loop_father. */
6740 num_nodes
-= this_loop
->num_nodes
;
6741 flow_loop_tree_node_remove (bb
->loop_father
);
6742 flow_loop_tree_node_add (get_loop (dest_cfun
, 0), this_loop
);
6743 fixup_loop_arrays_after_move (saved_cfun
, cfun
, this_loop
);
6746 else if (bb
->loop_father
== loop0
&& loop0
!= loop
)
6749 /* Remove loop exits from the outlined region. */
6750 if (loops_for_fn (saved_cfun
)->exits
)
6751 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6753 void **slot
= htab_find_slot_with_hash
6754 (loops_for_fn (saved_cfun
)->exits
, e
,
6755 htab_hash_pointer (e
), NO_INSERT
);
6757 htab_clear_slot (loops_for_fn (saved_cfun
)->exits
, slot
);
6762 /* Adjust the number of blocks in the tree root of the outlined part. */
6763 get_loop (dest_cfun
, 0)->num_nodes
= bbs
.length () + 2;
6765 /* Setup a mapping to be used by move_block_to_fn. */
6766 loop
->aux
= current_loops
->tree_root
;
6767 loop0
->aux
= current_loops
->tree_root
;
6771 /* Move blocks from BBS into DEST_CFUN. */
6772 gcc_assert (bbs
.length () >= 2);
6773 after
= dest_cfun
->cfg
->x_entry_block_ptr
;
6774 vars_map
= pointer_map_create ();
6776 memset (&d
, 0, sizeof (d
));
6777 d
.orig_block
= orig_block
;
6778 d
.new_block
= DECL_INITIAL (dest_cfun
->decl
);
6779 d
.from_context
= cfun
->decl
;
6780 d
.to_context
= dest_cfun
->decl
;
6781 d
.vars_map
= vars_map
;
6782 d
.new_label_map
= new_label_map
;
6784 d
.remap_decls_p
= true;
6786 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6788 /* No need to update edge counts on the last block. It has
6789 already been updated earlier when we detached the region from
6790 the original CFG. */
6791 move_block_to_fn (dest_cfun
, bb
, after
, bb
!= exit_bb
, &d
);
6797 /* Loop sizes are no longer correct, fix them up. */
6798 loop
->num_nodes
-= num_nodes
;
6799 for (struct loop
*outer
= loop_outer (loop
);
6800 outer
; outer
= loop_outer (outer
))
6801 outer
->num_nodes
-= num_nodes
;
6802 loop0
->num_nodes
-= bbs
.length () - num_nodes
;
6804 if (saved_cfun
->has_simduid_loops
|| saved_cfun
->has_force_vect_loops
)
6807 for (i
= 0; vec_safe_iterate (loops
->larray
, i
, &aloop
); i
++)
6812 replace_by_duplicate_decl (&aloop
->simduid
, d
.vars_map
,
6814 dest_cfun
->has_simduid_loops
= true;
6816 if (aloop
->force_vect
)
6817 dest_cfun
->has_force_vect_loops
= true;
6821 /* Rewire BLOCK_SUBBLOCKS of orig_block. */
6825 gcc_assert (BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
6827 BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
6828 = BLOCK_SUBBLOCKS (orig_block
);
6829 for (block
= BLOCK_SUBBLOCKS (orig_block
);
6830 block
; block
= BLOCK_CHAIN (block
))
6831 BLOCK_SUPERCONTEXT (block
) = DECL_INITIAL (dest_cfun
->decl
);
6832 BLOCK_SUBBLOCKS (orig_block
) = NULL_TREE
;
6835 replace_block_vars_by_duplicates (DECL_INITIAL (dest_cfun
->decl
),
6836 vars_map
, dest_cfun
->decl
);
6839 htab_delete (new_label_map
);
6841 pointer_map_destroy (eh_map
);
6842 pointer_map_destroy (vars_map
);
6844 /* Rewire the entry and exit blocks. The successor to the entry
6845 block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
6846 the child function. Similarly, the predecessor of DEST_FN's
6847 EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR. We
6848 need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
6849 various CFG manipulation function get to the right CFG.
6851 FIXME, this is silly. The CFG ought to become a parameter to
6853 push_cfun (dest_cfun
);
6854 make_edge (ENTRY_BLOCK_PTR
, entry_bb
, EDGE_FALLTHRU
);
6856 make_edge (exit_bb
, EXIT_BLOCK_PTR
, 0);
6859 /* Back in the original function, the SESE region has disappeared,
6860 create a new basic block in its place. */
6861 bb
= create_empty_bb (entry_pred
[0]);
6863 add_bb_to_loop (bb
, loop
);
6864 for (i
= 0; i
< num_entry_edges
; i
++)
6866 e
= make_edge (entry_pred
[i
], bb
, entry_flag
[i
]);
6867 e
->probability
= entry_prob
[i
];
6870 for (i
= 0; i
< num_exit_edges
; i
++)
6872 e
= make_edge (bb
, exit_succ
[i
], exit_flag
[i
]);
6873 e
->probability
= exit_prob
[i
];
6876 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom_entry
);
6877 FOR_EACH_VEC_ELT (dom_bbs
, i
, abb
)
6878 set_immediate_dominator (CDI_DOMINATORS
, abb
, bb
);
6896 /* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in dumpfile.h)
6900 dump_function_to_file (tree fndecl
, FILE *file
, int flags
)
6902 tree arg
, var
, old_current_fndecl
= current_function_decl
;
6903 struct function
*dsf
;
6904 bool ignore_topmost_bind
= false, any_var
= false;
6907 bool tmclone
= (TREE_CODE (fndecl
) == FUNCTION_DECL
6908 && decl_is_tm_clone (fndecl
));
6909 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
6911 current_function_decl
= fndecl
;
6912 fprintf (file
, "%s %s(", function_name (fun
), tmclone
? "[tm-clone] " : "");
6914 arg
= DECL_ARGUMENTS (fndecl
);
6917 print_generic_expr (file
, TREE_TYPE (arg
), dump_flags
);
6918 fprintf (file
, " ");
6919 print_generic_expr (file
, arg
, dump_flags
);
6920 if (flags
& TDF_VERBOSE
)
6921 print_node (file
, "", arg
, 4);
6922 if (DECL_CHAIN (arg
))
6923 fprintf (file
, ", ");
6924 arg
= DECL_CHAIN (arg
);
6926 fprintf (file
, ")\n");
6928 if (flags
& TDF_VERBOSE
)
6929 print_node (file
, "", fndecl
, 2);
6931 dsf
= DECL_STRUCT_FUNCTION (fndecl
);
6932 if (dsf
&& (flags
& TDF_EH
))
6933 dump_eh_tree (file
, dsf
);
6935 if (flags
& TDF_RAW
&& !gimple_has_body_p (fndecl
))
6937 dump_node (fndecl
, TDF_SLIM
| flags
, file
);
6938 current_function_decl
= old_current_fndecl
;
6942 /* When GIMPLE is lowered, the variables are no longer available in
6943 BIND_EXPRs, so display them separately. */
6944 if (fun
&& fun
->decl
== fndecl
&& (fun
->curr_properties
& PROP_gimple_lcf
))
6947 ignore_topmost_bind
= true;
6949 fprintf (file
, "{\n");
6950 if (!vec_safe_is_empty (fun
->local_decls
))
6951 FOR_EACH_LOCAL_DECL (fun
, ix
, var
)
6953 print_generic_decl (file
, var
, flags
);
6954 if (flags
& TDF_VERBOSE
)
6955 print_node (file
, "", var
, 4);
6956 fprintf (file
, "\n");
6960 if (gimple_in_ssa_p (cfun
))
6961 for (ix
= 1; ix
< num_ssa_names
; ++ix
)
6963 tree name
= ssa_name (ix
);
6964 if (name
&& !SSA_NAME_VAR (name
))
6966 fprintf (file
, " ");
6967 print_generic_expr (file
, TREE_TYPE (name
), flags
);
6968 fprintf (file
, " ");
6969 print_generic_expr (file
, name
, flags
);
6970 fprintf (file
, ";\n");
6977 if (fun
&& fun
->decl
== fndecl
6979 && basic_block_info_for_function (fun
))
6981 /* If the CFG has been built, emit a CFG-based dump. */
6982 if (!ignore_topmost_bind
)
6983 fprintf (file
, "{\n");
6985 if (any_var
&& n_basic_blocks_for_function (fun
))
6986 fprintf (file
, "\n");
6988 FOR_EACH_BB_FN (bb
, fun
)
6989 dump_bb (file
, bb
, 2, flags
| TDF_COMMENT
);
6991 fprintf (file
, "}\n");
6993 else if (DECL_SAVED_TREE (fndecl
) == NULL
)
6995 /* The function is now in GIMPLE form but the CFG has not been
6996 built yet. Emit the single sequence of GIMPLE statements
6997 that make up its body. */
6998 gimple_seq body
= gimple_body (fndecl
);
7000 if (gimple_seq_first_stmt (body
)
7001 && gimple_seq_first_stmt (body
) == gimple_seq_last_stmt (body
)
7002 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
)
7003 print_gimple_seq (file
, body
, 0, flags
);
7006 if (!ignore_topmost_bind
)
7007 fprintf (file
, "{\n");
7010 fprintf (file
, "\n");
7012 print_gimple_seq (file
, body
, 2, flags
);
7013 fprintf (file
, "}\n");
7020 /* Make a tree based dump. */
7021 chain
= DECL_SAVED_TREE (fndecl
);
7022 if (chain
&& TREE_CODE (chain
) == BIND_EXPR
)
7024 if (ignore_topmost_bind
)
7026 chain
= BIND_EXPR_BODY (chain
);
7034 if (!ignore_topmost_bind
)
7035 fprintf (file
, "{\n");
7040 fprintf (file
, "\n");
7042 print_generic_stmt_indented (file
, chain
, flags
, indent
);
7043 if (ignore_topmost_bind
)
7044 fprintf (file
, "}\n");
7047 if (flags
& TDF_ENUMERATE_LOCALS
)
7048 dump_enumerated_decls (file
, flags
);
7049 fprintf (file
, "\n\n");
7051 current_function_decl
= old_current_fndecl
;
7054 /* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h) */
7057 debug_function (tree fn
, int flags
)
7059 dump_function_to_file (fn
, stderr
, flags
);
7063 /* Print on FILE the indexes for the predecessors of basic_block BB. */
7066 print_pred_bbs (FILE *file
, basic_block bb
)
7071 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7072 fprintf (file
, "bb_%d ", e
->src
->index
);
7076 /* Print on FILE the indexes for the successors of basic_block BB. */
7079 print_succ_bbs (FILE *file
, basic_block bb
)
7084 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7085 fprintf (file
, "bb_%d ", e
->dest
->index
);
7088 /* Print to FILE the basic block BB following the VERBOSITY level. */
7091 print_loops_bb (FILE *file
, basic_block bb
, int indent
, int verbosity
)
7093 char *s_indent
= (char *) alloca ((size_t) indent
+ 1);
7094 memset ((void *) s_indent
, ' ', (size_t) indent
);
7095 s_indent
[indent
] = '\0';
7097 /* Print basic_block's header. */
7100 fprintf (file
, "%s bb_%d (preds = {", s_indent
, bb
->index
);
7101 print_pred_bbs (file
, bb
);
7102 fprintf (file
, "}, succs = {");
7103 print_succ_bbs (file
, bb
);
7104 fprintf (file
, "})\n");
7107 /* Print basic_block's body. */
7110 fprintf (file
, "%s {\n", s_indent
);
7111 dump_bb (file
, bb
, indent
+ 4, TDF_VOPS
|TDF_MEMSYMS
);
7112 fprintf (file
, "%s }\n", s_indent
);
7116 static void print_loop_and_siblings (FILE *, struct loop
*, int, int);
7118 /* Pretty print LOOP on FILE, indented INDENT spaces. Following
7119 VERBOSITY level this outputs the contents of the loop, or just its
7123 print_loop (FILE *file
, struct loop
*loop
, int indent
, int verbosity
)
7131 s_indent
= (char *) alloca ((size_t) indent
+ 1);
7132 memset ((void *) s_indent
, ' ', (size_t) indent
);
7133 s_indent
[indent
] = '\0';
7135 /* Print loop's header. */
7136 fprintf (file
, "%sloop_%d (", s_indent
, loop
->num
);
7138 fprintf (file
, "header = %d", loop
->header
->index
);
7141 fprintf (file
, "deleted)\n");
7145 fprintf (file
, ", latch = %d", loop
->latch
->index
);
7147 fprintf (file
, ", multiple latches");
7148 fprintf (file
, ", niter = ");
7149 print_generic_expr (file
, loop
->nb_iterations
, 0);
7151 if (loop
->any_upper_bound
)
7153 fprintf (file
, ", upper_bound = ");
7154 dump_double_int (file
, loop
->nb_iterations_upper_bound
, true);
7157 if (loop
->any_estimate
)
7159 fprintf (file
, ", estimate = ");
7160 dump_double_int (file
, loop
->nb_iterations_estimate
, true);
7162 fprintf (file
, ")\n");
7164 /* Print loop's body. */
7167 fprintf (file
, "%s{\n", s_indent
);
7169 if (bb
->loop_father
== loop
)
7170 print_loops_bb (file
, bb
, indent
, verbosity
);
7172 print_loop_and_siblings (file
, loop
->inner
, indent
+ 2, verbosity
);
7173 fprintf (file
, "%s}\n", s_indent
);
7177 /* Print the LOOP and its sibling loops on FILE, indented INDENT
7178 spaces. Following VERBOSITY level this outputs the contents of the
7179 loop, or just its structure. */
7182 print_loop_and_siblings (FILE *file
, struct loop
*loop
, int indent
,
7188 print_loop (file
, loop
, indent
, verbosity
);
7189 print_loop_and_siblings (file
, loop
->next
, indent
, verbosity
);
7192 /* Follow a CFG edge from the entry point of the program, and on entry
7193 of a loop, pretty print the loop structure on FILE. */
7196 print_loops (FILE *file
, int verbosity
)
7200 bb
= ENTRY_BLOCK_PTR
;
7201 if (bb
&& bb
->loop_father
)
7202 print_loop_and_siblings (file
, bb
->loop_father
, 0, verbosity
);
7208 debug (struct loop
&ref
)
7210 print_loop (stderr
, &ref
, 0, /*verbosity*/0);
7214 debug (struct loop
*ptr
)
7219 fprintf (stderr
, "<nil>\n");
7222 /* Dump a loop verbosely. */
7225 debug_verbose (struct loop
&ref
)
7227 print_loop (stderr
, &ref
, 0, /*verbosity*/3);
7231 debug_verbose (struct loop
*ptr
)
7236 fprintf (stderr
, "<nil>\n");
7240 /* Debugging loops structure at tree level, at some VERBOSITY level. */
7243 debug_loops (int verbosity
)
7245 print_loops (stderr
, verbosity
);
7248 /* Print on stderr the code of LOOP, at some VERBOSITY level. */
7251 debug_loop (struct loop
*loop
, int verbosity
)
7253 print_loop (stderr
, loop
, 0, verbosity
);
7256 /* Print on stderr the code of loop number NUM, at some VERBOSITY
7260 debug_loop_num (unsigned num
, int verbosity
)
7262 debug_loop (get_loop (cfun
, num
), verbosity
);
7265 /* Return true if BB ends with a call, possibly followed by some
7266 instructions that must stay with the call. Return false,
7270 gimple_block_ends_with_call_p (basic_block bb
)
7272 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
7273 return !gsi_end_p (gsi
) && is_gimple_call (gsi_stmt (gsi
));
7277 /* Return true if BB ends with a conditional branch. Return false,
7281 gimple_block_ends_with_condjump_p (const_basic_block bb
)
7283 gimple stmt
= last_stmt (CONST_CAST_BB (bb
));
7284 return (stmt
&& gimple_code (stmt
) == GIMPLE_COND
);
7288 /* Return true if we need to add fake edge to exit at statement T.
7289 Helper function for gimple_flow_call_edges_add. */
7292 need_fake_edge_p (gimple t
)
7294 tree fndecl
= NULL_TREE
;
7297 /* NORETURN and LONGJMP calls already have an edge to exit.
7298 CONST and PURE calls do not need one.
7299 We don't currently check for CONST and PURE here, although
7300 it would be a good idea, because those attributes are
7301 figured out from the RTL in mark_constant_function, and
7302 the counter incrementation code from -fprofile-arcs
7303 leads to different results from -fbranch-probabilities. */
7304 if (is_gimple_call (t
))
7306 fndecl
= gimple_call_fndecl (t
);
7307 call_flags
= gimple_call_flags (t
);
7310 if (is_gimple_call (t
)
7312 && DECL_BUILT_IN (fndecl
)
7313 && (call_flags
& ECF_NOTHROW
)
7314 && !(call_flags
& ECF_RETURNS_TWICE
)
7315 /* fork() doesn't really return twice, but the effect of
7316 wrapping it in __gcov_fork() which calls __gcov_flush()
7317 and clears the counters before forking has the same
7318 effect as returning twice. Force a fake edge. */
7319 && !(DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7320 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FORK
))
7323 if (is_gimple_call (t
))
7329 if (!(call_flags
& ECF_NORETURN
))
7333 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7334 if ((e
->flags
& EDGE_FAKE
) == 0)
7338 if (gimple_code (t
) == GIMPLE_ASM
7339 && (gimple_asm_volatile_p (t
) || gimple_asm_input_p (t
)))
7346 /* Add fake edges to the function exit for any non constant and non
7347 noreturn calls (or noreturn calls with EH/abnormal edges),
7348 volatile inline assembly in the bitmap of blocks specified by BLOCKS
7349 or to the whole CFG if BLOCKS is zero. Return the number of blocks
7352 The goal is to expose cases in which entering a basic block does
7353 not imply that all subsequent instructions must be executed. */
7356 gimple_flow_call_edges_add (sbitmap blocks
)
7359 int blocks_split
= 0;
7360 int last_bb
= last_basic_block
;
7361 bool check_last_block
= false;
7363 if (n_basic_blocks
== NUM_FIXED_BLOCKS
)
7367 check_last_block
= true;
7369 check_last_block
= bitmap_bit_p (blocks
, EXIT_BLOCK_PTR
->prev_bb
->index
);
7371 /* In the last basic block, before epilogue generation, there will be
7372 a fallthru edge to EXIT. Special care is required if the last insn
7373 of the last basic block is a call because make_edge folds duplicate
7374 edges, which would result in the fallthru edge also being marked
7375 fake, which would result in the fallthru edge being removed by
7376 remove_fake_edges, which would result in an invalid CFG.
7378 Moreover, we can't elide the outgoing fake edge, since the block
7379 profiler needs to take this into account in order to solve the minimal
7380 spanning tree in the case that the call doesn't return.
7382 Handle this by adding a dummy instruction in a new last basic block. */
7383 if (check_last_block
)
7385 basic_block bb
= EXIT_BLOCK_PTR
->prev_bb
;
7386 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
7389 if (!gsi_end_p (gsi
))
7392 if (t
&& need_fake_edge_p (t
))
7396 e
= find_edge (bb
, EXIT_BLOCK_PTR
);
7399 gsi_insert_on_edge (e
, gimple_build_nop ());
7400 gsi_commit_edge_inserts ();
7405 /* Now add fake edges to the function exit for any non constant
7406 calls since there is no way that we can determine if they will
7408 for (i
= 0; i
< last_bb
; i
++)
7410 basic_block bb
= BASIC_BLOCK (i
);
7411 gimple_stmt_iterator gsi
;
7412 gimple stmt
, last_stmt
;
7417 if (blocks
&& !bitmap_bit_p (blocks
, i
))
7420 gsi
= gsi_last_nondebug_bb (bb
);
7421 if (!gsi_end_p (gsi
))
7423 last_stmt
= gsi_stmt (gsi
);
7426 stmt
= gsi_stmt (gsi
);
7427 if (need_fake_edge_p (stmt
))
7431 /* The handling above of the final block before the
7432 epilogue should be enough to verify that there is
7433 no edge to the exit block in CFG already.
7434 Calling make_edge in such case would cause us to
7435 mark that edge as fake and remove it later. */
7436 #ifdef ENABLE_CHECKING
7437 if (stmt
== last_stmt
)
7439 e
= find_edge (bb
, EXIT_BLOCK_PTR
);
7440 gcc_assert (e
== NULL
);
7444 /* Note that the following may create a new basic block
7445 and renumber the existing basic blocks. */
7446 if (stmt
!= last_stmt
)
7448 e
= split_block (bb
, stmt
);
7452 make_edge (bb
, EXIT_BLOCK_PTR
, EDGE_FAKE
);
7456 while (!gsi_end_p (gsi
));
7461 verify_flow_info ();
7463 return blocks_split
;
7466 /* Removes edge E and all the blocks dominated by it, and updates dominance
7467 information. The IL in E->src needs to be updated separately.
7468 If dominance info is not available, only the edge E is removed.*/
7471 remove_edge_and_dominated_blocks (edge e
)
7473 vec
<basic_block
> bbs_to_remove
= vNULL
;
7474 vec
<basic_block
> bbs_to_fix_dom
= vNULL
;
7478 bool none_removed
= false;
7480 basic_block bb
, dbb
;
7483 if (!dom_info_available_p (CDI_DOMINATORS
))
7489 /* No updating is needed for edges to exit. */
7490 if (e
->dest
== EXIT_BLOCK_PTR
)
7492 if (cfgcleanup_altered_bbs
)
7493 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
7498 /* First, we find the basic blocks to remove. If E->dest has a predecessor
7499 that is not dominated by E->dest, then this set is empty. Otherwise,
7500 all the basic blocks dominated by E->dest are removed.
7502 Also, to DF_IDOM we store the immediate dominators of the blocks in
7503 the dominance frontier of E (i.e., of the successors of the
7504 removed blocks, if there are any, and of E->dest otherwise). */
7505 FOR_EACH_EDGE (f
, ei
, e
->dest
->preds
)
7510 if (!dominated_by_p (CDI_DOMINATORS
, f
->src
, e
->dest
))
7512 none_removed
= true;
7517 df
= BITMAP_ALLOC (NULL
);
7518 df_idom
= BITMAP_ALLOC (NULL
);
7521 bitmap_set_bit (df_idom
,
7522 get_immediate_dominator (CDI_DOMINATORS
, e
->dest
)->index
);
7525 bbs_to_remove
= get_all_dominated_blocks (CDI_DOMINATORS
, e
->dest
);
7526 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
7528 FOR_EACH_EDGE (f
, ei
, bb
->succs
)
7530 if (f
->dest
!= EXIT_BLOCK_PTR
)
7531 bitmap_set_bit (df
, f
->dest
->index
);
7534 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
7535 bitmap_clear_bit (df
, bb
->index
);
7537 EXECUTE_IF_SET_IN_BITMAP (df
, 0, i
, bi
)
7539 bb
= BASIC_BLOCK (i
);
7540 bitmap_set_bit (df_idom
,
7541 get_immediate_dominator (CDI_DOMINATORS
, bb
)->index
);
7545 if (cfgcleanup_altered_bbs
)
7547 /* Record the set of the altered basic blocks. */
7548 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
7549 bitmap_ior_into (cfgcleanup_altered_bbs
, df
);
7552 /* Remove E and the cancelled blocks. */
7557 /* Walk backwards so as to get a chance to substitute all
7558 released DEFs into debug stmts. See
7559 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
7561 for (i
= bbs_to_remove
.length (); i
-- > 0; )
7562 delete_basic_block (bbs_to_remove
[i
]);
7565 /* Update the dominance information. The immediate dominator may change only
7566 for blocks whose immediate dominator belongs to DF_IDOM:
7568 Suppose that idom(X) = Y before removal of E and idom(X) != Y after the
7569 removal. Let Z the arbitrary block such that idom(Z) = Y and
7570 Z dominates X after the removal. Before removal, there exists a path P
7571 from Y to X that avoids Z. Let F be the last edge on P that is
7572 removed, and let W = F->dest. Before removal, idom(W) = Y (since Y
7573 dominates W, and because of P, Z does not dominate W), and W belongs to
7574 the dominance frontier of E. Therefore, Y belongs to DF_IDOM. */
7575 EXECUTE_IF_SET_IN_BITMAP (df_idom
, 0, i
, bi
)
7577 bb
= BASIC_BLOCK (i
);
7578 for (dbb
= first_dom_son (CDI_DOMINATORS
, bb
);
7580 dbb
= next_dom_son (CDI_DOMINATORS
, dbb
))
7581 bbs_to_fix_dom
.safe_push (dbb
);
7584 iterate_fix_dominators (CDI_DOMINATORS
, bbs_to_fix_dom
, true);
7587 BITMAP_FREE (df_idom
);
7588 bbs_to_remove
.release ();
7589 bbs_to_fix_dom
.release ();
7592 /* Purge dead EH edges from basic block BB. */
7595 gimple_purge_dead_eh_edges (basic_block bb
)
7597 bool changed
= false;
7600 gimple stmt
= last_stmt (bb
);
7602 if (stmt
&& stmt_can_throw_internal (stmt
))
7605 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
7607 if (e
->flags
& EDGE_EH
)
7609 remove_edge_and_dominated_blocks (e
);
7619 /* Purge dead EH edges from basic block listed in BLOCKS. */
7622 gimple_purge_all_dead_eh_edges (const_bitmap blocks
)
7624 bool changed
= false;
7628 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
7630 basic_block bb
= BASIC_BLOCK (i
);
7632 /* Earlier gimple_purge_dead_eh_edges could have removed
7633 this basic block already. */
7634 gcc_assert (bb
|| changed
);
7636 changed
|= gimple_purge_dead_eh_edges (bb
);
7642 /* Purge dead abnormal call edges from basic block BB. */
7645 gimple_purge_dead_abnormal_call_edges (basic_block bb
)
7647 bool changed
= false;
7650 gimple stmt
= last_stmt (bb
);
7652 if (!cfun
->has_nonlocal_label
7653 && !cfun
->calls_setjmp
)
7656 if (stmt
&& stmt_can_make_abnormal_goto (stmt
))
7659 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
7661 if (e
->flags
& EDGE_ABNORMAL
)
7663 if (e
->flags
& EDGE_FALLTHRU
)
7664 e
->flags
&= ~EDGE_ABNORMAL
;
7666 remove_edge_and_dominated_blocks (e
);
7676 /* Purge dead abnormal call edges from basic block listed in BLOCKS. */
7679 gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks
)
7681 bool changed
= false;
7685 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
7687 basic_block bb
= BASIC_BLOCK (i
);
7689 /* Earlier gimple_purge_dead_abnormal_call_edges could have removed
7690 this basic block already. */
7691 gcc_assert (bb
|| changed
);
7693 changed
|= gimple_purge_dead_abnormal_call_edges (bb
);
7699 /* This function is called whenever a new edge is created or
7703 gimple_execute_on_growing_pred (edge e
)
7705 basic_block bb
= e
->dest
;
7707 if (!gimple_seq_empty_p (phi_nodes (bb
)))
7708 reserve_phi_args_for_new_edge (bb
);
7711 /* This function is called immediately before edge E is removed from
7712 the edge vector E->dest->preds. */
7715 gimple_execute_on_shrinking_pred (edge e
)
7717 if (!gimple_seq_empty_p (phi_nodes (e
->dest
)))
7718 remove_phi_args (e
);
7721 /*---------------------------------------------------------------------------
7722 Helper functions for Loop versioning
7723 ---------------------------------------------------------------------------*/
7725 /* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy
7726 of 'first'. Both of them are dominated by 'new_head' basic block. When
7727 'new_head' was created by 'second's incoming edge it received phi arguments
7728 on the edge by split_edge(). Later, additional edge 'e' was created to
7729 connect 'new_head' and 'first'. Now this routine adds phi args on this
7730 additional edge 'e' that new_head to second edge received as part of edge
7734 gimple_lv_adjust_loop_header_phi (basic_block first
, basic_block second
,
7735 basic_block new_head
, edge e
)
7738 gimple_stmt_iterator psi1
, psi2
;
7740 edge e2
= find_edge (new_head
, second
);
7742 /* Because NEW_HEAD has been created by splitting SECOND's incoming
7743 edge, we should always have an edge from NEW_HEAD to SECOND. */
7744 gcc_assert (e2
!= NULL
);
7746 /* Browse all 'second' basic block phi nodes and add phi args to
7747 edge 'e' for 'first' head. PHI args are always in correct order. */
7749 for (psi2
= gsi_start_phis (second
),
7750 psi1
= gsi_start_phis (first
);
7751 !gsi_end_p (psi2
) && !gsi_end_p (psi1
);
7752 gsi_next (&psi2
), gsi_next (&psi1
))
7754 phi1
= gsi_stmt (psi1
);
7755 phi2
= gsi_stmt (psi2
);
7756 def
= PHI_ARG_DEF (phi2
, e2
->dest_idx
);
7757 add_phi_arg (phi1
, def
, e
, gimple_phi_arg_location_from_edge (phi2
, e2
));
7762 /* Adds a if else statement to COND_BB with condition COND_EXPR.
7763 SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
7764 the destination of the ELSE part. */
7767 gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED
,
7768 basic_block second_head ATTRIBUTE_UNUSED
,
7769 basic_block cond_bb
, void *cond_e
)
7771 gimple_stmt_iterator gsi
;
7772 gimple new_cond_expr
;
7773 tree cond_expr
= (tree
) cond_e
;
7776 /* Build new conditional expr */
7777 new_cond_expr
= gimple_build_cond_from_tree (cond_expr
,
7778 NULL_TREE
, NULL_TREE
);
7780 /* Add new cond in cond_bb. */
7781 gsi
= gsi_last_bb (cond_bb
);
7782 gsi_insert_after (&gsi
, new_cond_expr
, GSI_NEW_STMT
);
7784 /* Adjust edges appropriately to connect new head with first head
7785 as well as second head. */
7786 e0
= single_succ_edge (cond_bb
);
7787 e0
->flags
&= ~EDGE_FALLTHRU
;
7788 e0
->flags
|= EDGE_FALSE_VALUE
;
7792 /* Do book-keeping of basic block BB for the profile consistency checker.
7793 If AFTER_PASS is 0, do pre-pass accounting, or if AFTER_PASS is 1
7794 then do post-pass accounting. Store the counting in RECORD. */
7796 gimple_account_profile_record (basic_block bb
, int after_pass
,
7797 struct profile_record
*record
)
7799 gimple_stmt_iterator i
;
7800 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
7802 record
->size
[after_pass
]
7803 += estimate_num_insns (gsi_stmt (i
), &eni_size_weights
);
7804 if (profile_status
== PROFILE_READ
)
7805 record
->time
[after_pass
]
7806 += estimate_num_insns (gsi_stmt (i
),
7807 &eni_time_weights
) * bb
->count
;
7808 else if (profile_status
== PROFILE_GUESSED
)
7809 record
->time
[after_pass
]
7810 += estimate_num_insns (gsi_stmt (i
),
7811 &eni_time_weights
) * bb
->frequency
;
7815 struct cfg_hooks gimple_cfg_hooks
= {
7817 gimple_verify_flow_info
,
7818 gimple_dump_bb
, /* dump_bb */
7819 gimple_dump_bb_for_graph
, /* dump_bb_for_graph */
7820 create_bb
, /* create_basic_block */
7821 gimple_redirect_edge_and_branch
, /* redirect_edge_and_branch */
7822 gimple_redirect_edge_and_branch_force
, /* redirect_edge_and_branch_force */
7823 gimple_can_remove_branch_p
, /* can_remove_branch_p */
7824 remove_bb
, /* delete_basic_block */
7825 gimple_split_block
, /* split_block */
7826 gimple_move_block_after
, /* move_block_after */
7827 gimple_can_merge_blocks_p
, /* can_merge_blocks_p */
7828 gimple_merge_blocks
, /* merge_blocks */
7829 gimple_predict_edge
, /* predict_edge */
7830 gimple_predicted_by_p
, /* predicted_by_p */
7831 gimple_can_duplicate_bb_p
, /* can_duplicate_block_p */
7832 gimple_duplicate_bb
, /* duplicate_block */
7833 gimple_split_edge
, /* split_edge */
7834 gimple_make_forwarder_block
, /* make_forward_block */
7835 NULL
, /* tidy_fallthru_edge */
7836 NULL
, /* force_nonfallthru */
7837 gimple_block_ends_with_call_p
,/* block_ends_with_call_p */
7838 gimple_block_ends_with_condjump_p
, /* block_ends_with_condjump_p */
7839 gimple_flow_call_edges_add
, /* flow_call_edges_add */
7840 gimple_execute_on_growing_pred
, /* execute_on_growing_pred */
7841 gimple_execute_on_shrinking_pred
, /* execute_on_shrinking_pred */
7842 gimple_duplicate_loop_to_header_edge
, /* duplicate loop for trees */
7843 gimple_lv_add_condition_to_bb
, /* lv_add_condition_to_bb */
7844 gimple_lv_adjust_loop_header_phi
, /* lv_adjust_loop_header_phi*/
7845 extract_true_false_edges_from_block
, /* extract_cond_bb_edges */
7846 flush_pending_stmts
, /* flush_pending_stmts */
7847 gimple_empty_block_p
, /* block_empty_p */
7848 gimple_split_block_before_cond_jump
, /* split_block_before_cond_jump */
7849 gimple_account_profile_record
,
7853 /* Split all critical edges. */
7856 split_critical_edges (void)
7862 /* split_edge can redirect edges out of SWITCH_EXPRs, which can get
7863 expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
7864 mappings around the calls to split_edge. */
7865 start_recording_case_labels ();
7868 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7870 if (EDGE_CRITICAL_P (e
) && !(e
->flags
& EDGE_ABNORMAL
))
7872 /* PRE inserts statements to edges and expects that
7873 since split_critical_edges was done beforehand, committing edge
7874 insertions will not split more edges. In addition to critical
7875 edges we must split edges that have multiple successors and
7876 end by control flow statements, such as RESX.
7877 Go ahead and split them too. This matches the logic in
7878 gimple_find_edge_insert_loc. */
7879 else if ((!single_pred_p (e
->dest
)
7880 || !gimple_seq_empty_p (phi_nodes (e
->dest
))
7881 || e
->dest
== EXIT_BLOCK_PTR
)
7882 && e
->src
!= ENTRY_BLOCK_PTR
7883 && !(e
->flags
& EDGE_ABNORMAL
))
7885 gimple_stmt_iterator gsi
;
7887 gsi
= gsi_last_bb (e
->src
);
7888 if (!gsi_end_p (gsi
)
7889 && stmt_ends_bb_p (gsi_stmt (gsi
))
7890 && (gimple_code (gsi_stmt (gsi
)) != GIMPLE_RETURN
7891 && !gimple_call_builtin_p (gsi_stmt (gsi
),
7897 end_recording_case_labels ();
7903 const pass_data pass_data_split_crit_edges
=
7905 GIMPLE_PASS
, /* type */
7906 "crited", /* name */
7907 OPTGROUP_NONE
, /* optinfo_flags */
7908 false, /* has_gate */
7909 true, /* has_execute */
7910 TV_TREE_SPLIT_EDGES
, /* tv_id */
7911 PROP_cfg
, /* properties_required */
7912 PROP_no_crit_edges
, /* properties_provided */
7913 0, /* properties_destroyed */
7914 0, /* todo_flags_start */
7915 TODO_verify_flow
, /* todo_flags_finish */
7918 class pass_split_crit_edges
: public gimple_opt_pass
7921 pass_split_crit_edges (gcc::context
*ctxt
)
7922 : gimple_opt_pass (pass_data_split_crit_edges
, ctxt
)
7925 /* opt_pass methods: */
7926 unsigned int execute () { return split_critical_edges (); }
7928 opt_pass
* clone () { return new pass_split_crit_edges (m_ctxt
); }
7929 }; // class pass_split_crit_edges
7934 make_pass_split_crit_edges (gcc::context
*ctxt
)
7936 return new pass_split_crit_edges (ctxt
);
7940 /* Build a ternary operation and gimplify it. Emit code before GSI.
7941 Return the gimple_val holding the result. */
7944 gimplify_build3 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
7945 tree type
, tree a
, tree b
, tree c
)
7948 location_t loc
= gimple_location (gsi_stmt (*gsi
));
7950 ret
= fold_build3_loc (loc
, code
, type
, a
, b
, c
);
7953 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
7957 /* Build a binary operation and gimplify it. Emit code before GSI.
7958 Return the gimple_val holding the result. */
7961 gimplify_build2 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
7962 tree type
, tree a
, tree b
)
7966 ret
= fold_build2_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
, b
);
7969 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
7973 /* Build a unary operation and gimplify it. Emit code before GSI.
7974 Return the gimple_val holding the result. */
7977 gimplify_build1 (gimple_stmt_iterator
*gsi
, enum tree_code code
, tree type
,
7982 ret
= fold_build1_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
);
7985 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
7991 /* Emit return warnings. */
7994 execute_warn_function_return (void)
7996 source_location location
;
8001 if (!targetm
.warn_func_return (cfun
->decl
))
8004 /* If we have a path to EXIT, then we do return. */
8005 if (TREE_THIS_VOLATILE (cfun
->decl
)
8006 && EDGE_COUNT (EXIT_BLOCK_PTR
->preds
) > 0)
8008 location
= UNKNOWN_LOCATION
;
8009 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
8011 last
= last_stmt (e
->src
);
8012 if ((gimple_code (last
) == GIMPLE_RETURN
8013 || gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
8014 && (location
= gimple_location (last
)) != UNKNOWN_LOCATION
)
8017 if (location
== UNKNOWN_LOCATION
)
8018 location
= cfun
->function_end_locus
;
8019 warning_at (location
, 0, "%<noreturn%> function does return");
8022 /* If we see "return;" in some basic block, then we do reach the end
8023 without returning a value. */
8024 else if (warn_return_type
8025 && !TREE_NO_WARNING (cfun
->decl
)
8026 && EDGE_COUNT (EXIT_BLOCK_PTR
->preds
) > 0
8027 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (cfun
->decl
))))
8029 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
8031 gimple last
= last_stmt (e
->src
);
8032 if (gimple_code (last
) == GIMPLE_RETURN
8033 && gimple_return_retval (last
) == NULL
8034 && !gimple_no_warning_p (last
))
8036 location
= gimple_location (last
);
8037 if (location
== UNKNOWN_LOCATION
)
8038 location
= cfun
->function_end_locus
;
8039 warning_at (location
, OPT_Wreturn_type
, "control reaches end of non-void function");
8040 TREE_NO_WARNING (cfun
->decl
) = 1;
8049 /* Given a basic block B which ends with a conditional and has
8050 precisely two successors, determine which of the edges is taken if
8051 the conditional is true and which is taken if the conditional is
8052 false. Set TRUE_EDGE and FALSE_EDGE appropriately. */
8055 extract_true_false_edges_from_block (basic_block b
,
8059 edge e
= EDGE_SUCC (b
, 0);
8061 if (e
->flags
& EDGE_TRUE_VALUE
)
8064 *false_edge
= EDGE_SUCC (b
, 1);
8069 *true_edge
= EDGE_SUCC (b
, 1);
8075 const pass_data pass_data_warn_function_return
=
8077 GIMPLE_PASS
, /* type */
8078 "*warn_function_return", /* name */
8079 OPTGROUP_NONE
, /* optinfo_flags */
8080 false, /* has_gate */
8081 true, /* has_execute */
8082 TV_NONE
, /* tv_id */
8083 PROP_cfg
, /* properties_required */
8084 0, /* properties_provided */
8085 0, /* properties_destroyed */
8086 0, /* todo_flags_start */
8087 0, /* todo_flags_finish */
8090 class pass_warn_function_return
: public gimple_opt_pass
8093 pass_warn_function_return (gcc::context
*ctxt
)
8094 : gimple_opt_pass (pass_data_warn_function_return
, ctxt
)
8097 /* opt_pass methods: */
8098 unsigned int execute () { return execute_warn_function_return (); }
8100 }; // class pass_warn_function_return
8105 make_pass_warn_function_return (gcc::context
*ctxt
)
8107 return new pass_warn_function_return (ctxt
);
8110 /* Walk a gimplified function and warn for functions whose return value is
8111 ignored and attribute((warn_unused_result)) is set. This is done before
8112 inlining, so we don't have to worry about that. */
8115 do_warn_unused_result (gimple_seq seq
)
8118 gimple_stmt_iterator i
;
8120 for (i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
8122 gimple g
= gsi_stmt (i
);
8124 switch (gimple_code (g
))
8127 do_warn_unused_result (gimple_bind_body (g
));
8130 do_warn_unused_result (gimple_try_eval (g
));
8131 do_warn_unused_result (gimple_try_cleanup (g
));
8134 do_warn_unused_result (gimple_catch_handler (g
));
8136 case GIMPLE_EH_FILTER
:
8137 do_warn_unused_result (gimple_eh_filter_failure (g
));
8141 if (gimple_call_lhs (g
))
8143 if (gimple_call_internal_p (g
))
8146 /* This is a naked call, as opposed to a GIMPLE_CALL with an
8147 LHS. All calls whose value is ignored should be
8148 represented like this. Look for the attribute. */
8149 fdecl
= gimple_call_fndecl (g
);
8150 ftype
= gimple_call_fntype (g
);
8152 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
8154 location_t loc
= gimple_location (g
);
8157 warning_at (loc
, OPT_Wunused_result
,
8158 "ignoring return value of %qD, "
8159 "declared with attribute warn_unused_result",
8162 warning_at (loc
, OPT_Wunused_result
,
8163 "ignoring return value of function "
8164 "declared with attribute warn_unused_result");
8169 /* Not a container, not a call, or a call whose value is used. */
8176 run_warn_unused_result (void)
8178 do_warn_unused_result (gimple_body (current_function_decl
));
8183 gate_warn_unused_result (void)
8185 return flag_warn_unused_result
;
8190 const pass_data pass_data_warn_unused_result
=
8192 GIMPLE_PASS
, /* type */
8193 "*warn_unused_result", /* name */
8194 OPTGROUP_NONE
, /* optinfo_flags */
8195 true, /* has_gate */
8196 true, /* has_execute */
8197 TV_NONE
, /* tv_id */
8198 PROP_gimple_any
, /* properties_required */
8199 0, /* properties_provided */
8200 0, /* properties_destroyed */
8201 0, /* todo_flags_start */
8202 0, /* todo_flags_finish */
8205 class pass_warn_unused_result
: public gimple_opt_pass
8208 pass_warn_unused_result (gcc::context
*ctxt
)
8209 : gimple_opt_pass (pass_data_warn_unused_result
, ctxt
)
8212 /* opt_pass methods: */
8213 bool gate () { return gate_warn_unused_result (); }
8214 unsigned int execute () { return run_warn_unused_result (); }
8216 }; // class pass_warn_unused_result
8221 make_pass_warn_unused_result (gcc::context
*ctxt
)
8223 return new pass_warn_unused_result (ctxt
);
8226 /* IPA passes, compilation of earlier functions or inlining
8227 might have changed some properties, such as marked functions nothrow,
8228 pure, const or noreturn.
8229 Remove redundant edges and basic blocks, and create new ones if necessary.
8231 This pass can't be executed as stand alone pass from pass manager, because
8232 in between inlining and this fixup the verify_flow_info would fail. */
8235 execute_fixup_cfg (void)
8238 gimple_stmt_iterator gsi
;
8239 int todo
= gimple_in_ssa_p (cfun
) ? TODO_verify_ssa
: 0;
8240 gcov_type count_scale
;
8245 = GCOV_COMPUTE_SCALE (cgraph_get_node (current_function_decl
)->count
,
8246 ENTRY_BLOCK_PTR
->count
);
8248 ENTRY_BLOCK_PTR
->count
= cgraph_get_node (current_function_decl
)->count
;
8249 EXIT_BLOCK_PTR
->count
= apply_scale (EXIT_BLOCK_PTR
->count
,
8252 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR
->succs
)
8253 e
->count
= apply_scale (e
->count
, count_scale
);
8257 bb
->count
= apply_scale (bb
->count
, count_scale
);
8258 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
8260 gimple stmt
= gsi_stmt (gsi
);
8261 tree decl
= is_gimple_call (stmt
)
8262 ? gimple_call_fndecl (stmt
)
8266 int flags
= gimple_call_flags (stmt
);
8267 if (flags
& (ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
))
8269 if (gimple_purge_dead_abnormal_call_edges (bb
))
8270 todo
|= TODO_cleanup_cfg
;
8272 if (gimple_in_ssa_p (cfun
))
8274 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
8279 if (flags
& ECF_NORETURN
8280 && fixup_noreturn_call (stmt
))
8281 todo
|= TODO_cleanup_cfg
;
8284 if (maybe_clean_eh_stmt (stmt
)
8285 && gimple_purge_dead_eh_edges (bb
))
8286 todo
|= TODO_cleanup_cfg
;
8289 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8290 e
->count
= apply_scale (e
->count
, count_scale
);
8292 /* If we have a basic block with no successors that does not
8293 end with a control statement or a noreturn call end it with
8294 a call to __builtin_unreachable. This situation can occur
8295 when inlining a noreturn call that does in fact return. */
8296 if (EDGE_COUNT (bb
->succs
) == 0)
8298 gimple stmt
= last_stmt (bb
);
8300 || (!is_ctrl_stmt (stmt
)
8301 && (!is_gimple_call (stmt
)
8302 || (gimple_call_flags (stmt
) & ECF_NORETURN
) == 0)))
8304 stmt
= gimple_build_call
8305 (builtin_decl_implicit (BUILT_IN_UNREACHABLE
), 0);
8306 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
8307 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
8311 if (count_scale
!= REG_BR_PROB_BASE
)
8312 compute_function_frequency ();
8314 /* We just processed all calls. */
8315 if (cfun
->gimple_df
)
8316 vec_free (MODIFIED_NORETURN_CALLS (cfun
));
8318 /* Dump a textual representation of the flowgraph. */
8320 gimple_dump_cfg (dump_file
, dump_flags
);
8323 && (todo
& TODO_cleanup_cfg
))
8324 loops_state_set (LOOPS_NEED_FIXUP
);
8331 const pass_data pass_data_fixup_cfg
=
8333 GIMPLE_PASS
, /* type */
8334 "*free_cfg_annotations", /* name */
8335 OPTGROUP_NONE
, /* optinfo_flags */
8336 false, /* has_gate */
8337 true, /* has_execute */
8338 TV_NONE
, /* tv_id */
8339 PROP_cfg
, /* properties_required */
8340 0, /* properties_provided */
8341 0, /* properties_destroyed */
8342 0, /* todo_flags_start */
8343 0, /* todo_flags_finish */
8346 class pass_fixup_cfg
: public gimple_opt_pass
8349 pass_fixup_cfg (gcc::context
*ctxt
)
8350 : gimple_opt_pass (pass_data_fixup_cfg
, ctxt
)
8353 /* opt_pass methods: */
8354 opt_pass
* clone () { return new pass_fixup_cfg (m_ctxt
); }
8355 unsigned int execute () { return execute_fixup_cfg (); }
8357 }; // class pass_fixup_cfg
8362 make_pass_fixup_cfg (gcc::context
*ctxt
)
8364 return new pass_fixup_cfg (ctxt
);
8367 /* Garbage collection support for edge_def. */
8369 extern void gt_ggc_mx (tree
&);
8370 extern void gt_ggc_mx (gimple
&);
8371 extern void gt_ggc_mx (rtx
&);
8372 extern void gt_ggc_mx (basic_block
&);
8375 gt_ggc_mx (edge_def
*e
)
8377 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8379 gt_ggc_mx (e
->dest
);
8380 if (current_ir_type () == IR_GIMPLE
)
8381 gt_ggc_mx (e
->insns
.g
);
8383 gt_ggc_mx (e
->insns
.r
);
8387 /* PCH support for edge_def. */
8389 extern void gt_pch_nx (tree
&);
8390 extern void gt_pch_nx (gimple
&);
8391 extern void gt_pch_nx (rtx
&);
8392 extern void gt_pch_nx (basic_block
&);
8395 gt_pch_nx (edge_def
*e
)
8397 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8399 gt_pch_nx (e
->dest
);
8400 if (current_ir_type () == IR_GIMPLE
)
8401 gt_pch_nx (e
->insns
.g
);
8403 gt_pch_nx (e
->insns
.r
);
8408 gt_pch_nx (edge_def
*e
, gt_pointer_operator op
, void *cookie
)
8410 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8411 op (&(e
->src
), cookie
);
8412 op (&(e
->dest
), cookie
);
8413 if (current_ir_type () == IR_GIMPLE
)
8414 op (&(e
->insns
.g
), cookie
);
8416 op (&(e
->insns
.r
), cookie
);
8417 op (&(block
), cookie
);