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"
33 #include "tree-flow.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"
45 /* This file contains functions for building the Control Flow Graph (CFG)
46 for a function tree. */
48 /* Local declarations. */
50 /* Initial capacity for the basic block array. */
51 static const int initial_cfg_capacity
= 20;
53 /* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
54 which use a particular edge. The CASE_LABEL_EXPRs are chained together
55 via their CASE_CHAIN field, which we clear after we're done with the
56 hash table to prevent problems with duplication of GIMPLE_SWITCHes.
58 Access to this list of CASE_LABEL_EXPRs allows us to efficiently
59 update the case vector in response to edge redirections.
61 Right now this table is set up and torn down at key points in the
62 compilation process. It would be nice if we could make the table
63 more persistent. The key is getting notification of changes to
64 the CFG (particularly edge removal, creation and redirection). */
66 static struct pointer_map_t
*edge_to_cases
;
68 /* If we record edge_to_cases, this bitmap will hold indexes
69 of basic blocks that end in a GIMPLE_SWITCH which we touched
70 due to edge manipulations. */
72 static bitmap touched_switch_bbs
;
77 long num_merged_labels
;
80 static struct cfg_stats_d cfg_stats
;
82 /* Nonzero if we found a computed goto while building basic blocks. */
83 static bool found_computed_goto
;
85 /* Hash table to store last discriminator assigned for each locus. */
86 struct locus_discrim_map
92 /* Hashtable helpers. */
94 struct locus_discrim_hasher
: typed_free_remove
<locus_discrim_map
>
96 typedef locus_discrim_map value_type
;
97 typedef locus_discrim_map compare_type
;
98 static inline hashval_t
hash (const value_type
*);
99 static inline bool equal (const value_type
*, const compare_type
*);
102 /* Trivial hash function for a location_t. ITEM is a pointer to
103 a hash table entry that maps a location_t to a discriminator. */
106 locus_discrim_hasher::hash (const value_type
*item
)
108 return LOCATION_LINE (item
->locus
);
111 /* Equality function for the locus-to-discriminator map. A and B
112 point to the two hash table entries to compare. */
115 locus_discrim_hasher::equal (const value_type
*a
, const compare_type
*b
)
117 return LOCATION_LINE (a
->locus
) == LOCATION_LINE (b
->locus
);
120 static hash_table
<locus_discrim_hasher
> discriminator_per_locus
;
122 /* Basic blocks and flowgraphs. */
123 static void make_blocks (gimple_seq
);
124 static void factor_computed_gotos (void);
127 static void make_edges (void);
128 static void assign_discriminators (void);
129 static void make_cond_expr_edges (basic_block
);
130 static void make_gimple_switch_edges (basic_block
);
131 static void make_goto_expr_edges (basic_block
);
132 static void make_gimple_asm_edges (basic_block
);
133 static edge
gimple_redirect_edge_and_branch (edge
, basic_block
);
134 static edge
gimple_try_redirect_by_replacing_jump (edge
, basic_block
);
135 static unsigned int split_critical_edges (void);
137 /* Various helpers. */
138 static inline bool stmt_starts_bb_p (gimple
, gimple
);
139 static int gimple_verify_flow_info (void);
140 static void gimple_make_forwarder_block (edge
);
141 static gimple
first_non_label_stmt (basic_block
);
142 static bool verify_gimple_transaction (gimple
);
144 /* Flowgraph optimization and cleanup. */
145 static void gimple_merge_blocks (basic_block
, basic_block
);
146 static bool gimple_can_merge_blocks_p (basic_block
, basic_block
);
147 static void remove_bb (basic_block
);
148 static edge
find_taken_edge_computed_goto (basic_block
, tree
);
149 static edge
find_taken_edge_cond_expr (basic_block
, tree
);
150 static edge
find_taken_edge_switch_expr (basic_block
, tree
);
151 static tree
find_case_label_for_value (gimple
, tree
);
154 init_empty_tree_cfg_for_function (struct function
*fn
)
156 /* Initialize the basic block array. */
158 profile_status_for_function (fn
) = PROFILE_ABSENT
;
159 n_basic_blocks_for_function (fn
) = NUM_FIXED_BLOCKS
;
160 last_basic_block_for_function (fn
) = NUM_FIXED_BLOCKS
;
161 vec_alloc (basic_block_info_for_function (fn
), initial_cfg_capacity
);
162 vec_safe_grow_cleared (basic_block_info_for_function (fn
),
163 initial_cfg_capacity
);
165 /* Build a mapping of labels to their associated blocks. */
166 vec_alloc (label_to_block_map_for_function (fn
), initial_cfg_capacity
);
167 vec_safe_grow_cleared (label_to_block_map_for_function (fn
),
168 initial_cfg_capacity
);
170 SET_BASIC_BLOCK_FOR_FUNCTION (fn
, ENTRY_BLOCK
,
171 ENTRY_BLOCK_PTR_FOR_FUNCTION (fn
));
172 SET_BASIC_BLOCK_FOR_FUNCTION (fn
, EXIT_BLOCK
,
173 EXIT_BLOCK_PTR_FOR_FUNCTION (fn
));
175 ENTRY_BLOCK_PTR_FOR_FUNCTION (fn
)->next_bb
176 = EXIT_BLOCK_PTR_FOR_FUNCTION (fn
);
177 EXIT_BLOCK_PTR_FOR_FUNCTION (fn
)->prev_bb
178 = ENTRY_BLOCK_PTR_FOR_FUNCTION (fn
);
182 init_empty_tree_cfg (void)
184 init_empty_tree_cfg_for_function (cfun
);
187 /*---------------------------------------------------------------------------
189 ---------------------------------------------------------------------------*/
191 /* Entry point to the CFG builder for trees. SEQ is the sequence of
192 statements to be added to the flowgraph. */
195 build_gimple_cfg (gimple_seq seq
)
197 /* Register specific gimple functions. */
198 gimple_register_cfg_hooks ();
200 memset ((void *) &cfg_stats
, 0, sizeof (cfg_stats
));
202 init_empty_tree_cfg ();
204 found_computed_goto
= 0;
207 /* Computed gotos are hell to deal with, especially if there are
208 lots of them with a large number of destinations. So we factor
209 them to a common computed goto location before we build the
210 edge list. After we convert back to normal form, we will un-factor
211 the computed gotos since factoring introduces an unwanted jump. */
212 if (found_computed_goto
)
213 factor_computed_gotos ();
215 /* Make sure there is always at least one block, even if it's empty. */
216 if (n_basic_blocks
== NUM_FIXED_BLOCKS
)
217 create_empty_bb (ENTRY_BLOCK_PTR
);
219 /* Adjust the size of the array. */
220 if (basic_block_info
->length () < (size_t) n_basic_blocks
)
221 vec_safe_grow_cleared (basic_block_info
, n_basic_blocks
);
223 /* To speed up statement iterator walks, we first purge dead labels. */
224 cleanup_dead_labels ();
226 /* Group case nodes to reduce the number of edges.
227 We do this after cleaning up dead labels because otherwise we miss
228 a lot of obvious case merging opportunities. */
229 group_case_labels ();
231 /* Create the edges of the flowgraph. */
232 discriminator_per_locus
.create (13);
234 assign_discriminators ();
235 cleanup_dead_labels ();
236 discriminator_per_locus
.dispose ();
240 execute_build_cfg (void)
242 gimple_seq body
= gimple_body (current_function_decl
);
244 build_gimple_cfg (body
);
245 gimple_set_body (current_function_decl
, NULL
);
246 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
248 fprintf (dump_file
, "Scope blocks:\n");
249 dump_scope_blocks (dump_file
, dump_flags
);
252 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
256 struct gimple_opt_pass pass_build_cfg
=
261 OPTGROUP_NONE
, /* optinfo_flags */
263 execute_build_cfg
, /* execute */
266 0, /* static_pass_number */
267 TV_TREE_CFG
, /* tv_id */
268 PROP_gimple_leh
, /* properties_required */
269 PROP_cfg
| PROP_loops
, /* properties_provided */
270 0, /* properties_destroyed */
271 0, /* todo_flags_start */
272 TODO_verify_stmts
/* todo_flags_finish */
277 /* Return true if T is a computed goto. */
280 computed_goto_p (gimple t
)
282 return (gimple_code (t
) == GIMPLE_GOTO
283 && TREE_CODE (gimple_goto_dest (t
)) != LABEL_DECL
);
287 /* Search the CFG for any computed gotos. If found, factor them to a
288 common computed goto site. Also record the location of that site so
289 that we can un-factor the gotos after we have converted back to
293 factor_computed_gotos (void)
296 tree factored_label_decl
= NULL
;
298 gimple factored_computed_goto_label
= NULL
;
299 gimple factored_computed_goto
= NULL
;
301 /* We know there are one or more computed gotos in this function.
302 Examine the last statement in each basic block to see if the block
303 ends with a computed goto. */
307 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
313 last
= gsi_stmt (gsi
);
315 /* Ignore the computed goto we create when we factor the original
317 if (last
== factored_computed_goto
)
320 /* If the last statement is a computed goto, factor it. */
321 if (computed_goto_p (last
))
325 /* The first time we find a computed goto we need to create
326 the factored goto block and the variable each original
327 computed goto will use for their goto destination. */
328 if (!factored_computed_goto
)
330 basic_block new_bb
= create_empty_bb (bb
);
331 gimple_stmt_iterator new_gsi
= gsi_start_bb (new_bb
);
333 /* Create the destination of the factored goto. Each original
334 computed goto will put its desired destination into this
335 variable and jump to the label we create immediately
337 var
= create_tmp_var (ptr_type_node
, "gotovar");
339 /* Build a label for the new block which will contain the
340 factored computed goto. */
341 factored_label_decl
= create_artificial_label (UNKNOWN_LOCATION
);
342 factored_computed_goto_label
343 = gimple_build_label (factored_label_decl
);
344 gsi_insert_after (&new_gsi
, factored_computed_goto_label
,
347 /* Build our new computed goto. */
348 factored_computed_goto
= gimple_build_goto (var
);
349 gsi_insert_after (&new_gsi
, factored_computed_goto
, GSI_NEW_STMT
);
352 /* Copy the original computed goto's destination into VAR. */
353 assignment
= gimple_build_assign (var
, gimple_goto_dest (last
));
354 gsi_insert_before (&gsi
, assignment
, GSI_SAME_STMT
);
356 /* And re-vector the computed goto to the new destination. */
357 gimple_goto_set_dest (last
, factored_label_decl
);
363 /* Build a flowgraph for the sequence of stmts SEQ. */
366 make_blocks (gimple_seq seq
)
368 gimple_stmt_iterator i
= gsi_start (seq
);
370 bool start_new_block
= true;
371 bool first_stmt_of_seq
= true;
372 basic_block bb
= ENTRY_BLOCK_PTR
;
374 while (!gsi_end_p (i
))
381 /* If the statement starts a new basic block or if we have determined
382 in a previous pass that we need to create a new block for STMT, do
384 if (start_new_block
|| stmt_starts_bb_p (stmt
, prev_stmt
))
386 if (!first_stmt_of_seq
)
387 gsi_split_seq_before (&i
, &seq
);
388 bb
= create_basic_block (seq
, NULL
, bb
);
389 start_new_block
= false;
392 /* Now add STMT to BB and create the subgraphs for special statement
394 gimple_set_bb (stmt
, bb
);
396 if (computed_goto_p (stmt
))
397 found_computed_goto
= true;
399 /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
401 if (stmt_ends_bb_p (stmt
))
403 /* If the stmt can make abnormal goto use a new temporary
404 for the assignment to the LHS. This makes sure the old value
405 of the LHS is available on the abnormal edge. Otherwise
406 we will end up with overlapping life-ranges for abnormal
408 if (gimple_has_lhs (stmt
)
409 && stmt_can_make_abnormal_goto (stmt
)
410 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt
))))
412 tree lhs
= gimple_get_lhs (stmt
);
413 tree tmp
= create_tmp_var (TREE_TYPE (lhs
), NULL
);
414 gimple s
= gimple_build_assign (lhs
, tmp
);
415 gimple_set_location (s
, gimple_location (stmt
));
416 gimple_set_block (s
, gimple_block (stmt
));
417 gimple_set_lhs (stmt
, tmp
);
418 if (TREE_CODE (TREE_TYPE (tmp
)) == COMPLEX_TYPE
419 || TREE_CODE (TREE_TYPE (tmp
)) == VECTOR_TYPE
)
420 DECL_GIMPLE_REG_P (tmp
) = 1;
421 gsi_insert_after (&i
, s
, GSI_SAME_STMT
);
423 start_new_block
= true;
427 first_stmt_of_seq
= false;
432 /* Create and return a new empty basic block after bb AFTER. */
435 create_bb (void *h
, void *e
, basic_block after
)
441 /* Create and initialize a new basic block. Since alloc_block uses
442 GC allocation that clears memory to allocate a basic block, we do
443 not have to clear the newly allocated basic block here. */
446 bb
->index
= last_basic_block
;
448 set_bb_seq (bb
, h
? (gimple_seq
) h
: NULL
);
450 /* Add the new block to the linked list of blocks. */
451 link_block (bb
, after
);
453 /* Grow the basic block array if needed. */
454 if ((size_t) last_basic_block
== basic_block_info
->length ())
456 size_t new_size
= last_basic_block
+ (last_basic_block
+ 3) / 4;
457 vec_safe_grow_cleared (basic_block_info
, new_size
);
460 /* Add the newly created block to the array. */
461 SET_BASIC_BLOCK (last_basic_block
, bb
);
470 /*---------------------------------------------------------------------------
472 ---------------------------------------------------------------------------*/
474 /* Fold COND_EXPR_COND of each COND_EXPR. */
477 fold_cond_expr_cond (void)
483 gimple stmt
= last_stmt (bb
);
485 if (stmt
&& gimple_code (stmt
) == GIMPLE_COND
)
487 location_t loc
= gimple_location (stmt
);
491 fold_defer_overflow_warnings ();
492 cond
= fold_binary_loc (loc
, gimple_cond_code (stmt
), boolean_type_node
,
493 gimple_cond_lhs (stmt
), gimple_cond_rhs (stmt
));
496 zerop
= integer_zerop (cond
);
497 onep
= integer_onep (cond
);
500 zerop
= onep
= false;
502 fold_undefer_overflow_warnings (zerop
|| onep
,
504 WARN_STRICT_OVERFLOW_CONDITIONAL
);
506 gimple_cond_make_false (stmt
);
508 gimple_cond_make_true (stmt
);
513 /* Join all the blocks in the flowgraph. */
519 struct omp_region
*cur_region
= NULL
;
521 /* Create an edge from entry to the first block with executable
523 make_edge (ENTRY_BLOCK_PTR
, BASIC_BLOCK (NUM_FIXED_BLOCKS
), EDGE_FALLTHRU
);
525 /* Traverse the basic block array placing edges. */
528 gimple last
= last_stmt (bb
);
533 enum gimple_code code
= gimple_code (last
);
537 make_goto_expr_edges (bb
);
541 make_edge (bb
, EXIT_BLOCK_PTR
, 0);
545 make_cond_expr_edges (bb
);
549 make_gimple_switch_edges (bb
);
553 make_eh_edges (last
);
556 case GIMPLE_EH_DISPATCH
:
557 fallthru
= make_eh_dispatch_edges (last
);
561 /* If this function receives a nonlocal goto, then we need to
562 make edges from this call site to all the nonlocal goto
564 if (stmt_can_make_abnormal_goto (last
))
565 make_abnormal_goto_edges (bb
, true);
567 /* If this statement has reachable exception handlers, then
568 create abnormal edges to them. */
569 make_eh_edges (last
);
571 /* BUILTIN_RETURN is really a return statement. */
572 if (gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
573 make_edge (bb
, EXIT_BLOCK_PTR
, 0), fallthru
= false;
574 /* Some calls are known not to return. */
576 fallthru
= !(gimple_call_flags (last
) & ECF_NORETURN
);
580 /* A GIMPLE_ASSIGN may throw internally and thus be considered
582 if (is_ctrl_altering_stmt (last
))
583 make_eh_edges (last
);
588 make_gimple_asm_edges (bb
);
592 case GIMPLE_OMP_PARALLEL
:
593 case GIMPLE_OMP_TASK
:
595 case GIMPLE_OMP_SINGLE
:
596 case GIMPLE_OMP_MASTER
:
597 case GIMPLE_OMP_ORDERED
:
598 case GIMPLE_OMP_CRITICAL
:
599 case GIMPLE_OMP_SECTION
:
600 cur_region
= new_omp_region (bb
, code
, cur_region
);
604 case GIMPLE_OMP_SECTIONS
:
605 cur_region
= new_omp_region (bb
, code
, cur_region
);
609 case GIMPLE_OMP_SECTIONS_SWITCH
:
613 case GIMPLE_OMP_ATOMIC_LOAD
:
614 case GIMPLE_OMP_ATOMIC_STORE
:
618 case GIMPLE_OMP_RETURN
:
619 /* In the case of a GIMPLE_OMP_SECTION, the edge will go
620 somewhere other than the next block. This will be
622 cur_region
->exit
= bb
;
623 fallthru
= cur_region
->type
!= GIMPLE_OMP_SECTION
;
624 cur_region
= cur_region
->outer
;
627 case GIMPLE_OMP_CONTINUE
:
628 cur_region
->cont
= bb
;
629 switch (cur_region
->type
)
632 /* Mark all GIMPLE_OMP_FOR and GIMPLE_OMP_CONTINUE
633 succs edges as abnormal to prevent splitting
635 single_succ_edge (cur_region
->entry
)->flags
|= EDGE_ABNORMAL
;
636 /* Make the loopback edge. */
637 make_edge (bb
, single_succ (cur_region
->entry
),
640 /* Create an edge from GIMPLE_OMP_FOR to exit, which
641 corresponds to the case that the body of the loop
642 is not executed at all. */
643 make_edge (cur_region
->entry
, bb
->next_bb
, EDGE_ABNORMAL
);
644 make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
| EDGE_ABNORMAL
);
648 case GIMPLE_OMP_SECTIONS
:
649 /* Wire up the edges into and out of the nested sections. */
651 basic_block switch_bb
= single_succ (cur_region
->entry
);
653 struct omp_region
*i
;
654 for (i
= cur_region
->inner
; i
; i
= i
->next
)
656 gcc_assert (i
->type
== GIMPLE_OMP_SECTION
);
657 make_edge (switch_bb
, i
->entry
, 0);
658 make_edge (i
->exit
, bb
, EDGE_FALLTHRU
);
661 /* Make the loopback edge to the block with
662 GIMPLE_OMP_SECTIONS_SWITCH. */
663 make_edge (bb
, switch_bb
, 0);
665 /* Make the edge from the switch to exit. */
666 make_edge (switch_bb
, bb
->next_bb
, 0);
676 case GIMPLE_TRANSACTION
:
678 tree abort_label
= gimple_transaction_label (last
);
680 make_edge (bb
, label_to_block (abort_label
), EDGE_TM_ABORT
);
686 gcc_assert (!stmt_ends_bb_p (last
));
694 make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
700 /* Fold COND_EXPR_COND of each COND_EXPR. */
701 fold_cond_expr_cond ();
704 /* Find the next available discriminator value for LOCUS. The
705 discriminator distinguishes among several basic blocks that
706 share a common locus, allowing for more accurate sample-based
710 next_discriminator_for_locus (location_t locus
)
712 struct locus_discrim_map item
;
713 struct locus_discrim_map
**slot
;
716 item
.discriminator
= 0;
717 slot
= discriminator_per_locus
.find_slot_with_hash (
718 &item
, LOCATION_LINE (locus
), INSERT
);
720 if (*slot
== HTAB_EMPTY_ENTRY
)
722 *slot
= XNEW (struct locus_discrim_map
);
724 (*slot
)->locus
= locus
;
725 (*slot
)->discriminator
= 0;
727 (*slot
)->discriminator
++;
728 return (*slot
)->discriminator
;
731 /* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line. */
734 same_line_p (location_t locus1
, location_t locus2
)
736 expanded_location from
, to
;
738 if (locus1
== locus2
)
741 from
= expand_location (locus1
);
742 to
= expand_location (locus2
);
744 if (from
.line
!= to
.line
)
746 if (from
.file
== to
.file
)
748 return (from
.file
!= NULL
750 && filename_cmp (from
.file
, to
.file
) == 0);
753 /* Assign discriminators to each basic block. */
756 assign_discriminators (void)
764 gimple last
= last_stmt (bb
);
765 location_t locus
= last
? gimple_location (last
) : UNKNOWN_LOCATION
;
767 if (locus
== UNKNOWN_LOCATION
)
770 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
772 gimple first
= first_non_label_stmt (e
->dest
);
773 gimple last
= last_stmt (e
->dest
);
774 if ((first
&& same_line_p (locus
, gimple_location (first
)))
775 || (last
&& same_line_p (locus
, gimple_location (last
))))
777 if (e
->dest
->discriminator
!= 0 && bb
->discriminator
== 0)
778 bb
->discriminator
= next_discriminator_for_locus (locus
);
780 e
->dest
->discriminator
= next_discriminator_for_locus (locus
);
786 /* Create the edges for a GIMPLE_COND starting at block BB. */
789 make_cond_expr_edges (basic_block bb
)
791 gimple entry
= last_stmt (bb
);
792 gimple then_stmt
, else_stmt
;
793 basic_block then_bb
, else_bb
;
794 tree then_label
, else_label
;
798 gcc_assert (gimple_code (entry
) == GIMPLE_COND
);
800 /* Entry basic blocks for each component. */
801 then_label
= gimple_cond_true_label (entry
);
802 else_label
= gimple_cond_false_label (entry
);
803 then_bb
= label_to_block (then_label
);
804 else_bb
= label_to_block (else_label
);
805 then_stmt
= first_stmt (then_bb
);
806 else_stmt
= first_stmt (else_bb
);
808 e
= make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
809 e
->goto_locus
= gimple_location (then_stmt
);
810 e
= make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
812 e
->goto_locus
= gimple_location (else_stmt
);
814 /* We do not need the labels anymore. */
815 gimple_cond_set_true_label (entry
, NULL_TREE
);
816 gimple_cond_set_false_label (entry
, NULL_TREE
);
820 /* Called for each element in the hash table (P) as we delete the
821 edge to cases hash table.
823 Clear all the TREE_CHAINs to prevent problems with copying of
824 SWITCH_EXPRs and structure sharing rules, then free the hash table
828 edge_to_cases_cleanup (const void *key ATTRIBUTE_UNUSED
, void **value
,
829 void *data ATTRIBUTE_UNUSED
)
833 for (t
= (tree
) *value
; t
; t
= next
)
835 next
= CASE_CHAIN (t
);
836 CASE_CHAIN (t
) = NULL
;
843 /* Start recording information mapping edges to case labels. */
846 start_recording_case_labels (void)
848 gcc_assert (edge_to_cases
== NULL
);
849 edge_to_cases
= pointer_map_create ();
850 touched_switch_bbs
= BITMAP_ALLOC (NULL
);
853 /* Return nonzero if we are recording information for case labels. */
856 recording_case_labels_p (void)
858 return (edge_to_cases
!= NULL
);
861 /* Stop recording information mapping edges to case labels and
862 remove any information we have recorded. */
864 end_recording_case_labels (void)
868 pointer_map_traverse (edge_to_cases
, edge_to_cases_cleanup
, NULL
);
869 pointer_map_destroy (edge_to_cases
);
870 edge_to_cases
= NULL
;
871 EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs
, 0, i
, bi
)
873 basic_block bb
= BASIC_BLOCK (i
);
876 gimple stmt
= last_stmt (bb
);
877 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
878 group_case_labels_stmt (stmt
);
881 BITMAP_FREE (touched_switch_bbs
);
884 /* If we are inside a {start,end}_recording_cases block, then return
885 a chain of CASE_LABEL_EXPRs from T which reference E.
887 Otherwise return NULL. */
890 get_cases_for_edge (edge e
, gimple t
)
895 /* If we are not recording cases, then we do not have CASE_LABEL_EXPR
896 chains available. Return NULL so the caller can detect this case. */
897 if (!recording_case_labels_p ())
900 slot
= pointer_map_contains (edge_to_cases
, e
);
904 /* If we did not find E in the hash table, then this must be the first
905 time we have been queried for information about E & T. Add all the
906 elements from T to the hash table then perform the query again. */
908 n
= gimple_switch_num_labels (t
);
909 for (i
= 0; i
< n
; i
++)
911 tree elt
= gimple_switch_label (t
, i
);
912 tree lab
= CASE_LABEL (elt
);
913 basic_block label_bb
= label_to_block (lab
);
914 edge this_edge
= find_edge (e
->src
, label_bb
);
916 /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
918 slot
= pointer_map_insert (edge_to_cases
, this_edge
);
919 CASE_CHAIN (elt
) = (tree
) *slot
;
923 return (tree
) *pointer_map_contains (edge_to_cases
, e
);
926 /* Create the edges for a GIMPLE_SWITCH starting at block BB. */
929 make_gimple_switch_edges (basic_block bb
)
931 gimple entry
= last_stmt (bb
);
934 n
= gimple_switch_num_labels (entry
);
936 for (i
= 0; i
< n
; ++i
)
938 tree lab
= CASE_LABEL (gimple_switch_label (entry
, i
));
939 basic_block label_bb
= label_to_block (lab
);
940 make_edge (bb
, label_bb
, 0);
945 /* Return the basic block holding label DEST. */
948 label_to_block_fn (struct function
*ifun
, tree dest
)
950 int uid
= LABEL_DECL_UID (dest
);
952 /* We would die hard when faced by an undefined label. Emit a label to
953 the very first basic block. This will hopefully make even the dataflow
954 and undefined variable warnings quite right. */
955 if (seen_error () && uid
< 0)
957 gimple_stmt_iterator gsi
= gsi_start_bb (BASIC_BLOCK (NUM_FIXED_BLOCKS
));
960 stmt
= gimple_build_label (dest
);
961 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
962 uid
= LABEL_DECL_UID (dest
);
964 if (vec_safe_length (ifun
->cfg
->x_label_to_block_map
) <= (unsigned int) uid
)
966 return (*ifun
->cfg
->x_label_to_block_map
)[uid
];
969 /* Create edges for an abnormal goto statement at block BB. If FOR_CALL
970 is true, the source statement is a CALL_EXPR instead of a GOTO_EXPR. */
973 make_abnormal_goto_edges (basic_block bb
, bool for_call
)
975 basic_block target_bb
;
976 gimple_stmt_iterator gsi
;
978 FOR_EACH_BB (target_bb
)
980 for (gsi
= gsi_start_bb (target_bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
982 gimple label_stmt
= gsi_stmt (gsi
);
985 if (gimple_code (label_stmt
) != GIMPLE_LABEL
)
988 target
= gimple_label_label (label_stmt
);
990 /* Make an edge to every label block that has been marked as a
991 potential target for a computed goto or a non-local goto. */
992 if ((FORCED_LABEL (target
) && !for_call
)
993 || (DECL_NONLOCAL (target
) && for_call
))
995 make_edge (bb
, target_bb
, EDGE_ABNORMAL
);
999 if (!gsi_end_p (gsi
))
1001 /* Make an edge to every setjmp-like call. */
1002 gimple call_stmt
= gsi_stmt (gsi
);
1003 if (is_gimple_call (call_stmt
)
1004 && (gimple_call_flags (call_stmt
) & ECF_RETURNS_TWICE
))
1005 make_edge (bb
, target_bb
, EDGE_ABNORMAL
);
1010 /* Create edges for a goto statement at block BB. */
1013 make_goto_expr_edges (basic_block bb
)
1015 gimple_stmt_iterator last
= gsi_last_bb (bb
);
1016 gimple goto_t
= gsi_stmt (last
);
1018 /* A simple GOTO creates normal edges. */
1019 if (simple_goto_p (goto_t
))
1021 tree dest
= gimple_goto_dest (goto_t
);
1022 basic_block label_bb
= label_to_block (dest
);
1023 edge e
= make_edge (bb
, label_bb
, EDGE_FALLTHRU
);
1024 e
->goto_locus
= gimple_location (goto_t
);
1025 gsi_remove (&last
, true);
1029 /* A computed GOTO creates abnormal edges. */
1030 make_abnormal_goto_edges (bb
, false);
1033 /* Create edges for an asm statement with labels at block BB. */
1036 make_gimple_asm_edges (basic_block bb
)
1038 gimple stmt
= last_stmt (bb
);
1039 int i
, n
= gimple_asm_nlabels (stmt
);
1041 for (i
= 0; i
< n
; ++i
)
1043 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
1044 basic_block label_bb
= label_to_block (label
);
1045 make_edge (bb
, label_bb
, 0);
1049 /*---------------------------------------------------------------------------
1051 ---------------------------------------------------------------------------*/
1053 /* Cleanup useless labels in basic blocks. This is something we wish
1054 to do early because it allows us to group case labels before creating
1055 the edges for the CFG, and it speeds up block statement iterators in
1056 all passes later on.
1057 We rerun this pass after CFG is created, to get rid of the labels that
1058 are no longer referenced. After then we do not run it any more, since
1059 (almost) no new labels should be created. */
1061 /* A map from basic block index to the leading label of that block. */
1062 static struct label_record
1067 /* True if the label is referenced from somewhere. */
1071 /* Given LABEL return the first label in the same basic block. */
1074 main_block_label (tree label
)
1076 basic_block bb
= label_to_block (label
);
1077 tree main_label
= label_for_bb
[bb
->index
].label
;
1079 /* label_to_block possibly inserted undefined label into the chain. */
1082 label_for_bb
[bb
->index
].label
= label
;
1086 label_for_bb
[bb
->index
].used
= true;
1090 /* Clean up redundant labels within the exception tree. */
1093 cleanup_dead_labels_eh (void)
1100 if (cfun
->eh
== NULL
)
1103 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1104 if (lp
&& lp
->post_landing_pad
)
1106 lab
= main_block_label (lp
->post_landing_pad
);
1107 if (lab
!= lp
->post_landing_pad
)
1109 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1110 EH_LANDING_PAD_NR (lab
) = lp
->index
;
1114 FOR_ALL_EH_REGION (r
)
1118 case ERT_MUST_NOT_THROW
:
1124 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
1128 c
->label
= main_block_label (lab
);
1133 case ERT_ALLOWED_EXCEPTIONS
:
1134 lab
= r
->u
.allowed
.label
;
1136 r
->u
.allowed
.label
= main_block_label (lab
);
1142 /* Cleanup redundant labels. This is a three-step process:
1143 1) Find the leading label for each block.
1144 2) Redirect all references to labels to the leading labels.
1145 3) Cleanup all useless labels. */
1148 cleanup_dead_labels (void)
1151 label_for_bb
= XCNEWVEC (struct label_record
, last_basic_block
);
1153 /* Find a suitable label for each block. We use the first user-defined
1154 label if there is one, or otherwise just the first label we see. */
1157 gimple_stmt_iterator i
;
1159 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
1162 gimple stmt
= gsi_stmt (i
);
1164 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1167 label
= gimple_label_label (stmt
);
1169 /* If we have not yet seen a label for the current block,
1170 remember this one and see if there are more labels. */
1171 if (!label_for_bb
[bb
->index
].label
)
1173 label_for_bb
[bb
->index
].label
= label
;
1177 /* If we did see a label for the current block already, but it
1178 is an artificially created label, replace it if the current
1179 label is a user defined label. */
1180 if (!DECL_ARTIFICIAL (label
)
1181 && DECL_ARTIFICIAL (label_for_bb
[bb
->index
].label
))
1183 label_for_bb
[bb
->index
].label
= label
;
1189 /* Now redirect all jumps/branches to the selected label.
1190 First do so for each block ending in a control statement. */
1193 gimple stmt
= last_stmt (bb
);
1194 tree label
, new_label
;
1199 switch (gimple_code (stmt
))
1202 label
= gimple_cond_true_label (stmt
);
1205 new_label
= main_block_label (label
);
1206 if (new_label
!= label
)
1207 gimple_cond_set_true_label (stmt
, new_label
);
1210 label
= gimple_cond_false_label (stmt
);
1213 new_label
= main_block_label (label
);
1214 if (new_label
!= label
)
1215 gimple_cond_set_false_label (stmt
, new_label
);
1221 size_t i
, n
= gimple_switch_num_labels (stmt
);
1223 /* Replace all destination labels. */
1224 for (i
= 0; i
< n
; ++i
)
1226 tree case_label
= gimple_switch_label (stmt
, i
);
1227 label
= CASE_LABEL (case_label
);
1228 new_label
= main_block_label (label
);
1229 if (new_label
!= label
)
1230 CASE_LABEL (case_label
) = new_label
;
1237 int i
, n
= gimple_asm_nlabels (stmt
);
1239 for (i
= 0; i
< n
; ++i
)
1241 tree cons
= gimple_asm_label_op (stmt
, i
);
1242 tree label
= main_block_label (TREE_VALUE (cons
));
1243 TREE_VALUE (cons
) = label
;
1248 /* We have to handle gotos until they're removed, and we don't
1249 remove them until after we've created the CFG edges. */
1251 if (!computed_goto_p (stmt
))
1253 label
= gimple_goto_dest (stmt
);
1254 new_label
= main_block_label (label
);
1255 if (new_label
!= label
)
1256 gimple_goto_set_dest (stmt
, new_label
);
1260 case GIMPLE_TRANSACTION
:
1262 tree label
= gimple_transaction_label (stmt
);
1265 tree new_label
= main_block_label (label
);
1266 if (new_label
!= label
)
1267 gimple_transaction_set_label (stmt
, new_label
);
1277 /* Do the same for the exception region tree labels. */
1278 cleanup_dead_labels_eh ();
1280 /* Finally, purge dead labels. All user-defined labels and labels that
1281 can be the target of non-local gotos and labels which have their
1282 address taken are preserved. */
1285 gimple_stmt_iterator i
;
1286 tree label_for_this_bb
= label_for_bb
[bb
->index
].label
;
1288 if (!label_for_this_bb
)
1291 /* If the main label of the block is unused, we may still remove it. */
1292 if (!label_for_bb
[bb
->index
].used
)
1293 label_for_this_bb
= NULL
;
1295 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); )
1298 gimple stmt
= gsi_stmt (i
);
1300 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1303 label
= gimple_label_label (stmt
);
1305 if (label
== label_for_this_bb
1306 || !DECL_ARTIFICIAL (label
)
1307 || DECL_NONLOCAL (label
)
1308 || FORCED_LABEL (label
))
1311 gsi_remove (&i
, true);
1315 free (label_for_bb
);
1318 /* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
1319 the ones jumping to the same label.
1320 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
1323 group_case_labels_stmt (gimple stmt
)
1325 int old_size
= gimple_switch_num_labels (stmt
);
1326 int i
, j
, new_size
= old_size
;
1327 basic_block default_bb
= NULL
;
1329 default_bb
= label_to_block (CASE_LABEL (gimple_switch_default_label (stmt
)));
1331 /* Look for possible opportunities to merge cases. */
1333 while (i
< old_size
)
1335 tree base_case
, base_high
;
1336 basic_block base_bb
;
1338 base_case
= gimple_switch_label (stmt
, i
);
1340 gcc_assert (base_case
);
1341 base_bb
= label_to_block (CASE_LABEL (base_case
));
1343 /* Discard cases that have the same destination as the
1345 if (base_bb
== default_bb
)
1347 gimple_switch_set_label (stmt
, i
, NULL_TREE
);
1353 base_high
= CASE_HIGH (base_case
)
1354 ? CASE_HIGH (base_case
)
1355 : CASE_LOW (base_case
);
1358 /* Try to merge case labels. Break out when we reach the end
1359 of the label vector or when we cannot merge the next case
1360 label with the current one. */
1361 while (i
< old_size
)
1363 tree merge_case
= gimple_switch_label (stmt
, i
);
1364 basic_block merge_bb
= label_to_block (CASE_LABEL (merge_case
));
1365 double_int bhp1
= tree_to_double_int (base_high
) + double_int_one
;
1367 /* Merge the cases if they jump to the same place,
1368 and their ranges are consecutive. */
1369 if (merge_bb
== base_bb
1370 && tree_to_double_int (CASE_LOW (merge_case
)) == bhp1
)
1372 base_high
= CASE_HIGH (merge_case
) ?
1373 CASE_HIGH (merge_case
) : CASE_LOW (merge_case
);
1374 CASE_HIGH (base_case
) = base_high
;
1375 gimple_switch_set_label (stmt
, i
, NULL_TREE
);
1384 /* Compress the case labels in the label vector, and adjust the
1385 length of the vector. */
1386 for (i
= 0, j
= 0; i
< new_size
; i
++)
1388 while (! gimple_switch_label (stmt
, j
))
1390 gimple_switch_set_label (stmt
, i
,
1391 gimple_switch_label (stmt
, j
++));
1394 gcc_assert (new_size
<= old_size
);
1395 gimple_switch_set_num_labels (stmt
, new_size
);
1398 /* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
1399 and scan the sorted vector of cases. Combine the ones jumping to the
1403 group_case_labels (void)
1409 gimple stmt
= last_stmt (bb
);
1410 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1411 group_case_labels_stmt (stmt
);
1415 /* Checks whether we can merge block B into block A. */
1418 gimple_can_merge_blocks_p (basic_block a
, basic_block b
)
1421 gimple_stmt_iterator gsi
;
1423 if (!single_succ_p (a
))
1426 if (single_succ_edge (a
)->flags
& EDGE_COMPLEX
)
1429 if (single_succ (a
) != b
)
1432 if (!single_pred_p (b
))
1435 if (b
== EXIT_BLOCK_PTR
)
1438 /* If A ends by a statement causing exceptions or something similar, we
1439 cannot merge the blocks. */
1440 stmt
= last_stmt (a
);
1441 if (stmt
&& stmt_ends_bb_p (stmt
))
1444 /* Do not allow a block with only a non-local label to be merged. */
1446 && gimple_code (stmt
) == GIMPLE_LABEL
1447 && DECL_NONLOCAL (gimple_label_label (stmt
)))
1450 /* Examine the labels at the beginning of B. */
1451 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1454 stmt
= gsi_stmt (gsi
);
1455 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1457 lab
= gimple_label_label (stmt
);
1459 /* Do not remove user forced labels or for -O0 any user labels. */
1460 if (!DECL_ARTIFICIAL (lab
) && (!optimize
|| FORCED_LABEL (lab
)))
1464 /* Protect the loop latches. */
1465 if (current_loops
&& b
->loop_father
->latch
== b
)
1468 /* It must be possible to eliminate all phi nodes in B. If ssa form
1469 is not up-to-date and a name-mapping is registered, we cannot eliminate
1470 any phis. Symbols marked for renaming are never a problem though. */
1471 for (gsi
= gsi_start_phis (b
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1473 gimple phi
= gsi_stmt (gsi
);
1474 /* Technically only new names matter. */
1475 if (name_registered_for_update_p (PHI_RESULT (phi
)))
1479 /* When not optimizing, don't merge if we'd lose goto_locus. */
1481 && single_succ_edge (a
)->goto_locus
!= UNKNOWN_LOCATION
)
1483 location_t goto_locus
= single_succ_edge (a
)->goto_locus
;
1484 gimple_stmt_iterator prev
, next
;
1485 prev
= gsi_last_nondebug_bb (a
);
1486 next
= gsi_after_labels (b
);
1487 if (!gsi_end_p (next
) && is_gimple_debug (gsi_stmt (next
)))
1488 gsi_next_nondebug (&next
);
1489 if ((gsi_end_p (prev
)
1490 || gimple_location (gsi_stmt (prev
)) != goto_locus
)
1491 && (gsi_end_p (next
)
1492 || gimple_location (gsi_stmt (next
)) != goto_locus
))
1499 /* Return true if the var whose chain of uses starts at PTR has no
1502 has_zero_uses_1 (const ssa_use_operand_t
*head
)
1504 const ssa_use_operand_t
*ptr
;
1506 for (ptr
= head
->next
; ptr
!= head
; ptr
= ptr
->next
)
1507 if (!is_gimple_debug (USE_STMT (ptr
)))
1513 /* Return true if the var whose chain of uses starts at PTR has a
1514 single nondebug use. Set USE_P and STMT to that single nondebug
1515 use, if so, or to NULL otherwise. */
1517 single_imm_use_1 (const ssa_use_operand_t
*head
,
1518 use_operand_p
*use_p
, gimple
*stmt
)
1520 ssa_use_operand_t
*ptr
, *single_use
= 0;
1522 for (ptr
= head
->next
; ptr
!= head
; ptr
= ptr
->next
)
1523 if (!is_gimple_debug (USE_STMT (ptr
)))
1534 *use_p
= single_use
;
1537 *stmt
= single_use
? single_use
->loc
.stmt
: NULL
;
1539 return !!single_use
;
1542 /* Replaces all uses of NAME by VAL. */
1545 replace_uses_by (tree name
, tree val
)
1547 imm_use_iterator imm_iter
;
1552 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, name
)
1554 FOR_EACH_IMM_USE_ON_STMT (use
, imm_iter
)
1556 replace_exp (use
, val
);
1558 if (gimple_code (stmt
) == GIMPLE_PHI
)
1560 e
= gimple_phi_arg_edge (stmt
, PHI_ARG_INDEX_FROM_USE (use
));
1561 if (e
->flags
& EDGE_ABNORMAL
)
1563 /* This can only occur for virtual operands, since
1564 for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
1565 would prevent replacement. */
1566 gcc_checking_assert (virtual_operand_p (name
));
1567 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val
) = 1;
1572 if (gimple_code (stmt
) != GIMPLE_PHI
)
1574 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
1575 gimple orig_stmt
= stmt
;
1578 /* Mark the block if we changed the last stmt in it. */
1579 if (cfgcleanup_altered_bbs
1580 && stmt_ends_bb_p (stmt
))
1581 bitmap_set_bit (cfgcleanup_altered_bbs
, gimple_bb (stmt
)->index
);
1583 /* FIXME. It shouldn't be required to keep TREE_CONSTANT
1584 on ADDR_EXPRs up-to-date on GIMPLE. Propagation will
1585 only change sth from non-invariant to invariant, and only
1586 when propagating constants. */
1587 if (is_gimple_min_invariant (val
))
1588 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1590 tree op
= gimple_op (stmt
, i
);
1591 /* Operands may be empty here. For example, the labels
1592 of a GIMPLE_COND are nulled out following the creation
1593 of the corresponding CFG edges. */
1594 if (op
&& TREE_CODE (op
) == ADDR_EXPR
)
1595 recompute_tree_invariant_for_addr_expr (op
);
1598 if (fold_stmt (&gsi
))
1599 stmt
= gsi_stmt (gsi
);
1601 if (maybe_clean_or_replace_eh_stmt (orig_stmt
, stmt
))
1602 gimple_purge_dead_eh_edges (gimple_bb (stmt
));
1608 gcc_checking_assert (has_zero_uses (name
));
1610 /* Also update the trees stored in loop structures. */
1616 FOR_EACH_LOOP (li
, loop
, 0)
1618 substitute_in_loop_info (loop
, name
, val
);
1623 /* Merge block B into block A. */
1626 gimple_merge_blocks (basic_block a
, basic_block b
)
1628 gimple_stmt_iterator last
, gsi
, psi
;
1631 fprintf (dump_file
, "Merging blocks %d and %d\n", a
->index
, b
->index
);
1633 /* Remove all single-valued PHI nodes from block B of the form
1634 V_i = PHI <V_j> by propagating V_j to all the uses of V_i. */
1635 gsi
= gsi_last_bb (a
);
1636 for (psi
= gsi_start_phis (b
); !gsi_end_p (psi
); )
1638 gimple phi
= gsi_stmt (psi
);
1639 tree def
= gimple_phi_result (phi
), use
= gimple_phi_arg_def (phi
, 0);
1641 bool may_replace_uses
= (virtual_operand_p (def
)
1642 || may_propagate_copy (def
, use
));
1644 /* In case we maintain loop closed ssa form, do not propagate arguments
1645 of loop exit phi nodes. */
1647 && loops_state_satisfies_p (LOOP_CLOSED_SSA
)
1648 && !virtual_operand_p (def
)
1649 && TREE_CODE (use
) == SSA_NAME
1650 && a
->loop_father
!= b
->loop_father
)
1651 may_replace_uses
= false;
1653 if (!may_replace_uses
)
1655 gcc_assert (!virtual_operand_p (def
));
1657 /* Note that just emitting the copies is fine -- there is no problem
1658 with ordering of phi nodes. This is because A is the single
1659 predecessor of B, therefore results of the phi nodes cannot
1660 appear as arguments of the phi nodes. */
1661 copy
= gimple_build_assign (def
, use
);
1662 gsi_insert_after (&gsi
, copy
, GSI_NEW_STMT
);
1663 remove_phi_node (&psi
, false);
1667 /* If we deal with a PHI for virtual operands, we can simply
1668 propagate these without fussing with folding or updating
1670 if (virtual_operand_p (def
))
1672 imm_use_iterator iter
;
1673 use_operand_p use_p
;
1676 FOR_EACH_IMM_USE_STMT (stmt
, iter
, def
)
1677 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
1678 SET_USE (use_p
, use
);
1680 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
1681 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use
) = 1;
1684 replace_uses_by (def
, use
);
1686 remove_phi_node (&psi
, true);
1690 /* Ensure that B follows A. */
1691 move_block_after (b
, a
);
1693 gcc_assert (single_succ_edge (a
)->flags
& EDGE_FALLTHRU
);
1694 gcc_assert (!last_stmt (a
) || !stmt_ends_bb_p (last_stmt (a
)));
1696 /* Remove labels from B and set gimple_bb to A for other statements. */
1697 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
);)
1699 gimple stmt
= gsi_stmt (gsi
);
1700 if (gimple_code (stmt
) == GIMPLE_LABEL
)
1702 tree label
= gimple_label_label (stmt
);
1705 gsi_remove (&gsi
, false);
1707 /* Now that we can thread computed gotos, we might have
1708 a situation where we have a forced label in block B
1709 However, the label at the start of block B might still be
1710 used in other ways (think about the runtime checking for
1711 Fortran assigned gotos). So we can not just delete the
1712 label. Instead we move the label to the start of block A. */
1713 if (FORCED_LABEL (label
))
1715 gimple_stmt_iterator dest_gsi
= gsi_start_bb (a
);
1716 gsi_insert_before (&dest_gsi
, stmt
, GSI_NEW_STMT
);
1718 /* Other user labels keep around in a form of a debug stmt. */
1719 else if (!DECL_ARTIFICIAL (label
) && MAY_HAVE_DEBUG_STMTS
)
1721 gimple dbg
= gimple_build_debug_bind (label
,
1724 gimple_debug_bind_reset_value (dbg
);
1725 gsi_insert_before (&gsi
, dbg
, GSI_SAME_STMT
);
1728 lp_nr
= EH_LANDING_PAD_NR (label
);
1731 eh_landing_pad lp
= get_eh_landing_pad_from_number (lp_nr
);
1732 lp
->post_landing_pad
= NULL
;
1737 gimple_set_bb (stmt
, a
);
1742 /* Merge the sequences. */
1743 last
= gsi_last_bb (a
);
1744 gsi_insert_seq_after (&last
, bb_seq (b
), GSI_NEW_STMT
);
1745 set_bb_seq (b
, NULL
);
1747 if (cfgcleanup_altered_bbs
)
1748 bitmap_set_bit (cfgcleanup_altered_bbs
, a
->index
);
1752 /* Return the one of two successors of BB that is not reachable by a
1753 complex edge, if there is one. Else, return BB. We use
1754 this in optimizations that use post-dominators for their heuristics,
1755 to catch the cases in C++ where function calls are involved. */
1758 single_noncomplex_succ (basic_block bb
)
1761 if (EDGE_COUNT (bb
->succs
) != 2)
1764 e0
= EDGE_SUCC (bb
, 0);
1765 e1
= EDGE_SUCC (bb
, 1);
1766 if (e0
->flags
& EDGE_COMPLEX
)
1768 if (e1
->flags
& EDGE_COMPLEX
)
1774 /* T is CALL_EXPR. Set current_function_calls_* flags. */
1777 notice_special_calls (gimple call
)
1779 int flags
= gimple_call_flags (call
);
1781 if (flags
& ECF_MAY_BE_ALLOCA
)
1782 cfun
->calls_alloca
= true;
1783 if (flags
& ECF_RETURNS_TWICE
)
1784 cfun
->calls_setjmp
= true;
1788 /* Clear flags set by notice_special_calls. Used by dead code removal
1789 to update the flags. */
1792 clear_special_calls (void)
1794 cfun
->calls_alloca
= false;
1795 cfun
->calls_setjmp
= false;
1798 /* Remove PHI nodes associated with basic block BB and all edges out of BB. */
1801 remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb
)
1803 /* Since this block is no longer reachable, we can just delete all
1804 of its PHI nodes. */
1805 remove_phi_nodes (bb
);
1807 /* Remove edges to BB's successors. */
1808 while (EDGE_COUNT (bb
->succs
) > 0)
1809 remove_edge (EDGE_SUCC (bb
, 0));
1813 /* Remove statements of basic block BB. */
1816 remove_bb (basic_block bb
)
1818 gimple_stmt_iterator i
;
1822 fprintf (dump_file
, "Removing basic block %d\n", bb
->index
);
1823 if (dump_flags
& TDF_DETAILS
)
1825 dump_bb (dump_file
, bb
, 0, dump_flags
);
1826 fprintf (dump_file
, "\n");
1832 struct loop
*loop
= bb
->loop_father
;
1834 /* If a loop gets removed, clean up the information associated
1836 if (loop
->latch
== bb
1837 || loop
->header
== bb
)
1838 free_numbers_of_iterations_estimates_loop (loop
);
1841 /* Remove all the instructions in the block. */
1842 if (bb_seq (bb
) != NULL
)
1844 /* Walk backwards so as to get a chance to substitute all
1845 released DEFs into debug stmts. See
1846 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
1848 for (i
= gsi_last_bb (bb
); !gsi_end_p (i
);)
1850 gimple stmt
= gsi_stmt (i
);
1851 if (gimple_code (stmt
) == GIMPLE_LABEL
1852 && (FORCED_LABEL (gimple_label_label (stmt
))
1853 || DECL_NONLOCAL (gimple_label_label (stmt
))))
1856 gimple_stmt_iterator new_gsi
;
1858 /* A non-reachable non-local label may still be referenced.
1859 But it no longer needs to carry the extra semantics of
1861 if (DECL_NONLOCAL (gimple_label_label (stmt
)))
1863 DECL_NONLOCAL (gimple_label_label (stmt
)) = 0;
1864 FORCED_LABEL (gimple_label_label (stmt
)) = 1;
1867 new_bb
= bb
->prev_bb
;
1868 new_gsi
= gsi_start_bb (new_bb
);
1869 gsi_remove (&i
, false);
1870 gsi_insert_before (&new_gsi
, stmt
, GSI_NEW_STMT
);
1874 /* Release SSA definitions if we are in SSA. Note that we
1875 may be called when not in SSA. For example,
1876 final_cleanup calls this function via
1877 cleanup_tree_cfg. */
1878 if (gimple_in_ssa_p (cfun
))
1879 release_defs (stmt
);
1881 gsi_remove (&i
, true);
1885 i
= gsi_last_bb (bb
);
1891 remove_phi_nodes_and_edges_for_unreachable_block (bb
);
1892 bb
->il
.gimple
.seq
= NULL
;
1893 bb
->il
.gimple
.phi_nodes
= NULL
;
1897 /* Given a basic block BB ending with COND_EXPR or SWITCH_EXPR, and a
1898 predicate VAL, return the edge that will be taken out of the block.
1899 If VAL does not match a unique edge, NULL is returned. */
1902 find_taken_edge (basic_block bb
, tree val
)
1906 stmt
= last_stmt (bb
);
1909 gcc_assert (is_ctrl_stmt (stmt
));
1914 if (!is_gimple_min_invariant (val
))
1917 if (gimple_code (stmt
) == GIMPLE_COND
)
1918 return find_taken_edge_cond_expr (bb
, val
);
1920 if (gimple_code (stmt
) == GIMPLE_SWITCH
)
1921 return find_taken_edge_switch_expr (bb
, val
);
1923 if (computed_goto_p (stmt
))
1925 /* Only optimize if the argument is a label, if the argument is
1926 not a label then we can not construct a proper CFG.
1928 It may be the case that we only need to allow the LABEL_REF to
1929 appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
1930 appear inside a LABEL_EXPR just to be safe. */
1931 if ((TREE_CODE (val
) == ADDR_EXPR
|| TREE_CODE (val
) == LABEL_EXPR
)
1932 && TREE_CODE (TREE_OPERAND (val
, 0)) == LABEL_DECL
)
1933 return find_taken_edge_computed_goto (bb
, TREE_OPERAND (val
, 0));
1940 /* Given a constant value VAL and the entry block BB to a GOTO_EXPR
1941 statement, determine which of the outgoing edges will be taken out of the
1942 block. Return NULL if either edge may be taken. */
1945 find_taken_edge_computed_goto (basic_block bb
, tree val
)
1950 dest
= label_to_block (val
);
1953 e
= find_edge (bb
, dest
);
1954 gcc_assert (e
!= NULL
);
1960 /* Given a constant value VAL and the entry block BB to a COND_EXPR
1961 statement, determine which of the two edges will be taken out of the
1962 block. Return NULL if either edge may be taken. */
1965 find_taken_edge_cond_expr (basic_block bb
, tree val
)
1967 edge true_edge
, false_edge
;
1969 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
1971 gcc_assert (TREE_CODE (val
) == INTEGER_CST
);
1972 return (integer_zerop (val
) ? false_edge
: true_edge
);
1975 /* Given an INTEGER_CST VAL and the entry block BB to a SWITCH_EXPR
1976 statement, determine which edge will be taken out of the block. Return
1977 NULL if any edge may be taken. */
1980 find_taken_edge_switch_expr (basic_block bb
, tree val
)
1982 basic_block dest_bb
;
1987 switch_stmt
= last_stmt (bb
);
1988 taken_case
= find_case_label_for_value (switch_stmt
, val
);
1989 dest_bb
= label_to_block (CASE_LABEL (taken_case
));
1991 e
= find_edge (bb
, dest_bb
);
1997 /* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
1998 We can make optimal use here of the fact that the case labels are
1999 sorted: We can do a binary search for a case matching VAL. */
2002 find_case_label_for_value (gimple switch_stmt
, tree val
)
2004 size_t low
, high
, n
= gimple_switch_num_labels (switch_stmt
);
2005 tree default_case
= gimple_switch_default_label (switch_stmt
);
2007 for (low
= 0, high
= n
; high
- low
> 1; )
2009 size_t i
= (high
+ low
) / 2;
2010 tree t
= gimple_switch_label (switch_stmt
, i
);
2013 /* Cache the result of comparing CASE_LOW and val. */
2014 cmp
= tree_int_cst_compare (CASE_LOW (t
), val
);
2021 if (CASE_HIGH (t
) == NULL
)
2023 /* A singe-valued case label. */
2029 /* A case range. We can only handle integer ranges. */
2030 if (cmp
<= 0 && tree_int_cst_compare (CASE_HIGH (t
), val
) >= 0)
2035 return default_case
;
2039 /* Dump a basic block on stderr. */
2042 gimple_debug_bb (basic_block bb
)
2044 dump_bb (stderr
, bb
, 0, TDF_VOPS
|TDF_MEMSYMS
|TDF_BLOCKS
);
2048 /* Dump basic block with index N on stderr. */
2051 gimple_debug_bb_n (int n
)
2053 gimple_debug_bb (BASIC_BLOCK (n
));
2054 return BASIC_BLOCK (n
);
2058 /* Dump the CFG on stderr.
2060 FLAGS are the same used by the tree dumping functions
2061 (see TDF_* in dumpfile.h). */
2064 gimple_debug_cfg (int flags
)
2066 gimple_dump_cfg (stderr
, flags
);
2070 /* Dump the program showing basic block boundaries on the given FILE.
2072 FLAGS are the same used by the tree dumping functions (see TDF_* in
2076 gimple_dump_cfg (FILE *file
, int flags
)
2078 if (flags
& TDF_DETAILS
)
2080 dump_function_header (file
, current_function_decl
, flags
);
2081 fprintf (file
, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
2082 n_basic_blocks
, n_edges
, last_basic_block
);
2084 brief_dump_cfg (file
, flags
| TDF_COMMENT
);
2085 fprintf (file
, "\n");
2088 if (flags
& TDF_STATS
)
2089 dump_cfg_stats (file
);
2091 dump_function_to_file (current_function_decl
, file
, flags
| TDF_BLOCKS
);
2095 /* Dump CFG statistics on FILE. */
2098 dump_cfg_stats (FILE *file
)
2100 static long max_num_merged_labels
= 0;
2101 unsigned long size
, total
= 0;
2104 const char * const fmt_str
= "%-30s%-13s%12s\n";
2105 const char * const fmt_str_1
= "%-30s%13d%11lu%c\n";
2106 const char * const fmt_str_2
= "%-30s%13ld%11lu%c\n";
2107 const char * const fmt_str_3
= "%-43s%11lu%c\n";
2108 const char *funcname
= current_function_name ();
2110 fprintf (file
, "\nCFG Statistics for %s\n\n", funcname
);
2112 fprintf (file
, "---------------------------------------------------------\n");
2113 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
2114 fprintf (file
, fmt_str
, "", " instances ", "used ");
2115 fprintf (file
, "---------------------------------------------------------\n");
2117 size
= n_basic_blocks
* sizeof (struct basic_block_def
);
2119 fprintf (file
, fmt_str_1
, "Basic blocks", n_basic_blocks
,
2120 SCALE (size
), LABEL (size
));
2124 num_edges
+= EDGE_COUNT (bb
->succs
);
2125 size
= num_edges
* sizeof (struct edge_def
);
2127 fprintf (file
, fmt_str_2
, "Edges", num_edges
, SCALE (size
), LABEL (size
));
2129 fprintf (file
, "---------------------------------------------------------\n");
2130 fprintf (file
, fmt_str_3
, "Total memory used by CFG data", SCALE (total
),
2132 fprintf (file
, "---------------------------------------------------------\n");
2133 fprintf (file
, "\n");
2135 if (cfg_stats
.num_merged_labels
> max_num_merged_labels
)
2136 max_num_merged_labels
= cfg_stats
.num_merged_labels
;
2138 fprintf (file
, "Coalesced label blocks: %ld (Max so far: %ld)\n",
2139 cfg_stats
.num_merged_labels
, max_num_merged_labels
);
2141 fprintf (file
, "\n");
2145 /* Dump CFG statistics on stderr. Keep extern so that it's always
2146 linked in the final executable. */
2149 debug_cfg_stats (void)
2151 dump_cfg_stats (stderr
);
2154 /*---------------------------------------------------------------------------
2155 Miscellaneous helpers
2156 ---------------------------------------------------------------------------*/
2158 /* Return true if T, a GIMPLE_CALL, can make an abnormal transfer of control
2159 flow. Transfers of control flow associated with EH are excluded. */
2162 call_can_make_abnormal_goto (gimple t
)
2164 /* If the function has no non-local labels, then a call cannot make an
2165 abnormal transfer of control. */
2166 if (!cfun
->has_nonlocal_label
2167 && !cfun
->calls_setjmp
)
2170 /* Likewise if the call has no side effects. */
2171 if (!gimple_has_side_effects (t
))
2174 /* Likewise if the called function is leaf. */
2175 if (gimple_call_flags (t
) & ECF_LEAF
)
2182 /* Return true if T can make an abnormal transfer of control flow.
2183 Transfers of control flow associated with EH are excluded. */
2186 stmt_can_make_abnormal_goto (gimple t
)
2188 if (computed_goto_p (t
))
2190 if (is_gimple_call (t
))
2191 return call_can_make_abnormal_goto (t
);
2196 /* Return true if T represents a stmt that always transfers control. */
2199 is_ctrl_stmt (gimple t
)
2201 switch (gimple_code (t
))
2215 /* Return true if T is a statement that may alter the flow of control
2216 (e.g., a call to a non-returning function). */
2219 is_ctrl_altering_stmt (gimple t
)
2223 switch (gimple_code (t
))
2227 int flags
= gimple_call_flags (t
);
2229 /* A call alters control flow if it can make an abnormal goto. */
2230 if (call_can_make_abnormal_goto (t
))
2233 /* A call also alters control flow if it does not return. */
2234 if (flags
& ECF_NORETURN
)
2237 /* TM ending statements have backedges out of the transaction.
2238 Return true so we split the basic block containing them.
2239 Note that the TM_BUILTIN test is merely an optimization. */
2240 if ((flags
& ECF_TM_BUILTIN
)
2241 && is_tm_ending_fndecl (gimple_call_fndecl (t
)))
2244 /* BUILT_IN_RETURN call is same as return statement. */
2245 if (gimple_call_builtin_p (t
, BUILT_IN_RETURN
))
2250 case GIMPLE_EH_DISPATCH
:
2251 /* EH_DISPATCH branches to the individual catch handlers at
2252 this level of a try or allowed-exceptions region. It can
2253 fallthru to the next statement as well. */
2257 if (gimple_asm_nlabels (t
) > 0)
2262 /* OpenMP directives alter control flow. */
2265 case GIMPLE_TRANSACTION
:
2266 /* A transaction start alters control flow. */
2273 /* If a statement can throw, it alters control flow. */
2274 return stmt_can_throw_internal (t
);
2278 /* Return true if T is a simple local goto. */
2281 simple_goto_p (gimple t
)
2283 return (gimple_code (t
) == GIMPLE_GOTO
2284 && TREE_CODE (gimple_goto_dest (t
)) == LABEL_DECL
);
2288 /* Return true if STMT should start a new basic block. PREV_STMT is
2289 the statement preceding STMT. It is used when STMT is a label or a
2290 case label. Labels should only start a new basic block if their
2291 previous statement wasn't a label. Otherwise, sequence of labels
2292 would generate unnecessary basic blocks that only contain a single
2296 stmt_starts_bb_p (gimple stmt
, gimple prev_stmt
)
2301 /* Labels start a new basic block only if the preceding statement
2302 wasn't a label of the same type. This prevents the creation of
2303 consecutive blocks that have nothing but a single label. */
2304 if (gimple_code (stmt
) == GIMPLE_LABEL
)
2306 /* Nonlocal and computed GOTO targets always start a new block. */
2307 if (DECL_NONLOCAL (gimple_label_label (stmt
))
2308 || FORCED_LABEL (gimple_label_label (stmt
)))
2311 if (prev_stmt
&& gimple_code (prev_stmt
) == GIMPLE_LABEL
)
2313 if (DECL_NONLOCAL (gimple_label_label (prev_stmt
)))
2316 cfg_stats
.num_merged_labels
++;
2322 else if (gimple_code (stmt
) == GIMPLE_CALL
2323 && gimple_call_flags (stmt
) & ECF_RETURNS_TWICE
)
2324 /* setjmp acts similar to a nonlocal GOTO target and thus should
2325 start a new block. */
2332 /* Return true if T should end a basic block. */
2335 stmt_ends_bb_p (gimple t
)
2337 return is_ctrl_stmt (t
) || is_ctrl_altering_stmt (t
);
2340 /* Remove block annotations and other data structures. */
2343 delete_tree_cfg_annotations (void)
2345 vec_free (label_to_block_map
);
2349 /* Return the first statement in basic block BB. */
2352 first_stmt (basic_block bb
)
2354 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2357 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2365 /* Return the first non-label statement in basic block BB. */
2368 first_non_label_stmt (basic_block bb
)
2370 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2371 while (!gsi_end_p (i
) && gimple_code (gsi_stmt (i
)) == GIMPLE_LABEL
)
2373 return !gsi_end_p (i
) ? gsi_stmt (i
) : NULL
;
2376 /* Return the last statement in basic block BB. */
2379 last_stmt (basic_block bb
)
2381 gimple_stmt_iterator i
= gsi_last_bb (bb
);
2384 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2392 /* Return the last statement of an otherwise empty block. Return NULL
2393 if the block is totally empty, or if it contains more than one
2397 last_and_only_stmt (basic_block bb
)
2399 gimple_stmt_iterator i
= gsi_last_nondebug_bb (bb
);
2405 last
= gsi_stmt (i
);
2406 gsi_prev_nondebug (&i
);
2410 /* Empty statements should no longer appear in the instruction stream.
2411 Everything that might have appeared before should be deleted by
2412 remove_useless_stmts, and the optimizers should just gsi_remove
2413 instead of smashing with build_empty_stmt.
2415 Thus the only thing that should appear here in a block containing
2416 one executable statement is a label. */
2417 prev
= gsi_stmt (i
);
2418 if (gimple_code (prev
) == GIMPLE_LABEL
)
2424 /* Reinstall those PHI arguments queued in OLD_EDGE to NEW_EDGE. */
2427 reinstall_phi_args (edge new_edge
, edge old_edge
)
2429 edge_var_map_vector
*v
;
2432 gimple_stmt_iterator phis
;
2434 v
= redirect_edge_var_map_vector (old_edge
);
2438 for (i
= 0, phis
= gsi_start_phis (new_edge
->dest
);
2439 v
->iterate (i
, &vm
) && !gsi_end_p (phis
);
2440 i
++, gsi_next (&phis
))
2442 gimple phi
= gsi_stmt (phis
);
2443 tree result
= redirect_edge_var_map_result (vm
);
2444 tree arg
= redirect_edge_var_map_def (vm
);
2446 gcc_assert (result
== gimple_phi_result (phi
));
2448 add_phi_arg (phi
, arg
, new_edge
, redirect_edge_var_map_location (vm
));
2451 redirect_edge_var_map_clear (old_edge
);
2454 /* Returns the basic block after which the new basic block created
2455 by splitting edge EDGE_IN should be placed. Tries to keep the new block
2456 near its "logical" location. This is of most help to humans looking
2457 at debugging dumps. */
2460 split_edge_bb_loc (edge edge_in
)
2462 basic_block dest
= edge_in
->dest
;
2463 basic_block dest_prev
= dest
->prev_bb
;
2467 edge e
= find_edge (dest_prev
, dest
);
2468 if (e
&& !(e
->flags
& EDGE_COMPLEX
))
2469 return edge_in
->src
;
2474 /* Split a (typically critical) edge EDGE_IN. Return the new block.
2475 Abort on abnormal edges. */
2478 gimple_split_edge (edge edge_in
)
2480 basic_block new_bb
, after_bb
, dest
;
2483 /* Abnormal edges cannot be split. */
2484 gcc_assert (!(edge_in
->flags
& EDGE_ABNORMAL
));
2486 dest
= edge_in
->dest
;
2488 after_bb
= split_edge_bb_loc (edge_in
);
2490 new_bb
= create_empty_bb (after_bb
);
2491 new_bb
->frequency
= EDGE_FREQUENCY (edge_in
);
2492 new_bb
->count
= edge_in
->count
;
2493 new_edge
= make_edge (new_bb
, dest
, EDGE_FALLTHRU
);
2494 new_edge
->probability
= REG_BR_PROB_BASE
;
2495 new_edge
->count
= edge_in
->count
;
2497 e
= redirect_edge_and_branch (edge_in
, new_bb
);
2498 gcc_assert (e
== edge_in
);
2499 reinstall_phi_args (new_edge
, e
);
2505 /* Verify properties of the address expression T with base object BASE. */
2508 verify_address (tree t
, tree base
)
2511 bool old_side_effects
;
2513 bool new_side_effects
;
2515 old_constant
= TREE_CONSTANT (t
);
2516 old_side_effects
= TREE_SIDE_EFFECTS (t
);
2518 recompute_tree_invariant_for_addr_expr (t
);
2519 new_side_effects
= TREE_SIDE_EFFECTS (t
);
2520 new_constant
= TREE_CONSTANT (t
);
2522 if (old_constant
!= new_constant
)
2524 error ("constant not recomputed when ADDR_EXPR changed");
2527 if (old_side_effects
!= new_side_effects
)
2529 error ("side effects not recomputed when ADDR_EXPR changed");
2533 if (!(TREE_CODE (base
) == VAR_DECL
2534 || TREE_CODE (base
) == PARM_DECL
2535 || TREE_CODE (base
) == RESULT_DECL
))
2538 if (DECL_GIMPLE_REG_P (base
))
2540 error ("DECL_GIMPLE_REG_P set on a variable with address taken");
2547 /* Callback for walk_tree, check that all elements with address taken are
2548 properly noticed as such. The DATA is an int* that is 1 if TP was seen
2549 inside a PHI node. */
2552 verify_expr (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
2559 /* Check operand N for being valid GIMPLE and give error MSG if not. */
2560 #define CHECK_OP(N, MSG) \
2561 do { if (!is_gimple_val (TREE_OPERAND (t, N))) \
2562 { error (MSG); return TREE_OPERAND (t, N); }} while (0)
2564 switch (TREE_CODE (t
))
2567 if (SSA_NAME_IN_FREE_LIST (t
))
2569 error ("SSA name in freelist but still referenced");
2575 error ("INDIRECT_REF in gimple IL");
2579 x
= TREE_OPERAND (t
, 0);
2580 if (!POINTER_TYPE_P (TREE_TYPE (x
))
2581 || !is_gimple_mem_ref_addr (x
))
2583 error ("invalid first operand of MEM_REF");
2586 if (TREE_CODE (TREE_OPERAND (t
, 1)) != INTEGER_CST
2587 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 1))))
2589 error ("invalid offset operand of MEM_REF");
2590 return TREE_OPERAND (t
, 1);
2592 if (TREE_CODE (x
) == ADDR_EXPR
2593 && (x
= verify_address (x
, TREE_OPERAND (x
, 0))))
2599 x
= fold (ASSERT_EXPR_COND (t
));
2600 if (x
== boolean_false_node
)
2602 error ("ASSERT_EXPR with an always-false condition");
2608 error ("MODIFY_EXPR not expected while having tuples");
2615 gcc_assert (is_gimple_address (t
));
2617 /* Skip any references (they will be checked when we recurse down the
2618 tree) and ensure that any variable used as a prefix is marked
2620 for (x
= TREE_OPERAND (t
, 0);
2621 handled_component_p (x
);
2622 x
= TREE_OPERAND (x
, 0))
2625 if ((tem
= verify_address (t
, x
)))
2628 if (!(TREE_CODE (x
) == VAR_DECL
2629 || TREE_CODE (x
) == PARM_DECL
2630 || TREE_CODE (x
) == RESULT_DECL
))
2633 if (!TREE_ADDRESSABLE (x
))
2635 error ("address taken, but ADDRESSABLE bit not set");
2643 x
= COND_EXPR_COND (t
);
2644 if (!INTEGRAL_TYPE_P (TREE_TYPE (x
)))
2646 error ("non-integral used in condition");
2649 if (!is_gimple_condexpr (x
))
2651 error ("invalid conditional operand");
2656 case NON_LVALUE_EXPR
:
2657 case TRUTH_NOT_EXPR
:
2661 case FIX_TRUNC_EXPR
:
2666 CHECK_OP (0, "invalid operand to unary operator");
2672 if (!is_gimple_reg_type (TREE_TYPE (t
)))
2674 error ("non-scalar BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR");
2681 case ARRAY_RANGE_REF
:
2682 case VIEW_CONVERT_EXPR
:
2683 /* We have a nest of references. Verify that each of the operands
2684 that determine where to reference is either a constant or a variable,
2685 verify that the base is valid, and then show we've already checked
2687 while (handled_component_p (t
))
2689 if (TREE_CODE (t
) == COMPONENT_REF
&& TREE_OPERAND (t
, 2))
2690 CHECK_OP (2, "invalid COMPONENT_REF offset operator");
2691 else if (TREE_CODE (t
) == ARRAY_REF
2692 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
2694 CHECK_OP (1, "invalid array index");
2695 if (TREE_OPERAND (t
, 2))
2696 CHECK_OP (2, "invalid array lower bound");
2697 if (TREE_OPERAND (t
, 3))
2698 CHECK_OP (3, "invalid array stride");
2700 else if (TREE_CODE (t
) == BIT_FIELD_REF
)
2702 if (!host_integerp (TREE_OPERAND (t
, 1), 1)
2703 || !host_integerp (TREE_OPERAND (t
, 2), 1))
2705 error ("invalid position or size operand to BIT_FIELD_REF");
2708 if (INTEGRAL_TYPE_P (TREE_TYPE (t
))
2709 && (TYPE_PRECISION (TREE_TYPE (t
))
2710 != TREE_INT_CST_LOW (TREE_OPERAND (t
, 1))))
2712 error ("integral result type precision does not match "
2713 "field size of BIT_FIELD_REF");
2716 else if (!INTEGRAL_TYPE_P (TREE_TYPE (t
))
2717 && !AGGREGATE_TYPE_P (TREE_TYPE (t
))
2718 && TYPE_MODE (TREE_TYPE (t
)) != BLKmode
2719 && (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (t
)))
2720 != TREE_INT_CST_LOW (TREE_OPERAND (t
, 1))))
2722 error ("mode precision of non-integral result does not "
2723 "match field size of BIT_FIELD_REF");
2728 t
= TREE_OPERAND (t
, 0);
2731 if (!is_gimple_min_invariant (t
) && !is_gimple_lvalue (t
))
2733 error ("invalid reference prefix");
2740 /* PLUS_EXPR and MINUS_EXPR don't work on pointers, they should be done using
2741 POINTER_PLUS_EXPR. */
2742 if (POINTER_TYPE_P (TREE_TYPE (t
)))
2744 error ("invalid operand to plus/minus, type is a pointer");
2747 CHECK_OP (0, "invalid operand to binary operator");
2748 CHECK_OP (1, "invalid operand to binary operator");
2751 case POINTER_PLUS_EXPR
:
2752 /* Check to make sure the first operand is a pointer or reference type. */
2753 if (!POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 0))))
2755 error ("invalid operand to pointer plus, first operand is not a pointer");
2758 /* Check to make sure the second operand is a ptrofftype. */
2759 if (!ptrofftype_p (TREE_TYPE (TREE_OPERAND (t
, 1))))
2761 error ("invalid operand to pointer plus, second operand is not an "
2762 "integer type of appropriate width");
2772 case UNORDERED_EXPR
:
2781 case TRUNC_DIV_EXPR
:
2783 case FLOOR_DIV_EXPR
:
2784 case ROUND_DIV_EXPR
:
2785 case TRUNC_MOD_EXPR
:
2787 case FLOOR_MOD_EXPR
:
2788 case ROUND_MOD_EXPR
:
2790 case EXACT_DIV_EXPR
:
2800 CHECK_OP (0, "invalid operand to binary operator");
2801 CHECK_OP (1, "invalid operand to binary operator");
2805 if (TREE_CONSTANT (t
) && TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
2809 case CASE_LABEL_EXPR
:
2812 error ("invalid CASE_CHAIN");
2826 /* Verify if EXPR is either a GIMPLE ID or a GIMPLE indirect reference.
2827 Returns true if there is an error, otherwise false. */
2830 verify_types_in_gimple_min_lval (tree expr
)
2834 if (is_gimple_id (expr
))
2837 if (TREE_CODE (expr
) != TARGET_MEM_REF
2838 && TREE_CODE (expr
) != MEM_REF
)
2840 error ("invalid expression for min lvalue");
2844 /* TARGET_MEM_REFs are strange beasts. */
2845 if (TREE_CODE (expr
) == TARGET_MEM_REF
)
2848 op
= TREE_OPERAND (expr
, 0);
2849 if (!is_gimple_val (op
))
2851 error ("invalid operand in indirect reference");
2852 debug_generic_stmt (op
);
2855 /* Memory references now generally can involve a value conversion. */
2860 /* Verify if EXPR is a valid GIMPLE reference expression. If
2861 REQUIRE_LVALUE is true verifies it is an lvalue. Returns true
2862 if there is an error, otherwise false. */
2865 verify_types_in_gimple_reference (tree expr
, bool require_lvalue
)
2867 while (handled_component_p (expr
))
2869 tree op
= TREE_OPERAND (expr
, 0);
2871 if (TREE_CODE (expr
) == ARRAY_REF
2872 || TREE_CODE (expr
) == ARRAY_RANGE_REF
)
2874 if (!is_gimple_val (TREE_OPERAND (expr
, 1))
2875 || (TREE_OPERAND (expr
, 2)
2876 && !is_gimple_val (TREE_OPERAND (expr
, 2)))
2877 || (TREE_OPERAND (expr
, 3)
2878 && !is_gimple_val (TREE_OPERAND (expr
, 3))))
2880 error ("invalid operands to array reference");
2881 debug_generic_stmt (expr
);
2886 /* Verify if the reference array element types are compatible. */
2887 if (TREE_CODE (expr
) == ARRAY_REF
2888 && !useless_type_conversion_p (TREE_TYPE (expr
),
2889 TREE_TYPE (TREE_TYPE (op
))))
2891 error ("type mismatch in array reference");
2892 debug_generic_stmt (TREE_TYPE (expr
));
2893 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
2896 if (TREE_CODE (expr
) == ARRAY_RANGE_REF
2897 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr
)),
2898 TREE_TYPE (TREE_TYPE (op
))))
2900 error ("type mismatch in array range reference");
2901 debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr
)));
2902 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
2906 if ((TREE_CODE (expr
) == REALPART_EXPR
2907 || TREE_CODE (expr
) == IMAGPART_EXPR
)
2908 && !useless_type_conversion_p (TREE_TYPE (expr
),
2909 TREE_TYPE (TREE_TYPE (op
))))
2911 error ("type mismatch in real/imagpart reference");
2912 debug_generic_stmt (TREE_TYPE (expr
));
2913 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
2917 if (TREE_CODE (expr
) == COMPONENT_REF
2918 && !useless_type_conversion_p (TREE_TYPE (expr
),
2919 TREE_TYPE (TREE_OPERAND (expr
, 1))))
2921 error ("type mismatch in component reference");
2922 debug_generic_stmt (TREE_TYPE (expr
));
2923 debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr
, 1)));
2927 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
)
2929 /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
2930 that their operand is not an SSA name or an invariant when
2931 requiring an lvalue (this usually means there is a SRA or IPA-SRA
2932 bug). Otherwise there is nothing to verify, gross mismatches at
2933 most invoke undefined behavior. */
2935 && (TREE_CODE (op
) == SSA_NAME
2936 || is_gimple_min_invariant (op
)))
2938 error ("conversion of an SSA_NAME on the left hand side");
2939 debug_generic_stmt (expr
);
2942 else if (TREE_CODE (op
) == SSA_NAME
2943 && TYPE_SIZE (TREE_TYPE (expr
)) != TYPE_SIZE (TREE_TYPE (op
)))
2945 error ("conversion of register to a different size");
2946 debug_generic_stmt (expr
);
2949 else if (!handled_component_p (op
))
2956 if (TREE_CODE (expr
) == MEM_REF
)
2958 if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr
, 0)))
2960 error ("invalid address operand in MEM_REF");
2961 debug_generic_stmt (expr
);
2964 if (TREE_CODE (TREE_OPERAND (expr
, 1)) != INTEGER_CST
2965 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr
, 1))))
2967 error ("invalid offset operand in MEM_REF");
2968 debug_generic_stmt (expr
);
2972 else if (TREE_CODE (expr
) == TARGET_MEM_REF
)
2974 if (!TMR_BASE (expr
)
2975 || !is_gimple_mem_ref_addr (TMR_BASE (expr
)))
2977 error ("invalid address operand in TARGET_MEM_REF");
2980 if (!TMR_OFFSET (expr
)
2981 || TREE_CODE (TMR_OFFSET (expr
)) != INTEGER_CST
2982 || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr
))))
2984 error ("invalid offset operand in TARGET_MEM_REF");
2985 debug_generic_stmt (expr
);
2990 return ((require_lvalue
|| !is_gimple_min_invariant (expr
))
2991 && verify_types_in_gimple_min_lval (expr
));
2994 /* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
2995 list of pointer-to types that is trivially convertible to DEST. */
2998 one_pointer_to_useless_type_conversion_p (tree dest
, tree src_obj
)
3002 if (!TYPE_POINTER_TO (src_obj
))
3005 for (src
= TYPE_POINTER_TO (src_obj
); src
; src
= TYPE_NEXT_PTR_TO (src
))
3006 if (useless_type_conversion_p (dest
, src
))
3012 /* Return true if TYPE1 is a fixed-point type and if conversions to and
3013 from TYPE2 can be handled by FIXED_CONVERT_EXPR. */
3016 valid_fixed_convert_types_p (tree type1
, tree type2
)
3018 return (FIXED_POINT_TYPE_P (type1
)
3019 && (INTEGRAL_TYPE_P (type2
)
3020 || SCALAR_FLOAT_TYPE_P (type2
)
3021 || FIXED_POINT_TYPE_P (type2
)));
3024 /* Verify the contents of a GIMPLE_CALL STMT. Returns true when there
3025 is a problem, otherwise false. */
3028 verify_gimple_call (gimple stmt
)
3030 tree fn
= gimple_call_fn (stmt
);
3031 tree fntype
, fndecl
;
3034 if (gimple_call_internal_p (stmt
))
3038 error ("gimple call has two targets");
3039 debug_generic_stmt (fn
);
3047 error ("gimple call has no target");
3052 if (fn
&& !is_gimple_call_addr (fn
))
3054 error ("invalid function in gimple call");
3055 debug_generic_stmt (fn
);
3060 && (!POINTER_TYPE_P (TREE_TYPE (fn
))
3061 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != FUNCTION_TYPE
3062 && TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != METHOD_TYPE
)))
3064 error ("non-function in gimple call");
3068 fndecl
= gimple_call_fndecl (stmt
);
3070 && TREE_CODE (fndecl
) == FUNCTION_DECL
3071 && DECL_LOOPING_CONST_OR_PURE_P (fndecl
)
3072 && !DECL_PURE_P (fndecl
)
3073 && !TREE_READONLY (fndecl
))
3075 error ("invalid pure const state for function");
3079 if (gimple_call_lhs (stmt
)
3080 && (!is_gimple_lvalue (gimple_call_lhs (stmt
))
3081 || verify_types_in_gimple_reference (gimple_call_lhs (stmt
), true)))
3083 error ("invalid LHS in gimple call");
3087 if (gimple_call_lhs (stmt
) && gimple_call_noreturn_p (stmt
))
3089 error ("LHS in noreturn call");
3093 fntype
= gimple_call_fntype (stmt
);
3095 && gimple_call_lhs (stmt
)
3096 && !useless_type_conversion_p (TREE_TYPE (gimple_call_lhs (stmt
)),
3098 /* ??? At least C++ misses conversions at assignments from
3099 void * call results.
3100 ??? Java is completely off. Especially with functions
3101 returning java.lang.Object.
3102 For now simply allow arbitrary pointer type conversions. */
3103 && !(POINTER_TYPE_P (TREE_TYPE (gimple_call_lhs (stmt
)))
3104 && POINTER_TYPE_P (TREE_TYPE (fntype
))))
3106 error ("invalid conversion in gimple call");
3107 debug_generic_stmt (TREE_TYPE (gimple_call_lhs (stmt
)));
3108 debug_generic_stmt (TREE_TYPE (fntype
));
3112 if (gimple_call_chain (stmt
)
3113 && !is_gimple_val (gimple_call_chain (stmt
)))
3115 error ("invalid static chain in gimple call");
3116 debug_generic_stmt (gimple_call_chain (stmt
));
3120 /* If there is a static chain argument, this should not be an indirect
3121 call, and the decl should have DECL_STATIC_CHAIN set. */
3122 if (gimple_call_chain (stmt
))
3124 if (!gimple_call_fndecl (stmt
))
3126 error ("static chain in indirect gimple call");
3129 fn
= TREE_OPERAND (fn
, 0);
3131 if (!DECL_STATIC_CHAIN (fn
))
3133 error ("static chain with function that doesn%'t use one");
3138 /* ??? The C frontend passes unpromoted arguments in case it
3139 didn't see a function declaration before the call. So for now
3140 leave the call arguments mostly unverified. Once we gimplify
3141 unit-at-a-time we have a chance to fix this. */
3143 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
3145 tree arg
= gimple_call_arg (stmt
, i
);
3146 if ((is_gimple_reg_type (TREE_TYPE (arg
))
3147 && !is_gimple_val (arg
))
3148 || (!is_gimple_reg_type (TREE_TYPE (arg
))
3149 && !is_gimple_lvalue (arg
)))
3151 error ("invalid argument to gimple call");
3152 debug_generic_expr (arg
);
3160 /* Verifies the gimple comparison with the result type TYPE and
3161 the operands OP0 and OP1. */
3164 verify_gimple_comparison (tree type
, tree op0
, tree op1
)
3166 tree op0_type
= TREE_TYPE (op0
);
3167 tree op1_type
= TREE_TYPE (op1
);
3169 if (!is_gimple_val (op0
) || !is_gimple_val (op1
))
3171 error ("invalid operands in gimple comparison");
3175 /* For comparisons we do not have the operations type as the
3176 effective type the comparison is carried out in. Instead
3177 we require that either the first operand is trivially
3178 convertible into the second, or the other way around.
3179 Because we special-case pointers to void we allow
3180 comparisons of pointers with the same mode as well. */
3181 if (!useless_type_conversion_p (op0_type
, op1_type
)
3182 && !useless_type_conversion_p (op1_type
, op0_type
)
3183 && (!POINTER_TYPE_P (op0_type
)
3184 || !POINTER_TYPE_P (op1_type
)
3185 || TYPE_MODE (op0_type
) != TYPE_MODE (op1_type
)))
3187 error ("mismatching comparison operand types");
3188 debug_generic_expr (op0_type
);
3189 debug_generic_expr (op1_type
);
3193 /* The resulting type of a comparison may be an effective boolean type. */
3194 if (INTEGRAL_TYPE_P (type
)
3195 && (TREE_CODE (type
) == BOOLEAN_TYPE
3196 || TYPE_PRECISION (type
) == 1))
3198 if (TREE_CODE (op0_type
) == VECTOR_TYPE
3199 || TREE_CODE (op1_type
) == VECTOR_TYPE
)
3201 error ("vector comparison returning a boolean");
3202 debug_generic_expr (op0_type
);
3203 debug_generic_expr (op1_type
);
3207 /* Or an integer vector type with the same size and element count
3208 as the comparison operand types. */
3209 else if (TREE_CODE (type
) == VECTOR_TYPE
3210 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
3212 if (TREE_CODE (op0_type
) != VECTOR_TYPE
3213 || TREE_CODE (op1_type
) != VECTOR_TYPE
)
3215 error ("non-vector operands in vector comparison");
3216 debug_generic_expr (op0_type
);
3217 debug_generic_expr (op1_type
);
3221 if (TYPE_VECTOR_SUBPARTS (type
) != TYPE_VECTOR_SUBPARTS (op0_type
)
3222 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (type
)))
3223 != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0_type
))))
3224 /* The result of a vector comparison is of signed
3226 || TYPE_UNSIGNED (TREE_TYPE (type
)))
3228 error ("invalid vector comparison resulting type");
3229 debug_generic_expr (type
);
3235 error ("bogus comparison result type");
3236 debug_generic_expr (type
);
3243 /* Verify a gimple assignment statement STMT with an unary rhs.
3244 Returns true if anything is wrong. */
3247 verify_gimple_assign_unary (gimple stmt
)
3249 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3250 tree lhs
= gimple_assign_lhs (stmt
);
3251 tree lhs_type
= TREE_TYPE (lhs
);
3252 tree rhs1
= gimple_assign_rhs1 (stmt
);
3253 tree rhs1_type
= TREE_TYPE (rhs1
);
3255 if (!is_gimple_reg (lhs
))
3257 error ("non-register as LHS of unary operation");
3261 if (!is_gimple_val (rhs1
))
3263 error ("invalid operand in unary operation");
3267 /* First handle conversions. */
3272 /* Allow conversions from pointer type to integral type only if
3273 there is no sign or zero extension involved.
3274 For targets were the precision of ptrofftype doesn't match that
3275 of pointers we need to allow arbitrary conversions to ptrofftype. */
3276 if ((POINTER_TYPE_P (lhs_type
)
3277 && INTEGRAL_TYPE_P (rhs1_type
))
3278 || (POINTER_TYPE_P (rhs1_type
)
3279 && INTEGRAL_TYPE_P (lhs_type
)
3280 && (TYPE_PRECISION (rhs1_type
) >= TYPE_PRECISION (lhs_type
)
3281 || ptrofftype_p (sizetype
))))
3284 /* Allow conversion from integral to offset type and vice versa. */
3285 if ((TREE_CODE (lhs_type
) == OFFSET_TYPE
3286 && INTEGRAL_TYPE_P (rhs1_type
))
3287 || (INTEGRAL_TYPE_P (lhs_type
)
3288 && TREE_CODE (rhs1_type
) == OFFSET_TYPE
))
3291 /* Otherwise assert we are converting between types of the
3293 if (INTEGRAL_TYPE_P (lhs_type
) != INTEGRAL_TYPE_P (rhs1_type
))
3295 error ("invalid types in nop conversion");
3296 debug_generic_expr (lhs_type
);
3297 debug_generic_expr (rhs1_type
);
3304 case ADDR_SPACE_CONVERT_EXPR
:
3306 if (!POINTER_TYPE_P (rhs1_type
) || !POINTER_TYPE_P (lhs_type
)
3307 || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type
))
3308 == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type
))))
3310 error ("invalid types in address space conversion");
3311 debug_generic_expr (lhs_type
);
3312 debug_generic_expr (rhs1_type
);
3319 case FIXED_CONVERT_EXPR
:
3321 if (!valid_fixed_convert_types_p (lhs_type
, rhs1_type
)
3322 && !valid_fixed_convert_types_p (rhs1_type
, lhs_type
))
3324 error ("invalid types in fixed-point conversion");
3325 debug_generic_expr (lhs_type
);
3326 debug_generic_expr (rhs1_type
);
3335 if ((!INTEGRAL_TYPE_P (rhs1_type
) || !SCALAR_FLOAT_TYPE_P (lhs_type
))
3336 && (!VECTOR_INTEGER_TYPE_P (rhs1_type
)
3337 || !VECTOR_FLOAT_TYPE_P(lhs_type
)))
3339 error ("invalid types in conversion to floating point");
3340 debug_generic_expr (lhs_type
);
3341 debug_generic_expr (rhs1_type
);
3348 case FIX_TRUNC_EXPR
:
3350 if ((!INTEGRAL_TYPE_P (lhs_type
) || !SCALAR_FLOAT_TYPE_P (rhs1_type
))
3351 && (!VECTOR_INTEGER_TYPE_P (lhs_type
)
3352 || !VECTOR_FLOAT_TYPE_P(rhs1_type
)))
3354 error ("invalid types in conversion to integer");
3355 debug_generic_expr (lhs_type
);
3356 debug_generic_expr (rhs1_type
);
3363 case VEC_UNPACK_HI_EXPR
:
3364 case VEC_UNPACK_LO_EXPR
:
3365 case REDUC_MAX_EXPR
:
3366 case REDUC_MIN_EXPR
:
3367 case REDUC_PLUS_EXPR
:
3368 case VEC_UNPACK_FLOAT_HI_EXPR
:
3369 case VEC_UNPACK_FLOAT_LO_EXPR
:
3377 case NON_LVALUE_EXPR
:
3385 /* For the remaining codes assert there is no conversion involved. */
3386 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3388 error ("non-trivial conversion in unary operation");
3389 debug_generic_expr (lhs_type
);
3390 debug_generic_expr (rhs1_type
);
3397 /* Verify a gimple assignment statement STMT with a binary rhs.
3398 Returns true if anything is wrong. */
3401 verify_gimple_assign_binary (gimple stmt
)
3403 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3404 tree lhs
= gimple_assign_lhs (stmt
);
3405 tree lhs_type
= TREE_TYPE (lhs
);
3406 tree rhs1
= gimple_assign_rhs1 (stmt
);
3407 tree rhs1_type
= TREE_TYPE (rhs1
);
3408 tree rhs2
= gimple_assign_rhs2 (stmt
);
3409 tree rhs2_type
= TREE_TYPE (rhs2
);
3411 if (!is_gimple_reg (lhs
))
3413 error ("non-register as LHS of binary operation");
3417 if (!is_gimple_val (rhs1
)
3418 || !is_gimple_val (rhs2
))
3420 error ("invalid operands in binary operation");
3424 /* First handle operations that involve different types. */
3429 if (TREE_CODE (lhs_type
) != COMPLEX_TYPE
3430 || !(INTEGRAL_TYPE_P (rhs1_type
)
3431 || SCALAR_FLOAT_TYPE_P (rhs1_type
))
3432 || !(INTEGRAL_TYPE_P (rhs2_type
)
3433 || SCALAR_FLOAT_TYPE_P (rhs2_type
)))
3435 error ("type mismatch in complex expression");
3436 debug_generic_expr (lhs_type
);
3437 debug_generic_expr (rhs1_type
);
3438 debug_generic_expr (rhs2_type
);
3450 /* Shifts and rotates are ok on integral types, fixed point
3451 types and integer vector types. */
3452 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3453 && !FIXED_POINT_TYPE_P (rhs1_type
)
3454 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3455 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))))
3456 || (!INTEGRAL_TYPE_P (rhs2_type
)
3457 /* Vector shifts of vectors are also ok. */
3458 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3459 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3460 && TREE_CODE (rhs2_type
) == VECTOR_TYPE
3461 && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3462 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3464 error ("type mismatch in shift expression");
3465 debug_generic_expr (lhs_type
);
3466 debug_generic_expr (rhs1_type
);
3467 debug_generic_expr (rhs2_type
);
3474 case VEC_LSHIFT_EXPR
:
3475 case VEC_RSHIFT_EXPR
:
3477 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3478 || !(INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3479 || POINTER_TYPE_P (TREE_TYPE (rhs1_type
))
3480 || FIXED_POINT_TYPE_P (TREE_TYPE (rhs1_type
))
3481 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
)))
3482 || (!INTEGRAL_TYPE_P (rhs2_type
)
3483 && (TREE_CODE (rhs2_type
) != VECTOR_TYPE
3484 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3485 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3487 error ("type mismatch in vector shift expression");
3488 debug_generic_expr (lhs_type
);
3489 debug_generic_expr (rhs1_type
);
3490 debug_generic_expr (rhs2_type
);
3493 /* For shifting a vector of non-integral components we
3494 only allow shifting by a constant multiple of the element size. */
3495 if (!INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3496 && (TREE_CODE (rhs2
) != INTEGER_CST
3497 || !div_if_zero_remainder (EXACT_DIV_EXPR
, rhs2
,
3498 TYPE_SIZE (TREE_TYPE (rhs1_type
)))))
3500 error ("non-element sized vector shift of floating point vector");
3507 case WIDEN_LSHIFT_EXPR
:
3509 if (!INTEGRAL_TYPE_P (lhs_type
)
3510 || !INTEGRAL_TYPE_P (rhs1_type
)
3511 || TREE_CODE (rhs2
) != INTEGER_CST
3512 || (2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)))
3514 error ("type mismatch in widening vector shift expression");
3515 debug_generic_expr (lhs_type
);
3516 debug_generic_expr (rhs1_type
);
3517 debug_generic_expr (rhs2_type
);
3524 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3525 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3527 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3528 || TREE_CODE (lhs_type
) != VECTOR_TYPE
3529 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3530 || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3531 || TREE_CODE (rhs2
) != INTEGER_CST
3532 || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type
))
3533 > TYPE_PRECISION (TREE_TYPE (lhs_type
))))
3535 error ("type mismatch in widening vector shift expression");
3536 debug_generic_expr (lhs_type
);
3537 debug_generic_expr (rhs1_type
);
3538 debug_generic_expr (rhs2_type
);
3548 /* We use regular PLUS_EXPR and MINUS_EXPR for vectors.
3549 ??? This just makes the checker happy and may not be what is
3551 if (TREE_CODE (lhs_type
) == VECTOR_TYPE
3552 && POINTER_TYPE_P (TREE_TYPE (lhs_type
)))
3554 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3555 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
)
3557 error ("invalid non-vector operands to vector valued plus");
3560 lhs_type
= TREE_TYPE (lhs_type
);
3561 rhs1_type
= TREE_TYPE (rhs1_type
);
3562 rhs2_type
= TREE_TYPE (rhs2_type
);
3563 /* PLUS_EXPR is commutative, so we might end up canonicalizing
3564 the pointer to 2nd place. */
3565 if (POINTER_TYPE_P (rhs2_type
))
3567 tree tem
= rhs1_type
;
3568 rhs1_type
= rhs2_type
;
3571 goto do_pointer_plus_expr_check
;
3573 if (POINTER_TYPE_P (lhs_type
)
3574 || POINTER_TYPE_P (rhs1_type
)
3575 || POINTER_TYPE_P (rhs2_type
))
3577 error ("invalid (pointer) operands to plus/minus");
3581 /* Continue with generic binary expression handling. */
3585 case POINTER_PLUS_EXPR
:
3587 do_pointer_plus_expr_check
:
3588 if (!POINTER_TYPE_P (rhs1_type
)
3589 || !useless_type_conversion_p (lhs_type
, rhs1_type
)
3590 || !ptrofftype_p (rhs2_type
))
3592 error ("type mismatch in pointer plus expression");
3593 debug_generic_stmt (lhs_type
);
3594 debug_generic_stmt (rhs1_type
);
3595 debug_generic_stmt (rhs2_type
);
3602 case TRUTH_ANDIF_EXPR
:
3603 case TRUTH_ORIF_EXPR
:
3604 case TRUTH_AND_EXPR
:
3606 case TRUTH_XOR_EXPR
:
3616 case UNORDERED_EXPR
:
3624 /* Comparisons are also binary, but the result type is not
3625 connected to the operand types. */
3626 return verify_gimple_comparison (lhs_type
, rhs1
, rhs2
);
3628 case WIDEN_MULT_EXPR
:
3629 if (TREE_CODE (lhs_type
) != INTEGER_TYPE
)
3631 return ((2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
))
3632 || (TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
)));
3634 case WIDEN_SUM_EXPR
:
3635 case VEC_WIDEN_MULT_HI_EXPR
:
3636 case VEC_WIDEN_MULT_LO_EXPR
:
3637 case VEC_WIDEN_MULT_EVEN_EXPR
:
3638 case VEC_WIDEN_MULT_ODD_EXPR
:
3639 case VEC_PACK_TRUNC_EXPR
:
3640 case VEC_PACK_SAT_EXPR
:
3641 case VEC_PACK_FIX_TRUNC_EXPR
:
3646 case MULT_HIGHPART_EXPR
:
3647 case TRUNC_DIV_EXPR
:
3649 case FLOOR_DIV_EXPR
:
3650 case ROUND_DIV_EXPR
:
3651 case TRUNC_MOD_EXPR
:
3653 case FLOOR_MOD_EXPR
:
3654 case ROUND_MOD_EXPR
:
3656 case EXACT_DIV_EXPR
:
3662 /* Continue with generic binary expression handling. */
3669 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3670 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
3672 error ("type mismatch in binary expression");
3673 debug_generic_stmt (lhs_type
);
3674 debug_generic_stmt (rhs1_type
);
3675 debug_generic_stmt (rhs2_type
);
3682 /* Verify a gimple assignment statement STMT with a ternary rhs.
3683 Returns true if anything is wrong. */
3686 verify_gimple_assign_ternary (gimple stmt
)
3688 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3689 tree lhs
= gimple_assign_lhs (stmt
);
3690 tree lhs_type
= TREE_TYPE (lhs
);
3691 tree rhs1
= gimple_assign_rhs1 (stmt
);
3692 tree rhs1_type
= TREE_TYPE (rhs1
);
3693 tree rhs2
= gimple_assign_rhs2 (stmt
);
3694 tree rhs2_type
= TREE_TYPE (rhs2
);
3695 tree rhs3
= gimple_assign_rhs3 (stmt
);
3696 tree rhs3_type
= TREE_TYPE (rhs3
);
3698 if (!is_gimple_reg (lhs
))
3700 error ("non-register as LHS of ternary operation");
3704 if (((rhs_code
== VEC_COND_EXPR
|| rhs_code
== COND_EXPR
)
3705 ? !is_gimple_condexpr (rhs1
) : !is_gimple_val (rhs1
))
3706 || !is_gimple_val (rhs2
)
3707 || !is_gimple_val (rhs3
))
3709 error ("invalid operands in ternary operation");
3713 /* First handle operations that involve different types. */
3716 case WIDEN_MULT_PLUS_EXPR
:
3717 case WIDEN_MULT_MINUS_EXPR
:
3718 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3719 && !FIXED_POINT_TYPE_P (rhs1_type
))
3720 || !useless_type_conversion_p (rhs1_type
, rhs2_type
)
3721 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
3722 || 2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)
3723 || TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
))
3725 error ("type mismatch in widening multiply-accumulate expression");
3726 debug_generic_expr (lhs_type
);
3727 debug_generic_expr (rhs1_type
);
3728 debug_generic_expr (rhs2_type
);
3729 debug_generic_expr (rhs3_type
);
3735 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3736 || !useless_type_conversion_p (lhs_type
, rhs2_type
)
3737 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
3739 error ("type mismatch in fused multiply-add expression");
3740 debug_generic_expr (lhs_type
);
3741 debug_generic_expr (rhs1_type
);
3742 debug_generic_expr (rhs2_type
);
3743 debug_generic_expr (rhs3_type
);
3750 if (!useless_type_conversion_p (lhs_type
, rhs2_type
)
3751 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
3753 error ("type mismatch in conditional expression");
3754 debug_generic_expr (lhs_type
);
3755 debug_generic_expr (rhs2_type
);
3756 debug_generic_expr (rhs3_type
);
3762 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3763 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
3765 error ("type mismatch in vector permute expression");
3766 debug_generic_expr (lhs_type
);
3767 debug_generic_expr (rhs1_type
);
3768 debug_generic_expr (rhs2_type
);
3769 debug_generic_expr (rhs3_type
);
3773 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3774 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
3775 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
3777 error ("vector types expected in vector permute expression");
3778 debug_generic_expr (lhs_type
);
3779 debug_generic_expr (rhs1_type
);
3780 debug_generic_expr (rhs2_type
);
3781 debug_generic_expr (rhs3_type
);
3785 if (TYPE_VECTOR_SUBPARTS (rhs1_type
) != TYPE_VECTOR_SUBPARTS (rhs2_type
)
3786 || TYPE_VECTOR_SUBPARTS (rhs2_type
)
3787 != TYPE_VECTOR_SUBPARTS (rhs3_type
)
3788 || TYPE_VECTOR_SUBPARTS (rhs3_type
)
3789 != TYPE_VECTOR_SUBPARTS (lhs_type
))
3791 error ("vectors with different element number found "
3792 "in vector permute expression");
3793 debug_generic_expr (lhs_type
);
3794 debug_generic_expr (rhs1_type
);
3795 debug_generic_expr (rhs2_type
);
3796 debug_generic_expr (rhs3_type
);
3800 if (TREE_CODE (TREE_TYPE (rhs3_type
)) != INTEGER_TYPE
3801 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs3_type
)))
3802 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type
))))
3804 error ("invalid mask type in vector permute expression");
3805 debug_generic_expr (lhs_type
);
3806 debug_generic_expr (rhs1_type
);
3807 debug_generic_expr (rhs2_type
);
3808 debug_generic_expr (rhs3_type
);
3815 case REALIGN_LOAD_EXPR
:
3825 /* Verify a gimple assignment statement STMT with a single rhs.
3826 Returns true if anything is wrong. */
3829 verify_gimple_assign_single (gimple stmt
)
3831 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3832 tree lhs
= gimple_assign_lhs (stmt
);
3833 tree lhs_type
= TREE_TYPE (lhs
);
3834 tree rhs1
= gimple_assign_rhs1 (stmt
);
3835 tree rhs1_type
= TREE_TYPE (rhs1
);
3838 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3840 error ("non-trivial conversion at assignment");
3841 debug_generic_expr (lhs_type
);
3842 debug_generic_expr (rhs1_type
);
3846 if (gimple_clobber_p (stmt
)
3847 && !(DECL_P (lhs
) || TREE_CODE (lhs
) == MEM_REF
))
3849 error ("non-decl/MEM_REF LHS in clobber statement");
3850 debug_generic_expr (lhs
);
3854 if (handled_component_p (lhs
))
3855 res
|= verify_types_in_gimple_reference (lhs
, true);
3857 /* Special codes we cannot handle via their class. */
3862 tree op
= TREE_OPERAND (rhs1
, 0);
3863 if (!is_gimple_addressable (op
))
3865 error ("invalid operand in unary expression");
3869 /* Technically there is no longer a need for matching types, but
3870 gimple hygiene asks for this check. In LTO we can end up
3871 combining incompatible units and thus end up with addresses
3872 of globals that change their type to a common one. */
3874 && !types_compatible_p (TREE_TYPE (op
),
3875 TREE_TYPE (TREE_TYPE (rhs1
)))
3876 && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1
),
3879 error ("type mismatch in address expression");
3880 debug_generic_stmt (TREE_TYPE (rhs1
));
3881 debug_generic_stmt (TREE_TYPE (op
));
3885 return verify_types_in_gimple_reference (op
, true);
3890 error ("INDIRECT_REF in gimple IL");
3896 case ARRAY_RANGE_REF
:
3897 case VIEW_CONVERT_EXPR
:
3900 case TARGET_MEM_REF
:
3902 if (!is_gimple_reg (lhs
)
3903 && is_gimple_reg_type (TREE_TYPE (lhs
)))
3905 error ("invalid rhs for gimple memory store");
3906 debug_generic_stmt (lhs
);
3907 debug_generic_stmt (rhs1
);
3910 return res
|| verify_types_in_gimple_reference (rhs1
, false);
3922 /* tcc_declaration */
3927 if (!is_gimple_reg (lhs
)
3928 && !is_gimple_reg (rhs1
)
3929 && is_gimple_reg_type (TREE_TYPE (lhs
)))
3931 error ("invalid rhs for gimple memory store");
3932 debug_generic_stmt (lhs
);
3933 debug_generic_stmt (rhs1
);
3939 if (TREE_CODE (rhs1_type
) == VECTOR_TYPE
)
3942 tree elt_i
, elt_v
, elt_t
= NULL_TREE
;
3944 if (CONSTRUCTOR_NELTS (rhs1
) == 0)
3946 /* For vector CONSTRUCTORs we require that either it is empty
3947 CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
3948 (then the element count must be correct to cover the whole
3949 outer vector and index must be NULL on all elements, or it is
3950 a CONSTRUCTOR of scalar elements, where we as an exception allow
3951 smaller number of elements (assuming zero filling) and
3952 consecutive indexes as compared to NULL indexes (such
3953 CONSTRUCTORs can appear in the IL from FEs). */
3954 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1
), i
, elt_i
, elt_v
)
3956 if (elt_t
== NULL_TREE
)
3958 elt_t
= TREE_TYPE (elt_v
);
3959 if (TREE_CODE (elt_t
) == VECTOR_TYPE
)
3961 tree elt_t
= TREE_TYPE (elt_v
);
3962 if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
3965 error ("incorrect type of vector CONSTRUCTOR"
3967 debug_generic_stmt (rhs1
);
3970 else if (CONSTRUCTOR_NELTS (rhs1
)
3971 * TYPE_VECTOR_SUBPARTS (elt_t
)
3972 != TYPE_VECTOR_SUBPARTS (rhs1_type
))
3974 error ("incorrect number of vector CONSTRUCTOR"
3976 debug_generic_stmt (rhs1
);
3980 else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
3983 error ("incorrect type of vector CONSTRUCTOR elements");
3984 debug_generic_stmt (rhs1
);
3987 else if (CONSTRUCTOR_NELTS (rhs1
)
3988 > TYPE_VECTOR_SUBPARTS (rhs1_type
))
3990 error ("incorrect number of vector CONSTRUCTOR elements");
3991 debug_generic_stmt (rhs1
);
3995 else if (!useless_type_conversion_p (elt_t
, TREE_TYPE (elt_v
)))
3997 error ("incorrect type of vector CONSTRUCTOR elements");
3998 debug_generic_stmt (rhs1
);
4001 if (elt_i
!= NULL_TREE
4002 && (TREE_CODE (elt_t
) == VECTOR_TYPE
4003 || TREE_CODE (elt_i
) != INTEGER_CST
4004 || compare_tree_int (elt_i
, i
) != 0))
4006 error ("vector CONSTRUCTOR with non-NULL element index");
4007 debug_generic_stmt (rhs1
);
4015 case WITH_SIZE_EXPR
:
4025 /* Verify the contents of a GIMPLE_ASSIGN STMT. Returns true when there
4026 is a problem, otherwise false. */
4029 verify_gimple_assign (gimple stmt
)
4031 switch (gimple_assign_rhs_class (stmt
))
4033 case GIMPLE_SINGLE_RHS
:
4034 return verify_gimple_assign_single (stmt
);
4036 case GIMPLE_UNARY_RHS
:
4037 return verify_gimple_assign_unary (stmt
);
4039 case GIMPLE_BINARY_RHS
:
4040 return verify_gimple_assign_binary (stmt
);
4042 case GIMPLE_TERNARY_RHS
:
4043 return verify_gimple_assign_ternary (stmt
);
4050 /* Verify the contents of a GIMPLE_RETURN STMT. Returns true when there
4051 is a problem, otherwise false. */
4054 verify_gimple_return (gimple stmt
)
4056 tree op
= gimple_return_retval (stmt
);
4057 tree restype
= TREE_TYPE (TREE_TYPE (cfun
->decl
));
4059 /* We cannot test for present return values as we do not fix up missing
4060 return values from the original source. */
4064 if (!is_gimple_val (op
)
4065 && TREE_CODE (op
) != RESULT_DECL
)
4067 error ("invalid operand in return statement");
4068 debug_generic_stmt (op
);
4072 if ((TREE_CODE (op
) == RESULT_DECL
4073 && DECL_BY_REFERENCE (op
))
4074 || (TREE_CODE (op
) == SSA_NAME
4075 && SSA_NAME_VAR (op
)
4076 && TREE_CODE (SSA_NAME_VAR (op
)) == RESULT_DECL
4077 && DECL_BY_REFERENCE (SSA_NAME_VAR (op
))))
4078 op
= TREE_TYPE (op
);
4080 if (!useless_type_conversion_p (restype
, TREE_TYPE (op
)))
4082 error ("invalid conversion in return statement");
4083 debug_generic_stmt (restype
);
4084 debug_generic_stmt (TREE_TYPE (op
));
4092 /* Verify the contents of a GIMPLE_GOTO STMT. Returns true when there
4093 is a problem, otherwise false. */
4096 verify_gimple_goto (gimple stmt
)
4098 tree dest
= gimple_goto_dest (stmt
);
4100 /* ??? We have two canonical forms of direct goto destinations, a
4101 bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
4102 if (TREE_CODE (dest
) != LABEL_DECL
4103 && (!is_gimple_val (dest
)
4104 || !POINTER_TYPE_P (TREE_TYPE (dest
))))
4106 error ("goto destination is neither a label nor a pointer");
4113 /* Verify the contents of a GIMPLE_SWITCH STMT. Returns true when there
4114 is a problem, otherwise false. */
4117 verify_gimple_switch (gimple stmt
)
4120 tree elt
, prev_upper_bound
= NULL_TREE
;
4121 tree index_type
, elt_type
= NULL_TREE
;
4123 if (!is_gimple_val (gimple_switch_index (stmt
)))
4125 error ("invalid operand to switch statement");
4126 debug_generic_stmt (gimple_switch_index (stmt
));
4130 index_type
= TREE_TYPE (gimple_switch_index (stmt
));
4131 if (! INTEGRAL_TYPE_P (index_type
))
4133 error ("non-integral type switch statement");
4134 debug_generic_expr (index_type
);
4138 elt
= gimple_switch_label (stmt
, 0);
4139 if (CASE_LOW (elt
) != NULL_TREE
|| CASE_HIGH (elt
) != NULL_TREE
)
4141 error ("invalid default case label in switch statement");
4142 debug_generic_expr (elt
);
4146 n
= gimple_switch_num_labels (stmt
);
4147 for (i
= 1; i
< n
; i
++)
4149 elt
= gimple_switch_label (stmt
, i
);
4151 if (! CASE_LOW (elt
))
4153 error ("invalid case label in switch statement");
4154 debug_generic_expr (elt
);
4158 && ! tree_int_cst_lt (CASE_LOW (elt
), CASE_HIGH (elt
)))
4160 error ("invalid case range in switch statement");
4161 debug_generic_expr (elt
);
4167 if (TREE_TYPE (CASE_LOW (elt
)) != elt_type
4168 || (CASE_HIGH (elt
) && TREE_TYPE (CASE_HIGH (elt
)) != elt_type
))
4170 error ("type mismatch for case label in switch statement");
4171 debug_generic_expr (elt
);
4177 elt_type
= TREE_TYPE (CASE_LOW (elt
));
4178 if (TYPE_PRECISION (index_type
) < TYPE_PRECISION (elt_type
))
4180 error ("type precision mismatch in switch statement");
4185 if (prev_upper_bound
)
4187 if (! tree_int_cst_lt (prev_upper_bound
, CASE_LOW (elt
)))
4189 error ("case labels not sorted in switch statement");
4194 prev_upper_bound
= CASE_HIGH (elt
);
4195 if (! prev_upper_bound
)
4196 prev_upper_bound
= CASE_LOW (elt
);
4202 /* Verify a gimple debug statement STMT.
4203 Returns true if anything is wrong. */
4206 verify_gimple_debug (gimple stmt ATTRIBUTE_UNUSED
)
4208 /* There isn't much that could be wrong in a gimple debug stmt. A
4209 gimple debug bind stmt, for example, maps a tree, that's usually
4210 a VAR_DECL or a PARM_DECL, but that could also be some scalarized
4211 component or member of an aggregate type, to another tree, that
4212 can be an arbitrary expression. These stmts expand into debug
4213 insns, and are converted to debug notes by var-tracking.c. */
4217 /* Verify a gimple label statement STMT.
4218 Returns true if anything is wrong. */
4221 verify_gimple_label (gimple stmt
)
4223 tree decl
= gimple_label_label (stmt
);
4227 if (TREE_CODE (decl
) != LABEL_DECL
)
4230 uid
= LABEL_DECL_UID (decl
);
4232 && (uid
== -1 || (*label_to_block_map
)[uid
] != gimple_bb (stmt
)))
4234 error ("incorrect entry in label_to_block_map");
4238 uid
= EH_LANDING_PAD_NR (decl
);
4241 eh_landing_pad lp
= get_eh_landing_pad_from_number (uid
);
4242 if (decl
!= lp
->post_landing_pad
)
4244 error ("incorrect setting of landing pad number");
4252 /* Verify the GIMPLE statement STMT. Returns true if there is an
4253 error, otherwise false. */
4256 verify_gimple_stmt (gimple stmt
)
4258 switch (gimple_code (stmt
))
4261 return verify_gimple_assign (stmt
);
4264 return verify_gimple_label (stmt
);
4267 return verify_gimple_call (stmt
);
4270 if (TREE_CODE_CLASS (gimple_cond_code (stmt
)) != tcc_comparison
)
4272 error ("invalid comparison code in gimple cond");
4275 if (!(!gimple_cond_true_label (stmt
)
4276 || TREE_CODE (gimple_cond_true_label (stmt
)) == LABEL_DECL
)
4277 || !(!gimple_cond_false_label (stmt
)
4278 || TREE_CODE (gimple_cond_false_label (stmt
)) == LABEL_DECL
))
4280 error ("invalid labels in gimple cond");
4284 return verify_gimple_comparison (boolean_type_node
,
4285 gimple_cond_lhs (stmt
),
4286 gimple_cond_rhs (stmt
));
4289 return verify_gimple_goto (stmt
);
4292 return verify_gimple_switch (stmt
);
4295 return verify_gimple_return (stmt
);
4300 case GIMPLE_TRANSACTION
:
4301 return verify_gimple_transaction (stmt
);
4303 /* Tuples that do not have tree operands. */
4305 case GIMPLE_PREDICT
:
4307 case GIMPLE_EH_DISPATCH
:
4308 case GIMPLE_EH_MUST_NOT_THROW
:
4312 /* OpenMP directives are validated by the FE and never operated
4313 on by the optimizers. Furthermore, GIMPLE_OMP_FOR may contain
4314 non-gimple expressions when the main index variable has had
4315 its address taken. This does not affect the loop itself
4316 because the header of an GIMPLE_OMP_FOR is merely used to determine
4317 how to setup the parallel iteration. */
4321 return verify_gimple_debug (stmt
);
4328 /* Verify the contents of a GIMPLE_PHI. Returns true if there is a problem,
4329 and false otherwise. */
4332 verify_gimple_phi (gimple phi
)
4336 tree phi_result
= gimple_phi_result (phi
);
4341 error ("invalid PHI result");
4345 virtual_p
= virtual_operand_p (phi_result
);
4346 if (TREE_CODE (phi_result
) != SSA_NAME
4348 && SSA_NAME_VAR (phi_result
) != gimple_vop (cfun
)))
4350 error ("invalid PHI result");
4354 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4356 tree t
= gimple_phi_arg_def (phi
, i
);
4360 error ("missing PHI def");
4364 /* Addressable variables do have SSA_NAMEs but they
4365 are not considered gimple values. */
4366 else if ((TREE_CODE (t
) == SSA_NAME
4367 && virtual_p
!= virtual_operand_p (t
))
4369 && (TREE_CODE (t
) != SSA_NAME
4370 || SSA_NAME_VAR (t
) != gimple_vop (cfun
)))
4372 && !is_gimple_val (t
)))
4374 error ("invalid PHI argument");
4375 debug_generic_expr (t
);
4378 #ifdef ENABLE_TYPES_CHECKING
4379 if (!useless_type_conversion_p (TREE_TYPE (phi_result
), TREE_TYPE (t
)))
4381 error ("incompatible types in PHI argument %u", i
);
4382 debug_generic_stmt (TREE_TYPE (phi_result
));
4383 debug_generic_stmt (TREE_TYPE (t
));
4392 /* Verify the GIMPLE statements inside the sequence STMTS. */
4395 verify_gimple_in_seq_2 (gimple_seq stmts
)
4397 gimple_stmt_iterator ittr
;
4400 for (ittr
= gsi_start (stmts
); !gsi_end_p (ittr
); gsi_next (&ittr
))
4402 gimple stmt
= gsi_stmt (ittr
);
4404 switch (gimple_code (stmt
))
4407 err
|= verify_gimple_in_seq_2 (gimple_bind_body (stmt
));
4411 err
|= verify_gimple_in_seq_2 (gimple_try_eval (stmt
));
4412 err
|= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt
));
4415 case GIMPLE_EH_FILTER
:
4416 err
|= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt
));
4419 case GIMPLE_EH_ELSE
:
4420 err
|= verify_gimple_in_seq_2 (gimple_eh_else_n_body (stmt
));
4421 err
|= verify_gimple_in_seq_2 (gimple_eh_else_e_body (stmt
));
4425 err
|= verify_gimple_in_seq_2 (gimple_catch_handler (stmt
));
4428 case GIMPLE_TRANSACTION
:
4429 err
|= verify_gimple_transaction (stmt
);
4434 bool err2
= verify_gimple_stmt (stmt
);
4436 debug_gimple_stmt (stmt
);
4445 /* Verify the contents of a GIMPLE_TRANSACTION. Returns true if there
4446 is a problem, otherwise false. */
4449 verify_gimple_transaction (gimple stmt
)
4451 tree lab
= gimple_transaction_label (stmt
);
4452 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
4454 return verify_gimple_in_seq_2 (gimple_transaction_body (stmt
));
4458 /* Verify the GIMPLE statements inside the statement list STMTS. */
4461 verify_gimple_in_seq (gimple_seq stmts
)
4463 timevar_push (TV_TREE_STMT_VERIFY
);
4464 if (verify_gimple_in_seq_2 (stmts
))
4465 internal_error ("verify_gimple failed");
4466 timevar_pop (TV_TREE_STMT_VERIFY
);
4469 /* Return true when the T can be shared. */
4472 tree_node_can_be_shared (tree t
)
4474 if (IS_TYPE_OR_DECL_P (t
)
4475 || is_gimple_min_invariant (t
)
4476 || TREE_CODE (t
) == SSA_NAME
4477 || t
== error_mark_node
4478 || TREE_CODE (t
) == IDENTIFIER_NODE
)
4481 if (TREE_CODE (t
) == CASE_LABEL_EXPR
)
4490 /* Called via walk_tree. Verify tree sharing. */
4493 verify_node_sharing_1 (tree
*tp
, int *walk_subtrees
, void *data
)
4495 struct pointer_set_t
*visited
= (struct pointer_set_t
*) data
;
4497 if (tree_node_can_be_shared (*tp
))
4499 *walk_subtrees
= false;
4503 if (pointer_set_insert (visited
, *tp
))
4509 /* Called via walk_gimple_stmt. Verify tree sharing. */
4512 verify_node_sharing (tree
*tp
, int *walk_subtrees
, void *data
)
4514 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4515 return verify_node_sharing_1 (tp
, walk_subtrees
, wi
->info
);
4518 static bool eh_error_found
;
4520 verify_eh_throw_stmt_node (void **slot
, void *data
)
4522 struct throw_stmt_node
*node
= (struct throw_stmt_node
*)*slot
;
4523 struct pointer_set_t
*visited
= (struct pointer_set_t
*) data
;
4525 if (!pointer_set_contains (visited
, node
->stmt
))
4527 error ("dead STMT in EH table");
4528 debug_gimple_stmt (node
->stmt
);
4529 eh_error_found
= true;
4534 /* Verify if the location LOCs block is in BLOCKS. */
4537 verify_location (pointer_set_t
*blocks
, location_t loc
)
4539 tree block
= LOCATION_BLOCK (loc
);
4540 if (block
!= NULL_TREE
4541 && !pointer_set_contains (blocks
, block
))
4543 error ("location references block not in block tree");
4546 if (block
!= NULL_TREE
)
4547 return verify_location (blocks
, BLOCK_SOURCE_LOCATION (block
));
4551 /* Called via walk_tree. Verify that expressions have no blocks. */
4554 verify_expr_no_block (tree
*tp
, int *walk_subtrees
, void *)
4558 *walk_subtrees
= false;
4562 location_t loc
= EXPR_LOCATION (*tp
);
4563 if (LOCATION_BLOCK (loc
) != NULL
)
4569 /* Called via walk_tree. Verify locations of expressions. */
4572 verify_expr_location_1 (tree
*tp
, int *walk_subtrees
, void *data
)
4574 struct pointer_set_t
*blocks
= (struct pointer_set_t
*) data
;
4576 if (TREE_CODE (*tp
) == VAR_DECL
4577 && DECL_HAS_DEBUG_EXPR_P (*tp
))
4579 tree t
= DECL_DEBUG_EXPR (*tp
);
4580 tree addr
= walk_tree (&t
, verify_expr_no_block
, NULL
, NULL
);
4584 if ((TREE_CODE (*tp
) == VAR_DECL
4585 || TREE_CODE (*tp
) == PARM_DECL
4586 || TREE_CODE (*tp
) == RESULT_DECL
)
4587 && DECL_HAS_VALUE_EXPR_P (*tp
))
4589 tree t
= DECL_VALUE_EXPR (*tp
);
4590 tree addr
= walk_tree (&t
, verify_expr_no_block
, NULL
, NULL
);
4597 *walk_subtrees
= false;
4601 location_t loc
= EXPR_LOCATION (*tp
);
4602 if (verify_location (blocks
, loc
))
4608 /* Called via walk_gimple_op. Verify locations of expressions. */
4611 verify_expr_location (tree
*tp
, int *walk_subtrees
, void *data
)
4613 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4614 return verify_expr_location_1 (tp
, walk_subtrees
, wi
->info
);
4617 /* Insert all subblocks of BLOCK into BLOCKS and recurse. */
4620 collect_subblocks (pointer_set_t
*blocks
, tree block
)
4623 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
4625 pointer_set_insert (blocks
, t
);
4626 collect_subblocks (blocks
, t
);
4630 /* Verify the GIMPLE statements in the CFG of FN. */
4633 verify_gimple_in_cfg (struct function
*fn
)
4637 struct pointer_set_t
*visited
, *visited_stmts
, *blocks
;
4639 timevar_push (TV_TREE_STMT_VERIFY
);
4640 visited
= pointer_set_create ();
4641 visited_stmts
= pointer_set_create ();
4643 /* Collect all BLOCKs referenced by the BLOCK tree of FN. */
4644 blocks
= pointer_set_create ();
4645 if (DECL_INITIAL (fn
->decl
))
4647 pointer_set_insert (blocks
, DECL_INITIAL (fn
->decl
));
4648 collect_subblocks (blocks
, DECL_INITIAL (fn
->decl
));
4651 FOR_EACH_BB_FN (bb
, fn
)
4653 gimple_stmt_iterator gsi
;
4655 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4657 gimple phi
= gsi_stmt (gsi
);
4661 pointer_set_insert (visited_stmts
, phi
);
4663 if (gimple_bb (phi
) != bb
)
4665 error ("gimple_bb (phi) is set to a wrong basic block");
4669 err2
|= verify_gimple_phi (phi
);
4671 /* Only PHI arguments have locations. */
4672 if (gimple_location (phi
) != UNKNOWN_LOCATION
)
4674 error ("PHI node with location");
4678 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4680 tree arg
= gimple_phi_arg_def (phi
, i
);
4681 tree addr
= walk_tree (&arg
, verify_node_sharing_1
,
4685 error ("incorrect sharing of tree nodes");
4686 debug_generic_expr (addr
);
4689 location_t loc
= gimple_phi_arg_location (phi
, i
);
4690 if (virtual_operand_p (gimple_phi_result (phi
))
4691 && loc
!= UNKNOWN_LOCATION
)
4693 error ("virtual PHI with argument locations");
4696 addr
= walk_tree (&arg
, verify_expr_location_1
, blocks
, NULL
);
4699 debug_generic_expr (addr
);
4702 err2
|= verify_location (blocks
, loc
);
4706 debug_gimple_stmt (phi
);
4710 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4712 gimple stmt
= gsi_stmt (gsi
);
4714 struct walk_stmt_info wi
;
4718 pointer_set_insert (visited_stmts
, stmt
);
4720 if (gimple_bb (stmt
) != bb
)
4722 error ("gimple_bb (stmt) is set to a wrong basic block");
4726 err2
|= verify_gimple_stmt (stmt
);
4727 err2
|= verify_location (blocks
, gimple_location (stmt
));
4729 memset (&wi
, 0, sizeof (wi
));
4730 wi
.info
= (void *) visited
;
4731 addr
= walk_gimple_op (stmt
, verify_node_sharing
, &wi
);
4734 error ("incorrect sharing of tree nodes");
4735 debug_generic_expr (addr
);
4739 memset (&wi
, 0, sizeof (wi
));
4740 wi
.info
= (void *) blocks
;
4741 addr
= walk_gimple_op (stmt
, verify_expr_location
, &wi
);
4744 debug_generic_expr (addr
);
4748 /* ??? Instead of not checking these stmts at all the walker
4749 should know its context via wi. */
4750 if (!is_gimple_debug (stmt
)
4751 && !is_gimple_omp (stmt
))
4753 memset (&wi
, 0, sizeof (wi
));
4754 addr
= walk_gimple_op (stmt
, verify_expr
, &wi
);
4757 debug_generic_expr (addr
);
4758 inform (gimple_location (stmt
), "in statement");
4763 /* If the statement is marked as part of an EH region, then it is
4764 expected that the statement could throw. Verify that when we
4765 have optimizations that simplify statements such that we prove
4766 that they cannot throw, that we update other data structures
4768 lp_nr
= lookup_stmt_eh_lp (stmt
);
4771 if (!stmt_could_throw_p (stmt
))
4773 error ("statement marked for throw, but doesn%'t");
4777 && !gsi_one_before_end_p (gsi
)
4778 && stmt_can_throw_internal (stmt
))
4780 error ("statement marked for throw in middle of block");
4786 debug_gimple_stmt (stmt
);
4791 eh_error_found
= false;
4792 if (get_eh_throw_stmt_table (cfun
))
4793 htab_traverse (get_eh_throw_stmt_table (cfun
),
4794 verify_eh_throw_stmt_node
,
4797 if (err
|| eh_error_found
)
4798 internal_error ("verify_gimple failed");
4800 pointer_set_destroy (visited
);
4801 pointer_set_destroy (visited_stmts
);
4802 pointer_set_destroy (blocks
);
4803 verify_histograms ();
4804 timevar_pop (TV_TREE_STMT_VERIFY
);
4808 /* Verifies that the flow information is OK. */
4811 gimple_verify_flow_info (void)
4815 gimple_stmt_iterator gsi
;
4820 if (ENTRY_BLOCK_PTR
->il
.gimple
.seq
|| ENTRY_BLOCK_PTR
->il
.gimple
.phi_nodes
)
4822 error ("ENTRY_BLOCK has IL associated with it");
4826 if (EXIT_BLOCK_PTR
->il
.gimple
.seq
|| EXIT_BLOCK_PTR
->il
.gimple
.phi_nodes
)
4828 error ("EXIT_BLOCK has IL associated with it");
4832 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
4833 if (e
->flags
& EDGE_FALLTHRU
)
4835 error ("fallthru to exit from bb %d", e
->src
->index
);
4841 bool found_ctrl_stmt
= false;
4845 /* Skip labels on the start of basic block. */
4846 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4849 gimple prev_stmt
= stmt
;
4851 stmt
= gsi_stmt (gsi
);
4853 if (gimple_code (stmt
) != GIMPLE_LABEL
)
4856 label
= gimple_label_label (stmt
);
4857 if (prev_stmt
&& DECL_NONLOCAL (label
))
4859 error ("nonlocal label ");
4860 print_generic_expr (stderr
, label
, 0);
4861 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
4866 if (prev_stmt
&& EH_LANDING_PAD_NR (label
) != 0)
4868 error ("EH landing pad label ");
4869 print_generic_expr (stderr
, label
, 0);
4870 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
4875 if (label_to_block (label
) != bb
)
4878 print_generic_expr (stderr
, label
, 0);
4879 fprintf (stderr
, " to block does not match in bb %d",
4884 if (decl_function_context (label
) != current_function_decl
)
4887 print_generic_expr (stderr
, label
, 0);
4888 fprintf (stderr
, " has incorrect context in bb %d",
4894 /* Verify that body of basic block BB is free of control flow. */
4895 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
4897 gimple stmt
= gsi_stmt (gsi
);
4899 if (found_ctrl_stmt
)
4901 error ("control flow in the middle of basic block %d",
4906 if (stmt_ends_bb_p (stmt
))
4907 found_ctrl_stmt
= true;
4909 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4912 print_generic_expr (stderr
, gimple_label_label (stmt
), 0);
4913 fprintf (stderr
, " in the middle of basic block %d", bb
->index
);
4918 gsi
= gsi_last_bb (bb
);
4919 if (gsi_end_p (gsi
))
4922 stmt
= gsi_stmt (gsi
);
4924 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4927 err
|= verify_eh_edges (stmt
);
4929 if (is_ctrl_stmt (stmt
))
4931 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4932 if (e
->flags
& EDGE_FALLTHRU
)
4934 error ("fallthru edge after a control statement in bb %d",
4940 if (gimple_code (stmt
) != GIMPLE_COND
)
4942 /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
4943 after anything else but if statement. */
4944 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4945 if (e
->flags
& (EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
))
4947 error ("true/false edge after a non-GIMPLE_COND in bb %d",
4953 switch (gimple_code (stmt
))
4960 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
4964 || !(true_edge
->flags
& EDGE_TRUE_VALUE
)
4965 || !(false_edge
->flags
& EDGE_FALSE_VALUE
)
4966 || (true_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
4967 || (false_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
4968 || EDGE_COUNT (bb
->succs
) >= 3)
4970 error ("wrong outgoing edge flags at end of bb %d",
4978 if (simple_goto_p (stmt
))
4980 error ("explicit goto at end of bb %d", bb
->index
);
4985 /* FIXME. We should double check that the labels in the
4986 destination blocks have their address taken. */
4987 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4988 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_TRUE_VALUE
4989 | EDGE_FALSE_VALUE
))
4990 || !(e
->flags
& EDGE_ABNORMAL
))
4992 error ("wrong outgoing edge flags at end of bb %d",
5000 if (!gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
))
5002 /* ... fallthru ... */
5004 if (!single_succ_p (bb
)
5005 || (single_succ_edge (bb
)->flags
5006 & (EDGE_FALLTHRU
| EDGE_ABNORMAL
5007 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5009 error ("wrong outgoing edge flags at end of bb %d", bb
->index
);
5012 if (single_succ (bb
) != EXIT_BLOCK_PTR
)
5014 error ("return edge does not point to exit in bb %d",
5026 n
= gimple_switch_num_labels (stmt
);
5028 /* Mark all the destination basic blocks. */
5029 for (i
= 0; i
< n
; ++i
)
5031 tree lab
= CASE_LABEL (gimple_switch_label (stmt
, i
));
5032 basic_block label_bb
= label_to_block (lab
);
5033 gcc_assert (!label_bb
->aux
|| label_bb
->aux
== (void *)1);
5034 label_bb
->aux
= (void *)1;
5037 /* Verify that the case labels are sorted. */
5038 prev
= gimple_switch_label (stmt
, 0);
5039 for (i
= 1; i
< n
; ++i
)
5041 tree c
= gimple_switch_label (stmt
, i
);
5044 error ("found default case not at the start of "
5050 && !tree_int_cst_lt (CASE_LOW (prev
), CASE_LOW (c
)))
5052 error ("case labels not sorted: ");
5053 print_generic_expr (stderr
, prev
, 0);
5054 fprintf (stderr
," is greater than ");
5055 print_generic_expr (stderr
, c
, 0);
5056 fprintf (stderr
," but comes before it.\n");
5061 /* VRP will remove the default case if it can prove it will
5062 never be executed. So do not verify there always exists
5063 a default case here. */
5065 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5069 error ("extra outgoing edge %d->%d",
5070 bb
->index
, e
->dest
->index
);
5074 e
->dest
->aux
= (void *)2;
5075 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
5076 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5078 error ("wrong outgoing edge flags at end of bb %d",
5084 /* Check that we have all of them. */
5085 for (i
= 0; i
< n
; ++i
)
5087 tree lab
= CASE_LABEL (gimple_switch_label (stmt
, i
));
5088 basic_block label_bb
= label_to_block (lab
);
5090 if (label_bb
->aux
!= (void *)2)
5092 error ("missing edge %i->%i", bb
->index
, label_bb
->index
);
5097 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5098 e
->dest
->aux
= (void *)0;
5102 case GIMPLE_EH_DISPATCH
:
5103 err
|= verify_eh_dispatch_edge (stmt
);
5111 if (dom_info_state (CDI_DOMINATORS
) >= DOM_NO_FAST_QUERY
)
5112 verify_dominators (CDI_DOMINATORS
);
5118 /* Updates phi nodes after creating a forwarder block joined
5119 by edge FALLTHRU. */
5122 gimple_make_forwarder_block (edge fallthru
)
5126 basic_block dummy
, bb
;
5128 gimple_stmt_iterator gsi
;
5130 dummy
= fallthru
->src
;
5131 bb
= fallthru
->dest
;
5133 if (single_pred_p (bb
))
5136 /* If we redirected a branch we must create new PHI nodes at the
5138 for (gsi
= gsi_start_phis (dummy
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5140 gimple phi
, new_phi
;
5142 phi
= gsi_stmt (gsi
);
5143 var
= gimple_phi_result (phi
);
5144 new_phi
= create_phi_node (var
, bb
);
5145 gimple_phi_set_result (phi
, copy_ssa_name (var
, phi
));
5146 add_phi_arg (new_phi
, gimple_phi_result (phi
), fallthru
,
5150 /* Add the arguments we have stored on edges. */
5151 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
5156 flush_pending_stmts (e
);
5161 /* Return a non-special label in the head of basic block BLOCK.
5162 Create one if it doesn't exist. */
5165 gimple_block_label (basic_block bb
)
5167 gimple_stmt_iterator i
, s
= gsi_start_bb (bb
);
5172 for (i
= s
; !gsi_end_p (i
); first
= false, gsi_next (&i
))
5174 stmt
= gsi_stmt (i
);
5175 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5177 label
= gimple_label_label (stmt
);
5178 if (!DECL_NONLOCAL (label
))
5181 gsi_move_before (&i
, &s
);
5186 label
= create_artificial_label (UNKNOWN_LOCATION
);
5187 stmt
= gimple_build_label (label
);
5188 gsi_insert_before (&s
, stmt
, GSI_NEW_STMT
);
5193 /* Attempt to perform edge redirection by replacing a possibly complex
5194 jump instruction by a goto or by removing the jump completely.
5195 This can apply only if all edges now point to the same block. The
5196 parameters and return values are equivalent to
5197 redirect_edge_and_branch. */
5200 gimple_try_redirect_by_replacing_jump (edge e
, basic_block target
)
5202 basic_block src
= e
->src
;
5203 gimple_stmt_iterator i
;
5206 /* We can replace or remove a complex jump only when we have exactly
5208 if (EDGE_COUNT (src
->succs
) != 2
5209 /* Verify that all targets will be TARGET. Specifically, the
5210 edge that is not E must also go to TARGET. */
5211 || EDGE_SUCC (src
, EDGE_SUCC (src
, 0) == e
)->dest
!= target
)
5214 i
= gsi_last_bb (src
);
5218 stmt
= gsi_stmt (i
);
5220 if (gimple_code (stmt
) == GIMPLE_COND
|| gimple_code (stmt
) == GIMPLE_SWITCH
)
5222 gsi_remove (&i
, true);
5223 e
= ssa_redirect_edge (e
, target
);
5224 e
->flags
= EDGE_FALLTHRU
;
5232 /* Redirect E to DEST. Return NULL on failure. Otherwise, return the
5233 edge representing the redirected branch. */
5236 gimple_redirect_edge_and_branch (edge e
, basic_block dest
)
5238 basic_block bb
= e
->src
;
5239 gimple_stmt_iterator gsi
;
5243 if (e
->flags
& EDGE_ABNORMAL
)
5246 if (e
->dest
== dest
)
5249 if (e
->flags
& EDGE_EH
)
5250 return redirect_eh_edge (e
, dest
);
5252 if (e
->src
!= ENTRY_BLOCK_PTR
)
5254 ret
= gimple_try_redirect_by_replacing_jump (e
, dest
);
5259 gsi
= gsi_last_bb (bb
);
5260 stmt
= gsi_end_p (gsi
) ? NULL
: gsi_stmt (gsi
);
5262 switch (stmt
? gimple_code (stmt
) : GIMPLE_ERROR_MARK
)
5265 /* For COND_EXPR, we only need to redirect the edge. */
5269 /* No non-abnormal edges should lead from a non-simple goto, and
5270 simple ones should be represented implicitly. */
5275 tree label
= gimple_block_label (dest
);
5276 tree cases
= get_cases_for_edge (e
, stmt
);
5278 /* If we have a list of cases associated with E, then use it
5279 as it's a lot faster than walking the entire case vector. */
5282 edge e2
= find_edge (e
->src
, dest
);
5289 CASE_LABEL (cases
) = label
;
5290 cases
= CASE_CHAIN (cases
);
5293 /* If there was already an edge in the CFG, then we need
5294 to move all the cases associated with E to E2. */
5297 tree cases2
= get_cases_for_edge (e2
, stmt
);
5299 CASE_CHAIN (last
) = CASE_CHAIN (cases2
);
5300 CASE_CHAIN (cases2
) = first
;
5302 bitmap_set_bit (touched_switch_bbs
, gimple_bb (stmt
)->index
);
5306 size_t i
, n
= gimple_switch_num_labels (stmt
);
5308 for (i
= 0; i
< n
; i
++)
5310 tree elt
= gimple_switch_label (stmt
, i
);
5311 if (label_to_block (CASE_LABEL (elt
)) == e
->dest
)
5312 CASE_LABEL (elt
) = label
;
5320 int i
, n
= gimple_asm_nlabels (stmt
);
5323 for (i
= 0; i
< n
; ++i
)
5325 tree cons
= gimple_asm_label_op (stmt
, i
);
5326 if (label_to_block (TREE_VALUE (cons
)) == e
->dest
)
5329 label
= gimple_block_label (dest
);
5330 TREE_VALUE (cons
) = label
;
5334 /* If we didn't find any label matching the former edge in the
5335 asm labels, we must be redirecting the fallthrough
5337 gcc_assert (label
|| (e
->flags
& EDGE_FALLTHRU
));
5342 gsi_remove (&gsi
, true);
5343 e
->flags
|= EDGE_FALLTHRU
;
5346 case GIMPLE_OMP_RETURN
:
5347 case GIMPLE_OMP_CONTINUE
:
5348 case GIMPLE_OMP_SECTIONS_SWITCH
:
5349 case GIMPLE_OMP_FOR
:
5350 /* The edges from OMP constructs can be simply redirected. */
5353 case GIMPLE_EH_DISPATCH
:
5354 if (!(e
->flags
& EDGE_FALLTHRU
))
5355 redirect_eh_dispatch_edge (stmt
, e
, dest
);
5358 case GIMPLE_TRANSACTION
:
5359 /* The ABORT edge has a stored label associated with it, otherwise
5360 the edges are simply redirectable. */
5362 gimple_transaction_set_label (stmt
, gimple_block_label (dest
));
5366 /* Otherwise it must be a fallthru edge, and we don't need to
5367 do anything besides redirecting it. */
5368 gcc_assert (e
->flags
& EDGE_FALLTHRU
);
5372 /* Update/insert PHI nodes as necessary. */
5374 /* Now update the edges in the CFG. */
5375 e
= ssa_redirect_edge (e
, dest
);
5380 /* Returns true if it is possible to remove edge E by redirecting
5381 it to the destination of the other edge from E->src. */
5384 gimple_can_remove_branch_p (const_edge e
)
5386 if (e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
))
5392 /* Simple wrapper, as we can always redirect fallthru edges. */
5395 gimple_redirect_edge_and_branch_force (edge e
, basic_block dest
)
5397 e
= gimple_redirect_edge_and_branch (e
, dest
);
5404 /* Splits basic block BB after statement STMT (but at least after the
5405 labels). If STMT is NULL, BB is split just after the labels. */
5408 gimple_split_block (basic_block bb
, void *stmt
)
5410 gimple_stmt_iterator gsi
;
5411 gimple_stmt_iterator gsi_tgt
;
5418 new_bb
= create_empty_bb (bb
);
5420 /* Redirect the outgoing edges. */
5421 new_bb
->succs
= bb
->succs
;
5423 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
5426 if (stmt
&& gimple_code ((gimple
) stmt
) == GIMPLE_LABEL
)
5429 /* Move everything from GSI to the new basic block. */
5430 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5432 act
= gsi_stmt (gsi
);
5433 if (gimple_code (act
) == GIMPLE_LABEL
)
5446 if (gsi_end_p (gsi
))
5449 /* Split the statement list - avoid re-creating new containers as this
5450 brings ugly quadratic memory consumption in the inliner.
5451 (We are still quadratic since we need to update stmt BB pointers,
5453 gsi_split_seq_before (&gsi
, &list
);
5454 set_bb_seq (new_bb
, list
);
5455 for (gsi_tgt
= gsi_start (list
);
5456 !gsi_end_p (gsi_tgt
); gsi_next (&gsi_tgt
))
5457 gimple_set_bb (gsi_stmt (gsi_tgt
), new_bb
);
5463 /* Moves basic block BB after block AFTER. */
5466 gimple_move_block_after (basic_block bb
, basic_block after
)
5468 if (bb
->prev_bb
== after
)
5472 link_block (bb
, after
);
5478 /* Return TRUE if block BB has no executable statements, otherwise return
5482 gimple_empty_block_p (basic_block bb
)
5484 /* BB must have no executable statements. */
5485 gimple_stmt_iterator gsi
= gsi_after_labels (bb
);
5488 if (gsi_end_p (gsi
))
5490 if (is_gimple_debug (gsi_stmt (gsi
)))
5491 gsi_next_nondebug (&gsi
);
5492 return gsi_end_p (gsi
);
5496 /* Split a basic block if it ends with a conditional branch and if the
5497 other part of the block is not empty. */
5500 gimple_split_block_before_cond_jump (basic_block bb
)
5502 gimple last
, split_point
;
5503 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
5504 if (gsi_end_p (gsi
))
5506 last
= gsi_stmt (gsi
);
5507 if (gimple_code (last
) != GIMPLE_COND
5508 && gimple_code (last
) != GIMPLE_SWITCH
)
5510 gsi_prev_nondebug (&gsi
);
5511 split_point
= gsi_stmt (gsi
);
5512 return split_block (bb
, split_point
)->dest
;
5516 /* Return true if basic_block can be duplicated. */
5519 gimple_can_duplicate_bb_p (const_basic_block bb ATTRIBUTE_UNUSED
)
5524 /* Create a duplicate of the basic block BB. NOTE: This does not
5525 preserve SSA form. */
5528 gimple_duplicate_bb (basic_block bb
)
5531 gimple_stmt_iterator gsi
, gsi_tgt
;
5532 gimple_seq phis
= phi_nodes (bb
);
5533 gimple phi
, stmt
, copy
;
5535 new_bb
= create_empty_bb (EXIT_BLOCK_PTR
->prev_bb
);
5537 /* Copy the PHI nodes. We ignore PHI node arguments here because
5538 the incoming edges have not been setup yet. */
5539 for (gsi
= gsi_start (phis
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5541 phi
= gsi_stmt (gsi
);
5542 copy
= create_phi_node (NULL_TREE
, new_bb
);
5543 create_new_def_for (gimple_phi_result (phi
), copy
,
5544 gimple_phi_result_ptr (copy
));
5547 gsi_tgt
= gsi_start_bb (new_bb
);
5548 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5550 def_operand_p def_p
;
5551 ssa_op_iter op_iter
;
5554 stmt
= gsi_stmt (gsi
);
5555 if (gimple_code (stmt
) == GIMPLE_LABEL
)
5558 /* Don't duplicate label debug stmts. */
5559 if (gimple_debug_bind_p (stmt
)
5560 && TREE_CODE (gimple_debug_bind_get_var (stmt
))
5564 /* Create a new copy of STMT and duplicate STMT's virtual
5566 copy
= gimple_copy (stmt
);
5567 gsi_insert_after (&gsi_tgt
, copy
, GSI_NEW_STMT
);
5569 maybe_duplicate_eh_stmt (copy
, stmt
);
5570 gimple_duplicate_stmt_histograms (cfun
, copy
, cfun
, stmt
);
5572 /* When copying around a stmt writing into a local non-user
5573 aggregate, make sure it won't share stack slot with other
5575 lhs
= gimple_get_lhs (stmt
);
5576 if (lhs
&& TREE_CODE (lhs
) != SSA_NAME
)
5578 tree base
= get_base_address (lhs
);
5580 && (TREE_CODE (base
) == VAR_DECL
5581 || TREE_CODE (base
) == RESULT_DECL
)
5582 && DECL_IGNORED_P (base
)
5583 && !TREE_STATIC (base
)
5584 && !DECL_EXTERNAL (base
)
5585 && (TREE_CODE (base
) != VAR_DECL
5586 || !DECL_HAS_VALUE_EXPR_P (base
)))
5587 DECL_NONSHAREABLE (base
) = 1;
5590 /* Create new names for all the definitions created by COPY and
5591 add replacement mappings for each new name. */
5592 FOR_EACH_SSA_DEF_OPERAND (def_p
, copy
, op_iter
, SSA_OP_ALL_DEFS
)
5593 create_new_def_for (DEF_FROM_PTR (def_p
), copy
, def_p
);
5599 /* Adds phi node arguments for edge E_COPY after basic block duplication. */
5602 add_phi_args_after_copy_edge (edge e_copy
)
5604 basic_block bb
, bb_copy
= e_copy
->src
, dest
;
5607 gimple phi
, phi_copy
;
5609 gimple_stmt_iterator psi
, psi_copy
;
5611 if (gimple_seq_empty_p (phi_nodes (e_copy
->dest
)))
5614 bb
= bb_copy
->flags
& BB_DUPLICATED
? get_bb_original (bb_copy
) : bb_copy
;
5616 if (e_copy
->dest
->flags
& BB_DUPLICATED
)
5617 dest
= get_bb_original (e_copy
->dest
);
5619 dest
= e_copy
->dest
;
5621 e
= find_edge (bb
, dest
);
5624 /* During loop unrolling the target of the latch edge is copied.
5625 In this case we are not looking for edge to dest, but to
5626 duplicated block whose original was dest. */
5627 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5629 if ((e
->dest
->flags
& BB_DUPLICATED
)
5630 && get_bb_original (e
->dest
) == dest
)
5634 gcc_assert (e
!= NULL
);
5637 for (psi
= gsi_start_phis (e
->dest
),
5638 psi_copy
= gsi_start_phis (e_copy
->dest
);
5640 gsi_next (&psi
), gsi_next (&psi_copy
))
5642 phi
= gsi_stmt (psi
);
5643 phi_copy
= gsi_stmt (psi_copy
);
5644 def
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
5645 add_phi_arg (phi_copy
, def
, e_copy
,
5646 gimple_phi_arg_location_from_edge (phi
, e
));
5651 /* Basic block BB_COPY was created by code duplication. Add phi node
5652 arguments for edges going out of BB_COPY. The blocks that were
5653 duplicated have BB_DUPLICATED set. */
5656 add_phi_args_after_copy_bb (basic_block bb_copy
)
5661 FOR_EACH_EDGE (e_copy
, ei
, bb_copy
->succs
)
5663 add_phi_args_after_copy_edge (e_copy
);
5667 /* Blocks in REGION_COPY array of length N_REGION were created by
5668 duplication of basic blocks. Add phi node arguments for edges
5669 going from these blocks. If E_COPY is not NULL, also add
5670 phi node arguments for its destination.*/
5673 add_phi_args_after_copy (basic_block
*region_copy
, unsigned n_region
,
5678 for (i
= 0; i
< n_region
; i
++)
5679 region_copy
[i
]->flags
|= BB_DUPLICATED
;
5681 for (i
= 0; i
< n_region
; i
++)
5682 add_phi_args_after_copy_bb (region_copy
[i
]);
5684 add_phi_args_after_copy_edge (e_copy
);
5686 for (i
= 0; i
< n_region
; i
++)
5687 region_copy
[i
]->flags
&= ~BB_DUPLICATED
;
5690 /* Duplicates a REGION (set of N_REGION basic blocks) with just a single
5691 important exit edge EXIT. By important we mean that no SSA name defined
5692 inside region is live over the other exit edges of the region. All entry
5693 edges to the region must go to ENTRY->dest. The edge ENTRY is redirected
5694 to the duplicate of the region. Dominance and loop information is
5695 updated if UPDATE_DOMINANCE is true, but not the SSA web. If
5696 UPDATE_DOMINANCE is false then we assume that the caller will update the
5697 dominance information after calling this function. The new basic
5698 blocks are stored to REGION_COPY in the same order as they had in REGION,
5699 provided that REGION_COPY is not NULL.
5700 The function returns false if it is unable to copy the region,
5704 gimple_duplicate_sese_region (edge entry
, edge exit
,
5705 basic_block
*region
, unsigned n_region
,
5706 basic_block
*region_copy
,
5707 bool update_dominance
)
5710 bool free_region_copy
= false, copying_header
= false;
5711 struct loop
*loop
= entry
->dest
->loop_father
;
5713 vec
<basic_block
> doms
;
5715 int total_freq
= 0, entry_freq
= 0;
5716 gcov_type total_count
= 0, entry_count
= 0;
5718 if (!can_copy_bbs_p (region
, n_region
))
5721 /* Some sanity checking. Note that we do not check for all possible
5722 missuses of the functions. I.e. if you ask to copy something weird,
5723 it will work, but the state of structures probably will not be
5725 for (i
= 0; i
< n_region
; i
++)
5727 /* We do not handle subloops, i.e. all the blocks must belong to the
5729 if (region
[i
]->loop_father
!= loop
)
5732 if (region
[i
] != entry
->dest
5733 && region
[i
] == loop
->header
)
5737 set_loop_copy (loop
, loop
);
5739 /* In case the function is used for loop header copying (which is the primary
5740 use), ensure that EXIT and its copy will be new latch and entry edges. */
5741 if (loop
->header
== entry
->dest
)
5743 copying_header
= true;
5744 set_loop_copy (loop
, loop_outer (loop
));
5746 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, exit
->src
))
5749 for (i
= 0; i
< n_region
; i
++)
5750 if (region
[i
] != exit
->src
5751 && dominated_by_p (CDI_DOMINATORS
, region
[i
], exit
->src
))
5757 region_copy
= XNEWVEC (basic_block
, n_region
);
5758 free_region_copy
= true;
5761 initialize_original_copy_tables ();
5763 /* Record blocks outside the region that are dominated by something
5765 if (update_dominance
)
5768 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
5771 if (entry
->dest
->count
)
5773 total_count
= entry
->dest
->count
;
5774 entry_count
= entry
->count
;
5775 /* Fix up corner cases, to avoid division by zero or creation of negative
5777 if (entry_count
> total_count
)
5778 entry_count
= total_count
;
5782 total_freq
= entry
->dest
->frequency
;
5783 entry_freq
= EDGE_FREQUENCY (entry
);
5784 /* Fix up corner cases, to avoid division by zero or creation of negative
5786 if (total_freq
== 0)
5788 else if (entry_freq
> total_freq
)
5789 entry_freq
= total_freq
;
5792 copy_bbs (region
, n_region
, region_copy
, &exit
, 1, &exit_copy
, loop
,
5793 split_edge_bb_loc (entry
), update_dominance
);
5796 scale_bbs_frequencies_gcov_type (region
, n_region
,
5797 total_count
- entry_count
,
5799 scale_bbs_frequencies_gcov_type (region_copy
, n_region
, entry_count
,
5804 scale_bbs_frequencies_int (region
, n_region
, total_freq
- entry_freq
,
5806 scale_bbs_frequencies_int (region_copy
, n_region
, entry_freq
, total_freq
);
5811 loop
->header
= exit
->dest
;
5812 loop
->latch
= exit
->src
;
5815 /* Redirect the entry and add the phi node arguments. */
5816 redirected
= redirect_edge_and_branch (entry
, get_bb_copy (entry
->dest
));
5817 gcc_assert (redirected
!= NULL
);
5818 flush_pending_stmts (entry
);
5820 /* Concerning updating of dominators: We must recount dominators
5821 for entry block and its copy. Anything that is outside of the
5822 region, but was dominated by something inside needs recounting as
5824 if (update_dominance
)
5826 set_immediate_dominator (CDI_DOMINATORS
, entry
->dest
, entry
->src
);
5827 doms
.safe_push (get_bb_original (entry
->dest
));
5828 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
5832 /* Add the other PHI node arguments. */
5833 add_phi_args_after_copy (region_copy
, n_region
, NULL
);
5835 if (free_region_copy
)
5838 free_original_copy_tables ();
5842 /* Checks if BB is part of the region defined by N_REGION BBS. */
5844 bb_part_of_region_p (basic_block bb
, basic_block
* bbs
, unsigned n_region
)
5848 for (n
= 0; n
< n_region
; n
++)
5856 /* Duplicates REGION consisting of N_REGION blocks. The new blocks
5857 are stored to REGION_COPY in the same order in that they appear
5858 in REGION, if REGION_COPY is not NULL. ENTRY is the entry to
5859 the region, EXIT an exit from it. The condition guarding EXIT
5860 is moved to ENTRY. Returns true if duplication succeeds, false
5886 gimple_duplicate_sese_tail (edge entry ATTRIBUTE_UNUSED
, edge exit ATTRIBUTE_UNUSED
,
5887 basic_block
*region ATTRIBUTE_UNUSED
, unsigned n_region ATTRIBUTE_UNUSED
,
5888 basic_block
*region_copy ATTRIBUTE_UNUSED
)
5891 bool free_region_copy
= false;
5892 struct loop
*loop
= exit
->dest
->loop_father
;
5893 struct loop
*orig_loop
= entry
->dest
->loop_father
;
5894 basic_block switch_bb
, entry_bb
, nentry_bb
;
5895 vec
<basic_block
> doms
;
5896 int total_freq
= 0, exit_freq
= 0;
5897 gcov_type total_count
= 0, exit_count
= 0;
5898 edge exits
[2], nexits
[2], e
;
5899 gimple_stmt_iterator gsi
;
5902 basic_block exit_bb
;
5903 gimple_stmt_iterator psi
;
5906 struct loop
*target
, *aloop
, *cloop
;
5908 gcc_assert (EDGE_COUNT (exit
->src
->succs
) == 2);
5910 exits
[1] = EDGE_SUCC (exit
->src
, EDGE_SUCC (exit
->src
, 0) == exit
);
5912 if (!can_copy_bbs_p (region
, n_region
))
5915 initialize_original_copy_tables ();
5916 set_loop_copy (orig_loop
, loop
);
5919 for (aloop
= orig_loop
->inner
; aloop
; aloop
= aloop
->next
)
5921 if (bb_part_of_region_p (aloop
->header
, region
, n_region
))
5923 cloop
= duplicate_loop (aloop
, target
);
5924 duplicate_subloops (aloop
, cloop
);
5930 region_copy
= XNEWVEC (basic_block
, n_region
);
5931 free_region_copy
= true;
5934 gcc_assert (!need_ssa_update_p (cfun
));
5936 /* Record blocks outside the region that are dominated by something
5938 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
5940 if (exit
->src
->count
)
5942 total_count
= exit
->src
->count
;
5943 exit_count
= exit
->count
;
5944 /* Fix up corner cases, to avoid division by zero or creation of negative
5946 if (exit_count
> total_count
)
5947 exit_count
= total_count
;
5951 total_freq
= exit
->src
->frequency
;
5952 exit_freq
= EDGE_FREQUENCY (exit
);
5953 /* Fix up corner cases, to avoid division by zero or creation of negative
5955 if (total_freq
== 0)
5957 if (exit_freq
> total_freq
)
5958 exit_freq
= total_freq
;
5961 copy_bbs (region
, n_region
, region_copy
, exits
, 2, nexits
, orig_loop
,
5962 split_edge_bb_loc (exit
), true);
5965 scale_bbs_frequencies_gcov_type (region
, n_region
,
5966 total_count
- exit_count
,
5968 scale_bbs_frequencies_gcov_type (region_copy
, n_region
, exit_count
,
5973 scale_bbs_frequencies_int (region
, n_region
, total_freq
- exit_freq
,
5975 scale_bbs_frequencies_int (region_copy
, n_region
, exit_freq
, total_freq
);
5978 /* Create the switch block, and put the exit condition to it. */
5979 entry_bb
= entry
->dest
;
5980 nentry_bb
= get_bb_copy (entry_bb
);
5981 if (!last_stmt (entry
->src
)
5982 || !stmt_ends_bb_p (last_stmt (entry
->src
)))
5983 switch_bb
= entry
->src
;
5985 switch_bb
= split_edge (entry
);
5986 set_immediate_dominator (CDI_DOMINATORS
, nentry_bb
, switch_bb
);
5988 gsi
= gsi_last_bb (switch_bb
);
5989 cond_stmt
= last_stmt (exit
->src
);
5990 gcc_assert (gimple_code (cond_stmt
) == GIMPLE_COND
);
5991 cond_stmt
= gimple_copy (cond_stmt
);
5993 gsi_insert_after (&gsi
, cond_stmt
, GSI_NEW_STMT
);
5995 sorig
= single_succ_edge (switch_bb
);
5996 sorig
->flags
= exits
[1]->flags
;
5997 snew
= make_edge (switch_bb
, nentry_bb
, exits
[0]->flags
);
5999 /* Register the new edge from SWITCH_BB in loop exit lists. */
6000 rescan_loop_exit (snew
, true, false);
6002 /* Add the PHI node arguments. */
6003 add_phi_args_after_copy (region_copy
, n_region
, snew
);
6005 /* Get rid of now superfluous conditions and associated edges (and phi node
6007 exit_bb
= exit
->dest
;
6009 e
= redirect_edge_and_branch (exits
[0], exits
[1]->dest
);
6010 PENDING_STMT (e
) = NULL
;
6012 /* The latch of ORIG_LOOP was copied, and so was the backedge
6013 to the original header. We redirect this backedge to EXIT_BB. */
6014 for (i
= 0; i
< n_region
; i
++)
6015 if (get_bb_original (region_copy
[i
]) == orig_loop
->latch
)
6017 gcc_assert (single_succ_edge (region_copy
[i
]));
6018 e
= redirect_edge_and_branch (single_succ_edge (region_copy
[i
]), exit_bb
);
6019 PENDING_STMT (e
) = NULL
;
6020 for (psi
= gsi_start_phis (exit_bb
);
6024 phi
= gsi_stmt (psi
);
6025 def
= PHI_ARG_DEF (phi
, nexits
[0]->dest_idx
);
6026 add_phi_arg (phi
, def
, e
, gimple_phi_arg_location_from_edge (phi
, e
));
6029 e
= redirect_edge_and_branch (nexits
[1], nexits
[0]->dest
);
6030 PENDING_STMT (e
) = NULL
;
6032 /* Anything that is outside of the region, but was dominated by something
6033 inside needs to update dominance info. */
6034 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6036 /* Update the SSA web. */
6037 update_ssa (TODO_update_ssa
);
6039 if (free_region_copy
)
6042 free_original_copy_tables ();
6046 /* Add all the blocks dominated by ENTRY to the array BBS_P. Stop
6047 adding blocks when the dominator traversal reaches EXIT. This
6048 function silently assumes that ENTRY strictly dominates EXIT. */
6051 gather_blocks_in_sese_region (basic_block entry
, basic_block exit
,
6052 vec
<basic_block
> *bbs_p
)
6056 for (son
= first_dom_son (CDI_DOMINATORS
, entry
);
6058 son
= next_dom_son (CDI_DOMINATORS
, son
))
6060 bbs_p
->safe_push (son
);
6062 gather_blocks_in_sese_region (son
, exit
, bbs_p
);
6066 /* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
6067 The duplicates are recorded in VARS_MAP. */
6070 replace_by_duplicate_decl (tree
*tp
, struct pointer_map_t
*vars_map
,
6073 tree t
= *tp
, new_t
;
6074 struct function
*f
= DECL_STRUCT_FUNCTION (to_context
);
6077 if (DECL_CONTEXT (t
) == to_context
)
6080 loc
= pointer_map_contains (vars_map
, t
);
6084 loc
= pointer_map_insert (vars_map
, t
);
6088 new_t
= copy_var_decl (t
, DECL_NAME (t
), TREE_TYPE (t
));
6089 add_local_decl (f
, new_t
);
6093 gcc_assert (TREE_CODE (t
) == CONST_DECL
);
6094 new_t
= copy_node (t
);
6096 DECL_CONTEXT (new_t
) = to_context
;
6101 new_t
= (tree
) *loc
;
6107 /* Creates an ssa name in TO_CONTEXT equivalent to NAME.
6108 VARS_MAP maps old ssa names and var_decls to the new ones. */
6111 replace_ssa_name (tree name
, struct pointer_map_t
*vars_map
,
6117 gcc_assert (!virtual_operand_p (name
));
6119 loc
= pointer_map_contains (vars_map
, name
);
6123 tree decl
= SSA_NAME_VAR (name
);
6126 replace_by_duplicate_decl (&decl
, vars_map
, to_context
);
6127 new_name
= make_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6128 decl
, SSA_NAME_DEF_STMT (name
));
6129 if (SSA_NAME_IS_DEFAULT_DEF (name
))
6130 set_ssa_default_def (DECL_STRUCT_FUNCTION (to_context
),
6134 new_name
= copy_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6135 name
, SSA_NAME_DEF_STMT (name
));
6137 loc
= pointer_map_insert (vars_map
, name
);
6141 new_name
= (tree
) *loc
;
6152 struct pointer_map_t
*vars_map
;
6153 htab_t new_label_map
;
6154 struct pointer_map_t
*eh_map
;
6158 /* Helper for move_block_to_fn. Set TREE_BLOCK in every expression
6159 contained in *TP if it has been ORIG_BLOCK previously and change the
6160 DECL_CONTEXT of every local variable referenced in *TP. */
6163 move_stmt_op (tree
*tp
, int *walk_subtrees
, void *data
)
6165 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
6166 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6171 tree block
= TREE_BLOCK (t
);
6172 if (block
== p
->orig_block
6173 || (p
->orig_block
== NULL_TREE
6174 && block
!= NULL_TREE
))
6175 TREE_SET_BLOCK (t
, p
->new_block
);
6176 #ifdef ENABLE_CHECKING
6177 else if (block
!= NULL_TREE
)
6179 while (block
&& TREE_CODE (block
) == BLOCK
&& block
!= p
->orig_block
)
6180 block
= BLOCK_SUPERCONTEXT (block
);
6181 gcc_assert (block
== p
->orig_block
);
6185 else if (DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
)
6187 if (TREE_CODE (t
) == SSA_NAME
)
6188 *tp
= replace_ssa_name (t
, p
->vars_map
, p
->to_context
);
6189 else if (TREE_CODE (t
) == LABEL_DECL
)
6191 if (p
->new_label_map
)
6193 struct tree_map in
, *out
;
6195 out
= (struct tree_map
*)
6196 htab_find_with_hash (p
->new_label_map
, &in
, DECL_UID (t
));
6201 DECL_CONTEXT (t
) = p
->to_context
;
6203 else if (p
->remap_decls_p
)
6205 /* Replace T with its duplicate. T should no longer appear in the
6206 parent function, so this looks wasteful; however, it may appear
6207 in referenced_vars, and more importantly, as virtual operands of
6208 statements, and in alias lists of other variables. It would be
6209 quite difficult to expunge it from all those places. ??? It might
6210 suffice to do this for addressable variables. */
6211 if ((TREE_CODE (t
) == VAR_DECL
6212 && !is_global_var (t
))
6213 || TREE_CODE (t
) == CONST_DECL
)
6214 replace_by_duplicate_decl (tp
, p
->vars_map
, p
->to_context
);
6218 else if (TYPE_P (t
))
6224 /* Helper for move_stmt_r. Given an EH region number for the source
6225 function, map that to the duplicate EH regio number in the dest. */
6228 move_stmt_eh_region_nr (int old_nr
, struct move_stmt_d
*p
)
6230 eh_region old_r
, new_r
;
6233 old_r
= get_eh_region_from_number (old_nr
);
6234 slot
= pointer_map_contains (p
->eh_map
, old_r
);
6235 new_r
= (eh_region
) *slot
;
6237 return new_r
->index
;
6240 /* Similar, but operate on INTEGER_CSTs. */
6243 move_stmt_eh_region_tree_nr (tree old_t_nr
, struct move_stmt_d
*p
)
6247 old_nr
= tree_low_cst (old_t_nr
, 0);
6248 new_nr
= move_stmt_eh_region_nr (old_nr
, p
);
6250 return build_int_cst (integer_type_node
, new_nr
);
6253 /* Like move_stmt_op, but for gimple statements.
6255 Helper for move_block_to_fn. Set GIMPLE_BLOCK in every expression
6256 contained in the current statement in *GSI_P and change the
6257 DECL_CONTEXT of every local variable referenced in the current
6261 move_stmt_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
6262 struct walk_stmt_info
*wi
)
6264 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6265 gimple stmt
= gsi_stmt (*gsi_p
);
6266 tree block
= gimple_block (stmt
);
6268 if (block
== p
->orig_block
6269 || (p
->orig_block
== NULL_TREE
6270 && block
!= NULL_TREE
))
6271 gimple_set_block (stmt
, p
->new_block
);
6273 switch (gimple_code (stmt
))
6276 /* Remap the region numbers for __builtin_eh_{pointer,filter}. */
6278 tree r
, fndecl
= gimple_call_fndecl (stmt
);
6279 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
6280 switch (DECL_FUNCTION_CODE (fndecl
))
6282 case BUILT_IN_EH_COPY_VALUES
:
6283 r
= gimple_call_arg (stmt
, 1);
6284 r
= move_stmt_eh_region_tree_nr (r
, p
);
6285 gimple_call_set_arg (stmt
, 1, r
);
6288 case BUILT_IN_EH_POINTER
:
6289 case BUILT_IN_EH_FILTER
:
6290 r
= gimple_call_arg (stmt
, 0);
6291 r
= move_stmt_eh_region_tree_nr (r
, p
);
6292 gimple_call_set_arg (stmt
, 0, r
);
6303 int r
= gimple_resx_region (stmt
);
6304 r
= move_stmt_eh_region_nr (r
, p
);
6305 gimple_resx_set_region (stmt
, r
);
6309 case GIMPLE_EH_DISPATCH
:
6311 int r
= gimple_eh_dispatch_region (stmt
);
6312 r
= move_stmt_eh_region_nr (r
, p
);
6313 gimple_eh_dispatch_set_region (stmt
, r
);
6317 case GIMPLE_OMP_RETURN
:
6318 case GIMPLE_OMP_CONTINUE
:
6321 if (is_gimple_omp (stmt
))
6323 /* Do not remap variables inside OMP directives. Variables
6324 referenced in clauses and directive header belong to the
6325 parent function and should not be moved into the child
6327 bool save_remap_decls_p
= p
->remap_decls_p
;
6328 p
->remap_decls_p
= false;
6329 *handled_ops_p
= true;
6331 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt
), move_stmt_r
,
6334 p
->remap_decls_p
= save_remap_decls_p
;
6342 /* Move basic block BB from function CFUN to function DEST_FN. The
6343 block is moved out of the original linked list and placed after
6344 block AFTER in the new list. Also, the block is removed from the
6345 original array of blocks and placed in DEST_FN's array of blocks.
6346 If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
6347 updated to reflect the moved edges.
6349 The local variables are remapped to new instances, VARS_MAP is used
6350 to record the mapping. */
6353 move_block_to_fn (struct function
*dest_cfun
, basic_block bb
,
6354 basic_block after
, bool update_edge_count_p
,
6355 struct move_stmt_d
*d
)
6357 struct control_flow_graph
*cfg
;
6360 gimple_stmt_iterator si
;
6361 unsigned old_len
, new_len
;
6363 /* Remove BB from dominance structures. */
6364 delete_from_dominance_info (CDI_DOMINATORS
, bb
);
6366 /* Move BB from its current loop to the copy in the new function. */
6369 struct loop
*new_loop
= (struct loop
*)bb
->loop_father
->aux
;
6371 bb
->loop_father
= new_loop
;
6374 /* Link BB to the new linked list. */
6375 move_block_after (bb
, after
);
6377 /* Update the edge count in the corresponding flowgraphs. */
6378 if (update_edge_count_p
)
6379 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6381 cfun
->cfg
->x_n_edges
--;
6382 dest_cfun
->cfg
->x_n_edges
++;
6385 /* Remove BB from the original basic block array. */
6386 (*cfun
->cfg
->x_basic_block_info
)[bb
->index
] = NULL
;
6387 cfun
->cfg
->x_n_basic_blocks
--;
6389 /* Grow DEST_CFUN's basic block array if needed. */
6390 cfg
= dest_cfun
->cfg
;
6391 cfg
->x_n_basic_blocks
++;
6392 if (bb
->index
>= cfg
->x_last_basic_block
)
6393 cfg
->x_last_basic_block
= bb
->index
+ 1;
6395 old_len
= vec_safe_length (cfg
->x_basic_block_info
);
6396 if ((unsigned) cfg
->x_last_basic_block
>= old_len
)
6398 new_len
= cfg
->x_last_basic_block
+ (cfg
->x_last_basic_block
+ 3) / 4;
6399 vec_safe_grow_cleared (cfg
->x_basic_block_info
, new_len
);
6402 (*cfg
->x_basic_block_info
)[bb
->index
] = bb
;
6404 /* Remap the variables in phi nodes. */
6405 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); )
6407 gimple phi
= gsi_stmt (si
);
6409 tree op
= PHI_RESULT (phi
);
6413 if (virtual_operand_p (op
))
6415 /* Remove the phi nodes for virtual operands (alias analysis will be
6416 run for the new function, anyway). */
6417 remove_phi_node (&si
, true);
6421 SET_PHI_RESULT (phi
,
6422 replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
6423 FOR_EACH_PHI_ARG (use
, phi
, oi
, SSA_OP_USE
)
6425 op
= USE_FROM_PTR (use
);
6426 if (TREE_CODE (op
) == SSA_NAME
)
6427 SET_USE (use
, replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
6430 for (i
= 0; i
< EDGE_COUNT (bb
->preds
); i
++)
6432 location_t locus
= gimple_phi_arg_location (phi
, i
);
6433 tree block
= LOCATION_BLOCK (locus
);
6435 if (locus
== UNKNOWN_LOCATION
)
6437 if (d
->orig_block
== NULL_TREE
|| block
== d
->orig_block
)
6439 if (d
->new_block
== NULL_TREE
)
6440 locus
= LOCATION_LOCUS (locus
);
6442 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, d
->new_block
);
6443 gimple_phi_arg_set_location (phi
, i
, locus
);
6450 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6452 gimple stmt
= gsi_stmt (si
);
6453 struct walk_stmt_info wi
;
6455 memset (&wi
, 0, sizeof (wi
));
6457 walk_gimple_stmt (&si
, move_stmt_r
, move_stmt_op
, &wi
);
6459 if (gimple_code (stmt
) == GIMPLE_LABEL
)
6461 tree label
= gimple_label_label (stmt
);
6462 int uid
= LABEL_DECL_UID (label
);
6464 gcc_assert (uid
> -1);
6466 old_len
= vec_safe_length (cfg
->x_label_to_block_map
);
6467 if (old_len
<= (unsigned) uid
)
6469 new_len
= 3 * uid
/ 2 + 1;
6470 vec_safe_grow_cleared (cfg
->x_label_to_block_map
, new_len
);
6473 (*cfg
->x_label_to_block_map
)[uid
] = bb
;
6474 (*cfun
->cfg
->x_label_to_block_map
)[uid
] = NULL
;
6476 gcc_assert (DECL_CONTEXT (label
) == dest_cfun
->decl
);
6478 if (uid
>= dest_cfun
->cfg
->last_label_uid
)
6479 dest_cfun
->cfg
->last_label_uid
= uid
+ 1;
6482 maybe_duplicate_eh_stmt_fn (dest_cfun
, stmt
, cfun
, stmt
, d
->eh_map
, 0);
6483 remove_stmt_from_eh_lp_fn (cfun
, stmt
);
6485 gimple_duplicate_stmt_histograms (dest_cfun
, stmt
, cfun
, stmt
);
6486 gimple_remove_stmt_histograms (cfun
, stmt
);
6488 /* We cannot leave any operands allocated from the operand caches of
6489 the current function. */
6490 free_stmt_operands (stmt
);
6491 push_cfun (dest_cfun
);
6496 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6497 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
6499 tree block
= LOCATION_BLOCK (e
->goto_locus
);
6500 if (d
->orig_block
== NULL_TREE
6501 || block
== d
->orig_block
)
6502 e
->goto_locus
= d
->new_block
?
6503 COMBINE_LOCATION_DATA (line_table
, e
->goto_locus
, d
->new_block
) :
6504 LOCATION_LOCUS (e
->goto_locus
);
6508 /* Examine the statements in BB (which is in SRC_CFUN); find and return
6509 the outermost EH region. Use REGION as the incoming base EH region. */
6512 find_outermost_region_in_block (struct function
*src_cfun
,
6513 basic_block bb
, eh_region region
)
6515 gimple_stmt_iterator si
;
6517 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6519 gimple stmt
= gsi_stmt (si
);
6520 eh_region stmt_region
;
6523 lp_nr
= lookup_stmt_eh_lp_fn (src_cfun
, stmt
);
6524 stmt_region
= get_eh_region_from_lp_number_fn (src_cfun
, lp_nr
);
6528 region
= stmt_region
;
6529 else if (stmt_region
!= region
)
6531 region
= eh_region_outermost (src_cfun
, stmt_region
, region
);
6532 gcc_assert (region
!= NULL
);
6541 new_label_mapper (tree decl
, void *data
)
6543 htab_t hash
= (htab_t
) data
;
6547 gcc_assert (TREE_CODE (decl
) == LABEL_DECL
);
6549 m
= XNEW (struct tree_map
);
6550 m
->hash
= DECL_UID (decl
);
6551 m
->base
.from
= decl
;
6552 m
->to
= create_artificial_label (UNKNOWN_LOCATION
);
6553 LABEL_DECL_UID (m
->to
) = LABEL_DECL_UID (decl
);
6554 if (LABEL_DECL_UID (m
->to
) >= cfun
->cfg
->last_label_uid
)
6555 cfun
->cfg
->last_label_uid
= LABEL_DECL_UID (m
->to
) + 1;
6557 slot
= htab_find_slot_with_hash (hash
, m
, m
->hash
, INSERT
);
6558 gcc_assert (*slot
== NULL
);
6565 /* Change DECL_CONTEXT of all BLOCK_VARS in block, including
6569 replace_block_vars_by_duplicates (tree block
, struct pointer_map_t
*vars_map
,
6574 for (tp
= &BLOCK_VARS (block
); *tp
; tp
= &DECL_CHAIN (*tp
))
6577 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != CONST_DECL
)
6579 replace_by_duplicate_decl (&t
, vars_map
, to_context
);
6582 if (TREE_CODE (*tp
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (*tp
))
6584 SET_DECL_VALUE_EXPR (t
, DECL_VALUE_EXPR (*tp
));
6585 DECL_HAS_VALUE_EXPR_P (t
) = 1;
6587 DECL_CHAIN (t
) = DECL_CHAIN (*tp
);
6592 for (block
= BLOCK_SUBBLOCKS (block
); block
; block
= BLOCK_CHAIN (block
))
6593 replace_block_vars_by_duplicates (block
, vars_map
, to_context
);
6596 /* Fixup the loop arrays and numbers after moving LOOP and its subloops
6600 fixup_loop_arrays_after_move (struct function
*fn1
, struct function
*fn2
,
6603 /* Discard it from the old loop array. */
6604 (*get_loops (fn1
))[loop
->num
] = NULL
;
6606 /* Place it in the new loop array, assigning it a new number. */
6607 loop
->num
= number_of_loops (fn2
);
6608 vec_safe_push (loops_for_fn (fn2
)->larray
, loop
);
6610 /* Recurse to children. */
6611 for (loop
= loop
->inner
; loop
; loop
= loop
->next
)
6612 fixup_loop_arrays_after_move (fn1
, fn2
, loop
);
6615 /* Move a single-entry, single-exit region delimited by ENTRY_BB and
6616 EXIT_BB to function DEST_CFUN. The whole region is replaced by a
6617 single basic block in the original CFG and the new basic block is
6618 returned. DEST_CFUN must not have a CFG yet.
6620 Note that the region need not be a pure SESE region. Blocks inside
6621 the region may contain calls to abort/exit. The only restriction
6622 is that ENTRY_BB should be the only entry point and it must
6625 Change TREE_BLOCK of all statements in ORIG_BLOCK to the new
6626 functions outermost BLOCK, move all subblocks of ORIG_BLOCK
6627 to the new function.
6629 All local variables referenced in the region are assumed to be in
6630 the corresponding BLOCK_VARS and unexpanded variable lists
6631 associated with DEST_CFUN. */
6634 move_sese_region_to_fn (struct function
*dest_cfun
, basic_block entry_bb
,
6635 basic_block exit_bb
, tree orig_block
)
6637 vec
<basic_block
> bbs
, dom_bbs
;
6638 basic_block dom_entry
= get_immediate_dominator (CDI_DOMINATORS
, entry_bb
);
6639 basic_block after
, bb
, *entry_pred
, *exit_succ
, abb
;
6640 struct function
*saved_cfun
= cfun
;
6641 int *entry_flag
, *exit_flag
;
6642 unsigned *entry_prob
, *exit_prob
;
6643 unsigned i
, num_entry_edges
, num_exit_edges
;
6646 htab_t new_label_map
;
6647 struct pointer_map_t
*vars_map
, *eh_map
;
6648 struct loop
*loop
= entry_bb
->loop_father
;
6649 struct move_stmt_d d
;
6651 /* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
6653 gcc_assert (entry_bb
!= exit_bb
6655 || dominated_by_p (CDI_DOMINATORS
, exit_bb
, entry_bb
)));
6657 /* Collect all the blocks in the region. Manually add ENTRY_BB
6658 because it won't be added by dfs_enumerate_from. */
6660 bbs
.safe_push (entry_bb
);
6661 gather_blocks_in_sese_region (entry_bb
, exit_bb
, &bbs
);
6663 /* The blocks that used to be dominated by something in BBS will now be
6664 dominated by the new block. */
6665 dom_bbs
= get_dominated_by_region (CDI_DOMINATORS
,
6669 /* Detach ENTRY_BB and EXIT_BB from CFUN->CFG. We need to remember
6670 the predecessor edges to ENTRY_BB and the successor edges to
6671 EXIT_BB so that we can re-attach them to the new basic block that
6672 will replace the region. */
6673 num_entry_edges
= EDGE_COUNT (entry_bb
->preds
);
6674 entry_pred
= XNEWVEC (basic_block
, num_entry_edges
);
6675 entry_flag
= XNEWVEC (int, num_entry_edges
);
6676 entry_prob
= XNEWVEC (unsigned, num_entry_edges
);
6678 for (ei
= ei_start (entry_bb
->preds
); (e
= ei_safe_edge (ei
)) != NULL
;)
6680 entry_prob
[i
] = e
->probability
;
6681 entry_flag
[i
] = e
->flags
;
6682 entry_pred
[i
++] = e
->src
;
6688 num_exit_edges
= EDGE_COUNT (exit_bb
->succs
);
6689 exit_succ
= XNEWVEC (basic_block
, num_exit_edges
);
6690 exit_flag
= XNEWVEC (int, num_exit_edges
);
6691 exit_prob
= XNEWVEC (unsigned, num_exit_edges
);
6693 for (ei
= ei_start (exit_bb
->succs
); (e
= ei_safe_edge (ei
)) != NULL
;)
6695 exit_prob
[i
] = e
->probability
;
6696 exit_flag
[i
] = e
->flags
;
6697 exit_succ
[i
++] = e
->dest
;
6709 /* Switch context to the child function to initialize DEST_FN's CFG. */
6710 gcc_assert (dest_cfun
->cfg
== NULL
);
6711 push_cfun (dest_cfun
);
6713 init_empty_tree_cfg ();
6715 /* Initialize EH information for the new function. */
6717 new_label_map
= NULL
;
6720 eh_region region
= NULL
;
6722 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6723 region
= find_outermost_region_in_block (saved_cfun
, bb
, region
);
6725 init_eh_for_function ();
6728 new_label_map
= htab_create (17, tree_map_hash
, tree_map_eq
, free
);
6729 eh_map
= duplicate_eh_regions (saved_cfun
, region
, 0,
6730 new_label_mapper
, new_label_map
);
6734 /* Initialize an empty loop tree. */
6735 struct loops
*loops
= ggc_alloc_cleared_loops ();
6736 init_loops_structure (dest_cfun
, loops
, 1);
6737 loops
->state
= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
6738 set_loops_for_fn (dest_cfun
, loops
);
6740 /* Move the outlined loop tree part. */
6741 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6743 if (bb
->loop_father
->header
== bb
6744 && loop_outer (bb
->loop_father
) == loop
)
6746 struct loop
*loop
= bb
->loop_father
;
6747 flow_loop_tree_node_remove (bb
->loop_father
);
6748 flow_loop_tree_node_add (get_loop (dest_cfun
, 0), loop
);
6749 fixup_loop_arrays_after_move (saved_cfun
, cfun
, loop
);
6752 /* Remove loop exits from the outlined region. */
6753 if (loops_for_fn (saved_cfun
)->exits
)
6754 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6756 void **slot
= htab_find_slot_with_hash
6757 (loops_for_fn (saved_cfun
)->exits
, e
,
6758 htab_hash_pointer (e
), NO_INSERT
);
6760 htab_clear_slot (loops_for_fn (saved_cfun
)->exits
, slot
);
6765 /* Adjust the number of blocks in the tree root of the outlined part. */
6766 get_loop (dest_cfun
, 0)->num_nodes
= bbs
.length () + 2;
6768 /* Setup a mapping to be used by move_block_to_fn. */
6769 loop
->aux
= current_loops
->tree_root
;
6773 /* Move blocks from BBS into DEST_CFUN. */
6774 gcc_assert (bbs
.length () >= 2);
6775 after
= dest_cfun
->cfg
->x_entry_block_ptr
;
6776 vars_map
= pointer_map_create ();
6778 memset (&d
, 0, sizeof (d
));
6779 d
.orig_block
= orig_block
;
6780 d
.new_block
= DECL_INITIAL (dest_cfun
->decl
);
6781 d
.from_context
= cfun
->decl
;
6782 d
.to_context
= dest_cfun
->decl
;
6783 d
.vars_map
= vars_map
;
6784 d
.new_label_map
= new_label_map
;
6786 d
.remap_decls_p
= true;
6788 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6790 /* No need to update edge counts on the last block. It has
6791 already been updated earlier when we detached the region from
6792 the original CFG. */
6793 move_block_to_fn (dest_cfun
, bb
, after
, bb
!= exit_bb
, &d
);
6798 /* Loop sizes are no longer correct, fix them up. */
6799 loop
->num_nodes
-= bbs
.length ();
6800 for (struct loop
*outer
= loop_outer (loop
);
6801 outer
; outer
= loop_outer (outer
))
6802 outer
->num_nodes
-= bbs
.length ();
6804 /* Rewire BLOCK_SUBBLOCKS of orig_block. */
6808 gcc_assert (BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
6810 BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
6811 = BLOCK_SUBBLOCKS (orig_block
);
6812 for (block
= BLOCK_SUBBLOCKS (orig_block
);
6813 block
; block
= BLOCK_CHAIN (block
))
6814 BLOCK_SUPERCONTEXT (block
) = DECL_INITIAL (dest_cfun
->decl
);
6815 BLOCK_SUBBLOCKS (orig_block
) = NULL_TREE
;
6818 replace_block_vars_by_duplicates (DECL_INITIAL (dest_cfun
->decl
),
6819 vars_map
, dest_cfun
->decl
);
6822 htab_delete (new_label_map
);
6824 pointer_map_destroy (eh_map
);
6825 pointer_map_destroy (vars_map
);
6827 /* Rewire the entry and exit blocks. The successor to the entry
6828 block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
6829 the child function. Similarly, the predecessor of DEST_FN's
6830 EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR. We
6831 need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
6832 various CFG manipulation function get to the right CFG.
6834 FIXME, this is silly. The CFG ought to become a parameter to
6836 push_cfun (dest_cfun
);
6837 make_edge (ENTRY_BLOCK_PTR
, entry_bb
, EDGE_FALLTHRU
);
6839 make_edge (exit_bb
, EXIT_BLOCK_PTR
, 0);
6842 /* Back in the original function, the SESE region has disappeared,
6843 create a new basic block in its place. */
6844 bb
= create_empty_bb (entry_pred
[0]);
6846 add_bb_to_loop (bb
, loop
);
6847 for (i
= 0; i
< num_entry_edges
; i
++)
6849 e
= make_edge (entry_pred
[i
], bb
, entry_flag
[i
]);
6850 e
->probability
= entry_prob
[i
];
6853 for (i
= 0; i
< num_exit_edges
; i
++)
6855 e
= make_edge (bb
, exit_succ
[i
], exit_flag
[i
]);
6856 e
->probability
= exit_prob
[i
];
6859 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom_entry
);
6860 FOR_EACH_VEC_ELT (dom_bbs
, i
, abb
)
6861 set_immediate_dominator (CDI_DOMINATORS
, abb
, bb
);
6879 /* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in dumpfile.h)
6883 dump_function_to_file (tree fndecl
, FILE *file
, int flags
)
6885 tree arg
, var
, old_current_fndecl
= current_function_decl
;
6886 struct function
*dsf
;
6887 bool ignore_topmost_bind
= false, any_var
= false;
6890 bool tmclone
= (TREE_CODE (fndecl
) == FUNCTION_DECL
6891 && decl_is_tm_clone (fndecl
));
6892 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
6894 current_function_decl
= fndecl
;
6895 fprintf (file
, "%s %s(", function_name (fun
), tmclone
? "[tm-clone] " : "");
6897 arg
= DECL_ARGUMENTS (fndecl
);
6900 print_generic_expr (file
, TREE_TYPE (arg
), dump_flags
);
6901 fprintf (file
, " ");
6902 print_generic_expr (file
, arg
, dump_flags
);
6903 if (flags
& TDF_VERBOSE
)
6904 print_node (file
, "", arg
, 4);
6905 if (DECL_CHAIN (arg
))
6906 fprintf (file
, ", ");
6907 arg
= DECL_CHAIN (arg
);
6909 fprintf (file
, ")\n");
6911 if (flags
& TDF_VERBOSE
)
6912 print_node (file
, "", fndecl
, 2);
6914 dsf
= DECL_STRUCT_FUNCTION (fndecl
);
6915 if (dsf
&& (flags
& TDF_EH
))
6916 dump_eh_tree (file
, dsf
);
6918 if (flags
& TDF_RAW
&& !gimple_has_body_p (fndecl
))
6920 dump_node (fndecl
, TDF_SLIM
| flags
, file
);
6921 current_function_decl
= old_current_fndecl
;
6925 /* When GIMPLE is lowered, the variables are no longer available in
6926 BIND_EXPRs, so display them separately. */
6927 if (fun
&& fun
->decl
== fndecl
&& (fun
->curr_properties
& PROP_gimple_lcf
))
6930 ignore_topmost_bind
= true;
6932 fprintf (file
, "{\n");
6933 if (!vec_safe_is_empty (fun
->local_decls
))
6934 FOR_EACH_LOCAL_DECL (fun
, ix
, var
)
6936 print_generic_decl (file
, var
, flags
);
6937 if (flags
& TDF_VERBOSE
)
6938 print_node (file
, "", var
, 4);
6939 fprintf (file
, "\n");
6943 if (gimple_in_ssa_p (cfun
))
6944 for (ix
= 1; ix
< num_ssa_names
; ++ix
)
6946 tree name
= ssa_name (ix
);
6947 if (name
&& !SSA_NAME_VAR (name
))
6949 fprintf (file
, " ");
6950 print_generic_expr (file
, TREE_TYPE (name
), flags
);
6951 fprintf (file
, " ");
6952 print_generic_expr (file
, name
, flags
);
6953 fprintf (file
, ";\n");
6960 if (fun
&& fun
->decl
== fndecl
6962 && basic_block_info_for_function (fun
))
6964 /* If the CFG has been built, emit a CFG-based dump. */
6965 if (!ignore_topmost_bind
)
6966 fprintf (file
, "{\n");
6968 if (any_var
&& n_basic_blocks_for_function (fun
))
6969 fprintf (file
, "\n");
6971 FOR_EACH_BB_FN (bb
, fun
)
6972 dump_bb (file
, bb
, 2, flags
| TDF_COMMENT
);
6974 fprintf (file
, "}\n");
6976 else if (DECL_SAVED_TREE (fndecl
) == NULL
)
6978 /* The function is now in GIMPLE form but the CFG has not been
6979 built yet. Emit the single sequence of GIMPLE statements
6980 that make up its body. */
6981 gimple_seq body
= gimple_body (fndecl
);
6983 if (gimple_seq_first_stmt (body
)
6984 && gimple_seq_first_stmt (body
) == gimple_seq_last_stmt (body
)
6985 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
)
6986 print_gimple_seq (file
, body
, 0, flags
);
6989 if (!ignore_topmost_bind
)
6990 fprintf (file
, "{\n");
6993 fprintf (file
, "\n");
6995 print_gimple_seq (file
, body
, 2, flags
);
6996 fprintf (file
, "}\n");
7003 /* Make a tree based dump. */
7004 chain
= DECL_SAVED_TREE (fndecl
);
7005 if (chain
&& TREE_CODE (chain
) == BIND_EXPR
)
7007 if (ignore_topmost_bind
)
7009 chain
= BIND_EXPR_BODY (chain
);
7017 if (!ignore_topmost_bind
)
7018 fprintf (file
, "{\n");
7023 fprintf (file
, "\n");
7025 print_generic_stmt_indented (file
, chain
, flags
, indent
);
7026 if (ignore_topmost_bind
)
7027 fprintf (file
, "}\n");
7030 if (flags
& TDF_ENUMERATE_LOCALS
)
7031 dump_enumerated_decls (file
, flags
);
7032 fprintf (file
, "\n\n");
7034 current_function_decl
= old_current_fndecl
;
7037 /* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h) */
7040 debug_function (tree fn
, int flags
)
7042 dump_function_to_file (fn
, stderr
, flags
);
7046 /* Print on FILE the indexes for the predecessors of basic_block BB. */
7049 print_pred_bbs (FILE *file
, basic_block bb
)
7054 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7055 fprintf (file
, "bb_%d ", e
->src
->index
);
7059 /* Print on FILE the indexes for the successors of basic_block BB. */
7062 print_succ_bbs (FILE *file
, basic_block bb
)
7067 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7068 fprintf (file
, "bb_%d ", e
->dest
->index
);
7071 /* Print to FILE the basic block BB following the VERBOSITY level. */
7074 print_loops_bb (FILE *file
, basic_block bb
, int indent
, int verbosity
)
7076 char *s_indent
= (char *) alloca ((size_t) indent
+ 1);
7077 memset ((void *) s_indent
, ' ', (size_t) indent
);
7078 s_indent
[indent
] = '\0';
7080 /* Print basic_block's header. */
7083 fprintf (file
, "%s bb_%d (preds = {", s_indent
, bb
->index
);
7084 print_pred_bbs (file
, bb
);
7085 fprintf (file
, "}, succs = {");
7086 print_succ_bbs (file
, bb
);
7087 fprintf (file
, "})\n");
7090 /* Print basic_block's body. */
7093 fprintf (file
, "%s {\n", s_indent
);
7094 dump_bb (file
, bb
, indent
+ 4, TDF_VOPS
|TDF_MEMSYMS
);
7095 fprintf (file
, "%s }\n", s_indent
);
7099 static void print_loop_and_siblings (FILE *, struct loop
*, int, int);
7101 /* Pretty print LOOP on FILE, indented INDENT spaces. Following
7102 VERBOSITY level this outputs the contents of the loop, or just its
7106 print_loop (FILE *file
, struct loop
*loop
, int indent
, int verbosity
)
7114 s_indent
= (char *) alloca ((size_t) indent
+ 1);
7115 memset ((void *) s_indent
, ' ', (size_t) indent
);
7116 s_indent
[indent
] = '\0';
7118 /* Print loop's header. */
7119 fprintf (file
, "%sloop_%d (", s_indent
, loop
->num
);
7121 fprintf (file
, "header = %d", loop
->header
->index
);
7124 fprintf (file
, "deleted)\n");
7128 fprintf (file
, ", latch = %d", loop
->latch
->index
);
7130 fprintf (file
, ", multiple latches");
7131 fprintf (file
, ", niter = ");
7132 print_generic_expr (file
, loop
->nb_iterations
, 0);
7134 if (loop
->any_upper_bound
)
7136 fprintf (file
, ", upper_bound = ");
7137 dump_double_int (file
, loop
->nb_iterations_upper_bound
, true);
7140 if (loop
->any_estimate
)
7142 fprintf (file
, ", estimate = ");
7143 dump_double_int (file
, loop
->nb_iterations_estimate
, true);
7145 fprintf (file
, ")\n");
7147 /* Print loop's body. */
7150 fprintf (file
, "%s{\n", s_indent
);
7152 if (bb
->loop_father
== loop
)
7153 print_loops_bb (file
, bb
, indent
, verbosity
);
7155 print_loop_and_siblings (file
, loop
->inner
, indent
+ 2, verbosity
);
7156 fprintf (file
, "%s}\n", s_indent
);
7160 /* Print the LOOP and its sibling loops on FILE, indented INDENT
7161 spaces. Following VERBOSITY level this outputs the contents of the
7162 loop, or just its structure. */
7165 print_loop_and_siblings (FILE *file
, struct loop
*loop
, int indent
,
7171 print_loop (file
, loop
, indent
, verbosity
);
7172 print_loop_and_siblings (file
, loop
->next
, indent
, verbosity
);
7175 /* Follow a CFG edge from the entry point of the program, and on entry
7176 of a loop, pretty print the loop structure on FILE. */
7179 print_loops (FILE *file
, int verbosity
)
7183 bb
= ENTRY_BLOCK_PTR
;
7184 if (bb
&& bb
->loop_father
)
7185 print_loop_and_siblings (file
, bb
->loop_father
, 0, verbosity
);
7191 debug (struct loop
&ref
)
7193 print_loop (stderr
, &ref
, 0, /*verbosity*/0);
7197 debug (struct loop
*ptr
)
7202 fprintf (stderr
, "<nil>\n");
7205 /* Dump a loop verbosely. */
7208 debug_verbose (struct loop
&ref
)
7210 print_loop (stderr
, &ref
, 0, /*verbosity*/3);
7214 debug_verbose (struct loop
*ptr
)
7219 fprintf (stderr
, "<nil>\n");
7223 /* Debugging loops structure at tree level, at some VERBOSITY level. */
7226 debug_loops (int verbosity
)
7228 print_loops (stderr
, verbosity
);
7231 /* Print on stderr the code of LOOP, at some VERBOSITY level. */
7234 debug_loop (struct loop
*loop
, int verbosity
)
7236 print_loop (stderr
, loop
, 0, verbosity
);
7239 /* Print on stderr the code of loop number NUM, at some VERBOSITY
7243 debug_loop_num (unsigned num
, int verbosity
)
7245 debug_loop (get_loop (cfun
, num
), verbosity
);
7248 /* Return true if BB ends with a call, possibly followed by some
7249 instructions that must stay with the call. Return false,
7253 gimple_block_ends_with_call_p (basic_block bb
)
7255 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
7256 return !gsi_end_p (gsi
) && is_gimple_call (gsi_stmt (gsi
));
7260 /* Return true if BB ends with a conditional branch. Return false,
7264 gimple_block_ends_with_condjump_p (const_basic_block bb
)
7266 gimple stmt
= last_stmt (CONST_CAST_BB (bb
));
7267 return (stmt
&& gimple_code (stmt
) == GIMPLE_COND
);
7271 /* Return true if we need to add fake edge to exit at statement T.
7272 Helper function for gimple_flow_call_edges_add. */
7275 need_fake_edge_p (gimple t
)
7277 tree fndecl
= NULL_TREE
;
7280 /* NORETURN and LONGJMP calls already have an edge to exit.
7281 CONST and PURE calls do not need one.
7282 We don't currently check for CONST and PURE here, although
7283 it would be a good idea, because those attributes are
7284 figured out from the RTL in mark_constant_function, and
7285 the counter incrementation code from -fprofile-arcs
7286 leads to different results from -fbranch-probabilities. */
7287 if (is_gimple_call (t
))
7289 fndecl
= gimple_call_fndecl (t
);
7290 call_flags
= gimple_call_flags (t
);
7293 if (is_gimple_call (t
)
7295 && DECL_BUILT_IN (fndecl
)
7296 && (call_flags
& ECF_NOTHROW
)
7297 && !(call_flags
& ECF_RETURNS_TWICE
)
7298 /* fork() doesn't really return twice, but the effect of
7299 wrapping it in __gcov_fork() which calls __gcov_flush()
7300 and clears the counters before forking has the same
7301 effect as returning twice. Force a fake edge. */
7302 && !(DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7303 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FORK
))
7306 if (is_gimple_call (t
))
7312 if (!(call_flags
& ECF_NORETURN
))
7316 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7317 if ((e
->flags
& EDGE_FAKE
) == 0)
7321 if (gimple_code (t
) == GIMPLE_ASM
7322 && (gimple_asm_volatile_p (t
) || gimple_asm_input_p (t
)))
7329 /* Add fake edges to the function exit for any non constant and non
7330 noreturn calls (or noreturn calls with EH/abnormal edges),
7331 volatile inline assembly in the bitmap of blocks specified by BLOCKS
7332 or to the whole CFG if BLOCKS is zero. Return the number of blocks
7335 The goal is to expose cases in which entering a basic block does
7336 not imply that all subsequent instructions must be executed. */
7339 gimple_flow_call_edges_add (sbitmap blocks
)
7342 int blocks_split
= 0;
7343 int last_bb
= last_basic_block
;
7344 bool check_last_block
= false;
7346 if (n_basic_blocks
== NUM_FIXED_BLOCKS
)
7350 check_last_block
= true;
7352 check_last_block
= bitmap_bit_p (blocks
, EXIT_BLOCK_PTR
->prev_bb
->index
);
7354 /* In the last basic block, before epilogue generation, there will be
7355 a fallthru edge to EXIT. Special care is required if the last insn
7356 of the last basic block is a call because make_edge folds duplicate
7357 edges, which would result in the fallthru edge also being marked
7358 fake, which would result in the fallthru edge being removed by
7359 remove_fake_edges, which would result in an invalid CFG.
7361 Moreover, we can't elide the outgoing fake edge, since the block
7362 profiler needs to take this into account in order to solve the minimal
7363 spanning tree in the case that the call doesn't return.
7365 Handle this by adding a dummy instruction in a new last basic block. */
7366 if (check_last_block
)
7368 basic_block bb
= EXIT_BLOCK_PTR
->prev_bb
;
7369 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
7372 if (!gsi_end_p (gsi
))
7375 if (t
&& need_fake_edge_p (t
))
7379 e
= find_edge (bb
, EXIT_BLOCK_PTR
);
7382 gsi_insert_on_edge (e
, gimple_build_nop ());
7383 gsi_commit_edge_inserts ();
7388 /* Now add fake edges to the function exit for any non constant
7389 calls since there is no way that we can determine if they will
7391 for (i
= 0; i
< last_bb
; i
++)
7393 basic_block bb
= BASIC_BLOCK (i
);
7394 gimple_stmt_iterator gsi
;
7395 gimple stmt
, last_stmt
;
7400 if (blocks
&& !bitmap_bit_p (blocks
, i
))
7403 gsi
= gsi_last_nondebug_bb (bb
);
7404 if (!gsi_end_p (gsi
))
7406 last_stmt
= gsi_stmt (gsi
);
7409 stmt
= gsi_stmt (gsi
);
7410 if (need_fake_edge_p (stmt
))
7414 /* The handling above of the final block before the
7415 epilogue should be enough to verify that there is
7416 no edge to the exit block in CFG already.
7417 Calling make_edge in such case would cause us to
7418 mark that edge as fake and remove it later. */
7419 #ifdef ENABLE_CHECKING
7420 if (stmt
== last_stmt
)
7422 e
= find_edge (bb
, EXIT_BLOCK_PTR
);
7423 gcc_assert (e
== NULL
);
7427 /* Note that the following may create a new basic block
7428 and renumber the existing basic blocks. */
7429 if (stmt
!= last_stmt
)
7431 e
= split_block (bb
, stmt
);
7435 make_edge (bb
, EXIT_BLOCK_PTR
, EDGE_FAKE
);
7439 while (!gsi_end_p (gsi
));
7444 verify_flow_info ();
7446 return blocks_split
;
7449 /* Removes edge E and all the blocks dominated by it, and updates dominance
7450 information. The IL in E->src needs to be updated separately.
7451 If dominance info is not available, only the edge E is removed.*/
7454 remove_edge_and_dominated_blocks (edge e
)
7456 vec
<basic_block
> bbs_to_remove
= vNULL
;
7457 vec
<basic_block
> bbs_to_fix_dom
= vNULL
;
7461 bool none_removed
= false;
7463 basic_block bb
, dbb
;
7466 if (!dom_info_available_p (CDI_DOMINATORS
))
7472 /* No updating is needed for edges to exit. */
7473 if (e
->dest
== EXIT_BLOCK_PTR
)
7475 if (cfgcleanup_altered_bbs
)
7476 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
7481 /* First, we find the basic blocks to remove. If E->dest has a predecessor
7482 that is not dominated by E->dest, then this set is empty. Otherwise,
7483 all the basic blocks dominated by E->dest are removed.
7485 Also, to DF_IDOM we store the immediate dominators of the blocks in
7486 the dominance frontier of E (i.e., of the successors of the
7487 removed blocks, if there are any, and of E->dest otherwise). */
7488 FOR_EACH_EDGE (f
, ei
, e
->dest
->preds
)
7493 if (!dominated_by_p (CDI_DOMINATORS
, f
->src
, e
->dest
))
7495 none_removed
= true;
7500 df
= BITMAP_ALLOC (NULL
);
7501 df_idom
= BITMAP_ALLOC (NULL
);
7504 bitmap_set_bit (df_idom
,
7505 get_immediate_dominator (CDI_DOMINATORS
, e
->dest
)->index
);
7508 bbs_to_remove
= get_all_dominated_blocks (CDI_DOMINATORS
, e
->dest
);
7509 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
7511 FOR_EACH_EDGE (f
, ei
, bb
->succs
)
7513 if (f
->dest
!= EXIT_BLOCK_PTR
)
7514 bitmap_set_bit (df
, f
->dest
->index
);
7517 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
7518 bitmap_clear_bit (df
, bb
->index
);
7520 EXECUTE_IF_SET_IN_BITMAP (df
, 0, i
, bi
)
7522 bb
= BASIC_BLOCK (i
);
7523 bitmap_set_bit (df_idom
,
7524 get_immediate_dominator (CDI_DOMINATORS
, bb
)->index
);
7528 if (cfgcleanup_altered_bbs
)
7530 /* Record the set of the altered basic blocks. */
7531 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
7532 bitmap_ior_into (cfgcleanup_altered_bbs
, df
);
7535 /* Remove E and the cancelled blocks. */
7540 /* Walk backwards so as to get a chance to substitute all
7541 released DEFs into debug stmts. See
7542 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
7544 for (i
= bbs_to_remove
.length (); i
-- > 0; )
7545 delete_basic_block (bbs_to_remove
[i
]);
7548 /* Update the dominance information. The immediate dominator may change only
7549 for blocks whose immediate dominator belongs to DF_IDOM:
7551 Suppose that idom(X) = Y before removal of E and idom(X) != Y after the
7552 removal. Let Z the arbitrary block such that idom(Z) = Y and
7553 Z dominates X after the removal. Before removal, there exists a path P
7554 from Y to X that avoids Z. Let F be the last edge on P that is
7555 removed, and let W = F->dest. Before removal, idom(W) = Y (since Y
7556 dominates W, and because of P, Z does not dominate W), and W belongs to
7557 the dominance frontier of E. Therefore, Y belongs to DF_IDOM. */
7558 EXECUTE_IF_SET_IN_BITMAP (df_idom
, 0, i
, bi
)
7560 bb
= BASIC_BLOCK (i
);
7561 for (dbb
= first_dom_son (CDI_DOMINATORS
, bb
);
7563 dbb
= next_dom_son (CDI_DOMINATORS
, dbb
))
7564 bbs_to_fix_dom
.safe_push (dbb
);
7567 iterate_fix_dominators (CDI_DOMINATORS
, bbs_to_fix_dom
, true);
7570 BITMAP_FREE (df_idom
);
7571 bbs_to_remove
.release ();
7572 bbs_to_fix_dom
.release ();
7575 /* Purge dead EH edges from basic block BB. */
7578 gimple_purge_dead_eh_edges (basic_block bb
)
7580 bool changed
= false;
7583 gimple stmt
= last_stmt (bb
);
7585 if (stmt
&& stmt_can_throw_internal (stmt
))
7588 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
7590 if (e
->flags
& EDGE_EH
)
7592 remove_edge_and_dominated_blocks (e
);
7602 /* Purge dead EH edges from basic block listed in BLOCKS. */
7605 gimple_purge_all_dead_eh_edges (const_bitmap blocks
)
7607 bool changed
= false;
7611 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
7613 basic_block bb
= BASIC_BLOCK (i
);
7615 /* Earlier gimple_purge_dead_eh_edges could have removed
7616 this basic block already. */
7617 gcc_assert (bb
|| changed
);
7619 changed
|= gimple_purge_dead_eh_edges (bb
);
7625 /* Purge dead abnormal call edges from basic block BB. */
7628 gimple_purge_dead_abnormal_call_edges (basic_block bb
)
7630 bool changed
= false;
7633 gimple stmt
= last_stmt (bb
);
7635 if (!cfun
->has_nonlocal_label
7636 && !cfun
->calls_setjmp
)
7639 if (stmt
&& stmt_can_make_abnormal_goto (stmt
))
7642 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
7644 if (e
->flags
& EDGE_ABNORMAL
)
7646 if (e
->flags
& EDGE_FALLTHRU
)
7647 e
->flags
&= ~EDGE_ABNORMAL
;
7649 remove_edge_and_dominated_blocks (e
);
7659 /* Purge dead abnormal call edges from basic block listed in BLOCKS. */
7662 gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks
)
7664 bool changed
= false;
7668 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
7670 basic_block bb
= BASIC_BLOCK (i
);
7672 /* Earlier gimple_purge_dead_abnormal_call_edges could have removed
7673 this basic block already. */
7674 gcc_assert (bb
|| changed
);
7676 changed
|= gimple_purge_dead_abnormal_call_edges (bb
);
7682 /* This function is called whenever a new edge is created or
7686 gimple_execute_on_growing_pred (edge e
)
7688 basic_block bb
= e
->dest
;
7690 if (!gimple_seq_empty_p (phi_nodes (bb
)))
7691 reserve_phi_args_for_new_edge (bb
);
7694 /* This function is called immediately before edge E is removed from
7695 the edge vector E->dest->preds. */
7698 gimple_execute_on_shrinking_pred (edge e
)
7700 if (!gimple_seq_empty_p (phi_nodes (e
->dest
)))
7701 remove_phi_args (e
);
7704 /*---------------------------------------------------------------------------
7705 Helper functions for Loop versioning
7706 ---------------------------------------------------------------------------*/
7708 /* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy
7709 of 'first'. Both of them are dominated by 'new_head' basic block. When
7710 'new_head' was created by 'second's incoming edge it received phi arguments
7711 on the edge by split_edge(). Later, additional edge 'e' was created to
7712 connect 'new_head' and 'first'. Now this routine adds phi args on this
7713 additional edge 'e' that new_head to second edge received as part of edge
7717 gimple_lv_adjust_loop_header_phi (basic_block first
, basic_block second
,
7718 basic_block new_head
, edge e
)
7721 gimple_stmt_iterator psi1
, psi2
;
7723 edge e2
= find_edge (new_head
, second
);
7725 /* Because NEW_HEAD has been created by splitting SECOND's incoming
7726 edge, we should always have an edge from NEW_HEAD to SECOND. */
7727 gcc_assert (e2
!= NULL
);
7729 /* Browse all 'second' basic block phi nodes and add phi args to
7730 edge 'e' for 'first' head. PHI args are always in correct order. */
7732 for (psi2
= gsi_start_phis (second
),
7733 psi1
= gsi_start_phis (first
);
7734 !gsi_end_p (psi2
) && !gsi_end_p (psi1
);
7735 gsi_next (&psi2
), gsi_next (&psi1
))
7737 phi1
= gsi_stmt (psi1
);
7738 phi2
= gsi_stmt (psi2
);
7739 def
= PHI_ARG_DEF (phi2
, e2
->dest_idx
);
7740 add_phi_arg (phi1
, def
, e
, gimple_phi_arg_location_from_edge (phi2
, e2
));
7745 /* Adds a if else statement to COND_BB with condition COND_EXPR.
7746 SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
7747 the destination of the ELSE part. */
7750 gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED
,
7751 basic_block second_head ATTRIBUTE_UNUSED
,
7752 basic_block cond_bb
, void *cond_e
)
7754 gimple_stmt_iterator gsi
;
7755 gimple new_cond_expr
;
7756 tree cond_expr
= (tree
) cond_e
;
7759 /* Build new conditional expr */
7760 new_cond_expr
= gimple_build_cond_from_tree (cond_expr
,
7761 NULL_TREE
, NULL_TREE
);
7763 /* Add new cond in cond_bb. */
7764 gsi
= gsi_last_bb (cond_bb
);
7765 gsi_insert_after (&gsi
, new_cond_expr
, GSI_NEW_STMT
);
7767 /* Adjust edges appropriately to connect new head with first head
7768 as well as second head. */
7769 e0
= single_succ_edge (cond_bb
);
7770 e0
->flags
&= ~EDGE_FALLTHRU
;
7771 e0
->flags
|= EDGE_FALSE_VALUE
;
7775 /* Do book-keeping of basic block BB for the profile consistency checker.
7776 If AFTER_PASS is 0, do pre-pass accounting, or if AFTER_PASS is 1
7777 then do post-pass accounting. Store the counting in RECORD. */
7779 gimple_account_profile_record (basic_block bb
, int after_pass
,
7780 struct profile_record
*record
)
7782 gimple_stmt_iterator i
;
7783 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
7785 record
->size
[after_pass
]
7786 += estimate_num_insns (gsi_stmt (i
), &eni_size_weights
);
7787 if (profile_status
== PROFILE_READ
)
7788 record
->time
[after_pass
]
7789 += estimate_num_insns (gsi_stmt (i
),
7790 &eni_time_weights
) * bb
->count
;
7791 else if (profile_status
== PROFILE_GUESSED
)
7792 record
->time
[after_pass
]
7793 += estimate_num_insns (gsi_stmt (i
),
7794 &eni_time_weights
) * bb
->frequency
;
7798 struct cfg_hooks gimple_cfg_hooks
= {
7800 gimple_verify_flow_info
,
7801 gimple_dump_bb
, /* dump_bb */
7802 gimple_dump_bb_for_graph
, /* dump_bb_for_graph */
7803 create_bb
, /* create_basic_block */
7804 gimple_redirect_edge_and_branch
, /* redirect_edge_and_branch */
7805 gimple_redirect_edge_and_branch_force
, /* redirect_edge_and_branch_force */
7806 gimple_can_remove_branch_p
, /* can_remove_branch_p */
7807 remove_bb
, /* delete_basic_block */
7808 gimple_split_block
, /* split_block */
7809 gimple_move_block_after
, /* move_block_after */
7810 gimple_can_merge_blocks_p
, /* can_merge_blocks_p */
7811 gimple_merge_blocks
, /* merge_blocks */
7812 gimple_predict_edge
, /* predict_edge */
7813 gimple_predicted_by_p
, /* predicted_by_p */
7814 gimple_can_duplicate_bb_p
, /* can_duplicate_block_p */
7815 gimple_duplicate_bb
, /* duplicate_block */
7816 gimple_split_edge
, /* split_edge */
7817 gimple_make_forwarder_block
, /* make_forward_block */
7818 NULL
, /* tidy_fallthru_edge */
7819 NULL
, /* force_nonfallthru */
7820 gimple_block_ends_with_call_p
,/* block_ends_with_call_p */
7821 gimple_block_ends_with_condjump_p
, /* block_ends_with_condjump_p */
7822 gimple_flow_call_edges_add
, /* flow_call_edges_add */
7823 gimple_execute_on_growing_pred
, /* execute_on_growing_pred */
7824 gimple_execute_on_shrinking_pred
, /* execute_on_shrinking_pred */
7825 gimple_duplicate_loop_to_header_edge
, /* duplicate loop for trees */
7826 gimple_lv_add_condition_to_bb
, /* lv_add_condition_to_bb */
7827 gimple_lv_adjust_loop_header_phi
, /* lv_adjust_loop_header_phi*/
7828 extract_true_false_edges_from_block
, /* extract_cond_bb_edges */
7829 flush_pending_stmts
, /* flush_pending_stmts */
7830 gimple_empty_block_p
, /* block_empty_p */
7831 gimple_split_block_before_cond_jump
, /* split_block_before_cond_jump */
7832 gimple_account_profile_record
,
7836 /* Split all critical edges. */
7839 split_critical_edges (void)
7845 /* split_edge can redirect edges out of SWITCH_EXPRs, which can get
7846 expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
7847 mappings around the calls to split_edge. */
7848 start_recording_case_labels ();
7851 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7853 if (EDGE_CRITICAL_P (e
) && !(e
->flags
& EDGE_ABNORMAL
))
7855 /* PRE inserts statements to edges and expects that
7856 since split_critical_edges was done beforehand, committing edge
7857 insertions will not split more edges. In addition to critical
7858 edges we must split edges that have multiple successors and
7859 end by control flow statements, such as RESX.
7860 Go ahead and split them too. This matches the logic in
7861 gimple_find_edge_insert_loc. */
7862 else if ((!single_pred_p (e
->dest
)
7863 || !gimple_seq_empty_p (phi_nodes (e
->dest
))
7864 || e
->dest
== EXIT_BLOCK_PTR
)
7865 && e
->src
!= ENTRY_BLOCK_PTR
7866 && !(e
->flags
& EDGE_ABNORMAL
))
7868 gimple_stmt_iterator gsi
;
7870 gsi
= gsi_last_bb (e
->src
);
7871 if (!gsi_end_p (gsi
)
7872 && stmt_ends_bb_p (gsi_stmt (gsi
))
7873 && (gimple_code (gsi_stmt (gsi
)) != GIMPLE_RETURN
7874 && !gimple_call_builtin_p (gsi_stmt (gsi
),
7880 end_recording_case_labels ();
7884 struct gimple_opt_pass pass_split_crit_edges
=
7888 "crited", /* name */
7889 OPTGROUP_NONE
, /* optinfo_flags */
7891 split_critical_edges
, /* execute */
7894 0, /* static_pass_number */
7895 TV_TREE_SPLIT_EDGES
, /* tv_id */
7896 PROP_cfg
, /* properties required */
7897 PROP_no_crit_edges
, /* properties_provided */
7898 0, /* properties_destroyed */
7899 0, /* todo_flags_start */
7900 TODO_verify_flow
/* todo_flags_finish */
7905 /* Build a ternary operation and gimplify it. Emit code before GSI.
7906 Return the gimple_val holding the result. */
7909 gimplify_build3 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
7910 tree type
, tree a
, tree b
, tree c
)
7913 location_t loc
= gimple_location (gsi_stmt (*gsi
));
7915 ret
= fold_build3_loc (loc
, code
, type
, a
, b
, c
);
7918 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
7922 /* Build a binary operation and gimplify it. Emit code before GSI.
7923 Return the gimple_val holding the result. */
7926 gimplify_build2 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
7927 tree type
, tree a
, tree b
)
7931 ret
= fold_build2_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
, b
);
7934 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
7938 /* Build a unary operation and gimplify it. Emit code before GSI.
7939 Return the gimple_val holding the result. */
7942 gimplify_build1 (gimple_stmt_iterator
*gsi
, enum tree_code code
, tree type
,
7947 ret
= fold_build1_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
);
7950 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
7956 /* Emit return warnings. */
7959 execute_warn_function_return (void)
7961 source_location location
;
7966 if (!targetm
.warn_func_return (cfun
->decl
))
7969 /* If we have a path to EXIT, then we do return. */
7970 if (TREE_THIS_VOLATILE (cfun
->decl
)
7971 && EDGE_COUNT (EXIT_BLOCK_PTR
->preds
) > 0)
7973 location
= UNKNOWN_LOCATION
;
7974 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
7976 last
= last_stmt (e
->src
);
7977 if ((gimple_code (last
) == GIMPLE_RETURN
7978 || gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
7979 && (location
= gimple_location (last
)) != UNKNOWN_LOCATION
)
7982 if (location
== UNKNOWN_LOCATION
)
7983 location
= cfun
->function_end_locus
;
7984 warning_at (location
, 0, "%<noreturn%> function does return");
7987 /* If we see "return;" in some basic block, then we do reach the end
7988 without returning a value. */
7989 else if (warn_return_type
7990 && !TREE_NO_WARNING (cfun
->decl
)
7991 && EDGE_COUNT (EXIT_BLOCK_PTR
->preds
) > 0
7992 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (cfun
->decl
))))
7994 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
7996 gimple last
= last_stmt (e
->src
);
7997 if (gimple_code (last
) == GIMPLE_RETURN
7998 && gimple_return_retval (last
) == NULL
7999 && !gimple_no_warning_p (last
))
8001 location
= gimple_location (last
);
8002 if (location
== UNKNOWN_LOCATION
)
8003 location
= cfun
->function_end_locus
;
8004 warning_at (location
, OPT_Wreturn_type
, "control reaches end of non-void function");
8005 TREE_NO_WARNING (cfun
->decl
) = 1;
8014 /* Given a basic block B which ends with a conditional and has
8015 precisely two successors, determine which of the edges is taken if
8016 the conditional is true and which is taken if the conditional is
8017 false. Set TRUE_EDGE and FALSE_EDGE appropriately. */
8020 extract_true_false_edges_from_block (basic_block b
,
8024 edge e
= EDGE_SUCC (b
, 0);
8026 if (e
->flags
& EDGE_TRUE_VALUE
)
8029 *false_edge
= EDGE_SUCC (b
, 1);
8034 *true_edge
= EDGE_SUCC (b
, 1);
8038 struct gimple_opt_pass pass_warn_function_return
=
8042 "*warn_function_return", /* name */
8043 OPTGROUP_NONE
, /* optinfo_flags */
8045 execute_warn_function_return
, /* execute */
8048 0, /* static_pass_number */
8049 TV_NONE
, /* tv_id */
8050 PROP_cfg
, /* properties_required */
8051 0, /* properties_provided */
8052 0, /* properties_destroyed */
8053 0, /* todo_flags_start */
8054 0 /* todo_flags_finish */
8058 /* Emit noreturn warnings. */
8061 execute_warn_function_noreturn (void)
8063 if (!TREE_THIS_VOLATILE (current_function_decl
)
8064 && EDGE_COUNT (EXIT_BLOCK_PTR
->preds
) == 0)
8065 warn_function_noreturn (current_function_decl
);
8070 gate_warn_function_noreturn (void)
8072 return warn_suggest_attribute_noreturn
;
8075 struct gimple_opt_pass pass_warn_function_noreturn
=
8079 "*warn_function_noreturn", /* name */
8080 OPTGROUP_NONE
, /* optinfo_flags */
8081 gate_warn_function_noreturn
, /* gate */
8082 execute_warn_function_noreturn
, /* execute */
8085 0, /* static_pass_number */
8086 TV_NONE
, /* tv_id */
8087 PROP_cfg
, /* properties_required */
8088 0, /* properties_provided */
8089 0, /* properties_destroyed */
8090 0, /* todo_flags_start */
8091 0 /* todo_flags_finish */
8096 /* Walk a gimplified function and warn for functions whose return value is
8097 ignored and attribute((warn_unused_result)) is set. This is done before
8098 inlining, so we don't have to worry about that. */
8101 do_warn_unused_result (gimple_seq seq
)
8104 gimple_stmt_iterator i
;
8106 for (i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
8108 gimple g
= gsi_stmt (i
);
8110 switch (gimple_code (g
))
8113 do_warn_unused_result (gimple_bind_body (g
));
8116 do_warn_unused_result (gimple_try_eval (g
));
8117 do_warn_unused_result (gimple_try_cleanup (g
));
8120 do_warn_unused_result (gimple_catch_handler (g
));
8122 case GIMPLE_EH_FILTER
:
8123 do_warn_unused_result (gimple_eh_filter_failure (g
));
8127 if (gimple_call_lhs (g
))
8129 if (gimple_call_internal_p (g
))
8132 /* This is a naked call, as opposed to a GIMPLE_CALL with an
8133 LHS. All calls whose value is ignored should be
8134 represented like this. Look for the attribute. */
8135 fdecl
= gimple_call_fndecl (g
);
8136 ftype
= gimple_call_fntype (g
);
8138 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
8140 location_t loc
= gimple_location (g
);
8143 warning_at (loc
, OPT_Wunused_result
,
8144 "ignoring return value of %qD, "
8145 "declared with attribute warn_unused_result",
8148 warning_at (loc
, OPT_Wunused_result
,
8149 "ignoring return value of function "
8150 "declared with attribute warn_unused_result");
8155 /* Not a container, not a call, or a call whose value is used. */
8162 run_warn_unused_result (void)
8164 do_warn_unused_result (gimple_body (current_function_decl
));
8169 gate_warn_unused_result (void)
8171 return flag_warn_unused_result
;
8174 struct gimple_opt_pass pass_warn_unused_result
=
8178 "*warn_unused_result", /* name */
8179 OPTGROUP_NONE
, /* optinfo_flags */
8180 gate_warn_unused_result
, /* gate */
8181 run_warn_unused_result
, /* execute */
8184 0, /* static_pass_number */
8185 TV_NONE
, /* tv_id */
8186 PROP_gimple_any
, /* properties_required */
8187 0, /* properties_provided */
8188 0, /* properties_destroyed */
8189 0, /* todo_flags_start */
8190 0, /* todo_flags_finish */
8195 /* Garbage collection support for edge_def. */
8197 extern void gt_ggc_mx (tree
&);
8198 extern void gt_ggc_mx (gimple
&);
8199 extern void gt_ggc_mx (rtx
&);
8200 extern void gt_ggc_mx (basic_block
&);
8203 gt_ggc_mx (edge_def
*e
)
8205 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8207 gt_ggc_mx (e
->dest
);
8208 if (current_ir_type () == IR_GIMPLE
)
8209 gt_ggc_mx (e
->insns
.g
);
8211 gt_ggc_mx (e
->insns
.r
);
8215 /* PCH support for edge_def. */
8217 extern void gt_pch_nx (tree
&);
8218 extern void gt_pch_nx (gimple
&);
8219 extern void gt_pch_nx (rtx
&);
8220 extern void gt_pch_nx (basic_block
&);
8223 gt_pch_nx (edge_def
*e
)
8225 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8227 gt_pch_nx (e
->dest
);
8228 if (current_ir_type () == IR_GIMPLE
)
8229 gt_pch_nx (e
->insns
.g
);
8231 gt_pch_nx (e
->insns
.r
);
8236 gt_pch_nx (edge_def
*e
, gt_pointer_operator op
, void *cookie
)
8238 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8239 op (&(e
->src
), cookie
);
8240 op (&(e
->dest
), cookie
);
8241 if (current_ir_type () == IR_GIMPLE
)
8242 op (&(e
->insns
.g
), cookie
);
8244 op (&(e
->insns
.r
), cookie
);
8245 op (&(block
), cookie
);