1 /* Control flow functions for trees.
2 Copyright (C) 2001-2013 Free Software Foundation, Inc.
3 Contributed by Diego Novillo <dnovillo@redhat.com>
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
24 #include "hash-table.h"
28 #include "basic-block.h"
32 #include "gimple-pretty-print.h"
34 #include "tree-dump.h"
35 #include "tree-pass.h"
36 #include "diagnostic-core.h"
39 #include "tree-ssa-propagate.h"
40 #include "value-prof.h"
41 #include "pointer-set.h"
42 #include "tree-inline.h"
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
);
258 const pass_data pass_data_build_cfg
=
260 GIMPLE_PASS
, /* type */
262 OPTGROUP_NONE
, /* optinfo_flags */
263 false, /* has_gate */
264 true, /* has_execute */
265 TV_TREE_CFG
, /* tv_id */
266 PROP_gimple_leh
, /* properties_required */
267 ( PROP_cfg
| PROP_loops
), /* properties_provided */
268 0, /* properties_destroyed */
269 0, /* todo_flags_start */
270 TODO_verify_stmts
, /* todo_flags_finish */
273 class pass_build_cfg
: public gimple_opt_pass
276 pass_build_cfg (gcc::context
*ctxt
)
277 : gimple_opt_pass (pass_data_build_cfg
, ctxt
)
280 /* opt_pass methods: */
281 unsigned int execute () { return execute_build_cfg (); }
283 }; // class pass_build_cfg
288 make_pass_build_cfg (gcc::context
*ctxt
)
290 return new pass_build_cfg (ctxt
);
294 /* Return true if T is a computed goto. */
297 computed_goto_p (gimple t
)
299 return (gimple_code (t
) == GIMPLE_GOTO
300 && TREE_CODE (gimple_goto_dest (t
)) != LABEL_DECL
);
304 /* Search the CFG for any computed gotos. If found, factor them to a
305 common computed goto site. Also record the location of that site so
306 that we can un-factor the gotos after we have converted back to
310 factor_computed_gotos (void)
313 tree factored_label_decl
= NULL
;
315 gimple factored_computed_goto_label
= NULL
;
316 gimple factored_computed_goto
= NULL
;
318 /* We know there are one or more computed gotos in this function.
319 Examine the last statement in each basic block to see if the block
320 ends with a computed goto. */
324 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
330 last
= gsi_stmt (gsi
);
332 /* Ignore the computed goto we create when we factor the original
334 if (last
== factored_computed_goto
)
337 /* If the last statement is a computed goto, factor it. */
338 if (computed_goto_p (last
))
342 /* The first time we find a computed goto we need to create
343 the factored goto block and the variable each original
344 computed goto will use for their goto destination. */
345 if (!factored_computed_goto
)
347 basic_block new_bb
= create_empty_bb (bb
);
348 gimple_stmt_iterator new_gsi
= gsi_start_bb (new_bb
);
350 /* Create the destination of the factored goto. Each original
351 computed goto will put its desired destination into this
352 variable and jump to the label we create immediately
354 var
= create_tmp_var (ptr_type_node
, "gotovar");
356 /* Build a label for the new block which will contain the
357 factored computed goto. */
358 factored_label_decl
= create_artificial_label (UNKNOWN_LOCATION
);
359 factored_computed_goto_label
360 = gimple_build_label (factored_label_decl
);
361 gsi_insert_after (&new_gsi
, factored_computed_goto_label
,
364 /* Build our new computed goto. */
365 factored_computed_goto
= gimple_build_goto (var
);
366 gsi_insert_after (&new_gsi
, factored_computed_goto
, GSI_NEW_STMT
);
369 /* Copy the original computed goto's destination into VAR. */
370 assignment
= gimple_build_assign (var
, gimple_goto_dest (last
));
371 gsi_insert_before (&gsi
, assignment
, GSI_SAME_STMT
);
373 /* And re-vector the computed goto to the new destination. */
374 gimple_goto_set_dest (last
, factored_label_decl
);
380 /* Build a flowgraph for the sequence of stmts SEQ. */
383 make_blocks (gimple_seq seq
)
385 gimple_stmt_iterator i
= gsi_start (seq
);
387 bool start_new_block
= true;
388 bool first_stmt_of_seq
= true;
389 basic_block bb
= ENTRY_BLOCK_PTR
;
391 while (!gsi_end_p (i
))
398 /* If the statement starts a new basic block or if we have determined
399 in a previous pass that we need to create a new block for STMT, do
401 if (start_new_block
|| stmt_starts_bb_p (stmt
, prev_stmt
))
403 if (!first_stmt_of_seq
)
404 gsi_split_seq_before (&i
, &seq
);
405 bb
= create_basic_block (seq
, NULL
, bb
);
406 start_new_block
= false;
409 /* Now add STMT to BB and create the subgraphs for special statement
411 gimple_set_bb (stmt
, bb
);
413 if (computed_goto_p (stmt
))
414 found_computed_goto
= true;
416 /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
418 if (stmt_ends_bb_p (stmt
))
420 /* If the stmt can make abnormal goto use a new temporary
421 for the assignment to the LHS. This makes sure the old value
422 of the LHS is available on the abnormal edge. Otherwise
423 we will end up with overlapping life-ranges for abnormal
425 if (gimple_has_lhs (stmt
)
426 && stmt_can_make_abnormal_goto (stmt
)
427 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt
))))
429 tree lhs
= gimple_get_lhs (stmt
);
430 tree tmp
= create_tmp_var (TREE_TYPE (lhs
), NULL
);
431 gimple s
= gimple_build_assign (lhs
, tmp
);
432 gimple_set_location (s
, gimple_location (stmt
));
433 gimple_set_block (s
, gimple_block (stmt
));
434 gimple_set_lhs (stmt
, tmp
);
435 if (TREE_CODE (TREE_TYPE (tmp
)) == COMPLEX_TYPE
436 || TREE_CODE (TREE_TYPE (tmp
)) == VECTOR_TYPE
)
437 DECL_GIMPLE_REG_P (tmp
) = 1;
438 gsi_insert_after (&i
, s
, GSI_SAME_STMT
);
440 start_new_block
= true;
444 first_stmt_of_seq
= false;
449 /* Create and return a new empty basic block after bb AFTER. */
452 create_bb (void *h
, void *e
, basic_block after
)
458 /* Create and initialize a new basic block. Since alloc_block uses
459 GC allocation that clears memory to allocate a basic block, we do
460 not have to clear the newly allocated basic block here. */
463 bb
->index
= last_basic_block
;
465 set_bb_seq (bb
, h
? (gimple_seq
) h
: NULL
);
467 /* Add the new block to the linked list of blocks. */
468 link_block (bb
, after
);
470 /* Grow the basic block array if needed. */
471 if ((size_t) last_basic_block
== basic_block_info
->length ())
473 size_t new_size
= last_basic_block
+ (last_basic_block
+ 3) / 4;
474 vec_safe_grow_cleared (basic_block_info
, new_size
);
477 /* Add the newly created block to the array. */
478 SET_BASIC_BLOCK (last_basic_block
, bb
);
487 /*---------------------------------------------------------------------------
489 ---------------------------------------------------------------------------*/
491 /* Fold COND_EXPR_COND of each COND_EXPR. */
494 fold_cond_expr_cond (void)
500 gimple stmt
= last_stmt (bb
);
502 if (stmt
&& gimple_code (stmt
) == GIMPLE_COND
)
504 location_t loc
= gimple_location (stmt
);
508 fold_defer_overflow_warnings ();
509 cond
= fold_binary_loc (loc
, gimple_cond_code (stmt
), boolean_type_node
,
510 gimple_cond_lhs (stmt
), gimple_cond_rhs (stmt
));
513 zerop
= integer_zerop (cond
);
514 onep
= integer_onep (cond
);
517 zerop
= onep
= false;
519 fold_undefer_overflow_warnings (zerop
|| onep
,
521 WARN_STRICT_OVERFLOW_CONDITIONAL
);
523 gimple_cond_make_false (stmt
);
525 gimple_cond_make_true (stmt
);
530 /* Join all the blocks in the flowgraph. */
536 struct omp_region
*cur_region
= NULL
;
538 /* Create an edge from entry to the first block with executable
540 make_edge (ENTRY_BLOCK_PTR
, BASIC_BLOCK (NUM_FIXED_BLOCKS
), EDGE_FALLTHRU
);
542 /* Traverse the basic block array placing edges. */
545 gimple last
= last_stmt (bb
);
550 enum gimple_code code
= gimple_code (last
);
554 make_goto_expr_edges (bb
);
558 make_edge (bb
, EXIT_BLOCK_PTR
, 0);
562 make_cond_expr_edges (bb
);
566 make_gimple_switch_edges (bb
);
570 make_eh_edges (last
);
573 case GIMPLE_EH_DISPATCH
:
574 fallthru
= make_eh_dispatch_edges (last
);
578 /* If this function receives a nonlocal goto, then we need to
579 make edges from this call site to all the nonlocal goto
581 if (stmt_can_make_abnormal_goto (last
))
582 make_abnormal_goto_edges (bb
, true);
584 /* If this statement has reachable exception handlers, then
585 create abnormal edges to them. */
586 make_eh_edges (last
);
588 /* BUILTIN_RETURN is really a return statement. */
589 if (gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
590 make_edge (bb
, EXIT_BLOCK_PTR
, 0), fallthru
= false;
591 /* Some calls are known not to return. */
593 fallthru
= !(gimple_call_flags (last
) & ECF_NORETURN
);
597 /* A GIMPLE_ASSIGN may throw internally and thus be considered
599 if (is_ctrl_altering_stmt (last
))
600 make_eh_edges (last
);
605 make_gimple_asm_edges (bb
);
609 case GIMPLE_OMP_PARALLEL
:
610 case GIMPLE_OMP_TASK
:
612 case GIMPLE_OMP_SINGLE
:
613 case GIMPLE_OMP_MASTER
:
614 case GIMPLE_OMP_ORDERED
:
615 case GIMPLE_OMP_CRITICAL
:
616 case GIMPLE_OMP_SECTION
:
617 cur_region
= new_omp_region (bb
, code
, cur_region
);
621 case GIMPLE_OMP_SECTIONS
:
622 cur_region
= new_omp_region (bb
, code
, cur_region
);
626 case GIMPLE_OMP_SECTIONS_SWITCH
:
630 case GIMPLE_OMP_ATOMIC_LOAD
:
631 case GIMPLE_OMP_ATOMIC_STORE
:
635 case GIMPLE_OMP_RETURN
:
636 /* In the case of a GIMPLE_OMP_SECTION, the edge will go
637 somewhere other than the next block. This will be
639 cur_region
->exit
= bb
;
640 fallthru
= cur_region
->type
!= GIMPLE_OMP_SECTION
;
641 cur_region
= cur_region
->outer
;
644 case GIMPLE_OMP_CONTINUE
:
645 cur_region
->cont
= bb
;
646 switch (cur_region
->type
)
649 /* Mark all GIMPLE_OMP_FOR and GIMPLE_OMP_CONTINUE
650 succs edges as abnormal to prevent splitting
652 single_succ_edge (cur_region
->entry
)->flags
|= EDGE_ABNORMAL
;
653 /* Make the loopback edge. */
654 make_edge (bb
, single_succ (cur_region
->entry
),
657 /* Create an edge from GIMPLE_OMP_FOR to exit, which
658 corresponds to the case that the body of the loop
659 is not executed at all. */
660 make_edge (cur_region
->entry
, bb
->next_bb
, EDGE_ABNORMAL
);
661 make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
| EDGE_ABNORMAL
);
665 case GIMPLE_OMP_SECTIONS
:
666 /* Wire up the edges into and out of the nested sections. */
668 basic_block switch_bb
= single_succ (cur_region
->entry
);
670 struct omp_region
*i
;
671 for (i
= cur_region
->inner
; i
; i
= i
->next
)
673 gcc_assert (i
->type
== GIMPLE_OMP_SECTION
);
674 make_edge (switch_bb
, i
->entry
, 0);
675 make_edge (i
->exit
, bb
, EDGE_FALLTHRU
);
678 /* Make the loopback edge to the block with
679 GIMPLE_OMP_SECTIONS_SWITCH. */
680 make_edge (bb
, switch_bb
, 0);
682 /* Make the edge from the switch to exit. */
683 make_edge (switch_bb
, bb
->next_bb
, 0);
693 case GIMPLE_TRANSACTION
:
695 tree abort_label
= gimple_transaction_label (last
);
697 make_edge (bb
, label_to_block (abort_label
), EDGE_TM_ABORT
);
703 gcc_assert (!stmt_ends_bb_p (last
));
711 make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
717 /* Fold COND_EXPR_COND of each COND_EXPR. */
718 fold_cond_expr_cond ();
721 /* Find the next available discriminator value for LOCUS. The
722 discriminator distinguishes among several basic blocks that
723 share a common locus, allowing for more accurate sample-based
727 next_discriminator_for_locus (location_t locus
)
729 struct locus_discrim_map item
;
730 struct locus_discrim_map
**slot
;
733 item
.discriminator
= 0;
734 slot
= discriminator_per_locus
.find_slot_with_hash (
735 &item
, LOCATION_LINE (locus
), INSERT
);
737 if (*slot
== HTAB_EMPTY_ENTRY
)
739 *slot
= XNEW (struct locus_discrim_map
);
741 (*slot
)->locus
= locus
;
742 (*slot
)->discriminator
= 0;
744 (*slot
)->discriminator
++;
745 return (*slot
)->discriminator
;
748 /* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line. */
751 same_line_p (location_t locus1
, location_t locus2
)
753 expanded_location from
, to
;
755 if (locus1
== locus2
)
758 from
= expand_location (locus1
);
759 to
= expand_location (locus2
);
761 if (from
.line
!= to
.line
)
763 if (from
.file
== to
.file
)
765 return (from
.file
!= NULL
767 && filename_cmp (from
.file
, to
.file
) == 0);
770 /* Assign discriminators to each basic block. */
773 assign_discriminators (void)
781 gimple last
= last_stmt (bb
);
782 location_t locus
= last
? gimple_location (last
) : UNKNOWN_LOCATION
;
784 if (locus
== UNKNOWN_LOCATION
)
787 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
789 gimple first
= first_non_label_stmt (e
->dest
);
790 gimple last
= last_stmt (e
->dest
);
791 if ((first
&& same_line_p (locus
, gimple_location (first
)))
792 || (last
&& same_line_p (locus
, gimple_location (last
))))
794 if (e
->dest
->discriminator
!= 0 && bb
->discriminator
== 0)
795 bb
->discriminator
= next_discriminator_for_locus (locus
);
797 e
->dest
->discriminator
= next_discriminator_for_locus (locus
);
803 /* Create the edges for a GIMPLE_COND starting at block BB. */
806 make_cond_expr_edges (basic_block bb
)
808 gimple entry
= last_stmt (bb
);
809 gimple then_stmt
, else_stmt
;
810 basic_block then_bb
, else_bb
;
811 tree then_label
, else_label
;
815 gcc_assert (gimple_code (entry
) == GIMPLE_COND
);
817 /* Entry basic blocks for each component. */
818 then_label
= gimple_cond_true_label (entry
);
819 else_label
= gimple_cond_false_label (entry
);
820 then_bb
= label_to_block (then_label
);
821 else_bb
= label_to_block (else_label
);
822 then_stmt
= first_stmt (then_bb
);
823 else_stmt
= first_stmt (else_bb
);
825 e
= make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
826 e
->goto_locus
= gimple_location (then_stmt
);
827 e
= make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
829 e
->goto_locus
= gimple_location (else_stmt
);
831 /* We do not need the labels anymore. */
832 gimple_cond_set_true_label (entry
, NULL_TREE
);
833 gimple_cond_set_false_label (entry
, NULL_TREE
);
837 /* Called for each element in the hash table (P) as we delete the
838 edge to cases hash table.
840 Clear all the TREE_CHAINs to prevent problems with copying of
841 SWITCH_EXPRs and structure sharing rules, then free the hash table
845 edge_to_cases_cleanup (const void *key ATTRIBUTE_UNUSED
, void **value
,
846 void *data ATTRIBUTE_UNUSED
)
850 for (t
= (tree
) *value
; t
; t
= next
)
852 next
= CASE_CHAIN (t
);
853 CASE_CHAIN (t
) = NULL
;
860 /* Start recording information mapping edges to case labels. */
863 start_recording_case_labels (void)
865 gcc_assert (edge_to_cases
== NULL
);
866 edge_to_cases
= pointer_map_create ();
867 touched_switch_bbs
= BITMAP_ALLOC (NULL
);
870 /* Return nonzero if we are recording information for case labels. */
873 recording_case_labels_p (void)
875 return (edge_to_cases
!= NULL
);
878 /* Stop recording information mapping edges to case labels and
879 remove any information we have recorded. */
881 end_recording_case_labels (void)
885 pointer_map_traverse (edge_to_cases
, edge_to_cases_cleanup
, NULL
);
886 pointer_map_destroy (edge_to_cases
);
887 edge_to_cases
= NULL
;
888 EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs
, 0, i
, bi
)
890 basic_block bb
= BASIC_BLOCK (i
);
893 gimple stmt
= last_stmt (bb
);
894 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
895 group_case_labels_stmt (stmt
);
898 BITMAP_FREE (touched_switch_bbs
);
901 /* If we are inside a {start,end}_recording_cases block, then return
902 a chain of CASE_LABEL_EXPRs from T which reference E.
904 Otherwise return NULL. */
907 get_cases_for_edge (edge e
, gimple t
)
912 /* If we are not recording cases, then we do not have CASE_LABEL_EXPR
913 chains available. Return NULL so the caller can detect this case. */
914 if (!recording_case_labels_p ())
917 slot
= pointer_map_contains (edge_to_cases
, e
);
921 /* If we did not find E in the hash table, then this must be the first
922 time we have been queried for information about E & T. Add all the
923 elements from T to the hash table then perform the query again. */
925 n
= gimple_switch_num_labels (t
);
926 for (i
= 0; i
< n
; i
++)
928 tree elt
= gimple_switch_label (t
, i
);
929 tree lab
= CASE_LABEL (elt
);
930 basic_block label_bb
= label_to_block (lab
);
931 edge this_edge
= find_edge (e
->src
, label_bb
);
933 /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
935 slot
= pointer_map_insert (edge_to_cases
, this_edge
);
936 CASE_CHAIN (elt
) = (tree
) *slot
;
940 return (tree
) *pointer_map_contains (edge_to_cases
, e
);
943 /* Create the edges for a GIMPLE_SWITCH starting at block BB. */
946 make_gimple_switch_edges (basic_block bb
)
948 gimple entry
= last_stmt (bb
);
951 n
= gimple_switch_num_labels (entry
);
953 for (i
= 0; i
< n
; ++i
)
955 tree lab
= CASE_LABEL (gimple_switch_label (entry
, i
));
956 basic_block label_bb
= label_to_block (lab
);
957 make_edge (bb
, label_bb
, 0);
962 /* Return the basic block holding label DEST. */
965 label_to_block_fn (struct function
*ifun
, tree dest
)
967 int uid
= LABEL_DECL_UID (dest
);
969 /* We would die hard when faced by an undefined label. Emit a label to
970 the very first basic block. This will hopefully make even the dataflow
971 and undefined variable warnings quite right. */
972 if (seen_error () && uid
< 0)
974 gimple_stmt_iterator gsi
= gsi_start_bb (BASIC_BLOCK (NUM_FIXED_BLOCKS
));
977 stmt
= gimple_build_label (dest
);
978 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
979 uid
= LABEL_DECL_UID (dest
);
981 if (vec_safe_length (ifun
->cfg
->x_label_to_block_map
) <= (unsigned int) uid
)
983 return (*ifun
->cfg
->x_label_to_block_map
)[uid
];
986 /* Create edges for an abnormal goto statement at block BB. If FOR_CALL
987 is true, the source statement is a CALL_EXPR instead of a GOTO_EXPR. */
990 make_abnormal_goto_edges (basic_block bb
, bool for_call
)
992 basic_block target_bb
;
993 gimple_stmt_iterator gsi
;
995 FOR_EACH_BB (target_bb
)
997 for (gsi
= gsi_start_bb (target_bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
999 gimple label_stmt
= gsi_stmt (gsi
);
1002 if (gimple_code (label_stmt
) != GIMPLE_LABEL
)
1005 target
= gimple_label_label (label_stmt
);
1007 /* Make an edge to every label block that has been marked as a
1008 potential target for a computed goto or a non-local goto. */
1009 if ((FORCED_LABEL (target
) && !for_call
)
1010 || (DECL_NONLOCAL (target
) && for_call
))
1012 make_edge (bb
, target_bb
, EDGE_ABNORMAL
);
1016 if (!gsi_end_p (gsi
)
1017 && is_gimple_debug (gsi_stmt (gsi
)))
1018 gsi_next_nondebug (&gsi
);
1019 if (!gsi_end_p (gsi
))
1021 /* Make an edge to every setjmp-like call. */
1022 gimple call_stmt
= gsi_stmt (gsi
);
1023 if (is_gimple_call (call_stmt
)
1024 && (gimple_call_flags (call_stmt
) & ECF_RETURNS_TWICE
))
1025 make_edge (bb
, target_bb
, EDGE_ABNORMAL
);
1030 /* Create edges for a goto statement at block BB. */
1033 make_goto_expr_edges (basic_block bb
)
1035 gimple_stmt_iterator last
= gsi_last_bb (bb
);
1036 gimple goto_t
= gsi_stmt (last
);
1038 /* A simple GOTO creates normal edges. */
1039 if (simple_goto_p (goto_t
))
1041 tree dest
= gimple_goto_dest (goto_t
);
1042 basic_block label_bb
= label_to_block (dest
);
1043 edge e
= make_edge (bb
, label_bb
, EDGE_FALLTHRU
);
1044 e
->goto_locus
= gimple_location (goto_t
);
1045 gsi_remove (&last
, true);
1049 /* A computed GOTO creates abnormal edges. */
1050 make_abnormal_goto_edges (bb
, false);
1053 /* Create edges for an asm statement with labels at block BB. */
1056 make_gimple_asm_edges (basic_block bb
)
1058 gimple stmt
= last_stmt (bb
);
1059 int i
, n
= gimple_asm_nlabels (stmt
);
1061 for (i
= 0; i
< n
; ++i
)
1063 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
1064 basic_block label_bb
= label_to_block (label
);
1065 make_edge (bb
, label_bb
, 0);
1069 /*---------------------------------------------------------------------------
1071 ---------------------------------------------------------------------------*/
1073 /* Cleanup useless labels in basic blocks. This is something we wish
1074 to do early because it allows us to group case labels before creating
1075 the edges for the CFG, and it speeds up block statement iterators in
1076 all passes later on.
1077 We rerun this pass after CFG is created, to get rid of the labels that
1078 are no longer referenced. After then we do not run it any more, since
1079 (almost) no new labels should be created. */
1081 /* A map from basic block index to the leading label of that block. */
1082 static struct label_record
1087 /* True if the label is referenced from somewhere. */
1091 /* Given LABEL return the first label in the same basic block. */
1094 main_block_label (tree label
)
1096 basic_block bb
= label_to_block (label
);
1097 tree main_label
= label_for_bb
[bb
->index
].label
;
1099 /* label_to_block possibly inserted undefined label into the chain. */
1102 label_for_bb
[bb
->index
].label
= label
;
1106 label_for_bb
[bb
->index
].used
= true;
1110 /* Clean up redundant labels within the exception tree. */
1113 cleanup_dead_labels_eh (void)
1120 if (cfun
->eh
== NULL
)
1123 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1124 if (lp
&& lp
->post_landing_pad
)
1126 lab
= main_block_label (lp
->post_landing_pad
);
1127 if (lab
!= lp
->post_landing_pad
)
1129 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1130 EH_LANDING_PAD_NR (lab
) = lp
->index
;
1134 FOR_ALL_EH_REGION (r
)
1138 case ERT_MUST_NOT_THROW
:
1144 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
1148 c
->label
= main_block_label (lab
);
1153 case ERT_ALLOWED_EXCEPTIONS
:
1154 lab
= r
->u
.allowed
.label
;
1156 r
->u
.allowed
.label
= main_block_label (lab
);
1162 /* Cleanup redundant labels. This is a three-step process:
1163 1) Find the leading label for each block.
1164 2) Redirect all references to labels to the leading labels.
1165 3) Cleanup all useless labels. */
1168 cleanup_dead_labels (void)
1171 label_for_bb
= XCNEWVEC (struct label_record
, last_basic_block
);
1173 /* Find a suitable label for each block. We use the first user-defined
1174 label if there is one, or otherwise just the first label we see. */
1177 gimple_stmt_iterator i
;
1179 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
1182 gimple stmt
= gsi_stmt (i
);
1184 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1187 label
= gimple_label_label (stmt
);
1189 /* If we have not yet seen a label for the current block,
1190 remember this one and see if there are more labels. */
1191 if (!label_for_bb
[bb
->index
].label
)
1193 label_for_bb
[bb
->index
].label
= label
;
1197 /* If we did see a label for the current block already, but it
1198 is an artificially created label, replace it if the current
1199 label is a user defined label. */
1200 if (!DECL_ARTIFICIAL (label
)
1201 && DECL_ARTIFICIAL (label_for_bb
[bb
->index
].label
))
1203 label_for_bb
[bb
->index
].label
= label
;
1209 /* Now redirect all jumps/branches to the selected label.
1210 First do so for each block ending in a control statement. */
1213 gimple stmt
= last_stmt (bb
);
1214 tree label
, new_label
;
1219 switch (gimple_code (stmt
))
1222 label
= gimple_cond_true_label (stmt
);
1225 new_label
= main_block_label (label
);
1226 if (new_label
!= label
)
1227 gimple_cond_set_true_label (stmt
, new_label
);
1230 label
= gimple_cond_false_label (stmt
);
1233 new_label
= main_block_label (label
);
1234 if (new_label
!= label
)
1235 gimple_cond_set_false_label (stmt
, new_label
);
1241 size_t i
, n
= gimple_switch_num_labels (stmt
);
1243 /* Replace all destination labels. */
1244 for (i
= 0; i
< n
; ++i
)
1246 tree case_label
= gimple_switch_label (stmt
, i
);
1247 label
= CASE_LABEL (case_label
);
1248 new_label
= main_block_label (label
);
1249 if (new_label
!= label
)
1250 CASE_LABEL (case_label
) = new_label
;
1257 int i
, n
= gimple_asm_nlabels (stmt
);
1259 for (i
= 0; i
< n
; ++i
)
1261 tree cons
= gimple_asm_label_op (stmt
, i
);
1262 tree label
= main_block_label (TREE_VALUE (cons
));
1263 TREE_VALUE (cons
) = label
;
1268 /* We have to handle gotos until they're removed, and we don't
1269 remove them until after we've created the CFG edges. */
1271 if (!computed_goto_p (stmt
))
1273 label
= gimple_goto_dest (stmt
);
1274 new_label
= main_block_label (label
);
1275 if (new_label
!= label
)
1276 gimple_goto_set_dest (stmt
, new_label
);
1280 case GIMPLE_TRANSACTION
:
1282 tree label
= gimple_transaction_label (stmt
);
1285 tree new_label
= main_block_label (label
);
1286 if (new_label
!= label
)
1287 gimple_transaction_set_label (stmt
, new_label
);
1297 /* Do the same for the exception region tree labels. */
1298 cleanup_dead_labels_eh ();
1300 /* Finally, purge dead labels. All user-defined labels and labels that
1301 can be the target of non-local gotos and labels which have their
1302 address taken are preserved. */
1305 gimple_stmt_iterator i
;
1306 tree label_for_this_bb
= label_for_bb
[bb
->index
].label
;
1308 if (!label_for_this_bb
)
1311 /* If the main label of the block is unused, we may still remove it. */
1312 if (!label_for_bb
[bb
->index
].used
)
1313 label_for_this_bb
= NULL
;
1315 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); )
1318 gimple stmt
= gsi_stmt (i
);
1320 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1323 label
= gimple_label_label (stmt
);
1325 if (label
== label_for_this_bb
1326 || !DECL_ARTIFICIAL (label
)
1327 || DECL_NONLOCAL (label
)
1328 || FORCED_LABEL (label
))
1331 gsi_remove (&i
, true);
1335 free (label_for_bb
);
1338 /* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
1339 the ones jumping to the same label.
1340 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
1343 group_case_labels_stmt (gimple stmt
)
1345 int old_size
= gimple_switch_num_labels (stmt
);
1346 int i
, j
, new_size
= old_size
;
1347 basic_block default_bb
= NULL
;
1349 default_bb
= label_to_block (CASE_LABEL (gimple_switch_default_label (stmt
)));
1351 /* Look for possible opportunities to merge cases. */
1353 while (i
< old_size
)
1355 tree base_case
, base_high
;
1356 basic_block base_bb
;
1358 base_case
= gimple_switch_label (stmt
, i
);
1360 gcc_assert (base_case
);
1361 base_bb
= label_to_block (CASE_LABEL (base_case
));
1363 /* Discard cases that have the same destination as the
1365 if (base_bb
== default_bb
)
1367 gimple_switch_set_label (stmt
, i
, NULL_TREE
);
1373 base_high
= CASE_HIGH (base_case
)
1374 ? CASE_HIGH (base_case
)
1375 : CASE_LOW (base_case
);
1378 /* Try to merge case labels. Break out when we reach the end
1379 of the label vector or when we cannot merge the next case
1380 label with the current one. */
1381 while (i
< old_size
)
1383 tree merge_case
= gimple_switch_label (stmt
, i
);
1384 basic_block merge_bb
= label_to_block (CASE_LABEL (merge_case
));
1385 double_int bhp1
= tree_to_double_int (base_high
) + double_int_one
;
1387 /* Merge the cases if they jump to the same place,
1388 and their ranges are consecutive. */
1389 if (merge_bb
== base_bb
1390 && tree_to_double_int (CASE_LOW (merge_case
)) == bhp1
)
1392 base_high
= CASE_HIGH (merge_case
) ?
1393 CASE_HIGH (merge_case
) : CASE_LOW (merge_case
);
1394 CASE_HIGH (base_case
) = base_high
;
1395 gimple_switch_set_label (stmt
, i
, NULL_TREE
);
1404 /* Compress the case labels in the label vector, and adjust the
1405 length of the vector. */
1406 for (i
= 0, j
= 0; i
< new_size
; i
++)
1408 while (! gimple_switch_label (stmt
, j
))
1410 gimple_switch_set_label (stmt
, i
,
1411 gimple_switch_label (stmt
, j
++));
1414 gcc_assert (new_size
<= old_size
);
1415 gimple_switch_set_num_labels (stmt
, new_size
);
1418 /* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
1419 and scan the sorted vector of cases. Combine the ones jumping to the
1423 group_case_labels (void)
1429 gimple stmt
= last_stmt (bb
);
1430 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1431 group_case_labels_stmt (stmt
);
1435 /* Checks whether we can merge block B into block A. */
1438 gimple_can_merge_blocks_p (basic_block a
, basic_block b
)
1441 gimple_stmt_iterator gsi
;
1443 if (!single_succ_p (a
))
1446 if (single_succ_edge (a
)->flags
& EDGE_COMPLEX
)
1449 if (single_succ (a
) != b
)
1452 if (!single_pred_p (b
))
1455 if (b
== EXIT_BLOCK_PTR
)
1458 /* If A ends by a statement causing exceptions or something similar, we
1459 cannot merge the blocks. */
1460 stmt
= last_stmt (a
);
1461 if (stmt
&& stmt_ends_bb_p (stmt
))
1464 /* Do not allow a block with only a non-local label to be merged. */
1466 && gimple_code (stmt
) == GIMPLE_LABEL
1467 && DECL_NONLOCAL (gimple_label_label (stmt
)))
1470 /* Examine the labels at the beginning of B. */
1471 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1474 stmt
= gsi_stmt (gsi
);
1475 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1477 lab
= gimple_label_label (stmt
);
1479 /* Do not remove user forced labels or for -O0 any user labels. */
1480 if (!DECL_ARTIFICIAL (lab
) && (!optimize
|| FORCED_LABEL (lab
)))
1484 /* Protect the loop latches. */
1485 if (current_loops
&& b
->loop_father
->latch
== b
)
1488 /* It must be possible to eliminate all phi nodes in B. If ssa form
1489 is not up-to-date and a name-mapping is registered, we cannot eliminate
1490 any phis. Symbols marked for renaming are never a problem though. */
1491 for (gsi
= gsi_start_phis (b
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1493 gimple phi
= gsi_stmt (gsi
);
1494 /* Technically only new names matter. */
1495 if (name_registered_for_update_p (PHI_RESULT (phi
)))
1499 /* When not optimizing, don't merge if we'd lose goto_locus. */
1501 && single_succ_edge (a
)->goto_locus
!= UNKNOWN_LOCATION
)
1503 location_t goto_locus
= single_succ_edge (a
)->goto_locus
;
1504 gimple_stmt_iterator prev
, next
;
1505 prev
= gsi_last_nondebug_bb (a
);
1506 next
= gsi_after_labels (b
);
1507 if (!gsi_end_p (next
) && is_gimple_debug (gsi_stmt (next
)))
1508 gsi_next_nondebug (&next
);
1509 if ((gsi_end_p (prev
)
1510 || gimple_location (gsi_stmt (prev
)) != goto_locus
)
1511 && (gsi_end_p (next
)
1512 || gimple_location (gsi_stmt (next
)) != goto_locus
))
1519 /* Return true if the var whose chain of uses starts at PTR has no
1522 has_zero_uses_1 (const ssa_use_operand_t
*head
)
1524 const ssa_use_operand_t
*ptr
;
1526 for (ptr
= head
->next
; ptr
!= head
; ptr
= ptr
->next
)
1527 if (!is_gimple_debug (USE_STMT (ptr
)))
1533 /* Return true if the var whose chain of uses starts at PTR has a
1534 single nondebug use. Set USE_P and STMT to that single nondebug
1535 use, if so, or to NULL otherwise. */
1537 single_imm_use_1 (const ssa_use_operand_t
*head
,
1538 use_operand_p
*use_p
, gimple
*stmt
)
1540 ssa_use_operand_t
*ptr
, *single_use
= 0;
1542 for (ptr
= head
->next
; ptr
!= head
; ptr
= ptr
->next
)
1543 if (!is_gimple_debug (USE_STMT (ptr
)))
1554 *use_p
= single_use
;
1557 *stmt
= single_use
? single_use
->loc
.stmt
: NULL
;
1559 return !!single_use
;
1562 /* Replaces all uses of NAME by VAL. */
1565 replace_uses_by (tree name
, tree val
)
1567 imm_use_iterator imm_iter
;
1572 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, name
)
1574 FOR_EACH_IMM_USE_ON_STMT (use
, imm_iter
)
1576 replace_exp (use
, val
);
1578 if (gimple_code (stmt
) == GIMPLE_PHI
)
1580 e
= gimple_phi_arg_edge (stmt
, PHI_ARG_INDEX_FROM_USE (use
));
1581 if (e
->flags
& EDGE_ABNORMAL
)
1583 /* This can only occur for virtual operands, since
1584 for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
1585 would prevent replacement. */
1586 gcc_checking_assert (virtual_operand_p (name
));
1587 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val
) = 1;
1592 if (gimple_code (stmt
) != GIMPLE_PHI
)
1594 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
1595 gimple orig_stmt
= stmt
;
1598 /* Mark the block if we changed the last stmt in it. */
1599 if (cfgcleanup_altered_bbs
1600 && stmt_ends_bb_p (stmt
))
1601 bitmap_set_bit (cfgcleanup_altered_bbs
, gimple_bb (stmt
)->index
);
1603 /* FIXME. It shouldn't be required to keep TREE_CONSTANT
1604 on ADDR_EXPRs up-to-date on GIMPLE. Propagation will
1605 only change sth from non-invariant to invariant, and only
1606 when propagating constants. */
1607 if (is_gimple_min_invariant (val
))
1608 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1610 tree op
= gimple_op (stmt
, i
);
1611 /* Operands may be empty here. For example, the labels
1612 of a GIMPLE_COND are nulled out following the creation
1613 of the corresponding CFG edges. */
1614 if (op
&& TREE_CODE (op
) == ADDR_EXPR
)
1615 recompute_tree_invariant_for_addr_expr (op
);
1618 if (fold_stmt (&gsi
))
1619 stmt
= gsi_stmt (gsi
);
1621 if (maybe_clean_or_replace_eh_stmt (orig_stmt
, stmt
))
1622 gimple_purge_dead_eh_edges (gimple_bb (stmt
));
1628 gcc_checking_assert (has_zero_uses (name
));
1630 /* Also update the trees stored in loop structures. */
1636 FOR_EACH_LOOP (li
, loop
, 0)
1638 substitute_in_loop_info (loop
, name
, val
);
1643 /* Merge block B into block A. */
1646 gimple_merge_blocks (basic_block a
, basic_block b
)
1648 gimple_stmt_iterator last
, gsi
, psi
;
1651 fprintf (dump_file
, "Merging blocks %d and %d\n", a
->index
, b
->index
);
1653 /* Remove all single-valued PHI nodes from block B of the form
1654 V_i = PHI <V_j> by propagating V_j to all the uses of V_i. */
1655 gsi
= gsi_last_bb (a
);
1656 for (psi
= gsi_start_phis (b
); !gsi_end_p (psi
); )
1658 gimple phi
= gsi_stmt (psi
);
1659 tree def
= gimple_phi_result (phi
), use
= gimple_phi_arg_def (phi
, 0);
1661 bool may_replace_uses
= (virtual_operand_p (def
)
1662 || may_propagate_copy (def
, use
));
1664 /* In case we maintain loop closed ssa form, do not propagate arguments
1665 of loop exit phi nodes. */
1667 && loops_state_satisfies_p (LOOP_CLOSED_SSA
)
1668 && !virtual_operand_p (def
)
1669 && TREE_CODE (use
) == SSA_NAME
1670 && a
->loop_father
!= b
->loop_father
)
1671 may_replace_uses
= false;
1673 if (!may_replace_uses
)
1675 gcc_assert (!virtual_operand_p (def
));
1677 /* Note that just emitting the copies is fine -- there is no problem
1678 with ordering of phi nodes. This is because A is the single
1679 predecessor of B, therefore results of the phi nodes cannot
1680 appear as arguments of the phi nodes. */
1681 copy
= gimple_build_assign (def
, use
);
1682 gsi_insert_after (&gsi
, copy
, GSI_NEW_STMT
);
1683 remove_phi_node (&psi
, false);
1687 /* If we deal with a PHI for virtual operands, we can simply
1688 propagate these without fussing with folding or updating
1690 if (virtual_operand_p (def
))
1692 imm_use_iterator iter
;
1693 use_operand_p use_p
;
1696 FOR_EACH_IMM_USE_STMT (stmt
, iter
, def
)
1697 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
1698 SET_USE (use_p
, use
);
1700 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
1701 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use
) = 1;
1704 replace_uses_by (def
, use
);
1706 remove_phi_node (&psi
, true);
1710 /* Ensure that B follows A. */
1711 move_block_after (b
, a
);
1713 gcc_assert (single_succ_edge (a
)->flags
& EDGE_FALLTHRU
);
1714 gcc_assert (!last_stmt (a
) || !stmt_ends_bb_p (last_stmt (a
)));
1716 /* Remove labels from B and set gimple_bb to A for other statements. */
1717 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
);)
1719 gimple stmt
= gsi_stmt (gsi
);
1720 if (gimple_code (stmt
) == GIMPLE_LABEL
)
1722 tree label
= gimple_label_label (stmt
);
1725 gsi_remove (&gsi
, false);
1727 /* Now that we can thread computed gotos, we might have
1728 a situation where we have a forced label in block B
1729 However, the label at the start of block B might still be
1730 used in other ways (think about the runtime checking for
1731 Fortran assigned gotos). So we can not just delete the
1732 label. Instead we move the label to the start of block A. */
1733 if (FORCED_LABEL (label
))
1735 gimple_stmt_iterator dest_gsi
= gsi_start_bb (a
);
1736 gsi_insert_before (&dest_gsi
, stmt
, GSI_NEW_STMT
);
1738 /* Other user labels keep around in a form of a debug stmt. */
1739 else if (!DECL_ARTIFICIAL (label
) && MAY_HAVE_DEBUG_STMTS
)
1741 gimple dbg
= gimple_build_debug_bind (label
,
1744 gimple_debug_bind_reset_value (dbg
);
1745 gsi_insert_before (&gsi
, dbg
, GSI_SAME_STMT
);
1748 lp_nr
= EH_LANDING_PAD_NR (label
);
1751 eh_landing_pad lp
= get_eh_landing_pad_from_number (lp_nr
);
1752 lp
->post_landing_pad
= NULL
;
1757 gimple_set_bb (stmt
, a
);
1762 /* Merge the sequences. */
1763 last
= gsi_last_bb (a
);
1764 gsi_insert_seq_after (&last
, bb_seq (b
), GSI_NEW_STMT
);
1765 set_bb_seq (b
, NULL
);
1767 if (cfgcleanup_altered_bbs
)
1768 bitmap_set_bit (cfgcleanup_altered_bbs
, a
->index
);
1772 /* Return the one of two successors of BB that is not reachable by a
1773 complex edge, if there is one. Else, return BB. We use
1774 this in optimizations that use post-dominators for their heuristics,
1775 to catch the cases in C++ where function calls are involved. */
1778 single_noncomplex_succ (basic_block bb
)
1781 if (EDGE_COUNT (bb
->succs
) != 2)
1784 e0
= EDGE_SUCC (bb
, 0);
1785 e1
= EDGE_SUCC (bb
, 1);
1786 if (e0
->flags
& EDGE_COMPLEX
)
1788 if (e1
->flags
& EDGE_COMPLEX
)
1794 /* T is CALL_EXPR. Set current_function_calls_* flags. */
1797 notice_special_calls (gimple call
)
1799 int flags
= gimple_call_flags (call
);
1801 if (flags
& ECF_MAY_BE_ALLOCA
)
1802 cfun
->calls_alloca
= true;
1803 if (flags
& ECF_RETURNS_TWICE
)
1804 cfun
->calls_setjmp
= true;
1808 /* Clear flags set by notice_special_calls. Used by dead code removal
1809 to update the flags. */
1812 clear_special_calls (void)
1814 cfun
->calls_alloca
= false;
1815 cfun
->calls_setjmp
= false;
1818 /* Remove PHI nodes associated with basic block BB and all edges out of BB. */
1821 remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb
)
1823 /* Since this block is no longer reachable, we can just delete all
1824 of its PHI nodes. */
1825 remove_phi_nodes (bb
);
1827 /* Remove edges to BB's successors. */
1828 while (EDGE_COUNT (bb
->succs
) > 0)
1829 remove_edge (EDGE_SUCC (bb
, 0));
1833 /* Remove statements of basic block BB. */
1836 remove_bb (basic_block bb
)
1838 gimple_stmt_iterator i
;
1842 fprintf (dump_file
, "Removing basic block %d\n", bb
->index
);
1843 if (dump_flags
& TDF_DETAILS
)
1845 dump_bb (dump_file
, bb
, 0, dump_flags
);
1846 fprintf (dump_file
, "\n");
1852 struct loop
*loop
= bb
->loop_father
;
1854 /* If a loop gets removed, clean up the information associated
1856 if (loop
->latch
== bb
1857 || loop
->header
== bb
)
1858 free_numbers_of_iterations_estimates_loop (loop
);
1861 /* Remove all the instructions in the block. */
1862 if (bb_seq (bb
) != NULL
)
1864 /* Walk backwards so as to get a chance to substitute all
1865 released DEFs into debug stmts. See
1866 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
1868 for (i
= gsi_last_bb (bb
); !gsi_end_p (i
);)
1870 gimple stmt
= gsi_stmt (i
);
1871 if (gimple_code (stmt
) == GIMPLE_LABEL
1872 && (FORCED_LABEL (gimple_label_label (stmt
))
1873 || DECL_NONLOCAL (gimple_label_label (stmt
))))
1876 gimple_stmt_iterator new_gsi
;
1878 /* A non-reachable non-local label may still be referenced.
1879 But it no longer needs to carry the extra semantics of
1881 if (DECL_NONLOCAL (gimple_label_label (stmt
)))
1883 DECL_NONLOCAL (gimple_label_label (stmt
)) = 0;
1884 FORCED_LABEL (gimple_label_label (stmt
)) = 1;
1887 new_bb
= bb
->prev_bb
;
1888 new_gsi
= gsi_start_bb (new_bb
);
1889 gsi_remove (&i
, false);
1890 gsi_insert_before (&new_gsi
, stmt
, GSI_NEW_STMT
);
1894 /* Release SSA definitions if we are in SSA. Note that we
1895 may be called when not in SSA. For example,
1896 final_cleanup calls this function via
1897 cleanup_tree_cfg. */
1898 if (gimple_in_ssa_p (cfun
))
1899 release_defs (stmt
);
1901 gsi_remove (&i
, true);
1905 i
= gsi_last_bb (bb
);
1911 remove_phi_nodes_and_edges_for_unreachable_block (bb
);
1912 bb
->il
.gimple
.seq
= NULL
;
1913 bb
->il
.gimple
.phi_nodes
= NULL
;
1917 /* Given a basic block BB ending with COND_EXPR or SWITCH_EXPR, and a
1918 predicate VAL, return the edge that will be taken out of the block.
1919 If VAL does not match a unique edge, NULL is returned. */
1922 find_taken_edge (basic_block bb
, tree val
)
1926 stmt
= last_stmt (bb
);
1929 gcc_assert (is_ctrl_stmt (stmt
));
1934 if (!is_gimple_min_invariant (val
))
1937 if (gimple_code (stmt
) == GIMPLE_COND
)
1938 return find_taken_edge_cond_expr (bb
, val
);
1940 if (gimple_code (stmt
) == GIMPLE_SWITCH
)
1941 return find_taken_edge_switch_expr (bb
, val
);
1943 if (computed_goto_p (stmt
))
1945 /* Only optimize if the argument is a label, if the argument is
1946 not a label then we can not construct a proper CFG.
1948 It may be the case that we only need to allow the LABEL_REF to
1949 appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
1950 appear inside a LABEL_EXPR just to be safe. */
1951 if ((TREE_CODE (val
) == ADDR_EXPR
|| TREE_CODE (val
) == LABEL_EXPR
)
1952 && TREE_CODE (TREE_OPERAND (val
, 0)) == LABEL_DECL
)
1953 return find_taken_edge_computed_goto (bb
, TREE_OPERAND (val
, 0));
1960 /* Given a constant value VAL and the entry block BB to a GOTO_EXPR
1961 statement, determine which of the outgoing edges will be taken out of the
1962 block. Return NULL if either edge may be taken. */
1965 find_taken_edge_computed_goto (basic_block bb
, tree val
)
1970 dest
= label_to_block (val
);
1973 e
= find_edge (bb
, dest
);
1974 gcc_assert (e
!= NULL
);
1980 /* Given a constant value VAL and the entry block BB to a COND_EXPR
1981 statement, determine which of the two edges will be taken out of the
1982 block. Return NULL if either edge may be taken. */
1985 find_taken_edge_cond_expr (basic_block bb
, tree val
)
1987 edge true_edge
, false_edge
;
1989 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
1991 gcc_assert (TREE_CODE (val
) == INTEGER_CST
);
1992 return (integer_zerop (val
) ? false_edge
: true_edge
);
1995 /* Given an INTEGER_CST VAL and the entry block BB to a SWITCH_EXPR
1996 statement, determine which edge will be taken out of the block. Return
1997 NULL if any edge may be taken. */
2000 find_taken_edge_switch_expr (basic_block bb
, tree val
)
2002 basic_block dest_bb
;
2007 switch_stmt
= last_stmt (bb
);
2008 taken_case
= find_case_label_for_value (switch_stmt
, val
);
2009 dest_bb
= label_to_block (CASE_LABEL (taken_case
));
2011 e
= find_edge (bb
, dest_bb
);
2017 /* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
2018 We can make optimal use here of the fact that the case labels are
2019 sorted: We can do a binary search for a case matching VAL. */
2022 find_case_label_for_value (gimple switch_stmt
, tree val
)
2024 size_t low
, high
, n
= gimple_switch_num_labels (switch_stmt
);
2025 tree default_case
= gimple_switch_default_label (switch_stmt
);
2027 for (low
= 0, high
= n
; high
- low
> 1; )
2029 size_t i
= (high
+ low
) / 2;
2030 tree t
= gimple_switch_label (switch_stmt
, i
);
2033 /* Cache the result of comparing CASE_LOW and val. */
2034 cmp
= tree_int_cst_compare (CASE_LOW (t
), val
);
2041 if (CASE_HIGH (t
) == NULL
)
2043 /* A singe-valued case label. */
2049 /* A case range. We can only handle integer ranges. */
2050 if (cmp
<= 0 && tree_int_cst_compare (CASE_HIGH (t
), val
) >= 0)
2055 return default_case
;
2059 /* Dump a basic block on stderr. */
2062 gimple_debug_bb (basic_block bb
)
2064 dump_bb (stderr
, bb
, 0, TDF_VOPS
|TDF_MEMSYMS
|TDF_BLOCKS
);
2068 /* Dump basic block with index N on stderr. */
2071 gimple_debug_bb_n (int n
)
2073 gimple_debug_bb (BASIC_BLOCK (n
));
2074 return BASIC_BLOCK (n
);
2078 /* Dump the CFG on stderr.
2080 FLAGS are the same used by the tree dumping functions
2081 (see TDF_* in dumpfile.h). */
2084 gimple_debug_cfg (int flags
)
2086 gimple_dump_cfg (stderr
, flags
);
2090 /* Dump the program showing basic block boundaries on the given FILE.
2092 FLAGS are the same used by the tree dumping functions (see TDF_* in
2096 gimple_dump_cfg (FILE *file
, int flags
)
2098 if (flags
& TDF_DETAILS
)
2100 dump_function_header (file
, current_function_decl
, flags
);
2101 fprintf (file
, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
2102 n_basic_blocks
, n_edges
, last_basic_block
);
2104 brief_dump_cfg (file
, flags
| TDF_COMMENT
);
2105 fprintf (file
, "\n");
2108 if (flags
& TDF_STATS
)
2109 dump_cfg_stats (file
);
2111 dump_function_to_file (current_function_decl
, file
, flags
| TDF_BLOCKS
);
2115 /* Dump CFG statistics on FILE. */
2118 dump_cfg_stats (FILE *file
)
2120 static long max_num_merged_labels
= 0;
2121 unsigned long size
, total
= 0;
2124 const char * const fmt_str
= "%-30s%-13s%12s\n";
2125 const char * const fmt_str_1
= "%-30s%13d%11lu%c\n";
2126 const char * const fmt_str_2
= "%-30s%13ld%11lu%c\n";
2127 const char * const fmt_str_3
= "%-43s%11lu%c\n";
2128 const char *funcname
= current_function_name ();
2130 fprintf (file
, "\nCFG Statistics for %s\n\n", funcname
);
2132 fprintf (file
, "---------------------------------------------------------\n");
2133 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
2134 fprintf (file
, fmt_str
, "", " instances ", "used ");
2135 fprintf (file
, "---------------------------------------------------------\n");
2137 size
= n_basic_blocks
* sizeof (struct basic_block_def
);
2139 fprintf (file
, fmt_str_1
, "Basic blocks", n_basic_blocks
,
2140 SCALE (size
), LABEL (size
));
2144 num_edges
+= EDGE_COUNT (bb
->succs
);
2145 size
= num_edges
* sizeof (struct edge_def
);
2147 fprintf (file
, fmt_str_2
, "Edges", num_edges
, SCALE (size
), LABEL (size
));
2149 fprintf (file
, "---------------------------------------------------------\n");
2150 fprintf (file
, fmt_str_3
, "Total memory used by CFG data", SCALE (total
),
2152 fprintf (file
, "---------------------------------------------------------\n");
2153 fprintf (file
, "\n");
2155 if (cfg_stats
.num_merged_labels
> max_num_merged_labels
)
2156 max_num_merged_labels
= cfg_stats
.num_merged_labels
;
2158 fprintf (file
, "Coalesced label blocks: %ld (Max so far: %ld)\n",
2159 cfg_stats
.num_merged_labels
, max_num_merged_labels
);
2161 fprintf (file
, "\n");
2165 /* Dump CFG statistics on stderr. Keep extern so that it's always
2166 linked in the final executable. */
2169 debug_cfg_stats (void)
2171 dump_cfg_stats (stderr
);
2174 /*---------------------------------------------------------------------------
2175 Miscellaneous helpers
2176 ---------------------------------------------------------------------------*/
2178 /* Return true if T, a GIMPLE_CALL, can make an abnormal transfer of control
2179 flow. Transfers of control flow associated with EH are excluded. */
2182 call_can_make_abnormal_goto (gimple t
)
2184 /* If the function has no non-local labels, then a call cannot make an
2185 abnormal transfer of control. */
2186 if (!cfun
->has_nonlocal_label
2187 && !cfun
->calls_setjmp
)
2190 /* Likewise if the call has no side effects. */
2191 if (!gimple_has_side_effects (t
))
2194 /* Likewise if the called function is leaf. */
2195 if (gimple_call_flags (t
) & ECF_LEAF
)
2202 /* Return true if T can make an abnormal transfer of control flow.
2203 Transfers of control flow associated with EH are excluded. */
2206 stmt_can_make_abnormal_goto (gimple t
)
2208 if (computed_goto_p (t
))
2210 if (is_gimple_call (t
))
2211 return call_can_make_abnormal_goto (t
);
2216 /* Return true if T represents a stmt that always transfers control. */
2219 is_ctrl_stmt (gimple t
)
2221 switch (gimple_code (t
))
2235 /* Return true if T is a statement that may alter the flow of control
2236 (e.g., a call to a non-returning function). */
2239 is_ctrl_altering_stmt (gimple t
)
2243 switch (gimple_code (t
))
2247 int flags
= gimple_call_flags (t
);
2249 /* A call alters control flow if it can make an abnormal goto. */
2250 if (call_can_make_abnormal_goto (t
))
2253 /* A call also alters control flow if it does not return. */
2254 if (flags
& ECF_NORETURN
)
2257 /* TM ending statements have backedges out of the transaction.
2258 Return true so we split the basic block containing them.
2259 Note that the TM_BUILTIN test is merely an optimization. */
2260 if ((flags
& ECF_TM_BUILTIN
)
2261 && is_tm_ending_fndecl (gimple_call_fndecl (t
)))
2264 /* BUILT_IN_RETURN call is same as return statement. */
2265 if (gimple_call_builtin_p (t
, BUILT_IN_RETURN
))
2270 case GIMPLE_EH_DISPATCH
:
2271 /* EH_DISPATCH branches to the individual catch handlers at
2272 this level of a try or allowed-exceptions region. It can
2273 fallthru to the next statement as well. */
2277 if (gimple_asm_nlabels (t
) > 0)
2282 /* OpenMP directives alter control flow. */
2285 case GIMPLE_TRANSACTION
:
2286 /* A transaction start alters control flow. */
2293 /* If a statement can throw, it alters control flow. */
2294 return stmt_can_throw_internal (t
);
2298 /* Return true if T is a simple local goto. */
2301 simple_goto_p (gimple t
)
2303 return (gimple_code (t
) == GIMPLE_GOTO
2304 && TREE_CODE (gimple_goto_dest (t
)) == LABEL_DECL
);
2308 /* Return true if STMT should start a new basic block. PREV_STMT is
2309 the statement preceding STMT. It is used when STMT is a label or a
2310 case label. Labels should only start a new basic block if their
2311 previous statement wasn't a label. Otherwise, sequence of labels
2312 would generate unnecessary basic blocks that only contain a single
2316 stmt_starts_bb_p (gimple stmt
, gimple prev_stmt
)
2321 /* Labels start a new basic block only if the preceding statement
2322 wasn't a label of the same type. This prevents the creation of
2323 consecutive blocks that have nothing but a single label. */
2324 if (gimple_code (stmt
) == GIMPLE_LABEL
)
2326 /* Nonlocal and computed GOTO targets always start a new block. */
2327 if (DECL_NONLOCAL (gimple_label_label (stmt
))
2328 || FORCED_LABEL (gimple_label_label (stmt
)))
2331 if (prev_stmt
&& gimple_code (prev_stmt
) == GIMPLE_LABEL
)
2333 if (DECL_NONLOCAL (gimple_label_label (prev_stmt
)))
2336 cfg_stats
.num_merged_labels
++;
2342 else if (gimple_code (stmt
) == GIMPLE_CALL
2343 && gimple_call_flags (stmt
) & ECF_RETURNS_TWICE
)
2344 /* setjmp acts similar to a nonlocal GOTO target and thus should
2345 start a new block. */
2352 /* Return true if T should end a basic block. */
2355 stmt_ends_bb_p (gimple t
)
2357 return is_ctrl_stmt (t
) || is_ctrl_altering_stmt (t
);
2360 /* Remove block annotations and other data structures. */
2363 delete_tree_cfg_annotations (void)
2365 vec_free (label_to_block_map
);
2369 /* Return the first statement in basic block BB. */
2372 first_stmt (basic_block bb
)
2374 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2377 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2385 /* Return the first non-label statement in basic block BB. */
2388 first_non_label_stmt (basic_block bb
)
2390 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2391 while (!gsi_end_p (i
) && gimple_code (gsi_stmt (i
)) == GIMPLE_LABEL
)
2393 return !gsi_end_p (i
) ? gsi_stmt (i
) : NULL
;
2396 /* Return the last statement in basic block BB. */
2399 last_stmt (basic_block bb
)
2401 gimple_stmt_iterator i
= gsi_last_bb (bb
);
2404 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2412 /* Return the last statement of an otherwise empty block. Return NULL
2413 if the block is totally empty, or if it contains more than one
2417 last_and_only_stmt (basic_block bb
)
2419 gimple_stmt_iterator i
= gsi_last_nondebug_bb (bb
);
2425 last
= gsi_stmt (i
);
2426 gsi_prev_nondebug (&i
);
2430 /* Empty statements should no longer appear in the instruction stream.
2431 Everything that might have appeared before should be deleted by
2432 remove_useless_stmts, and the optimizers should just gsi_remove
2433 instead of smashing with build_empty_stmt.
2435 Thus the only thing that should appear here in a block containing
2436 one executable statement is a label. */
2437 prev
= gsi_stmt (i
);
2438 if (gimple_code (prev
) == GIMPLE_LABEL
)
2444 /* Reinstall those PHI arguments queued in OLD_EDGE to NEW_EDGE. */
2447 reinstall_phi_args (edge new_edge
, edge old_edge
)
2449 edge_var_map_vector
*v
;
2452 gimple_stmt_iterator phis
;
2454 v
= redirect_edge_var_map_vector (old_edge
);
2458 for (i
= 0, phis
= gsi_start_phis (new_edge
->dest
);
2459 v
->iterate (i
, &vm
) && !gsi_end_p (phis
);
2460 i
++, gsi_next (&phis
))
2462 gimple phi
= gsi_stmt (phis
);
2463 tree result
= redirect_edge_var_map_result (vm
);
2464 tree arg
= redirect_edge_var_map_def (vm
);
2466 gcc_assert (result
== gimple_phi_result (phi
));
2468 add_phi_arg (phi
, arg
, new_edge
, redirect_edge_var_map_location (vm
));
2471 redirect_edge_var_map_clear (old_edge
);
2474 /* Returns the basic block after which the new basic block created
2475 by splitting edge EDGE_IN should be placed. Tries to keep the new block
2476 near its "logical" location. This is of most help to humans looking
2477 at debugging dumps. */
2480 split_edge_bb_loc (edge edge_in
)
2482 basic_block dest
= edge_in
->dest
;
2483 basic_block dest_prev
= dest
->prev_bb
;
2487 edge e
= find_edge (dest_prev
, dest
);
2488 if (e
&& !(e
->flags
& EDGE_COMPLEX
))
2489 return edge_in
->src
;
2494 /* Split a (typically critical) edge EDGE_IN. Return the new block.
2495 Abort on abnormal edges. */
2498 gimple_split_edge (edge edge_in
)
2500 basic_block new_bb
, after_bb
, dest
;
2503 /* Abnormal edges cannot be split. */
2504 gcc_assert (!(edge_in
->flags
& EDGE_ABNORMAL
));
2506 dest
= edge_in
->dest
;
2508 after_bb
= split_edge_bb_loc (edge_in
);
2510 new_bb
= create_empty_bb (after_bb
);
2511 new_bb
->frequency
= EDGE_FREQUENCY (edge_in
);
2512 new_bb
->count
= edge_in
->count
;
2513 new_edge
= make_edge (new_bb
, dest
, EDGE_FALLTHRU
);
2514 new_edge
->probability
= REG_BR_PROB_BASE
;
2515 new_edge
->count
= edge_in
->count
;
2517 e
= redirect_edge_and_branch (edge_in
, new_bb
);
2518 gcc_assert (e
== edge_in
);
2519 reinstall_phi_args (new_edge
, e
);
2525 /* Verify properties of the address expression T with base object BASE. */
2528 verify_address (tree t
, tree base
)
2531 bool old_side_effects
;
2533 bool new_side_effects
;
2535 old_constant
= TREE_CONSTANT (t
);
2536 old_side_effects
= TREE_SIDE_EFFECTS (t
);
2538 recompute_tree_invariant_for_addr_expr (t
);
2539 new_side_effects
= TREE_SIDE_EFFECTS (t
);
2540 new_constant
= TREE_CONSTANT (t
);
2542 if (old_constant
!= new_constant
)
2544 error ("constant not recomputed when ADDR_EXPR changed");
2547 if (old_side_effects
!= new_side_effects
)
2549 error ("side effects not recomputed when ADDR_EXPR changed");
2553 if (!(TREE_CODE (base
) == VAR_DECL
2554 || TREE_CODE (base
) == PARM_DECL
2555 || TREE_CODE (base
) == RESULT_DECL
))
2558 if (DECL_GIMPLE_REG_P (base
))
2560 error ("DECL_GIMPLE_REG_P set on a variable with address taken");
2567 /* Callback for walk_tree, check that all elements with address taken are
2568 properly noticed as such. The DATA is an int* that is 1 if TP was seen
2569 inside a PHI node. */
2572 verify_expr (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
2579 /* Check operand N for being valid GIMPLE and give error MSG if not. */
2580 #define CHECK_OP(N, MSG) \
2581 do { if (!is_gimple_val (TREE_OPERAND (t, N))) \
2582 { error (MSG); return TREE_OPERAND (t, N); }} while (0)
2584 switch (TREE_CODE (t
))
2587 if (SSA_NAME_IN_FREE_LIST (t
))
2589 error ("SSA name in freelist but still referenced");
2595 error ("INDIRECT_REF in gimple IL");
2599 x
= TREE_OPERAND (t
, 0);
2600 if (!POINTER_TYPE_P (TREE_TYPE (x
))
2601 || !is_gimple_mem_ref_addr (x
))
2603 error ("invalid first operand of MEM_REF");
2606 if (TREE_CODE (TREE_OPERAND (t
, 1)) != INTEGER_CST
2607 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 1))))
2609 error ("invalid offset operand of MEM_REF");
2610 return TREE_OPERAND (t
, 1);
2612 if (TREE_CODE (x
) == ADDR_EXPR
2613 && (x
= verify_address (x
, TREE_OPERAND (x
, 0))))
2619 x
= fold (ASSERT_EXPR_COND (t
));
2620 if (x
== boolean_false_node
)
2622 error ("ASSERT_EXPR with an always-false condition");
2628 error ("MODIFY_EXPR not expected while having tuples");
2635 gcc_assert (is_gimple_address (t
));
2637 /* Skip any references (they will be checked when we recurse down the
2638 tree) and ensure that any variable used as a prefix is marked
2640 for (x
= TREE_OPERAND (t
, 0);
2641 handled_component_p (x
);
2642 x
= TREE_OPERAND (x
, 0))
2645 if ((tem
= verify_address (t
, x
)))
2648 if (!(TREE_CODE (x
) == VAR_DECL
2649 || TREE_CODE (x
) == PARM_DECL
2650 || TREE_CODE (x
) == RESULT_DECL
))
2653 if (!TREE_ADDRESSABLE (x
))
2655 error ("address taken, but ADDRESSABLE bit not set");
2663 x
= COND_EXPR_COND (t
);
2664 if (!INTEGRAL_TYPE_P (TREE_TYPE (x
)))
2666 error ("non-integral used in condition");
2669 if (!is_gimple_condexpr (x
))
2671 error ("invalid conditional operand");
2676 case NON_LVALUE_EXPR
:
2677 case TRUTH_NOT_EXPR
:
2681 case FIX_TRUNC_EXPR
:
2686 CHECK_OP (0, "invalid operand to unary operator");
2692 if (!is_gimple_reg_type (TREE_TYPE (t
)))
2694 error ("non-scalar BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR");
2698 if (TREE_CODE (t
) == BIT_FIELD_REF
)
2700 if (!host_integerp (TREE_OPERAND (t
, 1), 1)
2701 || !host_integerp (TREE_OPERAND (t
, 2), 1))
2703 error ("invalid position or size operand to BIT_FIELD_REF");
2706 if (INTEGRAL_TYPE_P (TREE_TYPE (t
))
2707 && (TYPE_PRECISION (TREE_TYPE (t
))
2708 != TREE_INT_CST_LOW (TREE_OPERAND (t
, 1))))
2710 error ("integral result type precision does not match "
2711 "field size of BIT_FIELD_REF");
2714 else if (!INTEGRAL_TYPE_P (TREE_TYPE (t
))
2715 && TYPE_MODE (TREE_TYPE (t
)) != BLKmode
2716 && (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (t
)))
2717 != TREE_INT_CST_LOW (TREE_OPERAND (t
, 1))))
2719 error ("mode precision of non-integral result does not "
2720 "match field size of BIT_FIELD_REF");
2724 t
= TREE_OPERAND (t
, 0);
2729 case ARRAY_RANGE_REF
:
2730 case VIEW_CONVERT_EXPR
:
2731 /* We have a nest of references. Verify that each of the operands
2732 that determine where to reference is either a constant or a variable,
2733 verify that the base is valid, and then show we've already checked
2735 while (handled_component_p (t
))
2737 if (TREE_CODE (t
) == COMPONENT_REF
&& TREE_OPERAND (t
, 2))
2738 CHECK_OP (2, "invalid COMPONENT_REF offset operator");
2739 else if (TREE_CODE (t
) == ARRAY_REF
2740 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
2742 CHECK_OP (1, "invalid array index");
2743 if (TREE_OPERAND (t
, 2))
2744 CHECK_OP (2, "invalid array lower bound");
2745 if (TREE_OPERAND (t
, 3))
2746 CHECK_OP (3, "invalid array stride");
2748 else if (TREE_CODE (t
) == BIT_FIELD_REF
2749 || TREE_CODE (t
) == REALPART_EXPR
2750 || TREE_CODE (t
) == IMAGPART_EXPR
)
2752 error ("non-top-level BIT_FIELD_REF, IMAGPART_EXPR or "
2757 t
= TREE_OPERAND (t
, 0);
2760 if (!is_gimple_min_invariant (t
) && !is_gimple_lvalue (t
))
2762 error ("invalid reference prefix");
2769 /* PLUS_EXPR and MINUS_EXPR don't work on pointers, they should be done using
2770 POINTER_PLUS_EXPR. */
2771 if (POINTER_TYPE_P (TREE_TYPE (t
)))
2773 error ("invalid operand to plus/minus, type is a pointer");
2776 CHECK_OP (0, "invalid operand to binary operator");
2777 CHECK_OP (1, "invalid operand to binary operator");
2780 case POINTER_PLUS_EXPR
:
2781 /* Check to make sure the first operand is a pointer or reference type. */
2782 if (!POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 0))))
2784 error ("invalid operand to pointer plus, first operand is not a pointer");
2787 /* Check to make sure the second operand is a ptrofftype. */
2788 if (!ptrofftype_p (TREE_TYPE (TREE_OPERAND (t
, 1))))
2790 error ("invalid operand to pointer plus, second operand is not an "
2791 "integer type of appropriate width");
2801 case UNORDERED_EXPR
:
2810 case TRUNC_DIV_EXPR
:
2812 case FLOOR_DIV_EXPR
:
2813 case ROUND_DIV_EXPR
:
2814 case TRUNC_MOD_EXPR
:
2816 case FLOOR_MOD_EXPR
:
2817 case ROUND_MOD_EXPR
:
2819 case EXACT_DIV_EXPR
:
2829 CHECK_OP (0, "invalid operand to binary operator");
2830 CHECK_OP (1, "invalid operand to binary operator");
2834 if (TREE_CONSTANT (t
) && TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
2838 case CASE_LABEL_EXPR
:
2841 error ("invalid CASE_CHAIN");
2855 /* Verify if EXPR is either a GIMPLE ID or a GIMPLE indirect reference.
2856 Returns true if there is an error, otherwise false. */
2859 verify_types_in_gimple_min_lval (tree expr
)
2863 if (is_gimple_id (expr
))
2866 if (TREE_CODE (expr
) != TARGET_MEM_REF
2867 && TREE_CODE (expr
) != MEM_REF
)
2869 error ("invalid expression for min lvalue");
2873 /* TARGET_MEM_REFs are strange beasts. */
2874 if (TREE_CODE (expr
) == TARGET_MEM_REF
)
2877 op
= TREE_OPERAND (expr
, 0);
2878 if (!is_gimple_val (op
))
2880 error ("invalid operand in indirect reference");
2881 debug_generic_stmt (op
);
2884 /* Memory references now generally can involve a value conversion. */
2889 /* Verify if EXPR is a valid GIMPLE reference expression. If
2890 REQUIRE_LVALUE is true verifies it is an lvalue. Returns true
2891 if there is an error, otherwise false. */
2894 verify_types_in_gimple_reference (tree expr
, bool require_lvalue
)
2896 while (handled_component_p (expr
))
2898 tree op
= TREE_OPERAND (expr
, 0);
2900 if (TREE_CODE (expr
) == ARRAY_REF
2901 || TREE_CODE (expr
) == ARRAY_RANGE_REF
)
2903 if (!is_gimple_val (TREE_OPERAND (expr
, 1))
2904 || (TREE_OPERAND (expr
, 2)
2905 && !is_gimple_val (TREE_OPERAND (expr
, 2)))
2906 || (TREE_OPERAND (expr
, 3)
2907 && !is_gimple_val (TREE_OPERAND (expr
, 3))))
2909 error ("invalid operands to array reference");
2910 debug_generic_stmt (expr
);
2915 /* Verify if the reference array element types are compatible. */
2916 if (TREE_CODE (expr
) == ARRAY_REF
2917 && !useless_type_conversion_p (TREE_TYPE (expr
),
2918 TREE_TYPE (TREE_TYPE (op
))))
2920 error ("type mismatch in array reference");
2921 debug_generic_stmt (TREE_TYPE (expr
));
2922 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
2925 if (TREE_CODE (expr
) == ARRAY_RANGE_REF
2926 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr
)),
2927 TREE_TYPE (TREE_TYPE (op
))))
2929 error ("type mismatch in array range reference");
2930 debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr
)));
2931 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
2935 if ((TREE_CODE (expr
) == REALPART_EXPR
2936 || TREE_CODE (expr
) == IMAGPART_EXPR
)
2937 && !useless_type_conversion_p (TREE_TYPE (expr
),
2938 TREE_TYPE (TREE_TYPE (op
))))
2940 error ("type mismatch in real/imagpart reference");
2941 debug_generic_stmt (TREE_TYPE (expr
));
2942 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
2946 if (TREE_CODE (expr
) == COMPONENT_REF
2947 && !useless_type_conversion_p (TREE_TYPE (expr
),
2948 TREE_TYPE (TREE_OPERAND (expr
, 1))))
2950 error ("type mismatch in component reference");
2951 debug_generic_stmt (TREE_TYPE (expr
));
2952 debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr
, 1)));
2956 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
)
2958 /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
2959 that their operand is not an SSA name or an invariant when
2960 requiring an lvalue (this usually means there is a SRA or IPA-SRA
2961 bug). Otherwise there is nothing to verify, gross mismatches at
2962 most invoke undefined behavior. */
2964 && (TREE_CODE (op
) == SSA_NAME
2965 || is_gimple_min_invariant (op
)))
2967 error ("conversion of an SSA_NAME on the left hand side");
2968 debug_generic_stmt (expr
);
2971 else if (TREE_CODE (op
) == SSA_NAME
2972 && TYPE_SIZE (TREE_TYPE (expr
)) != TYPE_SIZE (TREE_TYPE (op
)))
2974 error ("conversion of register to a different size");
2975 debug_generic_stmt (expr
);
2978 else if (!handled_component_p (op
))
2985 if (TREE_CODE (expr
) == MEM_REF
)
2987 if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr
, 0)))
2989 error ("invalid address operand in MEM_REF");
2990 debug_generic_stmt (expr
);
2993 if (TREE_CODE (TREE_OPERAND (expr
, 1)) != INTEGER_CST
2994 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr
, 1))))
2996 error ("invalid offset operand in MEM_REF");
2997 debug_generic_stmt (expr
);
3001 else if (TREE_CODE (expr
) == TARGET_MEM_REF
)
3003 if (!TMR_BASE (expr
)
3004 || !is_gimple_mem_ref_addr (TMR_BASE (expr
)))
3006 error ("invalid address operand in TARGET_MEM_REF");
3009 if (!TMR_OFFSET (expr
)
3010 || TREE_CODE (TMR_OFFSET (expr
)) != INTEGER_CST
3011 || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr
))))
3013 error ("invalid offset operand in TARGET_MEM_REF");
3014 debug_generic_stmt (expr
);
3019 return ((require_lvalue
|| !is_gimple_min_invariant (expr
))
3020 && verify_types_in_gimple_min_lval (expr
));
3023 /* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
3024 list of pointer-to types that is trivially convertible to DEST. */
3027 one_pointer_to_useless_type_conversion_p (tree dest
, tree src_obj
)
3031 if (!TYPE_POINTER_TO (src_obj
))
3034 for (src
= TYPE_POINTER_TO (src_obj
); src
; src
= TYPE_NEXT_PTR_TO (src
))
3035 if (useless_type_conversion_p (dest
, src
))
3041 /* Return true if TYPE1 is a fixed-point type and if conversions to and
3042 from TYPE2 can be handled by FIXED_CONVERT_EXPR. */
3045 valid_fixed_convert_types_p (tree type1
, tree type2
)
3047 return (FIXED_POINT_TYPE_P (type1
)
3048 && (INTEGRAL_TYPE_P (type2
)
3049 || SCALAR_FLOAT_TYPE_P (type2
)
3050 || FIXED_POINT_TYPE_P (type2
)));
3053 /* Verify the contents of a GIMPLE_CALL STMT. Returns true when there
3054 is a problem, otherwise false. */
3057 verify_gimple_call (gimple stmt
)
3059 tree fn
= gimple_call_fn (stmt
);
3060 tree fntype
, fndecl
;
3063 if (gimple_call_internal_p (stmt
))
3067 error ("gimple call has two targets");
3068 debug_generic_stmt (fn
);
3076 error ("gimple call has no target");
3081 if (fn
&& !is_gimple_call_addr (fn
))
3083 error ("invalid function in gimple call");
3084 debug_generic_stmt (fn
);
3089 && (!POINTER_TYPE_P (TREE_TYPE (fn
))
3090 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != FUNCTION_TYPE
3091 && TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != METHOD_TYPE
)))
3093 error ("non-function in gimple call");
3097 fndecl
= gimple_call_fndecl (stmt
);
3099 && TREE_CODE (fndecl
) == FUNCTION_DECL
3100 && DECL_LOOPING_CONST_OR_PURE_P (fndecl
)
3101 && !DECL_PURE_P (fndecl
)
3102 && !TREE_READONLY (fndecl
))
3104 error ("invalid pure const state for function");
3108 if (gimple_call_lhs (stmt
)
3109 && (!is_gimple_lvalue (gimple_call_lhs (stmt
))
3110 || verify_types_in_gimple_reference (gimple_call_lhs (stmt
), true)))
3112 error ("invalid LHS in gimple call");
3116 if (gimple_call_lhs (stmt
) && gimple_call_noreturn_p (stmt
))
3118 error ("LHS in noreturn call");
3122 fntype
= gimple_call_fntype (stmt
);
3124 && gimple_call_lhs (stmt
)
3125 && !useless_type_conversion_p (TREE_TYPE (gimple_call_lhs (stmt
)),
3127 /* ??? At least C++ misses conversions at assignments from
3128 void * call results.
3129 ??? Java is completely off. Especially with functions
3130 returning java.lang.Object.
3131 For now simply allow arbitrary pointer type conversions. */
3132 && !(POINTER_TYPE_P (TREE_TYPE (gimple_call_lhs (stmt
)))
3133 && POINTER_TYPE_P (TREE_TYPE (fntype
))))
3135 error ("invalid conversion in gimple call");
3136 debug_generic_stmt (TREE_TYPE (gimple_call_lhs (stmt
)));
3137 debug_generic_stmt (TREE_TYPE (fntype
));
3141 if (gimple_call_chain (stmt
)
3142 && !is_gimple_val (gimple_call_chain (stmt
)))
3144 error ("invalid static chain in gimple call");
3145 debug_generic_stmt (gimple_call_chain (stmt
));
3149 /* If there is a static chain argument, this should not be an indirect
3150 call, and the decl should have DECL_STATIC_CHAIN set. */
3151 if (gimple_call_chain (stmt
))
3153 if (!gimple_call_fndecl (stmt
))
3155 error ("static chain in indirect gimple call");
3158 fn
= TREE_OPERAND (fn
, 0);
3160 if (!DECL_STATIC_CHAIN (fn
))
3162 error ("static chain with function that doesn%'t use one");
3167 /* ??? The C frontend passes unpromoted arguments in case it
3168 didn't see a function declaration before the call. So for now
3169 leave the call arguments mostly unverified. Once we gimplify
3170 unit-at-a-time we have a chance to fix this. */
3172 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
3174 tree arg
= gimple_call_arg (stmt
, i
);
3175 if ((is_gimple_reg_type (TREE_TYPE (arg
))
3176 && !is_gimple_val (arg
))
3177 || (!is_gimple_reg_type (TREE_TYPE (arg
))
3178 && !is_gimple_lvalue (arg
)))
3180 error ("invalid argument to gimple call");
3181 debug_generic_expr (arg
);
3189 /* Verifies the gimple comparison with the result type TYPE and
3190 the operands OP0 and OP1. */
3193 verify_gimple_comparison (tree type
, tree op0
, tree op1
)
3195 tree op0_type
= TREE_TYPE (op0
);
3196 tree op1_type
= TREE_TYPE (op1
);
3198 if (!is_gimple_val (op0
) || !is_gimple_val (op1
))
3200 error ("invalid operands in gimple comparison");
3204 /* For comparisons we do not have the operations type as the
3205 effective type the comparison is carried out in. Instead
3206 we require that either the first operand is trivially
3207 convertible into the second, or the other way around.
3208 Because we special-case pointers to void we allow
3209 comparisons of pointers with the same mode as well. */
3210 if (!useless_type_conversion_p (op0_type
, op1_type
)
3211 && !useless_type_conversion_p (op1_type
, op0_type
)
3212 && (!POINTER_TYPE_P (op0_type
)
3213 || !POINTER_TYPE_P (op1_type
)
3214 || TYPE_MODE (op0_type
) != TYPE_MODE (op1_type
)))
3216 error ("mismatching comparison operand types");
3217 debug_generic_expr (op0_type
);
3218 debug_generic_expr (op1_type
);
3222 /* The resulting type of a comparison may be an effective boolean type. */
3223 if (INTEGRAL_TYPE_P (type
)
3224 && (TREE_CODE (type
) == BOOLEAN_TYPE
3225 || TYPE_PRECISION (type
) == 1))
3227 if (TREE_CODE (op0_type
) == VECTOR_TYPE
3228 || TREE_CODE (op1_type
) == VECTOR_TYPE
)
3230 error ("vector comparison returning a boolean");
3231 debug_generic_expr (op0_type
);
3232 debug_generic_expr (op1_type
);
3236 /* Or an integer vector type with the same size and element count
3237 as the comparison operand types. */
3238 else if (TREE_CODE (type
) == VECTOR_TYPE
3239 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
3241 if (TREE_CODE (op0_type
) != VECTOR_TYPE
3242 || TREE_CODE (op1_type
) != VECTOR_TYPE
)
3244 error ("non-vector operands in vector comparison");
3245 debug_generic_expr (op0_type
);
3246 debug_generic_expr (op1_type
);
3250 if (TYPE_VECTOR_SUBPARTS (type
) != TYPE_VECTOR_SUBPARTS (op0_type
)
3251 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (type
)))
3252 != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0_type
))))
3253 /* The result of a vector comparison is of signed
3255 || TYPE_UNSIGNED (TREE_TYPE (type
)))
3257 error ("invalid vector comparison resulting type");
3258 debug_generic_expr (type
);
3264 error ("bogus comparison result type");
3265 debug_generic_expr (type
);
3272 /* Verify a gimple assignment statement STMT with an unary rhs.
3273 Returns true if anything is wrong. */
3276 verify_gimple_assign_unary (gimple stmt
)
3278 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3279 tree lhs
= gimple_assign_lhs (stmt
);
3280 tree lhs_type
= TREE_TYPE (lhs
);
3281 tree rhs1
= gimple_assign_rhs1 (stmt
);
3282 tree rhs1_type
= TREE_TYPE (rhs1
);
3284 if (!is_gimple_reg (lhs
))
3286 error ("non-register as LHS of unary operation");
3290 if (!is_gimple_val (rhs1
))
3292 error ("invalid operand in unary operation");
3296 /* First handle conversions. */
3301 /* Allow conversions from pointer type to integral type only if
3302 there is no sign or zero extension involved.
3303 For targets were the precision of ptrofftype doesn't match that
3304 of pointers we need to allow arbitrary conversions to ptrofftype. */
3305 if ((POINTER_TYPE_P (lhs_type
)
3306 && INTEGRAL_TYPE_P (rhs1_type
))
3307 || (POINTER_TYPE_P (rhs1_type
)
3308 && INTEGRAL_TYPE_P (lhs_type
)
3309 && (TYPE_PRECISION (rhs1_type
) >= TYPE_PRECISION (lhs_type
)
3310 || ptrofftype_p (sizetype
))))
3313 /* Allow conversion from integral to offset type and vice versa. */
3314 if ((TREE_CODE (lhs_type
) == OFFSET_TYPE
3315 && INTEGRAL_TYPE_P (rhs1_type
))
3316 || (INTEGRAL_TYPE_P (lhs_type
)
3317 && TREE_CODE (rhs1_type
) == OFFSET_TYPE
))
3320 /* Otherwise assert we are converting between types of the
3322 if (INTEGRAL_TYPE_P (lhs_type
) != INTEGRAL_TYPE_P (rhs1_type
))
3324 error ("invalid types in nop conversion");
3325 debug_generic_expr (lhs_type
);
3326 debug_generic_expr (rhs1_type
);
3333 case ADDR_SPACE_CONVERT_EXPR
:
3335 if (!POINTER_TYPE_P (rhs1_type
) || !POINTER_TYPE_P (lhs_type
)
3336 || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type
))
3337 == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type
))))
3339 error ("invalid types in address space conversion");
3340 debug_generic_expr (lhs_type
);
3341 debug_generic_expr (rhs1_type
);
3348 case FIXED_CONVERT_EXPR
:
3350 if (!valid_fixed_convert_types_p (lhs_type
, rhs1_type
)
3351 && !valid_fixed_convert_types_p (rhs1_type
, lhs_type
))
3353 error ("invalid types in fixed-point conversion");
3354 debug_generic_expr (lhs_type
);
3355 debug_generic_expr (rhs1_type
);
3364 if ((!INTEGRAL_TYPE_P (rhs1_type
) || !SCALAR_FLOAT_TYPE_P (lhs_type
))
3365 && (!VECTOR_INTEGER_TYPE_P (rhs1_type
)
3366 || !VECTOR_FLOAT_TYPE_P (lhs_type
)))
3368 error ("invalid types in conversion to floating point");
3369 debug_generic_expr (lhs_type
);
3370 debug_generic_expr (rhs1_type
);
3377 case FIX_TRUNC_EXPR
:
3379 if ((!INTEGRAL_TYPE_P (lhs_type
) || !SCALAR_FLOAT_TYPE_P (rhs1_type
))
3380 && (!VECTOR_INTEGER_TYPE_P (lhs_type
)
3381 || !VECTOR_FLOAT_TYPE_P (rhs1_type
)))
3383 error ("invalid types in conversion to integer");
3384 debug_generic_expr (lhs_type
);
3385 debug_generic_expr (rhs1_type
);
3392 case VEC_UNPACK_HI_EXPR
:
3393 case VEC_UNPACK_LO_EXPR
:
3394 case REDUC_MAX_EXPR
:
3395 case REDUC_MIN_EXPR
:
3396 case REDUC_PLUS_EXPR
:
3397 case VEC_UNPACK_FLOAT_HI_EXPR
:
3398 case VEC_UNPACK_FLOAT_LO_EXPR
:
3406 case NON_LVALUE_EXPR
:
3414 /* For the remaining codes assert there is no conversion involved. */
3415 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3417 error ("non-trivial conversion in unary operation");
3418 debug_generic_expr (lhs_type
);
3419 debug_generic_expr (rhs1_type
);
3426 /* Verify a gimple assignment statement STMT with a binary rhs.
3427 Returns true if anything is wrong. */
3430 verify_gimple_assign_binary (gimple stmt
)
3432 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3433 tree lhs
= gimple_assign_lhs (stmt
);
3434 tree lhs_type
= TREE_TYPE (lhs
);
3435 tree rhs1
= gimple_assign_rhs1 (stmt
);
3436 tree rhs1_type
= TREE_TYPE (rhs1
);
3437 tree rhs2
= gimple_assign_rhs2 (stmt
);
3438 tree rhs2_type
= TREE_TYPE (rhs2
);
3440 if (!is_gimple_reg (lhs
))
3442 error ("non-register as LHS of binary operation");
3446 if (!is_gimple_val (rhs1
)
3447 || !is_gimple_val (rhs2
))
3449 error ("invalid operands in binary operation");
3453 /* First handle operations that involve different types. */
3458 if (TREE_CODE (lhs_type
) != COMPLEX_TYPE
3459 || !(INTEGRAL_TYPE_P (rhs1_type
)
3460 || SCALAR_FLOAT_TYPE_P (rhs1_type
))
3461 || !(INTEGRAL_TYPE_P (rhs2_type
)
3462 || SCALAR_FLOAT_TYPE_P (rhs2_type
)))
3464 error ("type mismatch in complex expression");
3465 debug_generic_expr (lhs_type
);
3466 debug_generic_expr (rhs1_type
);
3467 debug_generic_expr (rhs2_type
);
3479 /* Shifts and rotates are ok on integral types, fixed point
3480 types and integer vector types. */
3481 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3482 && !FIXED_POINT_TYPE_P (rhs1_type
)
3483 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3484 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))))
3485 || (!INTEGRAL_TYPE_P (rhs2_type
)
3486 /* Vector shifts of vectors are also ok. */
3487 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3488 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3489 && TREE_CODE (rhs2_type
) == VECTOR_TYPE
3490 && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3491 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3493 error ("type mismatch in shift expression");
3494 debug_generic_expr (lhs_type
);
3495 debug_generic_expr (rhs1_type
);
3496 debug_generic_expr (rhs2_type
);
3503 case VEC_LSHIFT_EXPR
:
3504 case VEC_RSHIFT_EXPR
:
3506 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3507 || !(INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3508 || POINTER_TYPE_P (TREE_TYPE (rhs1_type
))
3509 || FIXED_POINT_TYPE_P (TREE_TYPE (rhs1_type
))
3510 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
)))
3511 || (!INTEGRAL_TYPE_P (rhs2_type
)
3512 && (TREE_CODE (rhs2_type
) != VECTOR_TYPE
3513 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3514 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3516 error ("type mismatch in vector shift expression");
3517 debug_generic_expr (lhs_type
);
3518 debug_generic_expr (rhs1_type
);
3519 debug_generic_expr (rhs2_type
);
3522 /* For shifting a vector of non-integral components we
3523 only allow shifting by a constant multiple of the element size. */
3524 if (!INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3525 && (TREE_CODE (rhs2
) != INTEGER_CST
3526 || !div_if_zero_remainder (EXACT_DIV_EXPR
, rhs2
,
3527 TYPE_SIZE (TREE_TYPE (rhs1_type
)))))
3529 error ("non-element sized vector shift of floating point vector");
3536 case WIDEN_LSHIFT_EXPR
:
3538 if (!INTEGRAL_TYPE_P (lhs_type
)
3539 || !INTEGRAL_TYPE_P (rhs1_type
)
3540 || TREE_CODE (rhs2
) != INTEGER_CST
3541 || (2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)))
3543 error ("type mismatch in widening vector shift expression");
3544 debug_generic_expr (lhs_type
);
3545 debug_generic_expr (rhs1_type
);
3546 debug_generic_expr (rhs2_type
);
3553 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3554 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3556 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3557 || TREE_CODE (lhs_type
) != VECTOR_TYPE
3558 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3559 || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3560 || TREE_CODE (rhs2
) != INTEGER_CST
3561 || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type
))
3562 > TYPE_PRECISION (TREE_TYPE (lhs_type
))))
3564 error ("type mismatch in widening vector shift expression");
3565 debug_generic_expr (lhs_type
);
3566 debug_generic_expr (rhs1_type
);
3567 debug_generic_expr (rhs2_type
);
3577 tree lhs_etype
= lhs_type
;
3578 tree rhs1_etype
= rhs1_type
;
3579 tree rhs2_etype
= rhs2_type
;
3580 if (TREE_CODE (lhs_type
) == VECTOR_TYPE
)
3582 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3583 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
)
3585 error ("invalid non-vector operands to vector valued plus");
3588 lhs_etype
= TREE_TYPE (lhs_type
);
3589 rhs1_etype
= TREE_TYPE (rhs1_type
);
3590 rhs2_etype
= TREE_TYPE (rhs2_type
);
3592 if (POINTER_TYPE_P (lhs_etype
)
3593 || POINTER_TYPE_P (rhs1_etype
)
3594 || POINTER_TYPE_P (rhs2_etype
))
3596 error ("invalid (pointer) operands to plus/minus");
3600 /* Continue with generic binary expression handling. */
3604 case POINTER_PLUS_EXPR
:
3606 if (!POINTER_TYPE_P (rhs1_type
)
3607 || !useless_type_conversion_p (lhs_type
, rhs1_type
)
3608 || !ptrofftype_p (rhs2_type
))
3610 error ("type mismatch in pointer plus expression");
3611 debug_generic_stmt (lhs_type
);
3612 debug_generic_stmt (rhs1_type
);
3613 debug_generic_stmt (rhs2_type
);
3620 case TRUTH_ANDIF_EXPR
:
3621 case TRUTH_ORIF_EXPR
:
3622 case TRUTH_AND_EXPR
:
3624 case TRUTH_XOR_EXPR
:
3634 case UNORDERED_EXPR
:
3642 /* Comparisons are also binary, but the result type is not
3643 connected to the operand types. */
3644 return verify_gimple_comparison (lhs_type
, rhs1
, rhs2
);
3646 case WIDEN_MULT_EXPR
:
3647 if (TREE_CODE (lhs_type
) != INTEGER_TYPE
)
3649 return ((2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
))
3650 || (TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
)));
3652 case WIDEN_SUM_EXPR
:
3653 case VEC_WIDEN_MULT_HI_EXPR
:
3654 case VEC_WIDEN_MULT_LO_EXPR
:
3655 case VEC_WIDEN_MULT_EVEN_EXPR
:
3656 case VEC_WIDEN_MULT_ODD_EXPR
:
3657 case VEC_PACK_TRUNC_EXPR
:
3658 case VEC_PACK_SAT_EXPR
:
3659 case VEC_PACK_FIX_TRUNC_EXPR
:
3664 case MULT_HIGHPART_EXPR
:
3665 case TRUNC_DIV_EXPR
:
3667 case FLOOR_DIV_EXPR
:
3668 case ROUND_DIV_EXPR
:
3669 case TRUNC_MOD_EXPR
:
3671 case FLOOR_MOD_EXPR
:
3672 case ROUND_MOD_EXPR
:
3674 case EXACT_DIV_EXPR
:
3680 /* Continue with generic binary expression handling. */
3687 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3688 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
3690 error ("type mismatch in binary expression");
3691 debug_generic_stmt (lhs_type
);
3692 debug_generic_stmt (rhs1_type
);
3693 debug_generic_stmt (rhs2_type
);
3700 /* Verify a gimple assignment statement STMT with a ternary rhs.
3701 Returns true if anything is wrong. */
3704 verify_gimple_assign_ternary (gimple stmt
)
3706 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3707 tree lhs
= gimple_assign_lhs (stmt
);
3708 tree lhs_type
= TREE_TYPE (lhs
);
3709 tree rhs1
= gimple_assign_rhs1 (stmt
);
3710 tree rhs1_type
= TREE_TYPE (rhs1
);
3711 tree rhs2
= gimple_assign_rhs2 (stmt
);
3712 tree rhs2_type
= TREE_TYPE (rhs2
);
3713 tree rhs3
= gimple_assign_rhs3 (stmt
);
3714 tree rhs3_type
= TREE_TYPE (rhs3
);
3716 if (!is_gimple_reg (lhs
))
3718 error ("non-register as LHS of ternary operation");
3722 if (((rhs_code
== VEC_COND_EXPR
|| rhs_code
== COND_EXPR
)
3723 ? !is_gimple_condexpr (rhs1
) : !is_gimple_val (rhs1
))
3724 || !is_gimple_val (rhs2
)
3725 || !is_gimple_val (rhs3
))
3727 error ("invalid operands in ternary operation");
3731 /* First handle operations that involve different types. */
3734 case WIDEN_MULT_PLUS_EXPR
:
3735 case WIDEN_MULT_MINUS_EXPR
:
3736 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3737 && !FIXED_POINT_TYPE_P (rhs1_type
))
3738 || !useless_type_conversion_p (rhs1_type
, rhs2_type
)
3739 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
3740 || 2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)
3741 || TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
))
3743 error ("type mismatch in widening multiply-accumulate expression");
3744 debug_generic_expr (lhs_type
);
3745 debug_generic_expr (rhs1_type
);
3746 debug_generic_expr (rhs2_type
);
3747 debug_generic_expr (rhs3_type
);
3753 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3754 || !useless_type_conversion_p (lhs_type
, rhs2_type
)
3755 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
3757 error ("type mismatch in fused multiply-add expression");
3758 debug_generic_expr (lhs_type
);
3759 debug_generic_expr (rhs1_type
);
3760 debug_generic_expr (rhs2_type
);
3761 debug_generic_expr (rhs3_type
);
3768 if (!useless_type_conversion_p (lhs_type
, rhs2_type
)
3769 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
3771 error ("type mismatch in conditional expression");
3772 debug_generic_expr (lhs_type
);
3773 debug_generic_expr (rhs2_type
);
3774 debug_generic_expr (rhs3_type
);
3780 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3781 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
3783 error ("type mismatch in vector permute expression");
3784 debug_generic_expr (lhs_type
);
3785 debug_generic_expr (rhs1_type
);
3786 debug_generic_expr (rhs2_type
);
3787 debug_generic_expr (rhs3_type
);
3791 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3792 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
3793 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
3795 error ("vector types expected in vector permute expression");
3796 debug_generic_expr (lhs_type
);
3797 debug_generic_expr (rhs1_type
);
3798 debug_generic_expr (rhs2_type
);
3799 debug_generic_expr (rhs3_type
);
3803 if (TYPE_VECTOR_SUBPARTS (rhs1_type
) != TYPE_VECTOR_SUBPARTS (rhs2_type
)
3804 || TYPE_VECTOR_SUBPARTS (rhs2_type
)
3805 != TYPE_VECTOR_SUBPARTS (rhs3_type
)
3806 || TYPE_VECTOR_SUBPARTS (rhs3_type
)
3807 != TYPE_VECTOR_SUBPARTS (lhs_type
))
3809 error ("vectors with different element number found "
3810 "in vector permute expression");
3811 debug_generic_expr (lhs_type
);
3812 debug_generic_expr (rhs1_type
);
3813 debug_generic_expr (rhs2_type
);
3814 debug_generic_expr (rhs3_type
);
3818 if (TREE_CODE (TREE_TYPE (rhs3_type
)) != INTEGER_TYPE
3819 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs3_type
)))
3820 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type
))))
3822 error ("invalid mask type in vector permute expression");
3823 debug_generic_expr (lhs_type
);
3824 debug_generic_expr (rhs1_type
);
3825 debug_generic_expr (rhs2_type
);
3826 debug_generic_expr (rhs3_type
);
3833 case REALIGN_LOAD_EXPR
:
3843 /* Verify a gimple assignment statement STMT with a single rhs.
3844 Returns true if anything is wrong. */
3847 verify_gimple_assign_single (gimple stmt
)
3849 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3850 tree lhs
= gimple_assign_lhs (stmt
);
3851 tree lhs_type
= TREE_TYPE (lhs
);
3852 tree rhs1
= gimple_assign_rhs1 (stmt
);
3853 tree rhs1_type
= TREE_TYPE (rhs1
);
3856 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3858 error ("non-trivial conversion at assignment");
3859 debug_generic_expr (lhs_type
);
3860 debug_generic_expr (rhs1_type
);
3864 if (gimple_clobber_p (stmt
)
3865 && !(DECL_P (lhs
) || TREE_CODE (lhs
) == MEM_REF
))
3867 error ("non-decl/MEM_REF LHS in clobber statement");
3868 debug_generic_expr (lhs
);
3872 if (handled_component_p (lhs
))
3873 res
|= verify_types_in_gimple_reference (lhs
, true);
3875 /* Special codes we cannot handle via their class. */
3880 tree op
= TREE_OPERAND (rhs1
, 0);
3881 if (!is_gimple_addressable (op
))
3883 error ("invalid operand in unary expression");
3887 /* Technically there is no longer a need for matching types, but
3888 gimple hygiene asks for this check. In LTO we can end up
3889 combining incompatible units and thus end up with addresses
3890 of globals that change their type to a common one. */
3892 && !types_compatible_p (TREE_TYPE (op
),
3893 TREE_TYPE (TREE_TYPE (rhs1
)))
3894 && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1
),
3897 error ("type mismatch in address expression");
3898 debug_generic_stmt (TREE_TYPE (rhs1
));
3899 debug_generic_stmt (TREE_TYPE (op
));
3903 return verify_types_in_gimple_reference (op
, true);
3908 error ("INDIRECT_REF in gimple IL");
3914 case ARRAY_RANGE_REF
:
3915 case VIEW_CONVERT_EXPR
:
3918 case TARGET_MEM_REF
:
3920 if (!is_gimple_reg (lhs
)
3921 && is_gimple_reg_type (TREE_TYPE (lhs
)))
3923 error ("invalid rhs for gimple memory store");
3924 debug_generic_stmt (lhs
);
3925 debug_generic_stmt (rhs1
);
3928 return res
|| verify_types_in_gimple_reference (rhs1
, false);
3940 /* tcc_declaration */
3945 if (!is_gimple_reg (lhs
)
3946 && !is_gimple_reg (rhs1
)
3947 && is_gimple_reg_type (TREE_TYPE (lhs
)))
3949 error ("invalid rhs for gimple memory store");
3950 debug_generic_stmt (lhs
);
3951 debug_generic_stmt (rhs1
);
3957 if (TREE_CODE (rhs1_type
) == VECTOR_TYPE
)
3960 tree elt_i
, elt_v
, elt_t
= NULL_TREE
;
3962 if (CONSTRUCTOR_NELTS (rhs1
) == 0)
3964 /* For vector CONSTRUCTORs we require that either it is empty
3965 CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
3966 (then the element count must be correct to cover the whole
3967 outer vector and index must be NULL on all elements, or it is
3968 a CONSTRUCTOR of scalar elements, where we as an exception allow
3969 smaller number of elements (assuming zero filling) and
3970 consecutive indexes as compared to NULL indexes (such
3971 CONSTRUCTORs can appear in the IL from FEs). */
3972 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1
), i
, elt_i
, elt_v
)
3974 if (elt_t
== NULL_TREE
)
3976 elt_t
= TREE_TYPE (elt_v
);
3977 if (TREE_CODE (elt_t
) == VECTOR_TYPE
)
3979 tree elt_t
= TREE_TYPE (elt_v
);
3980 if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
3983 error ("incorrect type of vector CONSTRUCTOR"
3985 debug_generic_stmt (rhs1
);
3988 else if (CONSTRUCTOR_NELTS (rhs1
)
3989 * TYPE_VECTOR_SUBPARTS (elt_t
)
3990 != TYPE_VECTOR_SUBPARTS (rhs1_type
))
3992 error ("incorrect number of vector CONSTRUCTOR"
3994 debug_generic_stmt (rhs1
);
3998 else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
4001 error ("incorrect type of vector CONSTRUCTOR elements");
4002 debug_generic_stmt (rhs1
);
4005 else if (CONSTRUCTOR_NELTS (rhs1
)
4006 > TYPE_VECTOR_SUBPARTS (rhs1_type
))
4008 error ("incorrect number of vector CONSTRUCTOR elements");
4009 debug_generic_stmt (rhs1
);
4013 else if (!useless_type_conversion_p (elt_t
, TREE_TYPE (elt_v
)))
4015 error ("incorrect type of vector CONSTRUCTOR elements");
4016 debug_generic_stmt (rhs1
);
4019 if (elt_i
!= NULL_TREE
4020 && (TREE_CODE (elt_t
) == VECTOR_TYPE
4021 || TREE_CODE (elt_i
) != INTEGER_CST
4022 || compare_tree_int (elt_i
, i
) != 0))
4024 error ("vector CONSTRUCTOR with non-NULL element index");
4025 debug_generic_stmt (rhs1
);
4033 case WITH_SIZE_EXPR
:
4043 /* Verify the contents of a GIMPLE_ASSIGN STMT. Returns true when there
4044 is a problem, otherwise false. */
4047 verify_gimple_assign (gimple stmt
)
4049 switch (gimple_assign_rhs_class (stmt
))
4051 case GIMPLE_SINGLE_RHS
:
4052 return verify_gimple_assign_single (stmt
);
4054 case GIMPLE_UNARY_RHS
:
4055 return verify_gimple_assign_unary (stmt
);
4057 case GIMPLE_BINARY_RHS
:
4058 return verify_gimple_assign_binary (stmt
);
4060 case GIMPLE_TERNARY_RHS
:
4061 return verify_gimple_assign_ternary (stmt
);
4068 /* Verify the contents of a GIMPLE_RETURN STMT. Returns true when there
4069 is a problem, otherwise false. */
4072 verify_gimple_return (gimple stmt
)
4074 tree op
= gimple_return_retval (stmt
);
4075 tree restype
= TREE_TYPE (TREE_TYPE (cfun
->decl
));
4077 /* We cannot test for present return values as we do not fix up missing
4078 return values from the original source. */
4082 if (!is_gimple_val (op
)
4083 && TREE_CODE (op
) != RESULT_DECL
)
4085 error ("invalid operand in return statement");
4086 debug_generic_stmt (op
);
4090 if ((TREE_CODE (op
) == RESULT_DECL
4091 && DECL_BY_REFERENCE (op
))
4092 || (TREE_CODE (op
) == SSA_NAME
4093 && SSA_NAME_VAR (op
)
4094 && TREE_CODE (SSA_NAME_VAR (op
)) == RESULT_DECL
4095 && DECL_BY_REFERENCE (SSA_NAME_VAR (op
))))
4096 op
= TREE_TYPE (op
);
4098 if (!useless_type_conversion_p (restype
, TREE_TYPE (op
)))
4100 error ("invalid conversion in return statement");
4101 debug_generic_stmt (restype
);
4102 debug_generic_stmt (TREE_TYPE (op
));
4110 /* Verify the contents of a GIMPLE_GOTO STMT. Returns true when there
4111 is a problem, otherwise false. */
4114 verify_gimple_goto (gimple stmt
)
4116 tree dest
= gimple_goto_dest (stmt
);
4118 /* ??? We have two canonical forms of direct goto destinations, a
4119 bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
4120 if (TREE_CODE (dest
) != LABEL_DECL
4121 && (!is_gimple_val (dest
)
4122 || !POINTER_TYPE_P (TREE_TYPE (dest
))))
4124 error ("goto destination is neither a label nor a pointer");
4131 /* Verify the contents of a GIMPLE_SWITCH STMT. Returns true when there
4132 is a problem, otherwise false. */
4135 verify_gimple_switch (gimple stmt
)
4138 tree elt
, prev_upper_bound
= NULL_TREE
;
4139 tree index_type
, elt_type
= NULL_TREE
;
4141 if (!is_gimple_val (gimple_switch_index (stmt
)))
4143 error ("invalid operand to switch statement");
4144 debug_generic_stmt (gimple_switch_index (stmt
));
4148 index_type
= TREE_TYPE (gimple_switch_index (stmt
));
4149 if (! INTEGRAL_TYPE_P (index_type
))
4151 error ("non-integral type switch statement");
4152 debug_generic_expr (index_type
);
4156 elt
= gimple_switch_label (stmt
, 0);
4157 if (CASE_LOW (elt
) != NULL_TREE
|| CASE_HIGH (elt
) != NULL_TREE
)
4159 error ("invalid default case label in switch statement");
4160 debug_generic_expr (elt
);
4164 n
= gimple_switch_num_labels (stmt
);
4165 for (i
= 1; i
< n
; i
++)
4167 elt
= gimple_switch_label (stmt
, i
);
4169 if (! CASE_LOW (elt
))
4171 error ("invalid case label in switch statement");
4172 debug_generic_expr (elt
);
4176 && ! tree_int_cst_lt (CASE_LOW (elt
), CASE_HIGH (elt
)))
4178 error ("invalid case range in switch statement");
4179 debug_generic_expr (elt
);
4185 if (TREE_TYPE (CASE_LOW (elt
)) != elt_type
4186 || (CASE_HIGH (elt
) && TREE_TYPE (CASE_HIGH (elt
)) != elt_type
))
4188 error ("type mismatch for case label in switch statement");
4189 debug_generic_expr (elt
);
4195 elt_type
= TREE_TYPE (CASE_LOW (elt
));
4196 if (TYPE_PRECISION (index_type
) < TYPE_PRECISION (elt_type
))
4198 error ("type precision mismatch in switch statement");
4203 if (prev_upper_bound
)
4205 if (! tree_int_cst_lt (prev_upper_bound
, CASE_LOW (elt
)))
4207 error ("case labels not sorted in switch statement");
4212 prev_upper_bound
= CASE_HIGH (elt
);
4213 if (! prev_upper_bound
)
4214 prev_upper_bound
= CASE_LOW (elt
);
4220 /* Verify a gimple debug statement STMT.
4221 Returns true if anything is wrong. */
4224 verify_gimple_debug (gimple stmt ATTRIBUTE_UNUSED
)
4226 /* There isn't much that could be wrong in a gimple debug stmt. A
4227 gimple debug bind stmt, for example, maps a tree, that's usually
4228 a VAR_DECL or a PARM_DECL, but that could also be some scalarized
4229 component or member of an aggregate type, to another tree, that
4230 can be an arbitrary expression. These stmts expand into debug
4231 insns, and are converted to debug notes by var-tracking.c. */
4235 /* Verify a gimple label statement STMT.
4236 Returns true if anything is wrong. */
4239 verify_gimple_label (gimple stmt
)
4241 tree decl
= gimple_label_label (stmt
);
4245 if (TREE_CODE (decl
) != LABEL_DECL
)
4247 if (!DECL_NONLOCAL (decl
) && !FORCED_LABEL (decl
)
4248 && DECL_CONTEXT (decl
) != current_function_decl
)
4250 error ("label's context is not the current function decl");
4254 uid
= LABEL_DECL_UID (decl
);
4256 && (uid
== -1 || (*label_to_block_map
)[uid
] != gimple_bb (stmt
)))
4258 error ("incorrect entry in label_to_block_map");
4262 uid
= EH_LANDING_PAD_NR (decl
);
4265 eh_landing_pad lp
= get_eh_landing_pad_from_number (uid
);
4266 if (decl
!= lp
->post_landing_pad
)
4268 error ("incorrect setting of landing pad number");
4276 /* Verify the GIMPLE statement STMT. Returns true if there is an
4277 error, otherwise false. */
4280 verify_gimple_stmt (gimple stmt
)
4282 switch (gimple_code (stmt
))
4285 return verify_gimple_assign (stmt
);
4288 return verify_gimple_label (stmt
);
4291 return verify_gimple_call (stmt
);
4294 if (TREE_CODE_CLASS (gimple_cond_code (stmt
)) != tcc_comparison
)
4296 error ("invalid comparison code in gimple cond");
4299 if (!(!gimple_cond_true_label (stmt
)
4300 || TREE_CODE (gimple_cond_true_label (stmt
)) == LABEL_DECL
)
4301 || !(!gimple_cond_false_label (stmt
)
4302 || TREE_CODE (gimple_cond_false_label (stmt
)) == LABEL_DECL
))
4304 error ("invalid labels in gimple cond");
4308 return verify_gimple_comparison (boolean_type_node
,
4309 gimple_cond_lhs (stmt
),
4310 gimple_cond_rhs (stmt
));
4313 return verify_gimple_goto (stmt
);
4316 return verify_gimple_switch (stmt
);
4319 return verify_gimple_return (stmt
);
4324 case GIMPLE_TRANSACTION
:
4325 return verify_gimple_transaction (stmt
);
4327 /* Tuples that do not have tree operands. */
4329 case GIMPLE_PREDICT
:
4331 case GIMPLE_EH_DISPATCH
:
4332 case GIMPLE_EH_MUST_NOT_THROW
:
4336 /* OpenMP directives are validated by the FE and never operated
4337 on by the optimizers. Furthermore, GIMPLE_OMP_FOR may contain
4338 non-gimple expressions when the main index variable has had
4339 its address taken. This does not affect the loop itself
4340 because the header of an GIMPLE_OMP_FOR is merely used to determine
4341 how to setup the parallel iteration. */
4345 return verify_gimple_debug (stmt
);
4352 /* Verify the contents of a GIMPLE_PHI. Returns true if there is a problem,
4353 and false otherwise. */
4356 verify_gimple_phi (gimple phi
)
4360 tree phi_result
= gimple_phi_result (phi
);
4365 error ("invalid PHI result");
4369 virtual_p
= virtual_operand_p (phi_result
);
4370 if (TREE_CODE (phi_result
) != SSA_NAME
4372 && SSA_NAME_VAR (phi_result
) != gimple_vop (cfun
)))
4374 error ("invalid PHI result");
4378 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4380 tree t
= gimple_phi_arg_def (phi
, i
);
4384 error ("missing PHI def");
4388 /* Addressable variables do have SSA_NAMEs but they
4389 are not considered gimple values. */
4390 else if ((TREE_CODE (t
) == SSA_NAME
4391 && virtual_p
!= virtual_operand_p (t
))
4393 && (TREE_CODE (t
) != SSA_NAME
4394 || SSA_NAME_VAR (t
) != gimple_vop (cfun
)))
4396 && !is_gimple_val (t
)))
4398 error ("invalid PHI argument");
4399 debug_generic_expr (t
);
4402 #ifdef ENABLE_TYPES_CHECKING
4403 if (!useless_type_conversion_p (TREE_TYPE (phi_result
), TREE_TYPE (t
)))
4405 error ("incompatible types in PHI argument %u", i
);
4406 debug_generic_stmt (TREE_TYPE (phi_result
));
4407 debug_generic_stmt (TREE_TYPE (t
));
4416 /* Verify the GIMPLE statements inside the sequence STMTS. */
4419 verify_gimple_in_seq_2 (gimple_seq stmts
)
4421 gimple_stmt_iterator ittr
;
4424 for (ittr
= gsi_start (stmts
); !gsi_end_p (ittr
); gsi_next (&ittr
))
4426 gimple stmt
= gsi_stmt (ittr
);
4428 switch (gimple_code (stmt
))
4431 err
|= verify_gimple_in_seq_2 (gimple_bind_body (stmt
));
4435 err
|= verify_gimple_in_seq_2 (gimple_try_eval (stmt
));
4436 err
|= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt
));
4439 case GIMPLE_EH_FILTER
:
4440 err
|= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt
));
4443 case GIMPLE_EH_ELSE
:
4444 err
|= verify_gimple_in_seq_2 (gimple_eh_else_n_body (stmt
));
4445 err
|= verify_gimple_in_seq_2 (gimple_eh_else_e_body (stmt
));
4449 err
|= verify_gimple_in_seq_2 (gimple_catch_handler (stmt
));
4452 case GIMPLE_TRANSACTION
:
4453 err
|= verify_gimple_transaction (stmt
);
4458 bool err2
= verify_gimple_stmt (stmt
);
4460 debug_gimple_stmt (stmt
);
4469 /* Verify the contents of a GIMPLE_TRANSACTION. Returns true if there
4470 is a problem, otherwise false. */
4473 verify_gimple_transaction (gimple stmt
)
4475 tree lab
= gimple_transaction_label (stmt
);
4476 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
4478 return verify_gimple_in_seq_2 (gimple_transaction_body (stmt
));
4482 /* Verify the GIMPLE statements inside the statement list STMTS. */
4485 verify_gimple_in_seq (gimple_seq stmts
)
4487 timevar_push (TV_TREE_STMT_VERIFY
);
4488 if (verify_gimple_in_seq_2 (stmts
))
4489 internal_error ("verify_gimple failed");
4490 timevar_pop (TV_TREE_STMT_VERIFY
);
4493 /* Return true when the T can be shared. */
4496 tree_node_can_be_shared (tree t
)
4498 if (IS_TYPE_OR_DECL_P (t
)
4499 || is_gimple_min_invariant (t
)
4500 || TREE_CODE (t
) == SSA_NAME
4501 || t
== error_mark_node
4502 || TREE_CODE (t
) == IDENTIFIER_NODE
)
4505 if (TREE_CODE (t
) == CASE_LABEL_EXPR
)
4514 /* Called via walk_tree. Verify tree sharing. */
4517 verify_node_sharing_1 (tree
*tp
, int *walk_subtrees
, void *data
)
4519 struct pointer_set_t
*visited
= (struct pointer_set_t
*) data
;
4521 if (tree_node_can_be_shared (*tp
))
4523 *walk_subtrees
= false;
4527 if (pointer_set_insert (visited
, *tp
))
4533 /* Called via walk_gimple_stmt. Verify tree sharing. */
4536 verify_node_sharing (tree
*tp
, int *walk_subtrees
, void *data
)
4538 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4539 return verify_node_sharing_1 (tp
, walk_subtrees
, wi
->info
);
4542 static bool eh_error_found
;
4544 verify_eh_throw_stmt_node (void **slot
, void *data
)
4546 struct throw_stmt_node
*node
= (struct throw_stmt_node
*)*slot
;
4547 struct pointer_set_t
*visited
= (struct pointer_set_t
*) data
;
4549 if (!pointer_set_contains (visited
, node
->stmt
))
4551 error ("dead STMT in EH table");
4552 debug_gimple_stmt (node
->stmt
);
4553 eh_error_found
= true;
4558 /* Verify if the location LOCs block is in BLOCKS. */
4561 verify_location (pointer_set_t
*blocks
, location_t loc
)
4563 tree block
= LOCATION_BLOCK (loc
);
4564 if (block
!= NULL_TREE
4565 && !pointer_set_contains (blocks
, block
))
4567 error ("location references block not in block tree");
4570 if (block
!= NULL_TREE
)
4571 return verify_location (blocks
, BLOCK_SOURCE_LOCATION (block
));
4575 /* Called via walk_tree. Verify that expressions have no blocks. */
4578 verify_expr_no_block (tree
*tp
, int *walk_subtrees
, void *)
4582 *walk_subtrees
= false;
4586 location_t loc
= EXPR_LOCATION (*tp
);
4587 if (LOCATION_BLOCK (loc
) != NULL
)
4593 /* Called via walk_tree. Verify locations of expressions. */
4596 verify_expr_location_1 (tree
*tp
, int *walk_subtrees
, void *data
)
4598 struct pointer_set_t
*blocks
= (struct pointer_set_t
*) data
;
4600 if (TREE_CODE (*tp
) == VAR_DECL
4601 && DECL_HAS_DEBUG_EXPR_P (*tp
))
4603 tree t
= DECL_DEBUG_EXPR (*tp
);
4604 tree addr
= walk_tree (&t
, verify_expr_no_block
, NULL
, NULL
);
4608 if ((TREE_CODE (*tp
) == VAR_DECL
4609 || TREE_CODE (*tp
) == PARM_DECL
4610 || TREE_CODE (*tp
) == RESULT_DECL
)
4611 && DECL_HAS_VALUE_EXPR_P (*tp
))
4613 tree t
= DECL_VALUE_EXPR (*tp
);
4614 tree addr
= walk_tree (&t
, verify_expr_no_block
, NULL
, NULL
);
4621 *walk_subtrees
= false;
4625 location_t loc
= EXPR_LOCATION (*tp
);
4626 if (verify_location (blocks
, loc
))
4632 /* Called via walk_gimple_op. Verify locations of expressions. */
4635 verify_expr_location (tree
*tp
, int *walk_subtrees
, void *data
)
4637 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4638 return verify_expr_location_1 (tp
, walk_subtrees
, wi
->info
);
4641 /* Insert all subblocks of BLOCK into BLOCKS and recurse. */
4644 collect_subblocks (pointer_set_t
*blocks
, tree block
)
4647 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
4649 pointer_set_insert (blocks
, t
);
4650 collect_subblocks (blocks
, t
);
4654 /* Verify the GIMPLE statements in the CFG of FN. */
4657 verify_gimple_in_cfg (struct function
*fn
)
4661 struct pointer_set_t
*visited
, *visited_stmts
, *blocks
;
4663 timevar_push (TV_TREE_STMT_VERIFY
);
4664 visited
= pointer_set_create ();
4665 visited_stmts
= pointer_set_create ();
4667 /* Collect all BLOCKs referenced by the BLOCK tree of FN. */
4668 blocks
= pointer_set_create ();
4669 if (DECL_INITIAL (fn
->decl
))
4671 pointer_set_insert (blocks
, DECL_INITIAL (fn
->decl
));
4672 collect_subblocks (blocks
, DECL_INITIAL (fn
->decl
));
4675 FOR_EACH_BB_FN (bb
, fn
)
4677 gimple_stmt_iterator gsi
;
4679 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4681 gimple phi
= gsi_stmt (gsi
);
4685 pointer_set_insert (visited_stmts
, phi
);
4687 if (gimple_bb (phi
) != bb
)
4689 error ("gimple_bb (phi) is set to a wrong basic block");
4693 err2
|= verify_gimple_phi (phi
);
4695 /* Only PHI arguments have locations. */
4696 if (gimple_location (phi
) != UNKNOWN_LOCATION
)
4698 error ("PHI node with location");
4702 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4704 tree arg
= gimple_phi_arg_def (phi
, i
);
4705 tree addr
= walk_tree (&arg
, verify_node_sharing_1
,
4709 error ("incorrect sharing of tree nodes");
4710 debug_generic_expr (addr
);
4713 location_t loc
= gimple_phi_arg_location (phi
, i
);
4714 if (virtual_operand_p (gimple_phi_result (phi
))
4715 && loc
!= UNKNOWN_LOCATION
)
4717 error ("virtual PHI with argument locations");
4720 addr
= walk_tree (&arg
, verify_expr_location_1
, blocks
, NULL
);
4723 debug_generic_expr (addr
);
4726 err2
|= verify_location (blocks
, loc
);
4730 debug_gimple_stmt (phi
);
4734 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4736 gimple stmt
= gsi_stmt (gsi
);
4738 struct walk_stmt_info wi
;
4742 pointer_set_insert (visited_stmts
, stmt
);
4744 if (gimple_bb (stmt
) != bb
)
4746 error ("gimple_bb (stmt) is set to a wrong basic block");
4750 err2
|= verify_gimple_stmt (stmt
);
4751 err2
|= verify_location (blocks
, gimple_location (stmt
));
4753 memset (&wi
, 0, sizeof (wi
));
4754 wi
.info
= (void *) visited
;
4755 addr
= walk_gimple_op (stmt
, verify_node_sharing
, &wi
);
4758 error ("incorrect sharing of tree nodes");
4759 debug_generic_expr (addr
);
4763 memset (&wi
, 0, sizeof (wi
));
4764 wi
.info
= (void *) blocks
;
4765 addr
= walk_gimple_op (stmt
, verify_expr_location
, &wi
);
4768 debug_generic_expr (addr
);
4772 /* ??? Instead of not checking these stmts at all the walker
4773 should know its context via wi. */
4774 if (!is_gimple_debug (stmt
)
4775 && !is_gimple_omp (stmt
))
4777 memset (&wi
, 0, sizeof (wi
));
4778 addr
= walk_gimple_op (stmt
, verify_expr
, &wi
);
4781 debug_generic_expr (addr
);
4782 inform (gimple_location (stmt
), "in statement");
4787 /* If the statement is marked as part of an EH region, then it is
4788 expected that the statement could throw. Verify that when we
4789 have optimizations that simplify statements such that we prove
4790 that they cannot throw, that we update other data structures
4792 lp_nr
= lookup_stmt_eh_lp (stmt
);
4795 if (!stmt_could_throw_p (stmt
))
4797 error ("statement marked for throw, but doesn%'t");
4801 && !gsi_one_before_end_p (gsi
)
4802 && stmt_can_throw_internal (stmt
))
4804 error ("statement marked for throw in middle of block");
4810 debug_gimple_stmt (stmt
);
4815 eh_error_found
= false;
4816 if (get_eh_throw_stmt_table (cfun
))
4817 htab_traverse (get_eh_throw_stmt_table (cfun
),
4818 verify_eh_throw_stmt_node
,
4821 if (err
|| eh_error_found
)
4822 internal_error ("verify_gimple failed");
4824 pointer_set_destroy (visited
);
4825 pointer_set_destroy (visited_stmts
);
4826 pointer_set_destroy (blocks
);
4827 verify_histograms ();
4828 timevar_pop (TV_TREE_STMT_VERIFY
);
4832 /* Verifies that the flow information is OK. */
4835 gimple_verify_flow_info (void)
4839 gimple_stmt_iterator gsi
;
4844 if (ENTRY_BLOCK_PTR
->il
.gimple
.seq
|| ENTRY_BLOCK_PTR
->il
.gimple
.phi_nodes
)
4846 error ("ENTRY_BLOCK has IL associated with it");
4850 if (EXIT_BLOCK_PTR
->il
.gimple
.seq
|| EXIT_BLOCK_PTR
->il
.gimple
.phi_nodes
)
4852 error ("EXIT_BLOCK has IL associated with it");
4856 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
4857 if (e
->flags
& EDGE_FALLTHRU
)
4859 error ("fallthru to exit from bb %d", e
->src
->index
);
4865 bool found_ctrl_stmt
= false;
4869 /* Skip labels on the start of basic block. */
4870 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4873 gimple prev_stmt
= stmt
;
4875 stmt
= gsi_stmt (gsi
);
4877 if (gimple_code (stmt
) != GIMPLE_LABEL
)
4880 label
= gimple_label_label (stmt
);
4881 if (prev_stmt
&& DECL_NONLOCAL (label
))
4883 error ("nonlocal label ");
4884 print_generic_expr (stderr
, label
, 0);
4885 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
4890 if (prev_stmt
&& EH_LANDING_PAD_NR (label
) != 0)
4892 error ("EH landing pad label ");
4893 print_generic_expr (stderr
, label
, 0);
4894 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
4899 if (label_to_block (label
) != bb
)
4902 print_generic_expr (stderr
, label
, 0);
4903 fprintf (stderr
, " to block does not match in bb %d",
4908 if (decl_function_context (label
) != current_function_decl
)
4911 print_generic_expr (stderr
, label
, 0);
4912 fprintf (stderr
, " has incorrect context in bb %d",
4918 /* Verify that body of basic block BB is free of control flow. */
4919 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
4921 gimple stmt
= gsi_stmt (gsi
);
4923 if (found_ctrl_stmt
)
4925 error ("control flow in the middle of basic block %d",
4930 if (stmt_ends_bb_p (stmt
))
4931 found_ctrl_stmt
= true;
4933 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4936 print_generic_expr (stderr
, gimple_label_label (stmt
), 0);
4937 fprintf (stderr
, " in the middle of basic block %d", bb
->index
);
4942 gsi
= gsi_last_bb (bb
);
4943 if (gsi_end_p (gsi
))
4946 stmt
= gsi_stmt (gsi
);
4948 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4951 err
|= verify_eh_edges (stmt
);
4953 if (is_ctrl_stmt (stmt
))
4955 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4956 if (e
->flags
& EDGE_FALLTHRU
)
4958 error ("fallthru edge after a control statement in bb %d",
4964 if (gimple_code (stmt
) != GIMPLE_COND
)
4966 /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
4967 after anything else but if statement. */
4968 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4969 if (e
->flags
& (EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
))
4971 error ("true/false edge after a non-GIMPLE_COND in bb %d",
4977 switch (gimple_code (stmt
))
4984 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
4988 || !(true_edge
->flags
& EDGE_TRUE_VALUE
)
4989 || !(false_edge
->flags
& EDGE_FALSE_VALUE
)
4990 || (true_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
4991 || (false_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
4992 || EDGE_COUNT (bb
->succs
) >= 3)
4994 error ("wrong outgoing edge flags at end of bb %d",
5002 if (simple_goto_p (stmt
))
5004 error ("explicit goto at end of bb %d", bb
->index
);
5009 /* FIXME. We should double check that the labels in the
5010 destination blocks have their address taken. */
5011 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5012 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_TRUE_VALUE
5013 | EDGE_FALSE_VALUE
))
5014 || !(e
->flags
& EDGE_ABNORMAL
))
5016 error ("wrong outgoing edge flags at end of bb %d",
5024 if (!gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
))
5026 /* ... fallthru ... */
5028 if (!single_succ_p (bb
)
5029 || (single_succ_edge (bb
)->flags
5030 & (EDGE_FALLTHRU
| EDGE_ABNORMAL
5031 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5033 error ("wrong outgoing edge flags at end of bb %d", bb
->index
);
5036 if (single_succ (bb
) != EXIT_BLOCK_PTR
)
5038 error ("return edge does not point to exit in bb %d",
5050 n
= gimple_switch_num_labels (stmt
);
5052 /* Mark all the destination basic blocks. */
5053 for (i
= 0; i
< n
; ++i
)
5055 tree lab
= CASE_LABEL (gimple_switch_label (stmt
, i
));
5056 basic_block label_bb
= label_to_block (lab
);
5057 gcc_assert (!label_bb
->aux
|| label_bb
->aux
== (void *)1);
5058 label_bb
->aux
= (void *)1;
5061 /* Verify that the case labels are sorted. */
5062 prev
= gimple_switch_label (stmt
, 0);
5063 for (i
= 1; i
< n
; ++i
)
5065 tree c
= gimple_switch_label (stmt
, i
);
5068 error ("found default case not at the start of "
5074 && !tree_int_cst_lt (CASE_LOW (prev
), CASE_LOW (c
)))
5076 error ("case labels not sorted: ");
5077 print_generic_expr (stderr
, prev
, 0);
5078 fprintf (stderr
," is greater than ");
5079 print_generic_expr (stderr
, c
, 0);
5080 fprintf (stderr
," but comes before it.\n");
5085 /* VRP will remove the default case if it can prove it will
5086 never be executed. So do not verify there always exists
5087 a default case here. */
5089 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5093 error ("extra outgoing edge %d->%d",
5094 bb
->index
, e
->dest
->index
);
5098 e
->dest
->aux
= (void *)2;
5099 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
5100 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
5102 error ("wrong outgoing edge flags at end of bb %d",
5108 /* Check that we have all of them. */
5109 for (i
= 0; i
< n
; ++i
)
5111 tree lab
= CASE_LABEL (gimple_switch_label (stmt
, i
));
5112 basic_block label_bb
= label_to_block (lab
);
5114 if (label_bb
->aux
!= (void *)2)
5116 error ("missing edge %i->%i", bb
->index
, label_bb
->index
);
5121 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5122 e
->dest
->aux
= (void *)0;
5126 case GIMPLE_EH_DISPATCH
:
5127 err
|= verify_eh_dispatch_edge (stmt
);
5135 if (dom_info_state (CDI_DOMINATORS
) >= DOM_NO_FAST_QUERY
)
5136 verify_dominators (CDI_DOMINATORS
);
5142 /* Updates phi nodes after creating a forwarder block joined
5143 by edge FALLTHRU. */
5146 gimple_make_forwarder_block (edge fallthru
)
5150 basic_block dummy
, bb
;
5152 gimple_stmt_iterator gsi
;
5154 dummy
= fallthru
->src
;
5155 bb
= fallthru
->dest
;
5157 if (single_pred_p (bb
))
5160 /* If we redirected a branch we must create new PHI nodes at the
5162 for (gsi
= gsi_start_phis (dummy
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5164 gimple phi
, new_phi
;
5166 phi
= gsi_stmt (gsi
);
5167 var
= gimple_phi_result (phi
);
5168 new_phi
= create_phi_node (var
, bb
);
5169 gimple_phi_set_result (phi
, copy_ssa_name (var
, phi
));
5170 add_phi_arg (new_phi
, gimple_phi_result (phi
), fallthru
,
5174 /* Add the arguments we have stored on edges. */
5175 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
5180 flush_pending_stmts (e
);
5185 /* Return a non-special label in the head of basic block BLOCK.
5186 Create one if it doesn't exist. */
5189 gimple_block_label (basic_block bb
)
5191 gimple_stmt_iterator i
, s
= gsi_start_bb (bb
);
5196 for (i
= s
; !gsi_end_p (i
); first
= false, gsi_next (&i
))
5198 stmt
= gsi_stmt (i
);
5199 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5201 label
= gimple_label_label (stmt
);
5202 if (!DECL_NONLOCAL (label
))
5205 gsi_move_before (&i
, &s
);
5210 label
= create_artificial_label (UNKNOWN_LOCATION
);
5211 stmt
= gimple_build_label (label
);
5212 gsi_insert_before (&s
, stmt
, GSI_NEW_STMT
);
5217 /* Attempt to perform edge redirection by replacing a possibly complex
5218 jump instruction by a goto or by removing the jump completely.
5219 This can apply only if all edges now point to the same block. The
5220 parameters and return values are equivalent to
5221 redirect_edge_and_branch. */
5224 gimple_try_redirect_by_replacing_jump (edge e
, basic_block target
)
5226 basic_block src
= e
->src
;
5227 gimple_stmt_iterator i
;
5230 /* We can replace or remove a complex jump only when we have exactly
5232 if (EDGE_COUNT (src
->succs
) != 2
5233 /* Verify that all targets will be TARGET. Specifically, the
5234 edge that is not E must also go to TARGET. */
5235 || EDGE_SUCC (src
, EDGE_SUCC (src
, 0) == e
)->dest
!= target
)
5238 i
= gsi_last_bb (src
);
5242 stmt
= gsi_stmt (i
);
5244 if (gimple_code (stmt
) == GIMPLE_COND
|| gimple_code (stmt
) == GIMPLE_SWITCH
)
5246 gsi_remove (&i
, true);
5247 e
= ssa_redirect_edge (e
, target
);
5248 e
->flags
= EDGE_FALLTHRU
;
5256 /* Redirect E to DEST. Return NULL on failure. Otherwise, return the
5257 edge representing the redirected branch. */
5260 gimple_redirect_edge_and_branch (edge e
, basic_block dest
)
5262 basic_block bb
= e
->src
;
5263 gimple_stmt_iterator gsi
;
5267 if (e
->flags
& EDGE_ABNORMAL
)
5270 if (e
->dest
== dest
)
5273 if (e
->flags
& EDGE_EH
)
5274 return redirect_eh_edge (e
, dest
);
5276 if (e
->src
!= ENTRY_BLOCK_PTR
)
5278 ret
= gimple_try_redirect_by_replacing_jump (e
, dest
);
5283 gsi
= gsi_last_bb (bb
);
5284 stmt
= gsi_end_p (gsi
) ? NULL
: gsi_stmt (gsi
);
5286 switch (stmt
? gimple_code (stmt
) : GIMPLE_ERROR_MARK
)
5289 /* For COND_EXPR, we only need to redirect the edge. */
5293 /* No non-abnormal edges should lead from a non-simple goto, and
5294 simple ones should be represented implicitly. */
5299 tree label
= gimple_block_label (dest
);
5300 tree cases
= get_cases_for_edge (e
, stmt
);
5302 /* If we have a list of cases associated with E, then use it
5303 as it's a lot faster than walking the entire case vector. */
5306 edge e2
= find_edge (e
->src
, dest
);
5313 CASE_LABEL (cases
) = label
;
5314 cases
= CASE_CHAIN (cases
);
5317 /* If there was already an edge in the CFG, then we need
5318 to move all the cases associated with E to E2. */
5321 tree cases2
= get_cases_for_edge (e2
, stmt
);
5323 CASE_CHAIN (last
) = CASE_CHAIN (cases2
);
5324 CASE_CHAIN (cases2
) = first
;
5326 bitmap_set_bit (touched_switch_bbs
, gimple_bb (stmt
)->index
);
5330 size_t i
, n
= gimple_switch_num_labels (stmt
);
5332 for (i
= 0; i
< n
; i
++)
5334 tree elt
= gimple_switch_label (stmt
, i
);
5335 if (label_to_block (CASE_LABEL (elt
)) == e
->dest
)
5336 CASE_LABEL (elt
) = label
;
5344 int i
, n
= gimple_asm_nlabels (stmt
);
5347 for (i
= 0; i
< n
; ++i
)
5349 tree cons
= gimple_asm_label_op (stmt
, i
);
5350 if (label_to_block (TREE_VALUE (cons
)) == e
->dest
)
5353 label
= gimple_block_label (dest
);
5354 TREE_VALUE (cons
) = label
;
5358 /* If we didn't find any label matching the former edge in the
5359 asm labels, we must be redirecting the fallthrough
5361 gcc_assert (label
|| (e
->flags
& EDGE_FALLTHRU
));
5366 gsi_remove (&gsi
, true);
5367 e
->flags
|= EDGE_FALLTHRU
;
5370 case GIMPLE_OMP_RETURN
:
5371 case GIMPLE_OMP_CONTINUE
:
5372 case GIMPLE_OMP_SECTIONS_SWITCH
:
5373 case GIMPLE_OMP_FOR
:
5374 /* The edges from OMP constructs can be simply redirected. */
5377 case GIMPLE_EH_DISPATCH
:
5378 if (!(e
->flags
& EDGE_FALLTHRU
))
5379 redirect_eh_dispatch_edge (stmt
, e
, dest
);
5382 case GIMPLE_TRANSACTION
:
5383 /* The ABORT edge has a stored label associated with it, otherwise
5384 the edges are simply redirectable. */
5386 gimple_transaction_set_label (stmt
, gimple_block_label (dest
));
5390 /* Otherwise it must be a fallthru edge, and we don't need to
5391 do anything besides redirecting it. */
5392 gcc_assert (e
->flags
& EDGE_FALLTHRU
);
5396 /* Update/insert PHI nodes as necessary. */
5398 /* Now update the edges in the CFG. */
5399 e
= ssa_redirect_edge (e
, dest
);
5404 /* Returns true if it is possible to remove edge E by redirecting
5405 it to the destination of the other edge from E->src. */
5408 gimple_can_remove_branch_p (const_edge e
)
5410 if (e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
))
5416 /* Simple wrapper, as we can always redirect fallthru edges. */
5419 gimple_redirect_edge_and_branch_force (edge e
, basic_block dest
)
5421 e
= gimple_redirect_edge_and_branch (e
, dest
);
5428 /* Splits basic block BB after statement STMT (but at least after the
5429 labels). If STMT is NULL, BB is split just after the labels. */
5432 gimple_split_block (basic_block bb
, void *stmt
)
5434 gimple_stmt_iterator gsi
;
5435 gimple_stmt_iterator gsi_tgt
;
5442 new_bb
= create_empty_bb (bb
);
5444 /* Redirect the outgoing edges. */
5445 new_bb
->succs
= bb
->succs
;
5447 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
5450 if (stmt
&& gimple_code ((gimple
) stmt
) == GIMPLE_LABEL
)
5453 /* Move everything from GSI to the new basic block. */
5454 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5456 act
= gsi_stmt (gsi
);
5457 if (gimple_code (act
) == GIMPLE_LABEL
)
5470 if (gsi_end_p (gsi
))
5473 /* Split the statement list - avoid re-creating new containers as this
5474 brings ugly quadratic memory consumption in the inliner.
5475 (We are still quadratic since we need to update stmt BB pointers,
5477 gsi_split_seq_before (&gsi
, &list
);
5478 set_bb_seq (new_bb
, list
);
5479 for (gsi_tgt
= gsi_start (list
);
5480 !gsi_end_p (gsi_tgt
); gsi_next (&gsi_tgt
))
5481 gimple_set_bb (gsi_stmt (gsi_tgt
), new_bb
);
5487 /* Moves basic block BB after block AFTER. */
5490 gimple_move_block_after (basic_block bb
, basic_block after
)
5492 if (bb
->prev_bb
== after
)
5496 link_block (bb
, after
);
5502 /* Return TRUE if block BB has no executable statements, otherwise return
5506 gimple_empty_block_p (basic_block bb
)
5508 /* BB must have no executable statements. */
5509 gimple_stmt_iterator gsi
= gsi_after_labels (bb
);
5512 if (gsi_end_p (gsi
))
5514 if (is_gimple_debug (gsi_stmt (gsi
)))
5515 gsi_next_nondebug (&gsi
);
5516 return gsi_end_p (gsi
);
5520 /* Split a basic block if it ends with a conditional branch and if the
5521 other part of the block is not empty. */
5524 gimple_split_block_before_cond_jump (basic_block bb
)
5526 gimple last
, split_point
;
5527 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
5528 if (gsi_end_p (gsi
))
5530 last
= gsi_stmt (gsi
);
5531 if (gimple_code (last
) != GIMPLE_COND
5532 && gimple_code (last
) != GIMPLE_SWITCH
)
5534 gsi_prev_nondebug (&gsi
);
5535 split_point
= gsi_stmt (gsi
);
5536 return split_block (bb
, split_point
)->dest
;
5540 /* Return true if basic_block can be duplicated. */
5543 gimple_can_duplicate_bb_p (const_basic_block bb ATTRIBUTE_UNUSED
)
5548 /* Create a duplicate of the basic block BB. NOTE: This does not
5549 preserve SSA form. */
5552 gimple_duplicate_bb (basic_block bb
)
5555 gimple_stmt_iterator gsi
, gsi_tgt
;
5556 gimple_seq phis
= phi_nodes (bb
);
5557 gimple phi
, stmt
, copy
;
5559 new_bb
= create_empty_bb (EXIT_BLOCK_PTR
->prev_bb
);
5561 /* Copy the PHI nodes. We ignore PHI node arguments here because
5562 the incoming edges have not been setup yet. */
5563 for (gsi
= gsi_start (phis
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5565 phi
= gsi_stmt (gsi
);
5566 copy
= create_phi_node (NULL_TREE
, new_bb
);
5567 create_new_def_for (gimple_phi_result (phi
), copy
,
5568 gimple_phi_result_ptr (copy
));
5569 gimple_set_uid (copy
, gimple_uid (phi
));
5572 gsi_tgt
= gsi_start_bb (new_bb
);
5573 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5575 def_operand_p def_p
;
5576 ssa_op_iter op_iter
;
5579 stmt
= gsi_stmt (gsi
);
5580 if (gimple_code (stmt
) == GIMPLE_LABEL
)
5583 /* Don't duplicate label debug stmts. */
5584 if (gimple_debug_bind_p (stmt
)
5585 && TREE_CODE (gimple_debug_bind_get_var (stmt
))
5589 /* Create a new copy of STMT and duplicate STMT's virtual
5591 copy
= gimple_copy (stmt
);
5592 gsi_insert_after (&gsi_tgt
, copy
, GSI_NEW_STMT
);
5594 maybe_duplicate_eh_stmt (copy
, stmt
);
5595 gimple_duplicate_stmt_histograms (cfun
, copy
, cfun
, stmt
);
5597 /* When copying around a stmt writing into a local non-user
5598 aggregate, make sure it won't share stack slot with other
5600 lhs
= gimple_get_lhs (stmt
);
5601 if (lhs
&& TREE_CODE (lhs
) != SSA_NAME
)
5603 tree base
= get_base_address (lhs
);
5605 && (TREE_CODE (base
) == VAR_DECL
5606 || TREE_CODE (base
) == RESULT_DECL
)
5607 && DECL_IGNORED_P (base
)
5608 && !TREE_STATIC (base
)
5609 && !DECL_EXTERNAL (base
)
5610 && (TREE_CODE (base
) != VAR_DECL
5611 || !DECL_HAS_VALUE_EXPR_P (base
)))
5612 DECL_NONSHAREABLE (base
) = 1;
5615 /* Create new names for all the definitions created by COPY and
5616 add replacement mappings for each new name. */
5617 FOR_EACH_SSA_DEF_OPERAND (def_p
, copy
, op_iter
, SSA_OP_ALL_DEFS
)
5618 create_new_def_for (DEF_FROM_PTR (def_p
), copy
, def_p
);
5624 /* Adds phi node arguments for edge E_COPY after basic block duplication. */
5627 add_phi_args_after_copy_edge (edge e_copy
)
5629 basic_block bb
, bb_copy
= e_copy
->src
, dest
;
5632 gimple phi
, phi_copy
;
5634 gimple_stmt_iterator psi
, psi_copy
;
5636 if (gimple_seq_empty_p (phi_nodes (e_copy
->dest
)))
5639 bb
= bb_copy
->flags
& BB_DUPLICATED
? get_bb_original (bb_copy
) : bb_copy
;
5641 if (e_copy
->dest
->flags
& BB_DUPLICATED
)
5642 dest
= get_bb_original (e_copy
->dest
);
5644 dest
= e_copy
->dest
;
5646 e
= find_edge (bb
, dest
);
5649 /* During loop unrolling the target of the latch edge is copied.
5650 In this case we are not looking for edge to dest, but to
5651 duplicated block whose original was dest. */
5652 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5654 if ((e
->dest
->flags
& BB_DUPLICATED
)
5655 && get_bb_original (e
->dest
) == dest
)
5659 gcc_assert (e
!= NULL
);
5662 for (psi
= gsi_start_phis (e
->dest
),
5663 psi_copy
= gsi_start_phis (e_copy
->dest
);
5665 gsi_next (&psi
), gsi_next (&psi_copy
))
5667 phi
= gsi_stmt (psi
);
5668 phi_copy
= gsi_stmt (psi_copy
);
5669 def
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
5670 add_phi_arg (phi_copy
, def
, e_copy
,
5671 gimple_phi_arg_location_from_edge (phi
, e
));
5676 /* Basic block BB_COPY was created by code duplication. Add phi node
5677 arguments for edges going out of BB_COPY. The blocks that were
5678 duplicated have BB_DUPLICATED set. */
5681 add_phi_args_after_copy_bb (basic_block bb_copy
)
5686 FOR_EACH_EDGE (e_copy
, ei
, bb_copy
->succs
)
5688 add_phi_args_after_copy_edge (e_copy
);
5692 /* Blocks in REGION_COPY array of length N_REGION were created by
5693 duplication of basic blocks. Add phi node arguments for edges
5694 going from these blocks. If E_COPY is not NULL, also add
5695 phi node arguments for its destination.*/
5698 add_phi_args_after_copy (basic_block
*region_copy
, unsigned n_region
,
5703 for (i
= 0; i
< n_region
; i
++)
5704 region_copy
[i
]->flags
|= BB_DUPLICATED
;
5706 for (i
= 0; i
< n_region
; i
++)
5707 add_phi_args_after_copy_bb (region_copy
[i
]);
5709 add_phi_args_after_copy_edge (e_copy
);
5711 for (i
= 0; i
< n_region
; i
++)
5712 region_copy
[i
]->flags
&= ~BB_DUPLICATED
;
5715 /* Duplicates a REGION (set of N_REGION basic blocks) with just a single
5716 important exit edge EXIT. By important we mean that no SSA name defined
5717 inside region is live over the other exit edges of the region. All entry
5718 edges to the region must go to ENTRY->dest. The edge ENTRY is redirected
5719 to the duplicate of the region. Dominance and loop information is
5720 updated if UPDATE_DOMINANCE is true, but not the SSA web. If
5721 UPDATE_DOMINANCE is false then we assume that the caller will update the
5722 dominance information after calling this function. The new basic
5723 blocks are stored to REGION_COPY in the same order as they had in REGION,
5724 provided that REGION_COPY is not NULL.
5725 The function returns false if it is unable to copy the region,
5729 gimple_duplicate_sese_region (edge entry
, edge exit
,
5730 basic_block
*region
, unsigned n_region
,
5731 basic_block
*region_copy
,
5732 bool update_dominance
)
5735 bool free_region_copy
= false, copying_header
= false;
5736 struct loop
*loop
= entry
->dest
->loop_father
;
5738 vec
<basic_block
> doms
;
5740 int total_freq
= 0, entry_freq
= 0;
5741 gcov_type total_count
= 0, entry_count
= 0;
5743 if (!can_copy_bbs_p (region
, n_region
))
5746 /* Some sanity checking. Note that we do not check for all possible
5747 missuses of the functions. I.e. if you ask to copy something weird,
5748 it will work, but the state of structures probably will not be
5750 for (i
= 0; i
< n_region
; i
++)
5752 /* We do not handle subloops, i.e. all the blocks must belong to the
5754 if (region
[i
]->loop_father
!= loop
)
5757 if (region
[i
] != entry
->dest
5758 && region
[i
] == loop
->header
)
5762 set_loop_copy (loop
, loop
);
5764 /* In case the function is used for loop header copying (which is the primary
5765 use), ensure that EXIT and its copy will be new latch and entry edges. */
5766 if (loop
->header
== entry
->dest
)
5768 copying_header
= true;
5769 set_loop_copy (loop
, loop_outer (loop
));
5771 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, exit
->src
))
5774 for (i
= 0; i
< n_region
; i
++)
5775 if (region
[i
] != exit
->src
5776 && dominated_by_p (CDI_DOMINATORS
, region
[i
], exit
->src
))
5782 region_copy
= XNEWVEC (basic_block
, n_region
);
5783 free_region_copy
= true;
5786 initialize_original_copy_tables ();
5788 /* Record blocks outside the region that are dominated by something
5790 if (update_dominance
)
5793 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
5796 if (entry
->dest
->count
)
5798 total_count
= entry
->dest
->count
;
5799 entry_count
= entry
->count
;
5800 /* Fix up corner cases, to avoid division by zero or creation of negative
5802 if (entry_count
> total_count
)
5803 entry_count
= total_count
;
5807 total_freq
= entry
->dest
->frequency
;
5808 entry_freq
= EDGE_FREQUENCY (entry
);
5809 /* Fix up corner cases, to avoid division by zero or creation of negative
5811 if (total_freq
== 0)
5813 else if (entry_freq
> total_freq
)
5814 entry_freq
= total_freq
;
5817 copy_bbs (region
, n_region
, region_copy
, &exit
, 1, &exit_copy
, loop
,
5818 split_edge_bb_loc (entry
), update_dominance
);
5821 scale_bbs_frequencies_gcov_type (region
, n_region
,
5822 total_count
- entry_count
,
5824 scale_bbs_frequencies_gcov_type (region_copy
, n_region
, entry_count
,
5829 scale_bbs_frequencies_int (region
, n_region
, total_freq
- entry_freq
,
5831 scale_bbs_frequencies_int (region_copy
, n_region
, entry_freq
, total_freq
);
5836 loop
->header
= exit
->dest
;
5837 loop
->latch
= exit
->src
;
5840 /* Redirect the entry and add the phi node arguments. */
5841 redirected
= redirect_edge_and_branch (entry
, get_bb_copy (entry
->dest
));
5842 gcc_assert (redirected
!= NULL
);
5843 flush_pending_stmts (entry
);
5845 /* Concerning updating of dominators: We must recount dominators
5846 for entry block and its copy. Anything that is outside of the
5847 region, but was dominated by something inside needs recounting as
5849 if (update_dominance
)
5851 set_immediate_dominator (CDI_DOMINATORS
, entry
->dest
, entry
->src
);
5852 doms
.safe_push (get_bb_original (entry
->dest
));
5853 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
5857 /* Add the other PHI node arguments. */
5858 add_phi_args_after_copy (region_copy
, n_region
, NULL
);
5860 if (free_region_copy
)
5863 free_original_copy_tables ();
5867 /* Checks if BB is part of the region defined by N_REGION BBS. */
5869 bb_part_of_region_p (basic_block bb
, basic_block
* bbs
, unsigned n_region
)
5873 for (n
= 0; n
< n_region
; n
++)
5881 /* Duplicates REGION consisting of N_REGION blocks. The new blocks
5882 are stored to REGION_COPY in the same order in that they appear
5883 in REGION, if REGION_COPY is not NULL. ENTRY is the entry to
5884 the region, EXIT an exit from it. The condition guarding EXIT
5885 is moved to ENTRY. Returns true if duplication succeeds, false
5911 gimple_duplicate_sese_tail (edge entry ATTRIBUTE_UNUSED
, edge exit ATTRIBUTE_UNUSED
,
5912 basic_block
*region ATTRIBUTE_UNUSED
, unsigned n_region ATTRIBUTE_UNUSED
,
5913 basic_block
*region_copy ATTRIBUTE_UNUSED
)
5916 bool free_region_copy
= false;
5917 struct loop
*loop
= exit
->dest
->loop_father
;
5918 struct loop
*orig_loop
= entry
->dest
->loop_father
;
5919 basic_block switch_bb
, entry_bb
, nentry_bb
;
5920 vec
<basic_block
> doms
;
5921 int total_freq
= 0, exit_freq
= 0;
5922 gcov_type total_count
= 0, exit_count
= 0;
5923 edge exits
[2], nexits
[2], e
;
5924 gimple_stmt_iterator gsi
;
5927 basic_block exit_bb
;
5928 gimple_stmt_iterator psi
;
5931 struct loop
*target
, *aloop
, *cloop
;
5933 gcc_assert (EDGE_COUNT (exit
->src
->succs
) == 2);
5935 exits
[1] = EDGE_SUCC (exit
->src
, EDGE_SUCC (exit
->src
, 0) == exit
);
5937 if (!can_copy_bbs_p (region
, n_region
))
5940 initialize_original_copy_tables ();
5941 set_loop_copy (orig_loop
, loop
);
5944 for (aloop
= orig_loop
->inner
; aloop
; aloop
= aloop
->next
)
5946 if (bb_part_of_region_p (aloop
->header
, region
, n_region
))
5948 cloop
= duplicate_loop (aloop
, target
);
5949 duplicate_subloops (aloop
, cloop
);
5955 region_copy
= XNEWVEC (basic_block
, n_region
);
5956 free_region_copy
= true;
5959 gcc_assert (!need_ssa_update_p (cfun
));
5961 /* Record blocks outside the region that are dominated by something
5963 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
5965 if (exit
->src
->count
)
5967 total_count
= exit
->src
->count
;
5968 exit_count
= exit
->count
;
5969 /* Fix up corner cases, to avoid division by zero or creation of negative
5971 if (exit_count
> total_count
)
5972 exit_count
= total_count
;
5976 total_freq
= exit
->src
->frequency
;
5977 exit_freq
= EDGE_FREQUENCY (exit
);
5978 /* Fix up corner cases, to avoid division by zero or creation of negative
5980 if (total_freq
== 0)
5982 if (exit_freq
> total_freq
)
5983 exit_freq
= total_freq
;
5986 copy_bbs (region
, n_region
, region_copy
, exits
, 2, nexits
, orig_loop
,
5987 split_edge_bb_loc (exit
), true);
5990 scale_bbs_frequencies_gcov_type (region
, n_region
,
5991 total_count
- exit_count
,
5993 scale_bbs_frequencies_gcov_type (region_copy
, n_region
, exit_count
,
5998 scale_bbs_frequencies_int (region
, n_region
, total_freq
- exit_freq
,
6000 scale_bbs_frequencies_int (region_copy
, n_region
, exit_freq
, total_freq
);
6003 /* Create the switch block, and put the exit condition to it. */
6004 entry_bb
= entry
->dest
;
6005 nentry_bb
= get_bb_copy (entry_bb
);
6006 if (!last_stmt (entry
->src
)
6007 || !stmt_ends_bb_p (last_stmt (entry
->src
)))
6008 switch_bb
= entry
->src
;
6010 switch_bb
= split_edge (entry
);
6011 set_immediate_dominator (CDI_DOMINATORS
, nentry_bb
, switch_bb
);
6013 gsi
= gsi_last_bb (switch_bb
);
6014 cond_stmt
= last_stmt (exit
->src
);
6015 gcc_assert (gimple_code (cond_stmt
) == GIMPLE_COND
);
6016 cond_stmt
= gimple_copy (cond_stmt
);
6018 gsi_insert_after (&gsi
, cond_stmt
, GSI_NEW_STMT
);
6020 sorig
= single_succ_edge (switch_bb
);
6021 sorig
->flags
= exits
[1]->flags
;
6022 snew
= make_edge (switch_bb
, nentry_bb
, exits
[0]->flags
);
6024 /* Register the new edge from SWITCH_BB in loop exit lists. */
6025 rescan_loop_exit (snew
, true, false);
6027 /* Add the PHI node arguments. */
6028 add_phi_args_after_copy (region_copy
, n_region
, snew
);
6030 /* Get rid of now superfluous conditions and associated edges (and phi node
6032 exit_bb
= exit
->dest
;
6034 e
= redirect_edge_and_branch (exits
[0], exits
[1]->dest
);
6035 PENDING_STMT (e
) = NULL
;
6037 /* The latch of ORIG_LOOP was copied, and so was the backedge
6038 to the original header. We redirect this backedge to EXIT_BB. */
6039 for (i
= 0; i
< n_region
; i
++)
6040 if (get_bb_original (region_copy
[i
]) == orig_loop
->latch
)
6042 gcc_assert (single_succ_edge (region_copy
[i
]));
6043 e
= redirect_edge_and_branch (single_succ_edge (region_copy
[i
]), exit_bb
);
6044 PENDING_STMT (e
) = NULL
;
6045 for (psi
= gsi_start_phis (exit_bb
);
6049 phi
= gsi_stmt (psi
);
6050 def
= PHI_ARG_DEF (phi
, nexits
[0]->dest_idx
);
6051 add_phi_arg (phi
, def
, e
, gimple_phi_arg_location_from_edge (phi
, e
));
6054 e
= redirect_edge_and_branch (nexits
[1], nexits
[0]->dest
);
6055 PENDING_STMT (e
) = NULL
;
6057 /* Anything that is outside of the region, but was dominated by something
6058 inside needs to update dominance info. */
6059 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
6061 /* Update the SSA web. */
6062 update_ssa (TODO_update_ssa
);
6064 if (free_region_copy
)
6067 free_original_copy_tables ();
6071 /* Add all the blocks dominated by ENTRY to the array BBS_P. Stop
6072 adding blocks when the dominator traversal reaches EXIT. This
6073 function silently assumes that ENTRY strictly dominates EXIT. */
6076 gather_blocks_in_sese_region (basic_block entry
, basic_block exit
,
6077 vec
<basic_block
> *bbs_p
)
6081 for (son
= first_dom_son (CDI_DOMINATORS
, entry
);
6083 son
= next_dom_son (CDI_DOMINATORS
, son
))
6085 bbs_p
->safe_push (son
);
6087 gather_blocks_in_sese_region (son
, exit
, bbs_p
);
6091 /* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
6092 The duplicates are recorded in VARS_MAP. */
6095 replace_by_duplicate_decl (tree
*tp
, struct pointer_map_t
*vars_map
,
6098 tree t
= *tp
, new_t
;
6099 struct function
*f
= DECL_STRUCT_FUNCTION (to_context
);
6102 if (DECL_CONTEXT (t
) == to_context
)
6105 loc
= pointer_map_contains (vars_map
, t
);
6109 loc
= pointer_map_insert (vars_map
, t
);
6113 new_t
= copy_var_decl (t
, DECL_NAME (t
), TREE_TYPE (t
));
6114 add_local_decl (f
, new_t
);
6118 gcc_assert (TREE_CODE (t
) == CONST_DECL
);
6119 new_t
= copy_node (t
);
6121 DECL_CONTEXT (new_t
) = to_context
;
6126 new_t
= (tree
) *loc
;
6132 /* Creates an ssa name in TO_CONTEXT equivalent to NAME.
6133 VARS_MAP maps old ssa names and var_decls to the new ones. */
6136 replace_ssa_name (tree name
, struct pointer_map_t
*vars_map
,
6142 gcc_assert (!virtual_operand_p (name
));
6144 loc
= pointer_map_contains (vars_map
, name
);
6148 tree decl
= SSA_NAME_VAR (name
);
6151 replace_by_duplicate_decl (&decl
, vars_map
, to_context
);
6152 new_name
= make_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6153 decl
, SSA_NAME_DEF_STMT (name
));
6154 if (SSA_NAME_IS_DEFAULT_DEF (name
))
6155 set_ssa_default_def (DECL_STRUCT_FUNCTION (to_context
),
6159 new_name
= copy_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6160 name
, SSA_NAME_DEF_STMT (name
));
6162 loc
= pointer_map_insert (vars_map
, name
);
6166 new_name
= (tree
) *loc
;
6177 struct pointer_map_t
*vars_map
;
6178 htab_t new_label_map
;
6179 struct pointer_map_t
*eh_map
;
6183 /* Helper for move_block_to_fn. Set TREE_BLOCK in every expression
6184 contained in *TP if it has been ORIG_BLOCK previously and change the
6185 DECL_CONTEXT of every local variable referenced in *TP. */
6188 move_stmt_op (tree
*tp
, int *walk_subtrees
, void *data
)
6190 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
6191 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6196 tree block
= TREE_BLOCK (t
);
6197 if (block
== p
->orig_block
6198 || (p
->orig_block
== NULL_TREE
6199 && block
!= NULL_TREE
))
6200 TREE_SET_BLOCK (t
, p
->new_block
);
6201 #ifdef ENABLE_CHECKING
6202 else if (block
!= NULL_TREE
)
6204 while (block
&& TREE_CODE (block
) == BLOCK
&& block
!= p
->orig_block
)
6205 block
= BLOCK_SUPERCONTEXT (block
);
6206 gcc_assert (block
== p
->orig_block
);
6210 else if (DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
)
6212 if (TREE_CODE (t
) == SSA_NAME
)
6213 *tp
= replace_ssa_name (t
, p
->vars_map
, p
->to_context
);
6214 else if (TREE_CODE (t
) == LABEL_DECL
)
6216 if (p
->new_label_map
)
6218 struct tree_map in
, *out
;
6220 out
= (struct tree_map
*)
6221 htab_find_with_hash (p
->new_label_map
, &in
, DECL_UID (t
));
6226 DECL_CONTEXT (t
) = p
->to_context
;
6228 else if (p
->remap_decls_p
)
6230 /* Replace T with its duplicate. T should no longer appear in the
6231 parent function, so this looks wasteful; however, it may appear
6232 in referenced_vars, and more importantly, as virtual operands of
6233 statements, and in alias lists of other variables. It would be
6234 quite difficult to expunge it from all those places. ??? It might
6235 suffice to do this for addressable variables. */
6236 if ((TREE_CODE (t
) == VAR_DECL
6237 && !is_global_var (t
))
6238 || TREE_CODE (t
) == CONST_DECL
)
6239 replace_by_duplicate_decl (tp
, p
->vars_map
, p
->to_context
);
6243 else if (TYPE_P (t
))
6249 /* Helper for move_stmt_r. Given an EH region number for the source
6250 function, map that to the duplicate EH regio number in the dest. */
6253 move_stmt_eh_region_nr (int old_nr
, struct move_stmt_d
*p
)
6255 eh_region old_r
, new_r
;
6258 old_r
= get_eh_region_from_number (old_nr
);
6259 slot
= pointer_map_contains (p
->eh_map
, old_r
);
6260 new_r
= (eh_region
) *slot
;
6262 return new_r
->index
;
6265 /* Similar, but operate on INTEGER_CSTs. */
6268 move_stmt_eh_region_tree_nr (tree old_t_nr
, struct move_stmt_d
*p
)
6272 old_nr
= tree_low_cst (old_t_nr
, 0);
6273 new_nr
= move_stmt_eh_region_nr (old_nr
, p
);
6275 return build_int_cst (integer_type_node
, new_nr
);
6278 /* Like move_stmt_op, but for gimple statements.
6280 Helper for move_block_to_fn. Set GIMPLE_BLOCK in every expression
6281 contained in the current statement in *GSI_P and change the
6282 DECL_CONTEXT of every local variable referenced in the current
6286 move_stmt_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
6287 struct walk_stmt_info
*wi
)
6289 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6290 gimple stmt
= gsi_stmt (*gsi_p
);
6291 tree block
= gimple_block (stmt
);
6293 if (block
== p
->orig_block
6294 || (p
->orig_block
== NULL_TREE
6295 && block
!= NULL_TREE
))
6296 gimple_set_block (stmt
, p
->new_block
);
6298 switch (gimple_code (stmt
))
6301 /* Remap the region numbers for __builtin_eh_{pointer,filter}. */
6303 tree r
, fndecl
= gimple_call_fndecl (stmt
);
6304 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
6305 switch (DECL_FUNCTION_CODE (fndecl
))
6307 case BUILT_IN_EH_COPY_VALUES
:
6308 r
= gimple_call_arg (stmt
, 1);
6309 r
= move_stmt_eh_region_tree_nr (r
, p
);
6310 gimple_call_set_arg (stmt
, 1, r
);
6313 case BUILT_IN_EH_POINTER
:
6314 case BUILT_IN_EH_FILTER
:
6315 r
= gimple_call_arg (stmt
, 0);
6316 r
= move_stmt_eh_region_tree_nr (r
, p
);
6317 gimple_call_set_arg (stmt
, 0, r
);
6328 int r
= gimple_resx_region (stmt
);
6329 r
= move_stmt_eh_region_nr (r
, p
);
6330 gimple_resx_set_region (stmt
, r
);
6334 case GIMPLE_EH_DISPATCH
:
6336 int r
= gimple_eh_dispatch_region (stmt
);
6337 r
= move_stmt_eh_region_nr (r
, p
);
6338 gimple_eh_dispatch_set_region (stmt
, r
);
6342 case GIMPLE_OMP_RETURN
:
6343 case GIMPLE_OMP_CONTINUE
:
6346 if (is_gimple_omp (stmt
))
6348 /* Do not remap variables inside OMP directives. Variables
6349 referenced in clauses and directive header belong to the
6350 parent function and should not be moved into the child
6352 bool save_remap_decls_p
= p
->remap_decls_p
;
6353 p
->remap_decls_p
= false;
6354 *handled_ops_p
= true;
6356 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt
), move_stmt_r
,
6359 p
->remap_decls_p
= save_remap_decls_p
;
6367 /* Move basic block BB from function CFUN to function DEST_FN. The
6368 block is moved out of the original linked list and placed after
6369 block AFTER in the new list. Also, the block is removed from the
6370 original array of blocks and placed in DEST_FN's array of blocks.
6371 If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
6372 updated to reflect the moved edges.
6374 The local variables are remapped to new instances, VARS_MAP is used
6375 to record the mapping. */
6378 move_block_to_fn (struct function
*dest_cfun
, basic_block bb
,
6379 basic_block after
, bool update_edge_count_p
,
6380 struct move_stmt_d
*d
)
6382 struct control_flow_graph
*cfg
;
6385 gimple_stmt_iterator si
;
6386 unsigned old_len
, new_len
;
6388 /* Remove BB from dominance structures. */
6389 delete_from_dominance_info (CDI_DOMINATORS
, bb
);
6391 /* Move BB from its current loop to the copy in the new function. */
6394 struct loop
*new_loop
= (struct loop
*)bb
->loop_father
->aux
;
6396 bb
->loop_father
= new_loop
;
6399 /* Link BB to the new linked list. */
6400 move_block_after (bb
, after
);
6402 /* Update the edge count in the corresponding flowgraphs. */
6403 if (update_edge_count_p
)
6404 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6406 cfun
->cfg
->x_n_edges
--;
6407 dest_cfun
->cfg
->x_n_edges
++;
6410 /* Remove BB from the original basic block array. */
6411 (*cfun
->cfg
->x_basic_block_info
)[bb
->index
] = NULL
;
6412 cfun
->cfg
->x_n_basic_blocks
--;
6414 /* Grow DEST_CFUN's basic block array if needed. */
6415 cfg
= dest_cfun
->cfg
;
6416 cfg
->x_n_basic_blocks
++;
6417 if (bb
->index
>= cfg
->x_last_basic_block
)
6418 cfg
->x_last_basic_block
= bb
->index
+ 1;
6420 old_len
= vec_safe_length (cfg
->x_basic_block_info
);
6421 if ((unsigned) cfg
->x_last_basic_block
>= old_len
)
6423 new_len
= cfg
->x_last_basic_block
+ (cfg
->x_last_basic_block
+ 3) / 4;
6424 vec_safe_grow_cleared (cfg
->x_basic_block_info
, new_len
);
6427 (*cfg
->x_basic_block_info
)[bb
->index
] = bb
;
6429 /* Remap the variables in phi nodes. */
6430 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); )
6432 gimple phi
= gsi_stmt (si
);
6434 tree op
= PHI_RESULT (phi
);
6438 if (virtual_operand_p (op
))
6440 /* Remove the phi nodes for virtual operands (alias analysis will be
6441 run for the new function, anyway). */
6442 remove_phi_node (&si
, true);
6446 SET_PHI_RESULT (phi
,
6447 replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
6448 FOR_EACH_PHI_ARG (use
, phi
, oi
, SSA_OP_USE
)
6450 op
= USE_FROM_PTR (use
);
6451 if (TREE_CODE (op
) == SSA_NAME
)
6452 SET_USE (use
, replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
6455 for (i
= 0; i
< EDGE_COUNT (bb
->preds
); i
++)
6457 location_t locus
= gimple_phi_arg_location (phi
, i
);
6458 tree block
= LOCATION_BLOCK (locus
);
6460 if (locus
== UNKNOWN_LOCATION
)
6462 if (d
->orig_block
== NULL_TREE
|| block
== d
->orig_block
)
6464 if (d
->new_block
== NULL_TREE
)
6465 locus
= LOCATION_LOCUS (locus
);
6467 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, d
->new_block
);
6468 gimple_phi_arg_set_location (phi
, i
, locus
);
6475 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6477 gimple stmt
= gsi_stmt (si
);
6478 struct walk_stmt_info wi
;
6480 memset (&wi
, 0, sizeof (wi
));
6482 walk_gimple_stmt (&si
, move_stmt_r
, move_stmt_op
, &wi
);
6484 if (gimple_code (stmt
) == GIMPLE_LABEL
)
6486 tree label
= gimple_label_label (stmt
);
6487 int uid
= LABEL_DECL_UID (label
);
6489 gcc_assert (uid
> -1);
6491 old_len
= vec_safe_length (cfg
->x_label_to_block_map
);
6492 if (old_len
<= (unsigned) uid
)
6494 new_len
= 3 * uid
/ 2 + 1;
6495 vec_safe_grow_cleared (cfg
->x_label_to_block_map
, new_len
);
6498 (*cfg
->x_label_to_block_map
)[uid
] = bb
;
6499 (*cfun
->cfg
->x_label_to_block_map
)[uid
] = NULL
;
6501 gcc_assert (DECL_CONTEXT (label
) == dest_cfun
->decl
);
6503 if (uid
>= dest_cfun
->cfg
->last_label_uid
)
6504 dest_cfun
->cfg
->last_label_uid
= uid
+ 1;
6507 maybe_duplicate_eh_stmt_fn (dest_cfun
, stmt
, cfun
, stmt
, d
->eh_map
, 0);
6508 remove_stmt_from_eh_lp_fn (cfun
, stmt
);
6510 gimple_duplicate_stmt_histograms (dest_cfun
, stmt
, cfun
, stmt
);
6511 gimple_remove_stmt_histograms (cfun
, stmt
);
6513 /* We cannot leave any operands allocated from the operand caches of
6514 the current function. */
6515 free_stmt_operands (stmt
);
6516 push_cfun (dest_cfun
);
6521 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6522 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
6524 tree block
= LOCATION_BLOCK (e
->goto_locus
);
6525 if (d
->orig_block
== NULL_TREE
6526 || block
== d
->orig_block
)
6527 e
->goto_locus
= d
->new_block
?
6528 COMBINE_LOCATION_DATA (line_table
, e
->goto_locus
, d
->new_block
) :
6529 LOCATION_LOCUS (e
->goto_locus
);
6533 /* Examine the statements in BB (which is in SRC_CFUN); find and return
6534 the outermost EH region. Use REGION as the incoming base EH region. */
6537 find_outermost_region_in_block (struct function
*src_cfun
,
6538 basic_block bb
, eh_region region
)
6540 gimple_stmt_iterator si
;
6542 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6544 gimple stmt
= gsi_stmt (si
);
6545 eh_region stmt_region
;
6548 lp_nr
= lookup_stmt_eh_lp_fn (src_cfun
, stmt
);
6549 stmt_region
= get_eh_region_from_lp_number_fn (src_cfun
, lp_nr
);
6553 region
= stmt_region
;
6554 else if (stmt_region
!= region
)
6556 region
= eh_region_outermost (src_cfun
, stmt_region
, region
);
6557 gcc_assert (region
!= NULL
);
6566 new_label_mapper (tree decl
, void *data
)
6568 htab_t hash
= (htab_t
) data
;
6572 gcc_assert (TREE_CODE (decl
) == LABEL_DECL
);
6574 m
= XNEW (struct tree_map
);
6575 m
->hash
= DECL_UID (decl
);
6576 m
->base
.from
= decl
;
6577 m
->to
= create_artificial_label (UNKNOWN_LOCATION
);
6578 LABEL_DECL_UID (m
->to
) = LABEL_DECL_UID (decl
);
6579 if (LABEL_DECL_UID (m
->to
) >= cfun
->cfg
->last_label_uid
)
6580 cfun
->cfg
->last_label_uid
= LABEL_DECL_UID (m
->to
) + 1;
6582 slot
= htab_find_slot_with_hash (hash
, m
, m
->hash
, INSERT
);
6583 gcc_assert (*slot
== NULL
);
6590 /* Change DECL_CONTEXT of all BLOCK_VARS in block, including
6594 replace_block_vars_by_duplicates (tree block
, struct pointer_map_t
*vars_map
,
6599 for (tp
= &BLOCK_VARS (block
); *tp
; tp
= &DECL_CHAIN (*tp
))
6602 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != CONST_DECL
)
6604 replace_by_duplicate_decl (&t
, vars_map
, to_context
);
6607 if (TREE_CODE (*tp
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (*tp
))
6609 SET_DECL_VALUE_EXPR (t
, DECL_VALUE_EXPR (*tp
));
6610 DECL_HAS_VALUE_EXPR_P (t
) = 1;
6612 DECL_CHAIN (t
) = DECL_CHAIN (*tp
);
6617 for (block
= BLOCK_SUBBLOCKS (block
); block
; block
= BLOCK_CHAIN (block
))
6618 replace_block_vars_by_duplicates (block
, vars_map
, to_context
);
6621 /* Fixup the loop arrays and numbers after moving LOOP and its subloops
6625 fixup_loop_arrays_after_move (struct function
*fn1
, struct function
*fn2
,
6628 /* Discard it from the old loop array. */
6629 (*get_loops (fn1
))[loop
->num
] = NULL
;
6631 /* Place it in the new loop array, assigning it a new number. */
6632 loop
->num
= number_of_loops (fn2
);
6633 vec_safe_push (loops_for_fn (fn2
)->larray
, loop
);
6635 /* Recurse to children. */
6636 for (loop
= loop
->inner
; loop
; loop
= loop
->next
)
6637 fixup_loop_arrays_after_move (fn1
, fn2
, loop
);
6640 /* Move a single-entry, single-exit region delimited by ENTRY_BB and
6641 EXIT_BB to function DEST_CFUN. The whole region is replaced by a
6642 single basic block in the original CFG and the new basic block is
6643 returned. DEST_CFUN must not have a CFG yet.
6645 Note that the region need not be a pure SESE region. Blocks inside
6646 the region may contain calls to abort/exit. The only restriction
6647 is that ENTRY_BB should be the only entry point and it must
6650 Change TREE_BLOCK of all statements in ORIG_BLOCK to the new
6651 functions outermost BLOCK, move all subblocks of ORIG_BLOCK
6652 to the new function.
6654 All local variables referenced in the region are assumed to be in
6655 the corresponding BLOCK_VARS and unexpanded variable lists
6656 associated with DEST_CFUN. */
6659 move_sese_region_to_fn (struct function
*dest_cfun
, basic_block entry_bb
,
6660 basic_block exit_bb
, tree orig_block
)
6662 vec
<basic_block
> bbs
, dom_bbs
;
6663 basic_block dom_entry
= get_immediate_dominator (CDI_DOMINATORS
, entry_bb
);
6664 basic_block after
, bb
, *entry_pred
, *exit_succ
, abb
;
6665 struct function
*saved_cfun
= cfun
;
6666 int *entry_flag
, *exit_flag
;
6667 unsigned *entry_prob
, *exit_prob
;
6668 unsigned i
, num_entry_edges
, num_exit_edges
, num_nodes
;
6671 htab_t new_label_map
;
6672 struct pointer_map_t
*vars_map
, *eh_map
;
6673 struct loop
*loop
= entry_bb
->loop_father
;
6674 struct loop
*loop0
= get_loop (saved_cfun
, 0);
6675 struct move_stmt_d d
;
6677 /* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
6679 gcc_assert (entry_bb
!= exit_bb
6681 || dominated_by_p (CDI_DOMINATORS
, exit_bb
, entry_bb
)));
6683 /* Collect all the blocks in the region. Manually add ENTRY_BB
6684 because it won't be added by dfs_enumerate_from. */
6686 bbs
.safe_push (entry_bb
);
6687 gather_blocks_in_sese_region (entry_bb
, exit_bb
, &bbs
);
6689 /* The blocks that used to be dominated by something in BBS will now be
6690 dominated by the new block. */
6691 dom_bbs
= get_dominated_by_region (CDI_DOMINATORS
,
6695 /* Detach ENTRY_BB and EXIT_BB from CFUN->CFG. We need to remember
6696 the predecessor edges to ENTRY_BB and the successor edges to
6697 EXIT_BB so that we can re-attach them to the new basic block that
6698 will replace the region. */
6699 num_entry_edges
= EDGE_COUNT (entry_bb
->preds
);
6700 entry_pred
= XNEWVEC (basic_block
, num_entry_edges
);
6701 entry_flag
= XNEWVEC (int, num_entry_edges
);
6702 entry_prob
= XNEWVEC (unsigned, num_entry_edges
);
6704 for (ei
= ei_start (entry_bb
->preds
); (e
= ei_safe_edge (ei
)) != NULL
;)
6706 entry_prob
[i
] = e
->probability
;
6707 entry_flag
[i
] = e
->flags
;
6708 entry_pred
[i
++] = e
->src
;
6714 num_exit_edges
= EDGE_COUNT (exit_bb
->succs
);
6715 exit_succ
= XNEWVEC (basic_block
, num_exit_edges
);
6716 exit_flag
= XNEWVEC (int, num_exit_edges
);
6717 exit_prob
= XNEWVEC (unsigned, num_exit_edges
);
6719 for (ei
= ei_start (exit_bb
->succs
); (e
= ei_safe_edge (ei
)) != NULL
;)
6721 exit_prob
[i
] = e
->probability
;
6722 exit_flag
[i
] = e
->flags
;
6723 exit_succ
[i
++] = e
->dest
;
6735 /* Switch context to the child function to initialize DEST_FN's CFG. */
6736 gcc_assert (dest_cfun
->cfg
== NULL
);
6737 push_cfun (dest_cfun
);
6739 init_empty_tree_cfg ();
6741 /* Initialize EH information for the new function. */
6743 new_label_map
= NULL
;
6746 eh_region region
= NULL
;
6748 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6749 region
= find_outermost_region_in_block (saved_cfun
, bb
, region
);
6751 init_eh_for_function ();
6754 new_label_map
= htab_create (17, tree_map_hash
, tree_map_eq
, free
);
6755 eh_map
= duplicate_eh_regions (saved_cfun
, region
, 0,
6756 new_label_mapper
, new_label_map
);
6760 /* Initialize an empty loop tree. */
6761 struct loops
*loops
= ggc_alloc_cleared_loops ();
6762 init_loops_structure (dest_cfun
, loops
, 1);
6763 loops
->state
= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
6764 set_loops_for_fn (dest_cfun
, loops
);
6766 /* Move the outlined loop tree part. */
6767 num_nodes
= bbs
.length ();
6768 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6770 if (bb
->loop_father
->header
== bb
)
6772 struct loop
*this_loop
= bb
->loop_father
;
6773 struct loop
*outer
= loop_outer (this_loop
);
6775 /* If the SESE region contains some bbs ending with
6776 a noreturn call, those are considered to belong
6777 to the outermost loop in saved_cfun, rather than
6778 the entry_bb's loop_father. */
6782 num_nodes
-= this_loop
->num_nodes
;
6783 flow_loop_tree_node_remove (bb
->loop_father
);
6784 flow_loop_tree_node_add (get_loop (dest_cfun
, 0), this_loop
);
6785 fixup_loop_arrays_after_move (saved_cfun
, cfun
, this_loop
);
6788 else if (bb
->loop_father
== loop0
&& loop0
!= loop
)
6791 /* Remove loop exits from the outlined region. */
6792 if (loops_for_fn (saved_cfun
)->exits
)
6793 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6795 void **slot
= htab_find_slot_with_hash
6796 (loops_for_fn (saved_cfun
)->exits
, e
,
6797 htab_hash_pointer (e
), NO_INSERT
);
6799 htab_clear_slot (loops_for_fn (saved_cfun
)->exits
, slot
);
6804 /* Adjust the number of blocks in the tree root of the outlined part. */
6805 get_loop (dest_cfun
, 0)->num_nodes
= bbs
.length () + 2;
6807 /* Setup a mapping to be used by move_block_to_fn. */
6808 loop
->aux
= current_loops
->tree_root
;
6809 loop0
->aux
= current_loops
->tree_root
;
6813 /* Move blocks from BBS into DEST_CFUN. */
6814 gcc_assert (bbs
.length () >= 2);
6815 after
= dest_cfun
->cfg
->x_entry_block_ptr
;
6816 vars_map
= pointer_map_create ();
6818 memset (&d
, 0, sizeof (d
));
6819 d
.orig_block
= orig_block
;
6820 d
.new_block
= DECL_INITIAL (dest_cfun
->decl
);
6821 d
.from_context
= cfun
->decl
;
6822 d
.to_context
= dest_cfun
->decl
;
6823 d
.vars_map
= vars_map
;
6824 d
.new_label_map
= new_label_map
;
6826 d
.remap_decls_p
= true;
6828 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6830 /* No need to update edge counts on the last block. It has
6831 already been updated earlier when we detached the region from
6832 the original CFG. */
6833 move_block_to_fn (dest_cfun
, bb
, after
, bb
!= exit_bb
, &d
);
6839 /* Loop sizes are no longer correct, fix them up. */
6840 loop
->num_nodes
-= num_nodes
;
6841 for (struct loop
*outer
= loop_outer (loop
);
6842 outer
; outer
= loop_outer (outer
))
6843 outer
->num_nodes
-= num_nodes
;
6844 loop0
->num_nodes
-= bbs
.length () - num_nodes
;
6846 if (saved_cfun
->has_simduid_loops
|| saved_cfun
->has_force_vect_loops
)
6849 for (i
= 0; vec_safe_iterate (loops
->larray
, i
, &aloop
); i
++)
6854 replace_by_duplicate_decl (&aloop
->simduid
, d
.vars_map
,
6856 dest_cfun
->has_simduid_loops
= true;
6858 if (aloop
->force_vect
)
6859 dest_cfun
->has_force_vect_loops
= true;
6863 /* Rewire BLOCK_SUBBLOCKS of orig_block. */
6867 gcc_assert (BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
6869 BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
6870 = BLOCK_SUBBLOCKS (orig_block
);
6871 for (block
= BLOCK_SUBBLOCKS (orig_block
);
6872 block
; block
= BLOCK_CHAIN (block
))
6873 BLOCK_SUPERCONTEXT (block
) = DECL_INITIAL (dest_cfun
->decl
);
6874 BLOCK_SUBBLOCKS (orig_block
) = NULL_TREE
;
6877 replace_block_vars_by_duplicates (DECL_INITIAL (dest_cfun
->decl
),
6878 vars_map
, dest_cfun
->decl
);
6881 htab_delete (new_label_map
);
6883 pointer_map_destroy (eh_map
);
6884 pointer_map_destroy (vars_map
);
6886 /* Rewire the entry and exit blocks. The successor to the entry
6887 block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
6888 the child function. Similarly, the predecessor of DEST_FN's
6889 EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR. We
6890 need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
6891 various CFG manipulation function get to the right CFG.
6893 FIXME, this is silly. The CFG ought to become a parameter to
6895 push_cfun (dest_cfun
);
6896 make_edge (ENTRY_BLOCK_PTR
, entry_bb
, EDGE_FALLTHRU
);
6898 make_edge (exit_bb
, EXIT_BLOCK_PTR
, 0);
6901 /* Back in the original function, the SESE region has disappeared,
6902 create a new basic block in its place. */
6903 bb
= create_empty_bb (entry_pred
[0]);
6905 add_bb_to_loop (bb
, loop
);
6906 for (i
= 0; i
< num_entry_edges
; i
++)
6908 e
= make_edge (entry_pred
[i
], bb
, entry_flag
[i
]);
6909 e
->probability
= entry_prob
[i
];
6912 for (i
= 0; i
< num_exit_edges
; i
++)
6914 e
= make_edge (bb
, exit_succ
[i
], exit_flag
[i
]);
6915 e
->probability
= exit_prob
[i
];
6918 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom_entry
);
6919 FOR_EACH_VEC_ELT (dom_bbs
, i
, abb
)
6920 set_immediate_dominator (CDI_DOMINATORS
, abb
, bb
);
6938 /* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in dumpfile.h)
6942 dump_function_to_file (tree fndecl
, FILE *file
, int flags
)
6944 tree arg
, var
, old_current_fndecl
= current_function_decl
;
6945 struct function
*dsf
;
6946 bool ignore_topmost_bind
= false, any_var
= false;
6949 bool tmclone
= (TREE_CODE (fndecl
) == FUNCTION_DECL
6950 && decl_is_tm_clone (fndecl
));
6951 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
6953 current_function_decl
= fndecl
;
6954 fprintf (file
, "%s %s(", function_name (fun
), tmclone
? "[tm-clone] " : "");
6956 arg
= DECL_ARGUMENTS (fndecl
);
6959 print_generic_expr (file
, TREE_TYPE (arg
), dump_flags
);
6960 fprintf (file
, " ");
6961 print_generic_expr (file
, arg
, dump_flags
);
6962 if (flags
& TDF_VERBOSE
)
6963 print_node (file
, "", arg
, 4);
6964 if (DECL_CHAIN (arg
))
6965 fprintf (file
, ", ");
6966 arg
= DECL_CHAIN (arg
);
6968 fprintf (file
, ")\n");
6970 if (flags
& TDF_VERBOSE
)
6971 print_node (file
, "", fndecl
, 2);
6973 dsf
= DECL_STRUCT_FUNCTION (fndecl
);
6974 if (dsf
&& (flags
& TDF_EH
))
6975 dump_eh_tree (file
, dsf
);
6977 if (flags
& TDF_RAW
&& !gimple_has_body_p (fndecl
))
6979 dump_node (fndecl
, TDF_SLIM
| flags
, file
);
6980 current_function_decl
= old_current_fndecl
;
6984 /* When GIMPLE is lowered, the variables are no longer available in
6985 BIND_EXPRs, so display them separately. */
6986 if (fun
&& fun
->decl
== fndecl
&& (fun
->curr_properties
& PROP_gimple_lcf
))
6989 ignore_topmost_bind
= true;
6991 fprintf (file
, "{\n");
6992 if (!vec_safe_is_empty (fun
->local_decls
))
6993 FOR_EACH_LOCAL_DECL (fun
, ix
, var
)
6995 print_generic_decl (file
, var
, flags
);
6996 if (flags
& TDF_VERBOSE
)
6997 print_node (file
, "", var
, 4);
6998 fprintf (file
, "\n");
7002 if (gimple_in_ssa_p (cfun
))
7003 for (ix
= 1; ix
< num_ssa_names
; ++ix
)
7005 tree name
= ssa_name (ix
);
7006 if (name
&& !SSA_NAME_VAR (name
))
7008 fprintf (file
, " ");
7009 print_generic_expr (file
, TREE_TYPE (name
), flags
);
7010 fprintf (file
, " ");
7011 print_generic_expr (file
, name
, flags
);
7012 fprintf (file
, ";\n");
7019 if (fun
&& fun
->decl
== fndecl
7021 && basic_block_info_for_function (fun
))
7023 /* If the CFG has been built, emit a CFG-based dump. */
7024 if (!ignore_topmost_bind
)
7025 fprintf (file
, "{\n");
7027 if (any_var
&& n_basic_blocks_for_function (fun
))
7028 fprintf (file
, "\n");
7030 FOR_EACH_BB_FN (bb
, fun
)
7031 dump_bb (file
, bb
, 2, flags
| TDF_COMMENT
);
7033 fprintf (file
, "}\n");
7035 else if (DECL_SAVED_TREE (fndecl
) == NULL
)
7037 /* The function is now in GIMPLE form but the CFG has not been
7038 built yet. Emit the single sequence of GIMPLE statements
7039 that make up its body. */
7040 gimple_seq body
= gimple_body (fndecl
);
7042 if (gimple_seq_first_stmt (body
)
7043 && gimple_seq_first_stmt (body
) == gimple_seq_last_stmt (body
)
7044 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
)
7045 print_gimple_seq (file
, body
, 0, flags
);
7048 if (!ignore_topmost_bind
)
7049 fprintf (file
, "{\n");
7052 fprintf (file
, "\n");
7054 print_gimple_seq (file
, body
, 2, flags
);
7055 fprintf (file
, "}\n");
7062 /* Make a tree based dump. */
7063 chain
= DECL_SAVED_TREE (fndecl
);
7064 if (chain
&& TREE_CODE (chain
) == BIND_EXPR
)
7066 if (ignore_topmost_bind
)
7068 chain
= BIND_EXPR_BODY (chain
);
7076 if (!ignore_topmost_bind
)
7077 fprintf (file
, "{\n");
7082 fprintf (file
, "\n");
7084 print_generic_stmt_indented (file
, chain
, flags
, indent
);
7085 if (ignore_topmost_bind
)
7086 fprintf (file
, "}\n");
7089 if (flags
& TDF_ENUMERATE_LOCALS
)
7090 dump_enumerated_decls (file
, flags
);
7091 fprintf (file
, "\n\n");
7093 current_function_decl
= old_current_fndecl
;
7096 /* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h) */
7099 debug_function (tree fn
, int flags
)
7101 dump_function_to_file (fn
, stderr
, flags
);
7105 /* Print on FILE the indexes for the predecessors of basic_block BB. */
7108 print_pred_bbs (FILE *file
, basic_block bb
)
7113 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7114 fprintf (file
, "bb_%d ", e
->src
->index
);
7118 /* Print on FILE the indexes for the successors of basic_block BB. */
7121 print_succ_bbs (FILE *file
, basic_block bb
)
7126 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7127 fprintf (file
, "bb_%d ", e
->dest
->index
);
7130 /* Print to FILE the basic block BB following the VERBOSITY level. */
7133 print_loops_bb (FILE *file
, basic_block bb
, int indent
, int verbosity
)
7135 char *s_indent
= (char *) alloca ((size_t) indent
+ 1);
7136 memset ((void *) s_indent
, ' ', (size_t) indent
);
7137 s_indent
[indent
] = '\0';
7139 /* Print basic_block's header. */
7142 fprintf (file
, "%s bb_%d (preds = {", s_indent
, bb
->index
);
7143 print_pred_bbs (file
, bb
);
7144 fprintf (file
, "}, succs = {");
7145 print_succ_bbs (file
, bb
);
7146 fprintf (file
, "})\n");
7149 /* Print basic_block's body. */
7152 fprintf (file
, "%s {\n", s_indent
);
7153 dump_bb (file
, bb
, indent
+ 4, TDF_VOPS
|TDF_MEMSYMS
);
7154 fprintf (file
, "%s }\n", s_indent
);
7158 static void print_loop_and_siblings (FILE *, struct loop
*, int, int);
7160 /* Pretty print LOOP on FILE, indented INDENT spaces. Following
7161 VERBOSITY level this outputs the contents of the loop, or just its
7165 print_loop (FILE *file
, struct loop
*loop
, int indent
, int verbosity
)
7173 s_indent
= (char *) alloca ((size_t) indent
+ 1);
7174 memset ((void *) s_indent
, ' ', (size_t) indent
);
7175 s_indent
[indent
] = '\0';
7177 /* Print loop's header. */
7178 fprintf (file
, "%sloop_%d (", s_indent
, loop
->num
);
7180 fprintf (file
, "header = %d", loop
->header
->index
);
7183 fprintf (file
, "deleted)\n");
7187 fprintf (file
, ", latch = %d", loop
->latch
->index
);
7189 fprintf (file
, ", multiple latches");
7190 fprintf (file
, ", niter = ");
7191 print_generic_expr (file
, loop
->nb_iterations
, 0);
7193 if (loop
->any_upper_bound
)
7195 fprintf (file
, ", upper_bound = ");
7196 dump_double_int (file
, loop
->nb_iterations_upper_bound
, true);
7199 if (loop
->any_estimate
)
7201 fprintf (file
, ", estimate = ");
7202 dump_double_int (file
, loop
->nb_iterations_estimate
, true);
7204 fprintf (file
, ")\n");
7206 /* Print loop's body. */
7209 fprintf (file
, "%s{\n", s_indent
);
7211 if (bb
->loop_father
== loop
)
7212 print_loops_bb (file
, bb
, indent
, verbosity
);
7214 print_loop_and_siblings (file
, loop
->inner
, indent
+ 2, verbosity
);
7215 fprintf (file
, "%s}\n", s_indent
);
7219 /* Print the LOOP and its sibling loops on FILE, indented INDENT
7220 spaces. Following VERBOSITY level this outputs the contents of the
7221 loop, or just its structure. */
7224 print_loop_and_siblings (FILE *file
, struct loop
*loop
, int indent
,
7230 print_loop (file
, loop
, indent
, verbosity
);
7231 print_loop_and_siblings (file
, loop
->next
, indent
, verbosity
);
7234 /* Follow a CFG edge from the entry point of the program, and on entry
7235 of a loop, pretty print the loop structure on FILE. */
7238 print_loops (FILE *file
, int verbosity
)
7242 bb
= ENTRY_BLOCK_PTR
;
7243 if (bb
&& bb
->loop_father
)
7244 print_loop_and_siblings (file
, bb
->loop_father
, 0, verbosity
);
7250 debug (struct loop
&ref
)
7252 print_loop (stderr
, &ref
, 0, /*verbosity*/0);
7256 debug (struct loop
*ptr
)
7261 fprintf (stderr
, "<nil>\n");
7264 /* Dump a loop verbosely. */
7267 debug_verbose (struct loop
&ref
)
7269 print_loop (stderr
, &ref
, 0, /*verbosity*/3);
7273 debug_verbose (struct loop
*ptr
)
7278 fprintf (stderr
, "<nil>\n");
7282 /* Debugging loops structure at tree level, at some VERBOSITY level. */
7285 debug_loops (int verbosity
)
7287 print_loops (stderr
, verbosity
);
7290 /* Print on stderr the code of LOOP, at some VERBOSITY level. */
7293 debug_loop (struct loop
*loop
, int verbosity
)
7295 print_loop (stderr
, loop
, 0, verbosity
);
7298 /* Print on stderr the code of loop number NUM, at some VERBOSITY
7302 debug_loop_num (unsigned num
, int verbosity
)
7304 debug_loop (get_loop (cfun
, num
), verbosity
);
7307 /* Return true if BB ends with a call, possibly followed by some
7308 instructions that must stay with the call. Return false,
7312 gimple_block_ends_with_call_p (basic_block bb
)
7314 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
7315 return !gsi_end_p (gsi
) && is_gimple_call (gsi_stmt (gsi
));
7319 /* Return true if BB ends with a conditional branch. Return false,
7323 gimple_block_ends_with_condjump_p (const_basic_block bb
)
7325 gimple stmt
= last_stmt (CONST_CAST_BB (bb
));
7326 return (stmt
&& gimple_code (stmt
) == GIMPLE_COND
);
7330 /* Return true if we need to add fake edge to exit at statement T.
7331 Helper function for gimple_flow_call_edges_add. */
7334 need_fake_edge_p (gimple t
)
7336 tree fndecl
= NULL_TREE
;
7339 /* NORETURN and LONGJMP calls already have an edge to exit.
7340 CONST and PURE calls do not need one.
7341 We don't currently check for CONST and PURE here, although
7342 it would be a good idea, because those attributes are
7343 figured out from the RTL in mark_constant_function, and
7344 the counter incrementation code from -fprofile-arcs
7345 leads to different results from -fbranch-probabilities. */
7346 if (is_gimple_call (t
))
7348 fndecl
= gimple_call_fndecl (t
);
7349 call_flags
= gimple_call_flags (t
);
7352 if (is_gimple_call (t
)
7354 && DECL_BUILT_IN (fndecl
)
7355 && (call_flags
& ECF_NOTHROW
)
7356 && !(call_flags
& ECF_RETURNS_TWICE
)
7357 /* fork() doesn't really return twice, but the effect of
7358 wrapping it in __gcov_fork() which calls __gcov_flush()
7359 and clears the counters before forking has the same
7360 effect as returning twice. Force a fake edge. */
7361 && !(DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7362 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FORK
))
7365 if (is_gimple_call (t
))
7371 if (!(call_flags
& ECF_NORETURN
))
7375 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7376 if ((e
->flags
& EDGE_FAKE
) == 0)
7380 if (gimple_code (t
) == GIMPLE_ASM
7381 && (gimple_asm_volatile_p (t
) || gimple_asm_input_p (t
)))
7388 /* Add fake edges to the function exit for any non constant and non
7389 noreturn calls (or noreturn calls with EH/abnormal edges),
7390 volatile inline assembly in the bitmap of blocks specified by BLOCKS
7391 or to the whole CFG if BLOCKS is zero. Return the number of blocks
7394 The goal is to expose cases in which entering a basic block does
7395 not imply that all subsequent instructions must be executed. */
7398 gimple_flow_call_edges_add (sbitmap blocks
)
7401 int blocks_split
= 0;
7402 int last_bb
= last_basic_block
;
7403 bool check_last_block
= false;
7405 if (n_basic_blocks
== NUM_FIXED_BLOCKS
)
7409 check_last_block
= true;
7411 check_last_block
= bitmap_bit_p (blocks
, EXIT_BLOCK_PTR
->prev_bb
->index
);
7413 /* In the last basic block, before epilogue generation, there will be
7414 a fallthru edge to EXIT. Special care is required if the last insn
7415 of the last basic block is a call because make_edge folds duplicate
7416 edges, which would result in the fallthru edge also being marked
7417 fake, which would result in the fallthru edge being removed by
7418 remove_fake_edges, which would result in an invalid CFG.
7420 Moreover, we can't elide the outgoing fake edge, since the block
7421 profiler needs to take this into account in order to solve the minimal
7422 spanning tree in the case that the call doesn't return.
7424 Handle this by adding a dummy instruction in a new last basic block. */
7425 if (check_last_block
)
7427 basic_block bb
= EXIT_BLOCK_PTR
->prev_bb
;
7428 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
7431 if (!gsi_end_p (gsi
))
7434 if (t
&& need_fake_edge_p (t
))
7438 e
= find_edge (bb
, EXIT_BLOCK_PTR
);
7441 gsi_insert_on_edge (e
, gimple_build_nop ());
7442 gsi_commit_edge_inserts ();
7447 /* Now add fake edges to the function exit for any non constant
7448 calls since there is no way that we can determine if they will
7450 for (i
= 0; i
< last_bb
; i
++)
7452 basic_block bb
= BASIC_BLOCK (i
);
7453 gimple_stmt_iterator gsi
;
7454 gimple stmt
, last_stmt
;
7459 if (blocks
&& !bitmap_bit_p (blocks
, i
))
7462 gsi
= gsi_last_nondebug_bb (bb
);
7463 if (!gsi_end_p (gsi
))
7465 last_stmt
= gsi_stmt (gsi
);
7468 stmt
= gsi_stmt (gsi
);
7469 if (need_fake_edge_p (stmt
))
7473 /* The handling above of the final block before the
7474 epilogue should be enough to verify that there is
7475 no edge to the exit block in CFG already.
7476 Calling make_edge in such case would cause us to
7477 mark that edge as fake and remove it later. */
7478 #ifdef ENABLE_CHECKING
7479 if (stmt
== last_stmt
)
7481 e
= find_edge (bb
, EXIT_BLOCK_PTR
);
7482 gcc_assert (e
== NULL
);
7486 /* Note that the following may create a new basic block
7487 and renumber the existing basic blocks. */
7488 if (stmt
!= last_stmt
)
7490 e
= split_block (bb
, stmt
);
7494 make_edge (bb
, EXIT_BLOCK_PTR
, EDGE_FAKE
);
7498 while (!gsi_end_p (gsi
));
7503 verify_flow_info ();
7505 return blocks_split
;
7508 /* Removes edge E and all the blocks dominated by it, and updates dominance
7509 information. The IL in E->src needs to be updated separately.
7510 If dominance info is not available, only the edge E is removed.*/
7513 remove_edge_and_dominated_blocks (edge e
)
7515 vec
<basic_block
> bbs_to_remove
= vNULL
;
7516 vec
<basic_block
> bbs_to_fix_dom
= vNULL
;
7520 bool none_removed
= false;
7522 basic_block bb
, dbb
;
7525 if (!dom_info_available_p (CDI_DOMINATORS
))
7531 /* No updating is needed for edges to exit. */
7532 if (e
->dest
== EXIT_BLOCK_PTR
)
7534 if (cfgcleanup_altered_bbs
)
7535 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
7540 /* First, we find the basic blocks to remove. If E->dest has a predecessor
7541 that is not dominated by E->dest, then this set is empty. Otherwise,
7542 all the basic blocks dominated by E->dest are removed.
7544 Also, to DF_IDOM we store the immediate dominators of the blocks in
7545 the dominance frontier of E (i.e., of the successors of the
7546 removed blocks, if there are any, and of E->dest otherwise). */
7547 FOR_EACH_EDGE (f
, ei
, e
->dest
->preds
)
7552 if (!dominated_by_p (CDI_DOMINATORS
, f
->src
, e
->dest
))
7554 none_removed
= true;
7559 df
= BITMAP_ALLOC (NULL
);
7560 df_idom
= BITMAP_ALLOC (NULL
);
7563 bitmap_set_bit (df_idom
,
7564 get_immediate_dominator (CDI_DOMINATORS
, e
->dest
)->index
);
7567 bbs_to_remove
= get_all_dominated_blocks (CDI_DOMINATORS
, e
->dest
);
7568 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
7570 FOR_EACH_EDGE (f
, ei
, bb
->succs
)
7572 if (f
->dest
!= EXIT_BLOCK_PTR
)
7573 bitmap_set_bit (df
, f
->dest
->index
);
7576 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
7577 bitmap_clear_bit (df
, bb
->index
);
7579 EXECUTE_IF_SET_IN_BITMAP (df
, 0, i
, bi
)
7581 bb
= BASIC_BLOCK (i
);
7582 bitmap_set_bit (df_idom
,
7583 get_immediate_dominator (CDI_DOMINATORS
, bb
)->index
);
7587 if (cfgcleanup_altered_bbs
)
7589 /* Record the set of the altered basic blocks. */
7590 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
7591 bitmap_ior_into (cfgcleanup_altered_bbs
, df
);
7594 /* Remove E and the cancelled blocks. */
7599 /* Walk backwards so as to get a chance to substitute all
7600 released DEFs into debug stmts. See
7601 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
7603 for (i
= bbs_to_remove
.length (); i
-- > 0; )
7604 delete_basic_block (bbs_to_remove
[i
]);
7607 /* Update the dominance information. The immediate dominator may change only
7608 for blocks whose immediate dominator belongs to DF_IDOM:
7610 Suppose that idom(X) = Y before removal of E and idom(X) != Y after the
7611 removal. Let Z the arbitrary block such that idom(Z) = Y and
7612 Z dominates X after the removal. Before removal, there exists a path P
7613 from Y to X that avoids Z. Let F be the last edge on P that is
7614 removed, and let W = F->dest. Before removal, idom(W) = Y (since Y
7615 dominates W, and because of P, Z does not dominate W), and W belongs to
7616 the dominance frontier of E. Therefore, Y belongs to DF_IDOM. */
7617 EXECUTE_IF_SET_IN_BITMAP (df_idom
, 0, i
, bi
)
7619 bb
= BASIC_BLOCK (i
);
7620 for (dbb
= first_dom_son (CDI_DOMINATORS
, bb
);
7622 dbb
= next_dom_son (CDI_DOMINATORS
, dbb
))
7623 bbs_to_fix_dom
.safe_push (dbb
);
7626 iterate_fix_dominators (CDI_DOMINATORS
, bbs_to_fix_dom
, true);
7629 BITMAP_FREE (df_idom
);
7630 bbs_to_remove
.release ();
7631 bbs_to_fix_dom
.release ();
7634 /* Purge dead EH edges from basic block BB. */
7637 gimple_purge_dead_eh_edges (basic_block bb
)
7639 bool changed
= false;
7642 gimple stmt
= last_stmt (bb
);
7644 if (stmt
&& stmt_can_throw_internal (stmt
))
7647 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
7649 if (e
->flags
& EDGE_EH
)
7651 remove_edge_and_dominated_blocks (e
);
7661 /* Purge dead EH edges from basic block listed in BLOCKS. */
7664 gimple_purge_all_dead_eh_edges (const_bitmap blocks
)
7666 bool changed
= false;
7670 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
7672 basic_block bb
= BASIC_BLOCK (i
);
7674 /* Earlier gimple_purge_dead_eh_edges could have removed
7675 this basic block already. */
7676 gcc_assert (bb
|| changed
);
7678 changed
|= gimple_purge_dead_eh_edges (bb
);
7684 /* Purge dead abnormal call edges from basic block BB. */
7687 gimple_purge_dead_abnormal_call_edges (basic_block bb
)
7689 bool changed
= false;
7692 gimple stmt
= last_stmt (bb
);
7694 if (!cfun
->has_nonlocal_label
7695 && !cfun
->calls_setjmp
)
7698 if (stmt
&& stmt_can_make_abnormal_goto (stmt
))
7701 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
7703 if (e
->flags
& EDGE_ABNORMAL
)
7705 if (e
->flags
& EDGE_FALLTHRU
)
7706 e
->flags
&= ~EDGE_ABNORMAL
;
7708 remove_edge_and_dominated_blocks (e
);
7718 /* Purge dead abnormal call edges from basic block listed in BLOCKS. */
7721 gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks
)
7723 bool changed
= false;
7727 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
7729 basic_block bb
= BASIC_BLOCK (i
);
7731 /* Earlier gimple_purge_dead_abnormal_call_edges could have removed
7732 this basic block already. */
7733 gcc_assert (bb
|| changed
);
7735 changed
|= gimple_purge_dead_abnormal_call_edges (bb
);
7741 /* This function is called whenever a new edge is created or
7745 gimple_execute_on_growing_pred (edge e
)
7747 basic_block bb
= e
->dest
;
7749 if (!gimple_seq_empty_p (phi_nodes (bb
)))
7750 reserve_phi_args_for_new_edge (bb
);
7753 /* This function is called immediately before edge E is removed from
7754 the edge vector E->dest->preds. */
7757 gimple_execute_on_shrinking_pred (edge e
)
7759 if (!gimple_seq_empty_p (phi_nodes (e
->dest
)))
7760 remove_phi_args (e
);
7763 /*---------------------------------------------------------------------------
7764 Helper functions for Loop versioning
7765 ---------------------------------------------------------------------------*/
7767 /* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy
7768 of 'first'. Both of them are dominated by 'new_head' basic block. When
7769 'new_head' was created by 'second's incoming edge it received phi arguments
7770 on the edge by split_edge(). Later, additional edge 'e' was created to
7771 connect 'new_head' and 'first'. Now this routine adds phi args on this
7772 additional edge 'e' that new_head to second edge received as part of edge
7776 gimple_lv_adjust_loop_header_phi (basic_block first
, basic_block second
,
7777 basic_block new_head
, edge e
)
7780 gimple_stmt_iterator psi1
, psi2
;
7782 edge e2
= find_edge (new_head
, second
);
7784 /* Because NEW_HEAD has been created by splitting SECOND's incoming
7785 edge, we should always have an edge from NEW_HEAD to SECOND. */
7786 gcc_assert (e2
!= NULL
);
7788 /* Browse all 'second' basic block phi nodes and add phi args to
7789 edge 'e' for 'first' head. PHI args are always in correct order. */
7791 for (psi2
= gsi_start_phis (second
),
7792 psi1
= gsi_start_phis (first
);
7793 !gsi_end_p (psi2
) && !gsi_end_p (psi1
);
7794 gsi_next (&psi2
), gsi_next (&psi1
))
7796 phi1
= gsi_stmt (psi1
);
7797 phi2
= gsi_stmt (psi2
);
7798 def
= PHI_ARG_DEF (phi2
, e2
->dest_idx
);
7799 add_phi_arg (phi1
, def
, e
, gimple_phi_arg_location_from_edge (phi2
, e2
));
7804 /* Adds a if else statement to COND_BB with condition COND_EXPR.
7805 SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
7806 the destination of the ELSE part. */
7809 gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED
,
7810 basic_block second_head ATTRIBUTE_UNUSED
,
7811 basic_block cond_bb
, void *cond_e
)
7813 gimple_stmt_iterator gsi
;
7814 gimple new_cond_expr
;
7815 tree cond_expr
= (tree
) cond_e
;
7818 /* Build new conditional expr */
7819 new_cond_expr
= gimple_build_cond_from_tree (cond_expr
,
7820 NULL_TREE
, NULL_TREE
);
7822 /* Add new cond in cond_bb. */
7823 gsi
= gsi_last_bb (cond_bb
);
7824 gsi_insert_after (&gsi
, new_cond_expr
, GSI_NEW_STMT
);
7826 /* Adjust edges appropriately to connect new head with first head
7827 as well as second head. */
7828 e0
= single_succ_edge (cond_bb
);
7829 e0
->flags
&= ~EDGE_FALLTHRU
;
7830 e0
->flags
|= EDGE_FALSE_VALUE
;
7834 /* Do book-keeping of basic block BB for the profile consistency checker.
7835 If AFTER_PASS is 0, do pre-pass accounting, or if AFTER_PASS is 1
7836 then do post-pass accounting. Store the counting in RECORD. */
7838 gimple_account_profile_record (basic_block bb
, int after_pass
,
7839 struct profile_record
*record
)
7841 gimple_stmt_iterator i
;
7842 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
7844 record
->size
[after_pass
]
7845 += estimate_num_insns (gsi_stmt (i
), &eni_size_weights
);
7846 if (profile_status
== PROFILE_READ
)
7847 record
->time
[after_pass
]
7848 += estimate_num_insns (gsi_stmt (i
),
7849 &eni_time_weights
) * bb
->count
;
7850 else if (profile_status
== PROFILE_GUESSED
)
7851 record
->time
[after_pass
]
7852 += estimate_num_insns (gsi_stmt (i
),
7853 &eni_time_weights
) * bb
->frequency
;
7857 struct cfg_hooks gimple_cfg_hooks
= {
7859 gimple_verify_flow_info
,
7860 gimple_dump_bb
, /* dump_bb */
7861 gimple_dump_bb_for_graph
, /* dump_bb_for_graph */
7862 create_bb
, /* create_basic_block */
7863 gimple_redirect_edge_and_branch
, /* redirect_edge_and_branch */
7864 gimple_redirect_edge_and_branch_force
, /* redirect_edge_and_branch_force */
7865 gimple_can_remove_branch_p
, /* can_remove_branch_p */
7866 remove_bb
, /* delete_basic_block */
7867 gimple_split_block
, /* split_block */
7868 gimple_move_block_after
, /* move_block_after */
7869 gimple_can_merge_blocks_p
, /* can_merge_blocks_p */
7870 gimple_merge_blocks
, /* merge_blocks */
7871 gimple_predict_edge
, /* predict_edge */
7872 gimple_predicted_by_p
, /* predicted_by_p */
7873 gimple_can_duplicate_bb_p
, /* can_duplicate_block_p */
7874 gimple_duplicate_bb
, /* duplicate_block */
7875 gimple_split_edge
, /* split_edge */
7876 gimple_make_forwarder_block
, /* make_forward_block */
7877 NULL
, /* tidy_fallthru_edge */
7878 NULL
, /* force_nonfallthru */
7879 gimple_block_ends_with_call_p
,/* block_ends_with_call_p */
7880 gimple_block_ends_with_condjump_p
, /* block_ends_with_condjump_p */
7881 gimple_flow_call_edges_add
, /* flow_call_edges_add */
7882 gimple_execute_on_growing_pred
, /* execute_on_growing_pred */
7883 gimple_execute_on_shrinking_pred
, /* execute_on_shrinking_pred */
7884 gimple_duplicate_loop_to_header_edge
, /* duplicate loop for trees */
7885 gimple_lv_add_condition_to_bb
, /* lv_add_condition_to_bb */
7886 gimple_lv_adjust_loop_header_phi
, /* lv_adjust_loop_header_phi*/
7887 extract_true_false_edges_from_block
, /* extract_cond_bb_edges */
7888 flush_pending_stmts
, /* flush_pending_stmts */
7889 gimple_empty_block_p
, /* block_empty_p */
7890 gimple_split_block_before_cond_jump
, /* split_block_before_cond_jump */
7891 gimple_account_profile_record
,
7895 /* Split all critical edges. */
7898 split_critical_edges (void)
7904 /* split_edge can redirect edges out of SWITCH_EXPRs, which can get
7905 expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
7906 mappings around the calls to split_edge. */
7907 start_recording_case_labels ();
7910 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7912 if (EDGE_CRITICAL_P (e
) && !(e
->flags
& EDGE_ABNORMAL
))
7914 /* PRE inserts statements to edges and expects that
7915 since split_critical_edges was done beforehand, committing edge
7916 insertions will not split more edges. In addition to critical
7917 edges we must split edges that have multiple successors and
7918 end by control flow statements, such as RESX.
7919 Go ahead and split them too. This matches the logic in
7920 gimple_find_edge_insert_loc. */
7921 else if ((!single_pred_p (e
->dest
)
7922 || !gimple_seq_empty_p (phi_nodes (e
->dest
))
7923 || e
->dest
== EXIT_BLOCK_PTR
)
7924 && e
->src
!= ENTRY_BLOCK_PTR
7925 && !(e
->flags
& EDGE_ABNORMAL
))
7927 gimple_stmt_iterator gsi
;
7929 gsi
= gsi_last_bb (e
->src
);
7930 if (!gsi_end_p (gsi
)
7931 && stmt_ends_bb_p (gsi_stmt (gsi
))
7932 && (gimple_code (gsi_stmt (gsi
)) != GIMPLE_RETURN
7933 && !gimple_call_builtin_p (gsi_stmt (gsi
),
7939 end_recording_case_labels ();
7945 const pass_data pass_data_split_crit_edges
=
7947 GIMPLE_PASS
, /* type */
7948 "crited", /* name */
7949 OPTGROUP_NONE
, /* optinfo_flags */
7950 false, /* has_gate */
7951 true, /* has_execute */
7952 TV_TREE_SPLIT_EDGES
, /* tv_id */
7953 PROP_cfg
, /* properties_required */
7954 PROP_no_crit_edges
, /* properties_provided */
7955 0, /* properties_destroyed */
7956 0, /* todo_flags_start */
7957 TODO_verify_flow
, /* todo_flags_finish */
7960 class pass_split_crit_edges
: public gimple_opt_pass
7963 pass_split_crit_edges (gcc::context
*ctxt
)
7964 : gimple_opt_pass (pass_data_split_crit_edges
, ctxt
)
7967 /* opt_pass methods: */
7968 unsigned int execute () { return split_critical_edges (); }
7970 opt_pass
* clone () { return new pass_split_crit_edges (m_ctxt
); }
7971 }; // class pass_split_crit_edges
7976 make_pass_split_crit_edges (gcc::context
*ctxt
)
7978 return new pass_split_crit_edges (ctxt
);
7982 /* Build a ternary operation and gimplify it. Emit code before GSI.
7983 Return the gimple_val holding the result. */
7986 gimplify_build3 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
7987 tree type
, tree a
, tree b
, tree c
)
7990 location_t loc
= gimple_location (gsi_stmt (*gsi
));
7992 ret
= fold_build3_loc (loc
, code
, type
, a
, b
, c
);
7995 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
7999 /* Build a binary operation and gimplify it. Emit code before GSI.
8000 Return the gimple_val holding the result. */
8003 gimplify_build2 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
8004 tree type
, tree a
, tree b
)
8008 ret
= fold_build2_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
, b
);
8011 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
8015 /* Build a unary operation and gimplify it. Emit code before GSI.
8016 Return the gimple_val holding the result. */
8019 gimplify_build1 (gimple_stmt_iterator
*gsi
, enum tree_code code
, tree type
,
8024 ret
= fold_build1_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
);
8027 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
8033 /* Emit return warnings. */
8036 execute_warn_function_return (void)
8038 source_location location
;
8043 if (!targetm
.warn_func_return (cfun
->decl
))
8046 /* If we have a path to EXIT, then we do return. */
8047 if (TREE_THIS_VOLATILE (cfun
->decl
)
8048 && EDGE_COUNT (EXIT_BLOCK_PTR
->preds
) > 0)
8050 location
= UNKNOWN_LOCATION
;
8051 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
8053 last
= last_stmt (e
->src
);
8054 if ((gimple_code (last
) == GIMPLE_RETURN
8055 || gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
8056 && (location
= gimple_location (last
)) != UNKNOWN_LOCATION
)
8059 if (location
== UNKNOWN_LOCATION
)
8060 location
= cfun
->function_end_locus
;
8061 warning_at (location
, 0, "%<noreturn%> function does return");
8064 /* If we see "return;" in some basic block, then we do reach the end
8065 without returning a value. */
8066 else if (warn_return_type
8067 && !TREE_NO_WARNING (cfun
->decl
)
8068 && EDGE_COUNT (EXIT_BLOCK_PTR
->preds
) > 0
8069 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (cfun
->decl
))))
8071 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
8073 gimple last
= last_stmt (e
->src
);
8074 if (gimple_code (last
) == GIMPLE_RETURN
8075 && gimple_return_retval (last
) == NULL
8076 && !gimple_no_warning_p (last
))
8078 location
= gimple_location (last
);
8079 if (location
== UNKNOWN_LOCATION
)
8080 location
= cfun
->function_end_locus
;
8081 warning_at (location
, OPT_Wreturn_type
, "control reaches end of non-void function");
8082 TREE_NO_WARNING (cfun
->decl
) = 1;
8091 /* Given a basic block B which ends with a conditional and has
8092 precisely two successors, determine which of the edges is taken if
8093 the conditional is true and which is taken if the conditional is
8094 false. Set TRUE_EDGE and FALSE_EDGE appropriately. */
8097 extract_true_false_edges_from_block (basic_block b
,
8101 edge e
= EDGE_SUCC (b
, 0);
8103 if (e
->flags
& EDGE_TRUE_VALUE
)
8106 *false_edge
= EDGE_SUCC (b
, 1);
8111 *true_edge
= EDGE_SUCC (b
, 1);
8117 const pass_data pass_data_warn_function_return
=
8119 GIMPLE_PASS
, /* type */
8120 "*warn_function_return", /* name */
8121 OPTGROUP_NONE
, /* optinfo_flags */
8122 false, /* has_gate */
8123 true, /* has_execute */
8124 TV_NONE
, /* tv_id */
8125 PROP_cfg
, /* properties_required */
8126 0, /* properties_provided */
8127 0, /* properties_destroyed */
8128 0, /* todo_flags_start */
8129 0, /* todo_flags_finish */
8132 class pass_warn_function_return
: public gimple_opt_pass
8135 pass_warn_function_return (gcc::context
*ctxt
)
8136 : gimple_opt_pass (pass_data_warn_function_return
, ctxt
)
8139 /* opt_pass methods: */
8140 unsigned int execute () { return execute_warn_function_return (); }
8142 }; // class pass_warn_function_return
8147 make_pass_warn_function_return (gcc::context
*ctxt
)
8149 return new pass_warn_function_return (ctxt
);
8152 /* Emit noreturn warnings. */
8155 execute_warn_function_noreturn (void)
8157 if (!TREE_THIS_VOLATILE (current_function_decl
)
8158 && EDGE_COUNT (EXIT_BLOCK_PTR
->preds
) == 0)
8159 warn_function_noreturn (current_function_decl
);
8164 gate_warn_function_noreturn (void)
8166 return warn_suggest_attribute_noreturn
;
8171 const pass_data pass_data_warn_function_noreturn
=
8173 GIMPLE_PASS
, /* type */
8174 "*warn_function_noreturn", /* name */
8175 OPTGROUP_NONE
, /* optinfo_flags */
8176 true, /* has_gate */
8177 true, /* has_execute */
8178 TV_NONE
, /* tv_id */
8179 PROP_cfg
, /* properties_required */
8180 0, /* properties_provided */
8181 0, /* properties_destroyed */
8182 0, /* todo_flags_start */
8183 0, /* todo_flags_finish */
8186 class pass_warn_function_noreturn
: public gimple_opt_pass
8189 pass_warn_function_noreturn (gcc::context
*ctxt
)
8190 : gimple_opt_pass (pass_data_warn_function_noreturn
, ctxt
)
8193 /* opt_pass methods: */
8194 bool gate () { return gate_warn_function_noreturn (); }
8195 unsigned int execute () { return execute_warn_function_noreturn (); }
8197 }; // class pass_warn_function_noreturn
8202 make_pass_warn_function_noreturn (gcc::context
*ctxt
)
8204 return new pass_warn_function_noreturn (ctxt
);
8208 /* Walk a gimplified function and warn for functions whose return value is
8209 ignored and attribute((warn_unused_result)) is set. This is done before
8210 inlining, so we don't have to worry about that. */
8213 do_warn_unused_result (gimple_seq seq
)
8216 gimple_stmt_iterator i
;
8218 for (i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
8220 gimple g
= gsi_stmt (i
);
8222 switch (gimple_code (g
))
8225 do_warn_unused_result (gimple_bind_body (g
));
8228 do_warn_unused_result (gimple_try_eval (g
));
8229 do_warn_unused_result (gimple_try_cleanup (g
));
8232 do_warn_unused_result (gimple_catch_handler (g
));
8234 case GIMPLE_EH_FILTER
:
8235 do_warn_unused_result (gimple_eh_filter_failure (g
));
8239 if (gimple_call_lhs (g
))
8241 if (gimple_call_internal_p (g
))
8244 /* This is a naked call, as opposed to a GIMPLE_CALL with an
8245 LHS. All calls whose value is ignored should be
8246 represented like this. Look for the attribute. */
8247 fdecl
= gimple_call_fndecl (g
);
8248 ftype
= gimple_call_fntype (g
);
8250 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
8252 location_t loc
= gimple_location (g
);
8255 warning_at (loc
, OPT_Wunused_result
,
8256 "ignoring return value of %qD, "
8257 "declared with attribute warn_unused_result",
8260 warning_at (loc
, OPT_Wunused_result
,
8261 "ignoring return value of function "
8262 "declared with attribute warn_unused_result");
8267 /* Not a container, not a call, or a call whose value is used. */
8274 run_warn_unused_result (void)
8276 do_warn_unused_result (gimple_body (current_function_decl
));
8281 gate_warn_unused_result (void)
8283 return flag_warn_unused_result
;
8288 const pass_data pass_data_warn_unused_result
=
8290 GIMPLE_PASS
, /* type */
8291 "*warn_unused_result", /* name */
8292 OPTGROUP_NONE
, /* optinfo_flags */
8293 true, /* has_gate */
8294 true, /* has_execute */
8295 TV_NONE
, /* tv_id */
8296 PROP_gimple_any
, /* properties_required */
8297 0, /* properties_provided */
8298 0, /* properties_destroyed */
8299 0, /* todo_flags_start */
8300 0, /* todo_flags_finish */
8303 class pass_warn_unused_result
: public gimple_opt_pass
8306 pass_warn_unused_result (gcc::context
*ctxt
)
8307 : gimple_opt_pass (pass_data_warn_unused_result
, ctxt
)
8310 /* opt_pass methods: */
8311 bool gate () { return gate_warn_unused_result (); }
8312 unsigned int execute () { return run_warn_unused_result (); }
8314 }; // class pass_warn_unused_result
8319 make_pass_warn_unused_result (gcc::context
*ctxt
)
8321 return new pass_warn_unused_result (ctxt
);
8325 /* Garbage collection support for edge_def. */
8327 extern void gt_ggc_mx (tree
&);
8328 extern void gt_ggc_mx (gimple
&);
8329 extern void gt_ggc_mx (rtx
&);
8330 extern void gt_ggc_mx (basic_block
&);
8333 gt_ggc_mx (edge_def
*e
)
8335 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8337 gt_ggc_mx (e
->dest
);
8338 if (current_ir_type () == IR_GIMPLE
)
8339 gt_ggc_mx (e
->insns
.g
);
8341 gt_ggc_mx (e
->insns
.r
);
8345 /* PCH support for edge_def. */
8347 extern void gt_pch_nx (tree
&);
8348 extern void gt_pch_nx (gimple
&);
8349 extern void gt_pch_nx (rtx
&);
8350 extern void gt_pch_nx (basic_block
&);
8353 gt_pch_nx (edge_def
*e
)
8355 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8357 gt_pch_nx (e
->dest
);
8358 if (current_ir_type () == IR_GIMPLE
)
8359 gt_pch_nx (e
->insns
.g
);
8361 gt_pch_nx (e
->insns
.r
);
8366 gt_pch_nx (edge_def
*e
, gt_pointer_operator op
, void *cookie
)
8368 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8369 op (&(e
->src
), cookie
);
8370 op (&(e
->dest
), cookie
);
8371 if (current_ir_type () == IR_GIMPLE
)
8372 op (&(e
->insns
.g
), cookie
);
8374 op (&(e
->insns
.r
), cookie
);
8375 op (&(block
), cookie
);