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 "gimple-ssa.h"
37 #include "tree-phinodes.h"
38 #include "ssa-iterators.h"
39 #include "tree-ssanames.h"
40 #include "tree-ssa-loop.h"
41 #include "tree-into-ssa.h"
44 #include "tree-dump.h"
45 #include "tree-pass.h"
46 #include "diagnostic-core.h"
49 #include "tree-ssa-propagate.h"
50 #include "value-prof.h"
51 #include "pointer-set.h"
52 #include "tree-inline.h"
54 #include "tree-ssa-live.h"
56 #include "tree-cfgcleanup.h"
58 /* This file contains functions for building the Control Flow Graph (CFG)
59 for a function tree. */
61 /* Local declarations. */
63 /* Initial capacity for the basic block array. */
64 static const int initial_cfg_capacity
= 20;
66 /* This hash table allows us to efficiently lookup all CASE_LABEL_EXPRs
67 which use a particular edge. The CASE_LABEL_EXPRs are chained together
68 via their CASE_CHAIN field, which we clear after we're done with the
69 hash table to prevent problems with duplication of GIMPLE_SWITCHes.
71 Access to this list of CASE_LABEL_EXPRs allows us to efficiently
72 update the case vector in response to edge redirections.
74 Right now this table is set up and torn down at key points in the
75 compilation process. It would be nice if we could make the table
76 more persistent. The key is getting notification of changes to
77 the CFG (particularly edge removal, creation and redirection). */
79 static struct pointer_map_t
*edge_to_cases
;
81 /* If we record edge_to_cases, this bitmap will hold indexes
82 of basic blocks that end in a GIMPLE_SWITCH which we touched
83 due to edge manipulations. */
85 static bitmap touched_switch_bbs
;
90 long num_merged_labels
;
93 static struct cfg_stats_d cfg_stats
;
95 /* Nonzero if we found a computed goto while building basic blocks. */
96 static bool found_computed_goto
;
98 /* Hash table to store last discriminator assigned for each locus. */
99 struct locus_discrim_map
105 /* Hashtable helpers. */
107 struct locus_discrim_hasher
: typed_free_remove
<locus_discrim_map
>
109 typedef locus_discrim_map value_type
;
110 typedef locus_discrim_map compare_type
;
111 static inline hashval_t
hash (const value_type
*);
112 static inline bool equal (const value_type
*, const compare_type
*);
115 /* Trivial hash function for a location_t. ITEM is a pointer to
116 a hash table entry that maps a location_t to a discriminator. */
119 locus_discrim_hasher::hash (const value_type
*item
)
121 return LOCATION_LINE (item
->locus
);
124 /* Equality function for the locus-to-discriminator map. A and B
125 point to the two hash table entries to compare. */
128 locus_discrim_hasher::equal (const value_type
*a
, const compare_type
*b
)
130 return LOCATION_LINE (a
->locus
) == LOCATION_LINE (b
->locus
);
133 static hash_table
<locus_discrim_hasher
> discriminator_per_locus
;
135 /* Basic blocks and flowgraphs. */
136 static void make_blocks (gimple_seq
);
137 static void factor_computed_gotos (void);
140 static void make_edges (void);
141 static void assign_discriminators (void);
142 static void make_cond_expr_edges (basic_block
);
143 static void make_gimple_switch_edges (basic_block
);
144 static void make_goto_expr_edges (basic_block
);
145 static void make_gimple_asm_edges (basic_block
);
146 static edge
gimple_redirect_edge_and_branch (edge
, basic_block
);
147 static edge
gimple_try_redirect_by_replacing_jump (edge
, basic_block
);
148 static unsigned int split_critical_edges (void);
150 /* Various helpers. */
151 static inline bool stmt_starts_bb_p (gimple
, gimple
);
152 static int gimple_verify_flow_info (void);
153 static void gimple_make_forwarder_block (edge
);
154 static gimple
first_non_label_stmt (basic_block
);
155 static bool verify_gimple_transaction (gimple
);
157 /* Flowgraph optimization and cleanup. */
158 static void gimple_merge_blocks (basic_block
, basic_block
);
159 static bool gimple_can_merge_blocks_p (basic_block
, basic_block
);
160 static void remove_bb (basic_block
);
161 static edge
find_taken_edge_computed_goto (basic_block
, tree
);
162 static edge
find_taken_edge_cond_expr (basic_block
, tree
);
163 static edge
find_taken_edge_switch_expr (basic_block
, tree
);
164 static tree
find_case_label_for_value (gimple
, tree
);
167 init_empty_tree_cfg_for_function (struct function
*fn
)
169 /* Initialize the basic block array. */
171 profile_status_for_function (fn
) = PROFILE_ABSENT
;
172 n_basic_blocks_for_function (fn
) = NUM_FIXED_BLOCKS
;
173 last_basic_block_for_function (fn
) = NUM_FIXED_BLOCKS
;
174 vec_alloc (basic_block_info_for_function (fn
), initial_cfg_capacity
);
175 vec_safe_grow_cleared (basic_block_info_for_function (fn
),
176 initial_cfg_capacity
);
178 /* Build a mapping of labels to their associated blocks. */
179 vec_alloc (label_to_block_map_for_function (fn
), initial_cfg_capacity
);
180 vec_safe_grow_cleared (label_to_block_map_for_function (fn
),
181 initial_cfg_capacity
);
183 SET_BASIC_BLOCK_FOR_FUNCTION (fn
, ENTRY_BLOCK
,
184 ENTRY_BLOCK_PTR_FOR_FUNCTION (fn
));
185 SET_BASIC_BLOCK_FOR_FUNCTION (fn
, EXIT_BLOCK
,
186 EXIT_BLOCK_PTR_FOR_FUNCTION (fn
));
188 ENTRY_BLOCK_PTR_FOR_FUNCTION (fn
)->next_bb
189 = EXIT_BLOCK_PTR_FOR_FUNCTION (fn
);
190 EXIT_BLOCK_PTR_FOR_FUNCTION (fn
)->prev_bb
191 = ENTRY_BLOCK_PTR_FOR_FUNCTION (fn
);
195 init_empty_tree_cfg (void)
197 init_empty_tree_cfg_for_function (cfun
);
200 /*---------------------------------------------------------------------------
202 ---------------------------------------------------------------------------*/
204 /* Entry point to the CFG builder for trees. SEQ is the sequence of
205 statements to be added to the flowgraph. */
208 build_gimple_cfg (gimple_seq seq
)
210 /* Register specific gimple functions. */
211 gimple_register_cfg_hooks ();
213 memset ((void *) &cfg_stats
, 0, sizeof (cfg_stats
));
215 init_empty_tree_cfg ();
217 found_computed_goto
= 0;
220 /* Computed gotos are hell to deal with, especially if there are
221 lots of them with a large number of destinations. So we factor
222 them to a common computed goto location before we build the
223 edge list. After we convert back to normal form, we will un-factor
224 the computed gotos since factoring introduces an unwanted jump. */
225 if (found_computed_goto
)
226 factor_computed_gotos ();
228 /* Make sure there is always at least one block, even if it's empty. */
229 if (n_basic_blocks
== NUM_FIXED_BLOCKS
)
230 create_empty_bb (ENTRY_BLOCK_PTR
);
232 /* Adjust the size of the array. */
233 if (basic_block_info
->length () < (size_t) n_basic_blocks
)
234 vec_safe_grow_cleared (basic_block_info
, n_basic_blocks
);
236 /* To speed up statement iterator walks, we first purge dead labels. */
237 cleanup_dead_labels ();
239 /* Group case nodes to reduce the number of edges.
240 We do this after cleaning up dead labels because otherwise we miss
241 a lot of obvious case merging opportunities. */
242 group_case_labels ();
244 /* Create the edges of the flowgraph. */
245 discriminator_per_locus
.create (13);
247 assign_discriminators ();
248 cleanup_dead_labels ();
249 discriminator_per_locus
.dispose ();
253 execute_build_cfg (void)
255 gimple_seq body
= gimple_body (current_function_decl
);
257 build_gimple_cfg (body
);
258 gimple_set_body (current_function_decl
, NULL
);
259 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
261 fprintf (dump_file
, "Scope blocks:\n");
262 dump_scope_blocks (dump_file
, dump_flags
);
265 loop_optimizer_init (AVOID_CFG_MODIFICATIONS
);
271 const pass_data pass_data_build_cfg
=
273 GIMPLE_PASS
, /* type */
275 OPTGROUP_NONE
, /* optinfo_flags */
276 false, /* has_gate */
277 true, /* has_execute */
278 TV_TREE_CFG
, /* tv_id */
279 PROP_gimple_leh
, /* properties_required */
280 ( PROP_cfg
| PROP_loops
), /* properties_provided */
281 0, /* properties_destroyed */
282 0, /* todo_flags_start */
283 TODO_verify_stmts
, /* todo_flags_finish */
286 class pass_build_cfg
: public gimple_opt_pass
289 pass_build_cfg (gcc::context
*ctxt
)
290 : gimple_opt_pass (pass_data_build_cfg
, ctxt
)
293 /* opt_pass methods: */
294 unsigned int execute () { return execute_build_cfg (); }
296 }; // class pass_build_cfg
301 make_pass_build_cfg (gcc::context
*ctxt
)
303 return new pass_build_cfg (ctxt
);
307 /* Return true if T is a computed goto. */
310 computed_goto_p (gimple t
)
312 return (gimple_code (t
) == GIMPLE_GOTO
313 && TREE_CODE (gimple_goto_dest (t
)) != LABEL_DECL
);
317 /* Search the CFG for any computed gotos. If found, factor them to a
318 common computed goto site. Also record the location of that site so
319 that we can un-factor the gotos after we have converted back to
323 factor_computed_gotos (void)
326 tree factored_label_decl
= NULL
;
328 gimple factored_computed_goto_label
= NULL
;
329 gimple factored_computed_goto
= NULL
;
331 /* We know there are one or more computed gotos in this function.
332 Examine the last statement in each basic block to see if the block
333 ends with a computed goto. */
337 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
343 last
= gsi_stmt (gsi
);
345 /* Ignore the computed goto we create when we factor the original
347 if (last
== factored_computed_goto
)
350 /* If the last statement is a computed goto, factor it. */
351 if (computed_goto_p (last
))
355 /* The first time we find a computed goto we need to create
356 the factored goto block and the variable each original
357 computed goto will use for their goto destination. */
358 if (!factored_computed_goto
)
360 basic_block new_bb
= create_empty_bb (bb
);
361 gimple_stmt_iterator new_gsi
= gsi_start_bb (new_bb
);
363 /* Create the destination of the factored goto. Each original
364 computed goto will put its desired destination into this
365 variable and jump to the label we create immediately
367 var
= create_tmp_var (ptr_type_node
, "gotovar");
369 /* Build a label for the new block which will contain the
370 factored computed goto. */
371 factored_label_decl
= create_artificial_label (UNKNOWN_LOCATION
);
372 factored_computed_goto_label
373 = gimple_build_label (factored_label_decl
);
374 gsi_insert_after (&new_gsi
, factored_computed_goto_label
,
377 /* Build our new computed goto. */
378 factored_computed_goto
= gimple_build_goto (var
);
379 gsi_insert_after (&new_gsi
, factored_computed_goto
, GSI_NEW_STMT
);
382 /* Copy the original computed goto's destination into VAR. */
383 assignment
= gimple_build_assign (var
, gimple_goto_dest (last
));
384 gsi_insert_before (&gsi
, assignment
, GSI_SAME_STMT
);
386 /* And re-vector the computed goto to the new destination. */
387 gimple_goto_set_dest (last
, factored_label_decl
);
393 /* Build a flowgraph for the sequence of stmts SEQ. */
396 make_blocks (gimple_seq seq
)
398 gimple_stmt_iterator i
= gsi_start (seq
);
400 bool start_new_block
= true;
401 bool first_stmt_of_seq
= true;
402 basic_block bb
= ENTRY_BLOCK_PTR
;
404 while (!gsi_end_p (i
))
411 /* If the statement starts a new basic block or if we have determined
412 in a previous pass that we need to create a new block for STMT, do
414 if (start_new_block
|| stmt_starts_bb_p (stmt
, prev_stmt
))
416 if (!first_stmt_of_seq
)
417 gsi_split_seq_before (&i
, &seq
);
418 bb
= create_basic_block (seq
, NULL
, bb
);
419 start_new_block
= false;
422 /* Now add STMT to BB and create the subgraphs for special statement
424 gimple_set_bb (stmt
, bb
);
426 if (computed_goto_p (stmt
))
427 found_computed_goto
= true;
429 /* If STMT is a basic block terminator, set START_NEW_BLOCK for the
431 if (stmt_ends_bb_p (stmt
))
433 /* If the stmt can make abnormal goto use a new temporary
434 for the assignment to the LHS. This makes sure the old value
435 of the LHS is available on the abnormal edge. Otherwise
436 we will end up with overlapping life-ranges for abnormal
438 if (gimple_has_lhs (stmt
)
439 && stmt_can_make_abnormal_goto (stmt
)
440 && is_gimple_reg_type (TREE_TYPE (gimple_get_lhs (stmt
))))
442 tree lhs
= gimple_get_lhs (stmt
);
443 tree tmp
= create_tmp_var (TREE_TYPE (lhs
), NULL
);
444 gimple s
= gimple_build_assign (lhs
, tmp
);
445 gimple_set_location (s
, gimple_location (stmt
));
446 gimple_set_block (s
, gimple_block (stmt
));
447 gimple_set_lhs (stmt
, tmp
);
448 if (TREE_CODE (TREE_TYPE (tmp
)) == COMPLEX_TYPE
449 || TREE_CODE (TREE_TYPE (tmp
)) == VECTOR_TYPE
)
450 DECL_GIMPLE_REG_P (tmp
) = 1;
451 gsi_insert_after (&i
, s
, GSI_SAME_STMT
);
453 start_new_block
= true;
457 first_stmt_of_seq
= false;
462 /* Create and return a new empty basic block after bb AFTER. */
465 create_bb (void *h
, void *e
, basic_block after
)
471 /* Create and initialize a new basic block. Since alloc_block uses
472 GC allocation that clears memory to allocate a basic block, we do
473 not have to clear the newly allocated basic block here. */
476 bb
->index
= last_basic_block
;
478 set_bb_seq (bb
, h
? (gimple_seq
) h
: NULL
);
480 /* Add the new block to the linked list of blocks. */
481 link_block (bb
, after
);
483 /* Grow the basic block array if needed. */
484 if ((size_t) last_basic_block
== basic_block_info
->length ())
486 size_t new_size
= last_basic_block
+ (last_basic_block
+ 3) / 4;
487 vec_safe_grow_cleared (basic_block_info
, new_size
);
490 /* Add the newly created block to the array. */
491 SET_BASIC_BLOCK (last_basic_block
, bb
);
500 /*---------------------------------------------------------------------------
502 ---------------------------------------------------------------------------*/
504 /* Fold COND_EXPR_COND of each COND_EXPR. */
507 fold_cond_expr_cond (void)
513 gimple stmt
= last_stmt (bb
);
515 if (stmt
&& gimple_code (stmt
) == GIMPLE_COND
)
517 location_t loc
= gimple_location (stmt
);
521 fold_defer_overflow_warnings ();
522 cond
= fold_binary_loc (loc
, gimple_cond_code (stmt
), boolean_type_node
,
523 gimple_cond_lhs (stmt
), gimple_cond_rhs (stmt
));
526 zerop
= integer_zerop (cond
);
527 onep
= integer_onep (cond
);
530 zerop
= onep
= false;
532 fold_undefer_overflow_warnings (zerop
|| onep
,
534 WARN_STRICT_OVERFLOW_CONDITIONAL
);
536 gimple_cond_make_false (stmt
);
538 gimple_cond_make_true (stmt
);
543 /* Join all the blocks in the flowgraph. */
549 struct omp_region
*cur_region
= NULL
;
551 /* Create an edge from entry to the first block with executable
553 make_edge (ENTRY_BLOCK_PTR
, BASIC_BLOCK (NUM_FIXED_BLOCKS
), EDGE_FALLTHRU
);
555 /* Traverse the basic block array placing edges. */
558 gimple last
= last_stmt (bb
);
563 enum gimple_code code
= gimple_code (last
);
567 make_goto_expr_edges (bb
);
571 make_edge (bb
, EXIT_BLOCK_PTR
, 0);
575 make_cond_expr_edges (bb
);
579 make_gimple_switch_edges (bb
);
583 make_eh_edges (last
);
586 case GIMPLE_EH_DISPATCH
:
587 fallthru
= make_eh_dispatch_edges (last
);
591 /* If this function receives a nonlocal goto, then we need to
592 make edges from this call site to all the nonlocal goto
594 if (stmt_can_make_abnormal_goto (last
))
595 make_abnormal_goto_edges (bb
, true);
597 /* If this statement has reachable exception handlers, then
598 create abnormal edges to them. */
599 make_eh_edges (last
);
601 /* BUILTIN_RETURN is really a return statement. */
602 if (gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
603 make_edge (bb
, EXIT_BLOCK_PTR
, 0), fallthru
= false;
604 /* Some calls are known not to return. */
606 fallthru
= !(gimple_call_flags (last
) & ECF_NORETURN
);
610 /* A GIMPLE_ASSIGN may throw internally and thus be considered
612 if (is_ctrl_altering_stmt (last
))
613 make_eh_edges (last
);
618 make_gimple_asm_edges (bb
);
623 fallthru
= make_gimple_omp_edges (bb
, &cur_region
);
626 case GIMPLE_TRANSACTION
:
628 tree abort_label
= gimple_transaction_label (last
);
630 make_edge (bb
, label_to_block (abort_label
), EDGE_TM_ABORT
);
636 gcc_assert (!stmt_ends_bb_p (last
));
644 make_edge (bb
, bb
->next_bb
, EDGE_FALLTHRU
);
649 /* Fold COND_EXPR_COND of each COND_EXPR. */
650 fold_cond_expr_cond ();
653 /* Find the next available discriminator value for LOCUS. The
654 discriminator distinguishes among several basic blocks that
655 share a common locus, allowing for more accurate sample-based
659 next_discriminator_for_locus (location_t locus
)
661 struct locus_discrim_map item
;
662 struct locus_discrim_map
**slot
;
665 item
.discriminator
= 0;
666 slot
= discriminator_per_locus
.find_slot_with_hash (
667 &item
, LOCATION_LINE (locus
), INSERT
);
669 if (*slot
== HTAB_EMPTY_ENTRY
)
671 *slot
= XNEW (struct locus_discrim_map
);
673 (*slot
)->locus
= locus
;
674 (*slot
)->discriminator
= 0;
676 (*slot
)->discriminator
++;
677 return (*slot
)->discriminator
;
680 /* Return TRUE if LOCUS1 and LOCUS2 refer to the same source line. */
683 same_line_p (location_t locus1
, location_t locus2
)
685 expanded_location from
, to
;
687 if (locus1
== locus2
)
690 from
= expand_location (locus1
);
691 to
= expand_location (locus2
);
693 if (from
.line
!= to
.line
)
695 if (from
.file
== to
.file
)
697 return (from
.file
!= NULL
699 && filename_cmp (from
.file
, to
.file
) == 0);
702 /* Assign discriminators to each basic block. */
705 assign_discriminators (void)
713 gimple last
= last_stmt (bb
);
714 location_t locus
= last
? gimple_location (last
) : UNKNOWN_LOCATION
;
716 if (locus
== UNKNOWN_LOCATION
)
719 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
721 gimple first
= first_non_label_stmt (e
->dest
);
722 gimple last
= last_stmt (e
->dest
);
723 if ((first
&& same_line_p (locus
, gimple_location (first
)))
724 || (last
&& same_line_p (locus
, gimple_location (last
))))
726 if (e
->dest
->discriminator
!= 0 && bb
->discriminator
== 0)
727 bb
->discriminator
= next_discriminator_for_locus (locus
);
729 e
->dest
->discriminator
= next_discriminator_for_locus (locus
);
735 /* Create the edges for a GIMPLE_COND starting at block BB. */
738 make_cond_expr_edges (basic_block bb
)
740 gimple entry
= last_stmt (bb
);
741 gimple then_stmt
, else_stmt
;
742 basic_block then_bb
, else_bb
;
743 tree then_label
, else_label
;
747 gcc_assert (gimple_code (entry
) == GIMPLE_COND
);
749 /* Entry basic blocks for each component. */
750 then_label
= gimple_cond_true_label (entry
);
751 else_label
= gimple_cond_false_label (entry
);
752 then_bb
= label_to_block (then_label
);
753 else_bb
= label_to_block (else_label
);
754 then_stmt
= first_stmt (then_bb
);
755 else_stmt
= first_stmt (else_bb
);
757 e
= make_edge (bb
, then_bb
, EDGE_TRUE_VALUE
);
758 e
->goto_locus
= gimple_location (then_stmt
);
759 e
= make_edge (bb
, else_bb
, EDGE_FALSE_VALUE
);
761 e
->goto_locus
= gimple_location (else_stmt
);
763 /* We do not need the labels anymore. */
764 gimple_cond_set_true_label (entry
, NULL_TREE
);
765 gimple_cond_set_false_label (entry
, NULL_TREE
);
769 /* Called for each element in the hash table (P) as we delete the
770 edge to cases hash table.
772 Clear all the TREE_CHAINs to prevent problems with copying of
773 SWITCH_EXPRs and structure sharing rules, then free the hash table
777 edge_to_cases_cleanup (const void *key ATTRIBUTE_UNUSED
, void **value
,
778 void *data ATTRIBUTE_UNUSED
)
782 for (t
= (tree
) *value
; t
; t
= next
)
784 next
= CASE_CHAIN (t
);
785 CASE_CHAIN (t
) = NULL
;
792 /* Start recording information mapping edges to case labels. */
795 start_recording_case_labels (void)
797 gcc_assert (edge_to_cases
== NULL
);
798 edge_to_cases
= pointer_map_create ();
799 touched_switch_bbs
= BITMAP_ALLOC (NULL
);
802 /* Return nonzero if we are recording information for case labels. */
805 recording_case_labels_p (void)
807 return (edge_to_cases
!= NULL
);
810 /* Stop recording information mapping edges to case labels and
811 remove any information we have recorded. */
813 end_recording_case_labels (void)
817 pointer_map_traverse (edge_to_cases
, edge_to_cases_cleanup
, NULL
);
818 pointer_map_destroy (edge_to_cases
);
819 edge_to_cases
= NULL
;
820 EXECUTE_IF_SET_IN_BITMAP (touched_switch_bbs
, 0, i
, bi
)
822 basic_block bb
= BASIC_BLOCK (i
);
825 gimple stmt
= last_stmt (bb
);
826 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
827 group_case_labels_stmt (stmt
);
830 BITMAP_FREE (touched_switch_bbs
);
833 /* If we are inside a {start,end}_recording_cases block, then return
834 a chain of CASE_LABEL_EXPRs from T which reference E.
836 Otherwise return NULL. */
839 get_cases_for_edge (edge e
, gimple t
)
844 /* If we are not recording cases, then we do not have CASE_LABEL_EXPR
845 chains available. Return NULL so the caller can detect this case. */
846 if (!recording_case_labels_p ())
849 slot
= pointer_map_contains (edge_to_cases
, e
);
853 /* If we did not find E in the hash table, then this must be the first
854 time we have been queried for information about E & T. Add all the
855 elements from T to the hash table then perform the query again. */
857 n
= gimple_switch_num_labels (t
);
858 for (i
= 0; i
< n
; i
++)
860 tree elt
= gimple_switch_label (t
, i
);
861 tree lab
= CASE_LABEL (elt
);
862 basic_block label_bb
= label_to_block (lab
);
863 edge this_edge
= find_edge (e
->src
, label_bb
);
865 /* Add it to the chain of CASE_LABEL_EXPRs referencing E, or create
867 slot
= pointer_map_insert (edge_to_cases
, this_edge
);
868 CASE_CHAIN (elt
) = (tree
) *slot
;
872 return (tree
) *pointer_map_contains (edge_to_cases
, e
);
875 /* Create the edges for a GIMPLE_SWITCH starting at block BB. */
878 make_gimple_switch_edges (basic_block bb
)
880 gimple entry
= last_stmt (bb
);
883 n
= gimple_switch_num_labels (entry
);
885 for (i
= 0; i
< n
; ++i
)
887 tree lab
= CASE_LABEL (gimple_switch_label (entry
, i
));
888 basic_block label_bb
= label_to_block (lab
);
889 make_edge (bb
, label_bb
, 0);
894 /* Return the basic block holding label DEST. */
897 label_to_block_fn (struct function
*ifun
, tree dest
)
899 int uid
= LABEL_DECL_UID (dest
);
901 /* We would die hard when faced by an undefined label. Emit a label to
902 the very first basic block. This will hopefully make even the dataflow
903 and undefined variable warnings quite right. */
904 if (seen_error () && uid
< 0)
906 gimple_stmt_iterator gsi
= gsi_start_bb (BASIC_BLOCK (NUM_FIXED_BLOCKS
));
909 stmt
= gimple_build_label (dest
);
910 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
911 uid
= LABEL_DECL_UID (dest
);
913 if (vec_safe_length (ifun
->cfg
->x_label_to_block_map
) <= (unsigned int) uid
)
915 return (*ifun
->cfg
->x_label_to_block_map
)[uid
];
918 /* Create edges for an abnormal goto statement at block BB. If FOR_CALL
919 is true, the source statement is a CALL_EXPR instead of a GOTO_EXPR. */
922 make_abnormal_goto_edges (basic_block bb
, bool for_call
)
924 basic_block target_bb
;
925 gimple_stmt_iterator gsi
;
927 FOR_EACH_BB (target_bb
)
929 for (gsi
= gsi_start_bb (target_bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
931 gimple label_stmt
= gsi_stmt (gsi
);
934 if (gimple_code (label_stmt
) != GIMPLE_LABEL
)
937 target
= gimple_label_label (label_stmt
);
939 /* Make an edge to every label block that has been marked as a
940 potential target for a computed goto or a non-local goto. */
941 if ((FORCED_LABEL (target
) && !for_call
)
942 || (DECL_NONLOCAL (target
) && for_call
))
944 make_edge (bb
, target_bb
, EDGE_ABNORMAL
);
949 && is_gimple_debug (gsi_stmt (gsi
)))
950 gsi_next_nondebug (&gsi
);
951 if (!gsi_end_p (gsi
))
953 /* Make an edge to every setjmp-like call. */
954 gimple call_stmt
= gsi_stmt (gsi
);
955 if (is_gimple_call (call_stmt
)
956 && (gimple_call_flags (call_stmt
) & ECF_RETURNS_TWICE
))
957 make_edge (bb
, target_bb
, EDGE_ABNORMAL
);
962 /* Create edges for a goto statement at block BB. */
965 make_goto_expr_edges (basic_block bb
)
967 gimple_stmt_iterator last
= gsi_last_bb (bb
);
968 gimple goto_t
= gsi_stmt (last
);
970 /* A simple GOTO creates normal edges. */
971 if (simple_goto_p (goto_t
))
973 tree dest
= gimple_goto_dest (goto_t
);
974 basic_block label_bb
= label_to_block (dest
);
975 edge e
= make_edge (bb
, label_bb
, EDGE_FALLTHRU
);
976 e
->goto_locus
= gimple_location (goto_t
);
977 gsi_remove (&last
, true);
981 /* A computed GOTO creates abnormal edges. */
982 make_abnormal_goto_edges (bb
, false);
985 /* Create edges for an asm statement with labels at block BB. */
988 make_gimple_asm_edges (basic_block bb
)
990 gimple stmt
= last_stmt (bb
);
991 int i
, n
= gimple_asm_nlabels (stmt
);
993 for (i
= 0; i
< n
; ++i
)
995 tree label
= TREE_VALUE (gimple_asm_label_op (stmt
, i
));
996 basic_block label_bb
= label_to_block (label
);
997 make_edge (bb
, label_bb
, 0);
1001 /*---------------------------------------------------------------------------
1003 ---------------------------------------------------------------------------*/
1005 /* Cleanup useless labels in basic blocks. This is something we wish
1006 to do early because it allows us to group case labels before creating
1007 the edges for the CFG, and it speeds up block statement iterators in
1008 all passes later on.
1009 We rerun this pass after CFG is created, to get rid of the labels that
1010 are no longer referenced. After then we do not run it any more, since
1011 (almost) no new labels should be created. */
1013 /* A map from basic block index to the leading label of that block. */
1014 static struct label_record
1019 /* True if the label is referenced from somewhere. */
1023 /* Given LABEL return the first label in the same basic block. */
1026 main_block_label (tree label
)
1028 basic_block bb
= label_to_block (label
);
1029 tree main_label
= label_for_bb
[bb
->index
].label
;
1031 /* label_to_block possibly inserted undefined label into the chain. */
1034 label_for_bb
[bb
->index
].label
= label
;
1038 label_for_bb
[bb
->index
].used
= true;
1042 /* Clean up redundant labels within the exception tree. */
1045 cleanup_dead_labels_eh (void)
1052 if (cfun
->eh
== NULL
)
1055 for (i
= 1; vec_safe_iterate (cfun
->eh
->lp_array
, i
, &lp
); ++i
)
1056 if (lp
&& lp
->post_landing_pad
)
1058 lab
= main_block_label (lp
->post_landing_pad
);
1059 if (lab
!= lp
->post_landing_pad
)
1061 EH_LANDING_PAD_NR (lp
->post_landing_pad
) = 0;
1062 EH_LANDING_PAD_NR (lab
) = lp
->index
;
1066 FOR_ALL_EH_REGION (r
)
1070 case ERT_MUST_NOT_THROW
:
1076 for (c
= r
->u
.eh_try
.first_catch
; c
; c
= c
->next_catch
)
1080 c
->label
= main_block_label (lab
);
1085 case ERT_ALLOWED_EXCEPTIONS
:
1086 lab
= r
->u
.allowed
.label
;
1088 r
->u
.allowed
.label
= main_block_label (lab
);
1094 /* Cleanup redundant labels. This is a three-step process:
1095 1) Find the leading label for each block.
1096 2) Redirect all references to labels to the leading labels.
1097 3) Cleanup all useless labels. */
1100 cleanup_dead_labels (void)
1103 label_for_bb
= XCNEWVEC (struct label_record
, last_basic_block
);
1105 /* Find a suitable label for each block. We use the first user-defined
1106 label if there is one, or otherwise just the first label we see. */
1109 gimple_stmt_iterator i
;
1111 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
1114 gimple stmt
= gsi_stmt (i
);
1116 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1119 label
= gimple_label_label (stmt
);
1121 /* If we have not yet seen a label for the current block,
1122 remember this one and see if there are more labels. */
1123 if (!label_for_bb
[bb
->index
].label
)
1125 label_for_bb
[bb
->index
].label
= label
;
1129 /* If we did see a label for the current block already, but it
1130 is an artificially created label, replace it if the current
1131 label is a user defined label. */
1132 if (!DECL_ARTIFICIAL (label
)
1133 && DECL_ARTIFICIAL (label_for_bb
[bb
->index
].label
))
1135 label_for_bb
[bb
->index
].label
= label
;
1141 /* Now redirect all jumps/branches to the selected label.
1142 First do so for each block ending in a control statement. */
1145 gimple stmt
= last_stmt (bb
);
1146 tree label
, new_label
;
1151 switch (gimple_code (stmt
))
1154 label
= gimple_cond_true_label (stmt
);
1157 new_label
= main_block_label (label
);
1158 if (new_label
!= label
)
1159 gimple_cond_set_true_label (stmt
, new_label
);
1162 label
= gimple_cond_false_label (stmt
);
1165 new_label
= main_block_label (label
);
1166 if (new_label
!= label
)
1167 gimple_cond_set_false_label (stmt
, new_label
);
1173 size_t i
, n
= gimple_switch_num_labels (stmt
);
1175 /* Replace all destination labels. */
1176 for (i
= 0; i
< n
; ++i
)
1178 tree case_label
= gimple_switch_label (stmt
, i
);
1179 label
= CASE_LABEL (case_label
);
1180 new_label
= main_block_label (label
);
1181 if (new_label
!= label
)
1182 CASE_LABEL (case_label
) = new_label
;
1189 int i
, n
= gimple_asm_nlabels (stmt
);
1191 for (i
= 0; i
< n
; ++i
)
1193 tree cons
= gimple_asm_label_op (stmt
, i
);
1194 tree label
= main_block_label (TREE_VALUE (cons
));
1195 TREE_VALUE (cons
) = label
;
1200 /* We have to handle gotos until they're removed, and we don't
1201 remove them until after we've created the CFG edges. */
1203 if (!computed_goto_p (stmt
))
1205 label
= gimple_goto_dest (stmt
);
1206 new_label
= main_block_label (label
);
1207 if (new_label
!= label
)
1208 gimple_goto_set_dest (stmt
, new_label
);
1212 case GIMPLE_TRANSACTION
:
1214 tree label
= gimple_transaction_label (stmt
);
1217 tree new_label
= main_block_label (label
);
1218 if (new_label
!= label
)
1219 gimple_transaction_set_label (stmt
, new_label
);
1229 /* Do the same for the exception region tree labels. */
1230 cleanup_dead_labels_eh ();
1232 /* Finally, purge dead labels. All user-defined labels and labels that
1233 can be the target of non-local gotos and labels which have their
1234 address taken are preserved. */
1237 gimple_stmt_iterator i
;
1238 tree label_for_this_bb
= label_for_bb
[bb
->index
].label
;
1240 if (!label_for_this_bb
)
1243 /* If the main label of the block is unused, we may still remove it. */
1244 if (!label_for_bb
[bb
->index
].used
)
1245 label_for_this_bb
= NULL
;
1247 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); )
1250 gimple stmt
= gsi_stmt (i
);
1252 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1255 label
= gimple_label_label (stmt
);
1257 if (label
== label_for_this_bb
1258 || !DECL_ARTIFICIAL (label
)
1259 || DECL_NONLOCAL (label
)
1260 || FORCED_LABEL (label
))
1263 gsi_remove (&i
, true);
1267 free (label_for_bb
);
1270 /* Scan the sorted vector of cases in STMT (a GIMPLE_SWITCH) and combine
1271 the ones jumping to the same label.
1272 Eg. three separate entries 1: 2: 3: become one entry 1..3: */
1275 group_case_labels_stmt (gimple stmt
)
1277 int old_size
= gimple_switch_num_labels (stmt
);
1278 int i
, j
, new_size
= old_size
;
1279 basic_block default_bb
= NULL
;
1281 default_bb
= label_to_block (CASE_LABEL (gimple_switch_default_label (stmt
)));
1283 /* Look for possible opportunities to merge cases. */
1285 while (i
< old_size
)
1287 tree base_case
, base_high
;
1288 basic_block base_bb
;
1290 base_case
= gimple_switch_label (stmt
, i
);
1292 gcc_assert (base_case
);
1293 base_bb
= label_to_block (CASE_LABEL (base_case
));
1295 /* Discard cases that have the same destination as the
1297 if (base_bb
== default_bb
)
1299 gimple_switch_set_label (stmt
, i
, NULL_TREE
);
1305 base_high
= CASE_HIGH (base_case
)
1306 ? CASE_HIGH (base_case
)
1307 : CASE_LOW (base_case
);
1310 /* Try to merge case labels. Break out when we reach the end
1311 of the label vector or when we cannot merge the next case
1312 label with the current one. */
1313 while (i
< old_size
)
1315 tree merge_case
= gimple_switch_label (stmt
, i
);
1316 basic_block merge_bb
= label_to_block (CASE_LABEL (merge_case
));
1317 double_int bhp1
= tree_to_double_int (base_high
) + double_int_one
;
1319 /* Merge the cases if they jump to the same place,
1320 and their ranges are consecutive. */
1321 if (merge_bb
== base_bb
1322 && tree_to_double_int (CASE_LOW (merge_case
)) == bhp1
)
1324 base_high
= CASE_HIGH (merge_case
) ?
1325 CASE_HIGH (merge_case
) : CASE_LOW (merge_case
);
1326 CASE_HIGH (base_case
) = base_high
;
1327 gimple_switch_set_label (stmt
, i
, NULL_TREE
);
1336 /* Compress the case labels in the label vector, and adjust the
1337 length of the vector. */
1338 for (i
= 0, j
= 0; i
< new_size
; i
++)
1340 while (! gimple_switch_label (stmt
, j
))
1342 gimple_switch_set_label (stmt
, i
,
1343 gimple_switch_label (stmt
, j
++));
1346 gcc_assert (new_size
<= old_size
);
1347 gimple_switch_set_num_labels (stmt
, new_size
);
1350 /* Look for blocks ending in a multiway branch (a GIMPLE_SWITCH),
1351 and scan the sorted vector of cases. Combine the ones jumping to the
1355 group_case_labels (void)
1361 gimple stmt
= last_stmt (bb
);
1362 if (stmt
&& gimple_code (stmt
) == GIMPLE_SWITCH
)
1363 group_case_labels_stmt (stmt
);
1367 /* Checks whether we can merge block B into block A. */
1370 gimple_can_merge_blocks_p (basic_block a
, basic_block b
)
1373 gimple_stmt_iterator gsi
;
1375 if (!single_succ_p (a
))
1378 if (single_succ_edge (a
)->flags
& EDGE_COMPLEX
)
1381 if (single_succ (a
) != b
)
1384 if (!single_pred_p (b
))
1387 if (b
== EXIT_BLOCK_PTR
)
1390 /* If A ends by a statement causing exceptions or something similar, we
1391 cannot merge the blocks. */
1392 stmt
= last_stmt (a
);
1393 if (stmt
&& stmt_ends_bb_p (stmt
))
1396 /* Do not allow a block with only a non-local label to be merged. */
1398 && gimple_code (stmt
) == GIMPLE_LABEL
1399 && DECL_NONLOCAL (gimple_label_label (stmt
)))
1402 /* Examine the labels at the beginning of B. */
1403 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1406 stmt
= gsi_stmt (gsi
);
1407 if (gimple_code (stmt
) != GIMPLE_LABEL
)
1409 lab
= gimple_label_label (stmt
);
1411 /* Do not remove user forced labels or for -O0 any user labels. */
1412 if (!DECL_ARTIFICIAL (lab
) && (!optimize
|| FORCED_LABEL (lab
)))
1416 /* Protect the loop latches. */
1417 if (current_loops
&& b
->loop_father
->latch
== b
)
1420 /* It must be possible to eliminate all phi nodes in B. If ssa form
1421 is not up-to-date and a name-mapping is registered, we cannot eliminate
1422 any phis. Symbols marked for renaming are never a problem though. */
1423 for (gsi
= gsi_start_phis (b
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1425 gimple phi
= gsi_stmt (gsi
);
1426 /* Technically only new names matter. */
1427 if (name_registered_for_update_p (PHI_RESULT (phi
)))
1431 /* When not optimizing, don't merge if we'd lose goto_locus. */
1433 && single_succ_edge (a
)->goto_locus
!= UNKNOWN_LOCATION
)
1435 location_t goto_locus
= single_succ_edge (a
)->goto_locus
;
1436 gimple_stmt_iterator prev
, next
;
1437 prev
= gsi_last_nondebug_bb (a
);
1438 next
= gsi_after_labels (b
);
1439 if (!gsi_end_p (next
) && is_gimple_debug (gsi_stmt (next
)))
1440 gsi_next_nondebug (&next
);
1441 if ((gsi_end_p (prev
)
1442 || gimple_location (gsi_stmt (prev
)) != goto_locus
)
1443 && (gsi_end_p (next
)
1444 || gimple_location (gsi_stmt (next
)) != goto_locus
))
1451 /* Replaces all uses of NAME by VAL. */
1454 replace_uses_by (tree name
, tree val
)
1456 imm_use_iterator imm_iter
;
1461 FOR_EACH_IMM_USE_STMT (stmt
, imm_iter
, name
)
1463 FOR_EACH_IMM_USE_ON_STMT (use
, imm_iter
)
1465 replace_exp (use
, val
);
1467 if (gimple_code (stmt
) == GIMPLE_PHI
)
1469 e
= gimple_phi_arg_edge (stmt
, PHI_ARG_INDEX_FROM_USE (use
));
1470 if (e
->flags
& EDGE_ABNORMAL
)
1472 /* This can only occur for virtual operands, since
1473 for the real ones SSA_NAME_OCCURS_IN_ABNORMAL_PHI (name))
1474 would prevent replacement. */
1475 gcc_checking_assert (virtual_operand_p (name
));
1476 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (val
) = 1;
1481 if (gimple_code (stmt
) != GIMPLE_PHI
)
1483 gimple_stmt_iterator gsi
= gsi_for_stmt (stmt
);
1484 gimple orig_stmt
= stmt
;
1487 /* Mark the block if we changed the last stmt in it. */
1488 if (cfgcleanup_altered_bbs
1489 && stmt_ends_bb_p (stmt
))
1490 bitmap_set_bit (cfgcleanup_altered_bbs
, gimple_bb (stmt
)->index
);
1492 /* FIXME. It shouldn't be required to keep TREE_CONSTANT
1493 on ADDR_EXPRs up-to-date on GIMPLE. Propagation will
1494 only change sth from non-invariant to invariant, and only
1495 when propagating constants. */
1496 if (is_gimple_min_invariant (val
))
1497 for (i
= 0; i
< gimple_num_ops (stmt
); i
++)
1499 tree op
= gimple_op (stmt
, i
);
1500 /* Operands may be empty here. For example, the labels
1501 of a GIMPLE_COND are nulled out following the creation
1502 of the corresponding CFG edges. */
1503 if (op
&& TREE_CODE (op
) == ADDR_EXPR
)
1504 recompute_tree_invariant_for_addr_expr (op
);
1507 if (fold_stmt (&gsi
))
1508 stmt
= gsi_stmt (gsi
);
1510 if (maybe_clean_or_replace_eh_stmt (orig_stmt
, stmt
))
1511 gimple_purge_dead_eh_edges (gimple_bb (stmt
));
1517 gcc_checking_assert (has_zero_uses (name
));
1519 /* Also update the trees stored in loop structures. */
1525 FOR_EACH_LOOP (li
, loop
, 0)
1527 substitute_in_loop_info (loop
, name
, val
);
1532 /* Merge block B into block A. */
1535 gimple_merge_blocks (basic_block a
, basic_block b
)
1537 gimple_stmt_iterator last
, gsi
, psi
;
1540 fprintf (dump_file
, "Merging blocks %d and %d\n", a
->index
, b
->index
);
1542 /* Remove all single-valued PHI nodes from block B of the form
1543 V_i = PHI <V_j> by propagating V_j to all the uses of V_i. */
1544 gsi
= gsi_last_bb (a
);
1545 for (psi
= gsi_start_phis (b
); !gsi_end_p (psi
); )
1547 gimple phi
= gsi_stmt (psi
);
1548 tree def
= gimple_phi_result (phi
), use
= gimple_phi_arg_def (phi
, 0);
1550 bool may_replace_uses
= (virtual_operand_p (def
)
1551 || may_propagate_copy (def
, use
));
1553 /* In case we maintain loop closed ssa form, do not propagate arguments
1554 of loop exit phi nodes. */
1556 && loops_state_satisfies_p (LOOP_CLOSED_SSA
)
1557 && !virtual_operand_p (def
)
1558 && TREE_CODE (use
) == SSA_NAME
1559 && a
->loop_father
!= b
->loop_father
)
1560 may_replace_uses
= false;
1562 if (!may_replace_uses
)
1564 gcc_assert (!virtual_operand_p (def
));
1566 /* Note that just emitting the copies is fine -- there is no problem
1567 with ordering of phi nodes. This is because A is the single
1568 predecessor of B, therefore results of the phi nodes cannot
1569 appear as arguments of the phi nodes. */
1570 copy
= gimple_build_assign (def
, use
);
1571 gsi_insert_after (&gsi
, copy
, GSI_NEW_STMT
);
1572 remove_phi_node (&psi
, false);
1576 /* If we deal with a PHI for virtual operands, we can simply
1577 propagate these without fussing with folding or updating
1579 if (virtual_operand_p (def
))
1581 imm_use_iterator iter
;
1582 use_operand_p use_p
;
1585 FOR_EACH_IMM_USE_STMT (stmt
, iter
, def
)
1586 FOR_EACH_IMM_USE_ON_STMT (use_p
, iter
)
1587 SET_USE (use_p
, use
);
1589 if (SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
))
1590 SSA_NAME_OCCURS_IN_ABNORMAL_PHI (use
) = 1;
1593 replace_uses_by (def
, use
);
1595 remove_phi_node (&psi
, true);
1599 /* Ensure that B follows A. */
1600 move_block_after (b
, a
);
1602 gcc_assert (single_succ_edge (a
)->flags
& EDGE_FALLTHRU
);
1603 gcc_assert (!last_stmt (a
) || !stmt_ends_bb_p (last_stmt (a
)));
1605 /* Remove labels from B and set gimple_bb to A for other statements. */
1606 for (gsi
= gsi_start_bb (b
); !gsi_end_p (gsi
);)
1608 gimple stmt
= gsi_stmt (gsi
);
1609 if (gimple_code (stmt
) == GIMPLE_LABEL
)
1611 tree label
= gimple_label_label (stmt
);
1614 gsi_remove (&gsi
, false);
1616 /* Now that we can thread computed gotos, we might have
1617 a situation where we have a forced label in block B
1618 However, the label at the start of block B might still be
1619 used in other ways (think about the runtime checking for
1620 Fortran assigned gotos). So we can not just delete the
1621 label. Instead we move the label to the start of block A. */
1622 if (FORCED_LABEL (label
))
1624 gimple_stmt_iterator dest_gsi
= gsi_start_bb (a
);
1625 gsi_insert_before (&dest_gsi
, stmt
, GSI_NEW_STMT
);
1627 /* Other user labels keep around in a form of a debug stmt. */
1628 else if (!DECL_ARTIFICIAL (label
) && MAY_HAVE_DEBUG_STMTS
)
1630 gimple dbg
= gimple_build_debug_bind (label
,
1633 gimple_debug_bind_reset_value (dbg
);
1634 gsi_insert_before (&gsi
, dbg
, GSI_SAME_STMT
);
1637 lp_nr
= EH_LANDING_PAD_NR (label
);
1640 eh_landing_pad lp
= get_eh_landing_pad_from_number (lp_nr
);
1641 lp
->post_landing_pad
= NULL
;
1646 gimple_set_bb (stmt
, a
);
1651 /* Merge the sequences. */
1652 last
= gsi_last_bb (a
);
1653 gsi_insert_seq_after (&last
, bb_seq (b
), GSI_NEW_STMT
);
1654 set_bb_seq (b
, NULL
);
1656 if (cfgcleanup_altered_bbs
)
1657 bitmap_set_bit (cfgcleanup_altered_bbs
, a
->index
);
1661 /* Return the one of two successors of BB that is not reachable by a
1662 complex edge, if there is one. Else, return BB. We use
1663 this in optimizations that use post-dominators for their heuristics,
1664 to catch the cases in C++ where function calls are involved. */
1667 single_noncomplex_succ (basic_block bb
)
1670 if (EDGE_COUNT (bb
->succs
) != 2)
1673 e0
= EDGE_SUCC (bb
, 0);
1674 e1
= EDGE_SUCC (bb
, 1);
1675 if (e0
->flags
& EDGE_COMPLEX
)
1677 if (e1
->flags
& EDGE_COMPLEX
)
1683 /* T is CALL_EXPR. Set current_function_calls_* flags. */
1686 notice_special_calls (gimple call
)
1688 int flags
= gimple_call_flags (call
);
1690 if (flags
& ECF_MAY_BE_ALLOCA
)
1691 cfun
->calls_alloca
= true;
1692 if (flags
& ECF_RETURNS_TWICE
)
1693 cfun
->calls_setjmp
= true;
1697 /* Clear flags set by notice_special_calls. Used by dead code removal
1698 to update the flags. */
1701 clear_special_calls (void)
1703 cfun
->calls_alloca
= false;
1704 cfun
->calls_setjmp
= false;
1707 /* Remove PHI nodes associated with basic block BB and all edges out of BB. */
1710 remove_phi_nodes_and_edges_for_unreachable_block (basic_block bb
)
1712 /* Since this block is no longer reachable, we can just delete all
1713 of its PHI nodes. */
1714 remove_phi_nodes (bb
);
1716 /* Remove edges to BB's successors. */
1717 while (EDGE_COUNT (bb
->succs
) > 0)
1718 remove_edge (EDGE_SUCC (bb
, 0));
1722 /* Remove statements of basic block BB. */
1725 remove_bb (basic_block bb
)
1727 gimple_stmt_iterator i
;
1731 fprintf (dump_file
, "Removing basic block %d\n", bb
->index
);
1732 if (dump_flags
& TDF_DETAILS
)
1734 dump_bb (dump_file
, bb
, 0, dump_flags
);
1735 fprintf (dump_file
, "\n");
1741 struct loop
*loop
= bb
->loop_father
;
1743 /* If a loop gets removed, clean up the information associated
1745 if (loop
->latch
== bb
1746 || loop
->header
== bb
)
1747 free_numbers_of_iterations_estimates_loop (loop
);
1750 /* Remove all the instructions in the block. */
1751 if (bb_seq (bb
) != NULL
)
1753 /* Walk backwards so as to get a chance to substitute all
1754 released DEFs into debug stmts. See
1755 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
1757 for (i
= gsi_last_bb (bb
); !gsi_end_p (i
);)
1759 gimple stmt
= gsi_stmt (i
);
1760 if (gimple_code (stmt
) == GIMPLE_LABEL
1761 && (FORCED_LABEL (gimple_label_label (stmt
))
1762 || DECL_NONLOCAL (gimple_label_label (stmt
))))
1765 gimple_stmt_iterator new_gsi
;
1767 /* A non-reachable non-local label may still be referenced.
1768 But it no longer needs to carry the extra semantics of
1770 if (DECL_NONLOCAL (gimple_label_label (stmt
)))
1772 DECL_NONLOCAL (gimple_label_label (stmt
)) = 0;
1773 FORCED_LABEL (gimple_label_label (stmt
)) = 1;
1776 new_bb
= bb
->prev_bb
;
1777 new_gsi
= gsi_start_bb (new_bb
);
1778 gsi_remove (&i
, false);
1779 gsi_insert_before (&new_gsi
, stmt
, GSI_NEW_STMT
);
1783 /* Release SSA definitions if we are in SSA. Note that we
1784 may be called when not in SSA. For example,
1785 final_cleanup calls this function via
1786 cleanup_tree_cfg. */
1787 if (gimple_in_ssa_p (cfun
))
1788 release_defs (stmt
);
1790 gsi_remove (&i
, true);
1794 i
= gsi_last_bb (bb
);
1800 remove_phi_nodes_and_edges_for_unreachable_block (bb
);
1801 bb
->il
.gimple
.seq
= NULL
;
1802 bb
->il
.gimple
.phi_nodes
= NULL
;
1806 /* Given a basic block BB ending with COND_EXPR or SWITCH_EXPR, and a
1807 predicate VAL, return the edge that will be taken out of the block.
1808 If VAL does not match a unique edge, NULL is returned. */
1811 find_taken_edge (basic_block bb
, tree val
)
1815 stmt
= last_stmt (bb
);
1818 gcc_assert (is_ctrl_stmt (stmt
));
1823 if (!is_gimple_min_invariant (val
))
1826 if (gimple_code (stmt
) == GIMPLE_COND
)
1827 return find_taken_edge_cond_expr (bb
, val
);
1829 if (gimple_code (stmt
) == GIMPLE_SWITCH
)
1830 return find_taken_edge_switch_expr (bb
, val
);
1832 if (computed_goto_p (stmt
))
1834 /* Only optimize if the argument is a label, if the argument is
1835 not a label then we can not construct a proper CFG.
1837 It may be the case that we only need to allow the LABEL_REF to
1838 appear inside an ADDR_EXPR, but we also allow the LABEL_REF to
1839 appear inside a LABEL_EXPR just to be safe. */
1840 if ((TREE_CODE (val
) == ADDR_EXPR
|| TREE_CODE (val
) == LABEL_EXPR
)
1841 && TREE_CODE (TREE_OPERAND (val
, 0)) == LABEL_DECL
)
1842 return find_taken_edge_computed_goto (bb
, TREE_OPERAND (val
, 0));
1849 /* Given a constant value VAL and the entry block BB to a GOTO_EXPR
1850 statement, determine which of the outgoing edges will be taken out of the
1851 block. Return NULL if either edge may be taken. */
1854 find_taken_edge_computed_goto (basic_block bb
, tree val
)
1859 dest
= label_to_block (val
);
1862 e
= find_edge (bb
, dest
);
1863 gcc_assert (e
!= NULL
);
1869 /* Given a constant value VAL and the entry block BB to a COND_EXPR
1870 statement, determine which of the two edges will be taken out of the
1871 block. Return NULL if either edge may be taken. */
1874 find_taken_edge_cond_expr (basic_block bb
, tree val
)
1876 edge true_edge
, false_edge
;
1878 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
1880 gcc_assert (TREE_CODE (val
) == INTEGER_CST
);
1881 return (integer_zerop (val
) ? false_edge
: true_edge
);
1884 /* Given an INTEGER_CST VAL and the entry block BB to a SWITCH_EXPR
1885 statement, determine which edge will be taken out of the block. Return
1886 NULL if any edge may be taken. */
1889 find_taken_edge_switch_expr (basic_block bb
, tree val
)
1891 basic_block dest_bb
;
1896 switch_stmt
= last_stmt (bb
);
1897 taken_case
= find_case_label_for_value (switch_stmt
, val
);
1898 dest_bb
= label_to_block (CASE_LABEL (taken_case
));
1900 e
= find_edge (bb
, dest_bb
);
1906 /* Return the CASE_LABEL_EXPR that SWITCH_STMT will take for VAL.
1907 We can make optimal use here of the fact that the case labels are
1908 sorted: We can do a binary search for a case matching VAL. */
1911 find_case_label_for_value (gimple switch_stmt
, tree val
)
1913 size_t low
, high
, n
= gimple_switch_num_labels (switch_stmt
);
1914 tree default_case
= gimple_switch_default_label (switch_stmt
);
1916 for (low
= 0, high
= n
; high
- low
> 1; )
1918 size_t i
= (high
+ low
) / 2;
1919 tree t
= gimple_switch_label (switch_stmt
, i
);
1922 /* Cache the result of comparing CASE_LOW and val. */
1923 cmp
= tree_int_cst_compare (CASE_LOW (t
), val
);
1930 if (CASE_HIGH (t
) == NULL
)
1932 /* A singe-valued case label. */
1938 /* A case range. We can only handle integer ranges. */
1939 if (cmp
<= 0 && tree_int_cst_compare (CASE_HIGH (t
), val
) >= 0)
1944 return default_case
;
1948 /* Dump a basic block on stderr. */
1951 gimple_debug_bb (basic_block bb
)
1953 dump_bb (stderr
, bb
, 0, TDF_VOPS
|TDF_MEMSYMS
|TDF_BLOCKS
);
1957 /* Dump basic block with index N on stderr. */
1960 gimple_debug_bb_n (int n
)
1962 gimple_debug_bb (BASIC_BLOCK (n
));
1963 return BASIC_BLOCK (n
);
1967 /* Dump the CFG on stderr.
1969 FLAGS are the same used by the tree dumping functions
1970 (see TDF_* in dumpfile.h). */
1973 gimple_debug_cfg (int flags
)
1975 gimple_dump_cfg (stderr
, flags
);
1979 /* Dump the program showing basic block boundaries on the given FILE.
1981 FLAGS are the same used by the tree dumping functions (see TDF_* in
1985 gimple_dump_cfg (FILE *file
, int flags
)
1987 if (flags
& TDF_DETAILS
)
1989 dump_function_header (file
, current_function_decl
, flags
);
1990 fprintf (file
, ";; \n%d basic blocks, %d edges, last basic block %d.\n\n",
1991 n_basic_blocks
, n_edges
, last_basic_block
);
1993 brief_dump_cfg (file
, flags
| TDF_COMMENT
);
1994 fprintf (file
, "\n");
1997 if (flags
& TDF_STATS
)
1998 dump_cfg_stats (file
);
2000 dump_function_to_file (current_function_decl
, file
, flags
| TDF_BLOCKS
);
2004 /* Dump CFG statistics on FILE. */
2007 dump_cfg_stats (FILE *file
)
2009 static long max_num_merged_labels
= 0;
2010 unsigned long size
, total
= 0;
2013 const char * const fmt_str
= "%-30s%-13s%12s\n";
2014 const char * const fmt_str_1
= "%-30s%13d%11lu%c\n";
2015 const char * const fmt_str_2
= "%-30s%13ld%11lu%c\n";
2016 const char * const fmt_str_3
= "%-43s%11lu%c\n";
2017 const char *funcname
= current_function_name ();
2019 fprintf (file
, "\nCFG Statistics for %s\n\n", funcname
);
2021 fprintf (file
, "---------------------------------------------------------\n");
2022 fprintf (file
, fmt_str
, "", " Number of ", "Memory");
2023 fprintf (file
, fmt_str
, "", " instances ", "used ");
2024 fprintf (file
, "---------------------------------------------------------\n");
2026 size
= n_basic_blocks
* sizeof (struct basic_block_def
);
2028 fprintf (file
, fmt_str_1
, "Basic blocks", n_basic_blocks
,
2029 SCALE (size
), LABEL (size
));
2033 num_edges
+= EDGE_COUNT (bb
->succs
);
2034 size
= num_edges
* sizeof (struct edge_def
);
2036 fprintf (file
, fmt_str_2
, "Edges", num_edges
, SCALE (size
), LABEL (size
));
2038 fprintf (file
, "---------------------------------------------------------\n");
2039 fprintf (file
, fmt_str_3
, "Total memory used by CFG data", SCALE (total
),
2041 fprintf (file
, "---------------------------------------------------------\n");
2042 fprintf (file
, "\n");
2044 if (cfg_stats
.num_merged_labels
> max_num_merged_labels
)
2045 max_num_merged_labels
= cfg_stats
.num_merged_labels
;
2047 fprintf (file
, "Coalesced label blocks: %ld (Max so far: %ld)\n",
2048 cfg_stats
.num_merged_labels
, max_num_merged_labels
);
2050 fprintf (file
, "\n");
2054 /* Dump CFG statistics on stderr. Keep extern so that it's always
2055 linked in the final executable. */
2058 debug_cfg_stats (void)
2060 dump_cfg_stats (stderr
);
2063 /*---------------------------------------------------------------------------
2064 Miscellaneous helpers
2065 ---------------------------------------------------------------------------*/
2067 /* Return true if T, a GIMPLE_CALL, can make an abnormal transfer of control
2068 flow. Transfers of control flow associated with EH are excluded. */
2071 call_can_make_abnormal_goto (gimple t
)
2073 /* If the function has no non-local labels, then a call cannot make an
2074 abnormal transfer of control. */
2075 if (!cfun
->has_nonlocal_label
2076 && !cfun
->calls_setjmp
)
2079 /* Likewise if the call has no side effects. */
2080 if (!gimple_has_side_effects (t
))
2083 /* Likewise if the called function is leaf. */
2084 if (gimple_call_flags (t
) & ECF_LEAF
)
2091 /* Return true if T can make an abnormal transfer of control flow.
2092 Transfers of control flow associated with EH are excluded. */
2095 stmt_can_make_abnormal_goto (gimple t
)
2097 if (computed_goto_p (t
))
2099 if (is_gimple_call (t
))
2100 return call_can_make_abnormal_goto (t
);
2105 /* Return true if T represents a stmt that always transfers control. */
2108 is_ctrl_stmt (gimple t
)
2110 switch (gimple_code (t
))
2124 /* Return true if T is a statement that may alter the flow of control
2125 (e.g., a call to a non-returning function). */
2128 is_ctrl_altering_stmt (gimple t
)
2132 switch (gimple_code (t
))
2136 int flags
= gimple_call_flags (t
);
2138 /* A call alters control flow if it can make an abnormal goto. */
2139 if (call_can_make_abnormal_goto (t
))
2142 /* A call also alters control flow if it does not return. */
2143 if (flags
& ECF_NORETURN
)
2146 /* TM ending statements have backedges out of the transaction.
2147 Return true so we split the basic block containing them.
2148 Note that the TM_BUILTIN test is merely an optimization. */
2149 if ((flags
& ECF_TM_BUILTIN
)
2150 && is_tm_ending_fndecl (gimple_call_fndecl (t
)))
2153 /* BUILT_IN_RETURN call is same as return statement. */
2154 if (gimple_call_builtin_p (t
, BUILT_IN_RETURN
))
2159 case GIMPLE_EH_DISPATCH
:
2160 /* EH_DISPATCH branches to the individual catch handlers at
2161 this level of a try or allowed-exceptions region. It can
2162 fallthru to the next statement as well. */
2166 if (gimple_asm_nlabels (t
) > 0)
2171 /* OpenMP directives alter control flow. */
2174 case GIMPLE_TRANSACTION
:
2175 /* A transaction start alters control flow. */
2182 /* If a statement can throw, it alters control flow. */
2183 return stmt_can_throw_internal (t
);
2187 /* Return true if T is a simple local goto. */
2190 simple_goto_p (gimple t
)
2192 return (gimple_code (t
) == GIMPLE_GOTO
2193 && TREE_CODE (gimple_goto_dest (t
)) == LABEL_DECL
);
2197 /* Return true if STMT should start a new basic block. PREV_STMT is
2198 the statement preceding STMT. It is used when STMT is a label or a
2199 case label. Labels should only start a new basic block if their
2200 previous statement wasn't a label. Otherwise, sequence of labels
2201 would generate unnecessary basic blocks that only contain a single
2205 stmt_starts_bb_p (gimple stmt
, gimple prev_stmt
)
2210 /* Labels start a new basic block only if the preceding statement
2211 wasn't a label of the same type. This prevents the creation of
2212 consecutive blocks that have nothing but a single label. */
2213 if (gimple_code (stmt
) == GIMPLE_LABEL
)
2215 /* Nonlocal and computed GOTO targets always start a new block. */
2216 if (DECL_NONLOCAL (gimple_label_label (stmt
))
2217 || FORCED_LABEL (gimple_label_label (stmt
)))
2220 if (prev_stmt
&& gimple_code (prev_stmt
) == GIMPLE_LABEL
)
2222 if (DECL_NONLOCAL (gimple_label_label (prev_stmt
)))
2225 cfg_stats
.num_merged_labels
++;
2231 else if (gimple_code (stmt
) == GIMPLE_CALL
2232 && gimple_call_flags (stmt
) & ECF_RETURNS_TWICE
)
2233 /* setjmp acts similar to a nonlocal GOTO target and thus should
2234 start a new block. */
2241 /* Return true if T should end a basic block. */
2244 stmt_ends_bb_p (gimple t
)
2246 return is_ctrl_stmt (t
) || is_ctrl_altering_stmt (t
);
2249 /* Remove block annotations and other data structures. */
2252 delete_tree_cfg_annotations (void)
2254 vec_free (label_to_block_map
);
2258 /* Return the first statement in basic block BB. */
2261 first_stmt (basic_block bb
)
2263 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2266 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2274 /* Return the first non-label statement in basic block BB. */
2277 first_non_label_stmt (basic_block bb
)
2279 gimple_stmt_iterator i
= gsi_start_bb (bb
);
2280 while (!gsi_end_p (i
) && gimple_code (gsi_stmt (i
)) == GIMPLE_LABEL
)
2282 return !gsi_end_p (i
) ? gsi_stmt (i
) : NULL
;
2285 /* Return the last statement in basic block BB. */
2288 last_stmt (basic_block bb
)
2290 gimple_stmt_iterator i
= gsi_last_bb (bb
);
2293 while (!gsi_end_p (i
) && is_gimple_debug ((stmt
= gsi_stmt (i
))))
2301 /* Return the last statement of an otherwise empty block. Return NULL
2302 if the block is totally empty, or if it contains more than one
2306 last_and_only_stmt (basic_block bb
)
2308 gimple_stmt_iterator i
= gsi_last_nondebug_bb (bb
);
2314 last
= gsi_stmt (i
);
2315 gsi_prev_nondebug (&i
);
2319 /* Empty statements should no longer appear in the instruction stream.
2320 Everything that might have appeared before should be deleted by
2321 remove_useless_stmts, and the optimizers should just gsi_remove
2322 instead of smashing with build_empty_stmt.
2324 Thus the only thing that should appear here in a block containing
2325 one executable statement is a label. */
2326 prev
= gsi_stmt (i
);
2327 if (gimple_code (prev
) == GIMPLE_LABEL
)
2333 /* Reinstall those PHI arguments queued in OLD_EDGE to NEW_EDGE. */
2336 reinstall_phi_args (edge new_edge
, edge old_edge
)
2338 edge_var_map_vector
*v
;
2341 gimple_stmt_iterator phis
;
2343 v
= redirect_edge_var_map_vector (old_edge
);
2347 for (i
= 0, phis
= gsi_start_phis (new_edge
->dest
);
2348 v
->iterate (i
, &vm
) && !gsi_end_p (phis
);
2349 i
++, gsi_next (&phis
))
2351 gimple phi
= gsi_stmt (phis
);
2352 tree result
= redirect_edge_var_map_result (vm
);
2353 tree arg
= redirect_edge_var_map_def (vm
);
2355 gcc_assert (result
== gimple_phi_result (phi
));
2357 add_phi_arg (phi
, arg
, new_edge
, redirect_edge_var_map_location (vm
));
2360 redirect_edge_var_map_clear (old_edge
);
2363 /* Returns the basic block after which the new basic block created
2364 by splitting edge EDGE_IN should be placed. Tries to keep the new block
2365 near its "logical" location. This is of most help to humans looking
2366 at debugging dumps. */
2369 split_edge_bb_loc (edge edge_in
)
2371 basic_block dest
= edge_in
->dest
;
2372 basic_block dest_prev
= dest
->prev_bb
;
2376 edge e
= find_edge (dest_prev
, dest
);
2377 if (e
&& !(e
->flags
& EDGE_COMPLEX
))
2378 return edge_in
->src
;
2383 /* Split a (typically critical) edge EDGE_IN. Return the new block.
2384 Abort on abnormal edges. */
2387 gimple_split_edge (edge edge_in
)
2389 basic_block new_bb
, after_bb
, dest
;
2392 /* Abnormal edges cannot be split. */
2393 gcc_assert (!(edge_in
->flags
& EDGE_ABNORMAL
));
2395 dest
= edge_in
->dest
;
2397 after_bb
= split_edge_bb_loc (edge_in
);
2399 new_bb
= create_empty_bb (after_bb
);
2400 new_bb
->frequency
= EDGE_FREQUENCY (edge_in
);
2401 new_bb
->count
= edge_in
->count
;
2402 new_edge
= make_edge (new_bb
, dest
, EDGE_FALLTHRU
);
2403 new_edge
->probability
= REG_BR_PROB_BASE
;
2404 new_edge
->count
= edge_in
->count
;
2406 e
= redirect_edge_and_branch (edge_in
, new_bb
);
2407 gcc_assert (e
== edge_in
);
2408 reinstall_phi_args (new_edge
, e
);
2414 /* Verify properties of the address expression T with base object BASE. */
2417 verify_address (tree t
, tree base
)
2420 bool old_side_effects
;
2422 bool new_side_effects
;
2424 old_constant
= TREE_CONSTANT (t
);
2425 old_side_effects
= TREE_SIDE_EFFECTS (t
);
2427 recompute_tree_invariant_for_addr_expr (t
);
2428 new_side_effects
= TREE_SIDE_EFFECTS (t
);
2429 new_constant
= TREE_CONSTANT (t
);
2431 if (old_constant
!= new_constant
)
2433 error ("constant not recomputed when ADDR_EXPR changed");
2436 if (old_side_effects
!= new_side_effects
)
2438 error ("side effects not recomputed when ADDR_EXPR changed");
2442 if (!(TREE_CODE (base
) == VAR_DECL
2443 || TREE_CODE (base
) == PARM_DECL
2444 || TREE_CODE (base
) == RESULT_DECL
))
2447 if (DECL_GIMPLE_REG_P (base
))
2449 error ("DECL_GIMPLE_REG_P set on a variable with address taken");
2456 /* Callback for walk_tree, check that all elements with address taken are
2457 properly noticed as such. The DATA is an int* that is 1 if TP was seen
2458 inside a PHI node. */
2461 verify_expr (tree
*tp
, int *walk_subtrees
, void *data ATTRIBUTE_UNUSED
)
2468 /* Check operand N for being valid GIMPLE and give error MSG if not. */
2469 #define CHECK_OP(N, MSG) \
2470 do { if (!is_gimple_val (TREE_OPERAND (t, N))) \
2471 { error (MSG); return TREE_OPERAND (t, N); }} while (0)
2473 switch (TREE_CODE (t
))
2476 if (SSA_NAME_IN_FREE_LIST (t
))
2478 error ("SSA name in freelist but still referenced");
2484 error ("INDIRECT_REF in gimple IL");
2488 x
= TREE_OPERAND (t
, 0);
2489 if (!POINTER_TYPE_P (TREE_TYPE (x
))
2490 || !is_gimple_mem_ref_addr (x
))
2492 error ("invalid first operand of MEM_REF");
2495 if (TREE_CODE (TREE_OPERAND (t
, 1)) != INTEGER_CST
2496 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 1))))
2498 error ("invalid offset operand of MEM_REF");
2499 return TREE_OPERAND (t
, 1);
2501 if (TREE_CODE (x
) == ADDR_EXPR
2502 && (x
= verify_address (x
, TREE_OPERAND (x
, 0))))
2508 x
= fold (ASSERT_EXPR_COND (t
));
2509 if (x
== boolean_false_node
)
2511 error ("ASSERT_EXPR with an always-false condition");
2517 error ("MODIFY_EXPR not expected while having tuples");
2524 gcc_assert (is_gimple_address (t
));
2526 /* Skip any references (they will be checked when we recurse down the
2527 tree) and ensure that any variable used as a prefix is marked
2529 for (x
= TREE_OPERAND (t
, 0);
2530 handled_component_p (x
);
2531 x
= TREE_OPERAND (x
, 0))
2534 if ((tem
= verify_address (t
, x
)))
2537 if (!(TREE_CODE (x
) == VAR_DECL
2538 || TREE_CODE (x
) == PARM_DECL
2539 || TREE_CODE (x
) == RESULT_DECL
))
2542 if (!TREE_ADDRESSABLE (x
))
2544 error ("address taken, but ADDRESSABLE bit not set");
2552 x
= COND_EXPR_COND (t
);
2553 if (!INTEGRAL_TYPE_P (TREE_TYPE (x
)))
2555 error ("non-integral used in condition");
2558 if (!is_gimple_condexpr (x
))
2560 error ("invalid conditional operand");
2565 case NON_LVALUE_EXPR
:
2566 case TRUTH_NOT_EXPR
:
2570 case FIX_TRUNC_EXPR
:
2575 CHECK_OP (0, "invalid operand to unary operator");
2581 if (!is_gimple_reg_type (TREE_TYPE (t
)))
2583 error ("non-scalar BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR");
2587 if (TREE_CODE (t
) == BIT_FIELD_REF
)
2589 if (!host_integerp (TREE_OPERAND (t
, 1), 1)
2590 || !host_integerp (TREE_OPERAND (t
, 2), 1))
2592 error ("invalid position or size operand to BIT_FIELD_REF");
2595 if (INTEGRAL_TYPE_P (TREE_TYPE (t
))
2596 && (TYPE_PRECISION (TREE_TYPE (t
))
2597 != TREE_INT_CST_LOW (TREE_OPERAND (t
, 1))))
2599 error ("integral result type precision does not match "
2600 "field size of BIT_FIELD_REF");
2603 else if (!INTEGRAL_TYPE_P (TREE_TYPE (t
))
2604 && TYPE_MODE (TREE_TYPE (t
)) != BLKmode
2605 && (GET_MODE_PRECISION (TYPE_MODE (TREE_TYPE (t
)))
2606 != TREE_INT_CST_LOW (TREE_OPERAND (t
, 1))))
2608 error ("mode precision of non-integral result does not "
2609 "match field size of BIT_FIELD_REF");
2613 t
= TREE_OPERAND (t
, 0);
2618 case ARRAY_RANGE_REF
:
2619 case VIEW_CONVERT_EXPR
:
2620 /* We have a nest of references. Verify that each of the operands
2621 that determine where to reference is either a constant or a variable,
2622 verify that the base is valid, and then show we've already checked
2624 while (handled_component_p (t
))
2626 if (TREE_CODE (t
) == COMPONENT_REF
&& TREE_OPERAND (t
, 2))
2627 CHECK_OP (2, "invalid COMPONENT_REF offset operator");
2628 else if (TREE_CODE (t
) == ARRAY_REF
2629 || TREE_CODE (t
) == ARRAY_RANGE_REF
)
2631 CHECK_OP (1, "invalid array index");
2632 if (TREE_OPERAND (t
, 2))
2633 CHECK_OP (2, "invalid array lower bound");
2634 if (TREE_OPERAND (t
, 3))
2635 CHECK_OP (3, "invalid array stride");
2637 else if (TREE_CODE (t
) == BIT_FIELD_REF
2638 || TREE_CODE (t
) == REALPART_EXPR
2639 || TREE_CODE (t
) == IMAGPART_EXPR
)
2641 error ("non-top-level BIT_FIELD_REF, IMAGPART_EXPR or "
2646 t
= TREE_OPERAND (t
, 0);
2649 if (!is_gimple_min_invariant (t
) && !is_gimple_lvalue (t
))
2651 error ("invalid reference prefix");
2658 /* PLUS_EXPR and MINUS_EXPR don't work on pointers, they should be done using
2659 POINTER_PLUS_EXPR. */
2660 if (POINTER_TYPE_P (TREE_TYPE (t
)))
2662 error ("invalid operand to plus/minus, type is a pointer");
2665 CHECK_OP (0, "invalid operand to binary operator");
2666 CHECK_OP (1, "invalid operand to binary operator");
2669 case POINTER_PLUS_EXPR
:
2670 /* Check to make sure the first operand is a pointer or reference type. */
2671 if (!POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (t
, 0))))
2673 error ("invalid operand to pointer plus, first operand is not a pointer");
2676 /* Check to make sure the second operand is a ptrofftype. */
2677 if (!ptrofftype_p (TREE_TYPE (TREE_OPERAND (t
, 1))))
2679 error ("invalid operand to pointer plus, second operand is not an "
2680 "integer type of appropriate width");
2690 case UNORDERED_EXPR
:
2699 case TRUNC_DIV_EXPR
:
2701 case FLOOR_DIV_EXPR
:
2702 case ROUND_DIV_EXPR
:
2703 case TRUNC_MOD_EXPR
:
2705 case FLOOR_MOD_EXPR
:
2706 case ROUND_MOD_EXPR
:
2708 case EXACT_DIV_EXPR
:
2718 CHECK_OP (0, "invalid operand to binary operator");
2719 CHECK_OP (1, "invalid operand to binary operator");
2723 if (TREE_CONSTANT (t
) && TREE_CODE (TREE_TYPE (t
)) == VECTOR_TYPE
)
2727 case CASE_LABEL_EXPR
:
2730 error ("invalid CASE_CHAIN");
2744 /* Verify if EXPR is either a GIMPLE ID or a GIMPLE indirect reference.
2745 Returns true if there is an error, otherwise false. */
2748 verify_types_in_gimple_min_lval (tree expr
)
2752 if (is_gimple_id (expr
))
2755 if (TREE_CODE (expr
) != TARGET_MEM_REF
2756 && TREE_CODE (expr
) != MEM_REF
)
2758 error ("invalid expression for min lvalue");
2762 /* TARGET_MEM_REFs are strange beasts. */
2763 if (TREE_CODE (expr
) == TARGET_MEM_REF
)
2766 op
= TREE_OPERAND (expr
, 0);
2767 if (!is_gimple_val (op
))
2769 error ("invalid operand in indirect reference");
2770 debug_generic_stmt (op
);
2773 /* Memory references now generally can involve a value conversion. */
2778 /* Verify if EXPR is a valid GIMPLE reference expression. If
2779 REQUIRE_LVALUE is true verifies it is an lvalue. Returns true
2780 if there is an error, otherwise false. */
2783 verify_types_in_gimple_reference (tree expr
, bool require_lvalue
)
2785 while (handled_component_p (expr
))
2787 tree op
= TREE_OPERAND (expr
, 0);
2789 if (TREE_CODE (expr
) == ARRAY_REF
2790 || TREE_CODE (expr
) == ARRAY_RANGE_REF
)
2792 if (!is_gimple_val (TREE_OPERAND (expr
, 1))
2793 || (TREE_OPERAND (expr
, 2)
2794 && !is_gimple_val (TREE_OPERAND (expr
, 2)))
2795 || (TREE_OPERAND (expr
, 3)
2796 && !is_gimple_val (TREE_OPERAND (expr
, 3))))
2798 error ("invalid operands to array reference");
2799 debug_generic_stmt (expr
);
2804 /* Verify if the reference array element types are compatible. */
2805 if (TREE_CODE (expr
) == ARRAY_REF
2806 && !useless_type_conversion_p (TREE_TYPE (expr
),
2807 TREE_TYPE (TREE_TYPE (op
))))
2809 error ("type mismatch in array reference");
2810 debug_generic_stmt (TREE_TYPE (expr
));
2811 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
2814 if (TREE_CODE (expr
) == ARRAY_RANGE_REF
2815 && !useless_type_conversion_p (TREE_TYPE (TREE_TYPE (expr
)),
2816 TREE_TYPE (TREE_TYPE (op
))))
2818 error ("type mismatch in array range reference");
2819 debug_generic_stmt (TREE_TYPE (TREE_TYPE (expr
)));
2820 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
2824 if ((TREE_CODE (expr
) == REALPART_EXPR
2825 || TREE_CODE (expr
) == IMAGPART_EXPR
)
2826 && !useless_type_conversion_p (TREE_TYPE (expr
),
2827 TREE_TYPE (TREE_TYPE (op
))))
2829 error ("type mismatch in real/imagpart reference");
2830 debug_generic_stmt (TREE_TYPE (expr
));
2831 debug_generic_stmt (TREE_TYPE (TREE_TYPE (op
)));
2835 if (TREE_CODE (expr
) == COMPONENT_REF
2836 && !useless_type_conversion_p (TREE_TYPE (expr
),
2837 TREE_TYPE (TREE_OPERAND (expr
, 1))))
2839 error ("type mismatch in component reference");
2840 debug_generic_stmt (TREE_TYPE (expr
));
2841 debug_generic_stmt (TREE_TYPE (TREE_OPERAND (expr
, 1)));
2845 if (TREE_CODE (expr
) == VIEW_CONVERT_EXPR
)
2847 /* For VIEW_CONVERT_EXPRs which are allowed here too, we only check
2848 that their operand is not an SSA name or an invariant when
2849 requiring an lvalue (this usually means there is a SRA or IPA-SRA
2850 bug). Otherwise there is nothing to verify, gross mismatches at
2851 most invoke undefined behavior. */
2853 && (TREE_CODE (op
) == SSA_NAME
2854 || is_gimple_min_invariant (op
)))
2856 error ("conversion of an SSA_NAME on the left hand side");
2857 debug_generic_stmt (expr
);
2860 else if (TREE_CODE (op
) == SSA_NAME
2861 && TYPE_SIZE (TREE_TYPE (expr
)) != TYPE_SIZE (TREE_TYPE (op
)))
2863 error ("conversion of register to a different size");
2864 debug_generic_stmt (expr
);
2867 else if (!handled_component_p (op
))
2874 if (TREE_CODE (expr
) == MEM_REF
)
2876 if (!is_gimple_mem_ref_addr (TREE_OPERAND (expr
, 0)))
2878 error ("invalid address operand in MEM_REF");
2879 debug_generic_stmt (expr
);
2882 if (TREE_CODE (TREE_OPERAND (expr
, 1)) != INTEGER_CST
2883 || !POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (expr
, 1))))
2885 error ("invalid offset operand in MEM_REF");
2886 debug_generic_stmt (expr
);
2890 else if (TREE_CODE (expr
) == TARGET_MEM_REF
)
2892 if (!TMR_BASE (expr
)
2893 || !is_gimple_mem_ref_addr (TMR_BASE (expr
)))
2895 error ("invalid address operand in TARGET_MEM_REF");
2898 if (!TMR_OFFSET (expr
)
2899 || TREE_CODE (TMR_OFFSET (expr
)) != INTEGER_CST
2900 || !POINTER_TYPE_P (TREE_TYPE (TMR_OFFSET (expr
))))
2902 error ("invalid offset operand in TARGET_MEM_REF");
2903 debug_generic_stmt (expr
);
2908 return ((require_lvalue
|| !is_gimple_min_invariant (expr
))
2909 && verify_types_in_gimple_min_lval (expr
));
2912 /* Returns true if there is one pointer type in TYPE_POINTER_TO (SRC_OBJ)
2913 list of pointer-to types that is trivially convertible to DEST. */
2916 one_pointer_to_useless_type_conversion_p (tree dest
, tree src_obj
)
2920 if (!TYPE_POINTER_TO (src_obj
))
2923 for (src
= TYPE_POINTER_TO (src_obj
); src
; src
= TYPE_NEXT_PTR_TO (src
))
2924 if (useless_type_conversion_p (dest
, src
))
2930 /* Return true if TYPE1 is a fixed-point type and if conversions to and
2931 from TYPE2 can be handled by FIXED_CONVERT_EXPR. */
2934 valid_fixed_convert_types_p (tree type1
, tree type2
)
2936 return (FIXED_POINT_TYPE_P (type1
)
2937 && (INTEGRAL_TYPE_P (type2
)
2938 || SCALAR_FLOAT_TYPE_P (type2
)
2939 || FIXED_POINT_TYPE_P (type2
)));
2942 /* Verify the contents of a GIMPLE_CALL STMT. Returns true when there
2943 is a problem, otherwise false. */
2946 verify_gimple_call (gimple stmt
)
2948 tree fn
= gimple_call_fn (stmt
);
2949 tree fntype
, fndecl
;
2952 if (gimple_call_internal_p (stmt
))
2956 error ("gimple call has two targets");
2957 debug_generic_stmt (fn
);
2965 error ("gimple call has no target");
2970 if (fn
&& !is_gimple_call_addr (fn
))
2972 error ("invalid function in gimple call");
2973 debug_generic_stmt (fn
);
2978 && (!POINTER_TYPE_P (TREE_TYPE (fn
))
2979 || (TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != FUNCTION_TYPE
2980 && TREE_CODE (TREE_TYPE (TREE_TYPE (fn
))) != METHOD_TYPE
)))
2982 error ("non-function in gimple call");
2986 fndecl
= gimple_call_fndecl (stmt
);
2988 && TREE_CODE (fndecl
) == FUNCTION_DECL
2989 && DECL_LOOPING_CONST_OR_PURE_P (fndecl
)
2990 && !DECL_PURE_P (fndecl
)
2991 && !TREE_READONLY (fndecl
))
2993 error ("invalid pure const state for function");
2997 if (gimple_call_lhs (stmt
)
2998 && (!is_gimple_lvalue (gimple_call_lhs (stmt
))
2999 || verify_types_in_gimple_reference (gimple_call_lhs (stmt
), true)))
3001 error ("invalid LHS in gimple call");
3005 if (gimple_call_lhs (stmt
) && gimple_call_noreturn_p (stmt
))
3007 error ("LHS in noreturn call");
3011 fntype
= gimple_call_fntype (stmt
);
3013 && gimple_call_lhs (stmt
)
3014 && !useless_type_conversion_p (TREE_TYPE (gimple_call_lhs (stmt
)),
3016 /* ??? At least C++ misses conversions at assignments from
3017 void * call results.
3018 ??? Java is completely off. Especially with functions
3019 returning java.lang.Object.
3020 For now simply allow arbitrary pointer type conversions. */
3021 && !(POINTER_TYPE_P (TREE_TYPE (gimple_call_lhs (stmt
)))
3022 && POINTER_TYPE_P (TREE_TYPE (fntype
))))
3024 error ("invalid conversion in gimple call");
3025 debug_generic_stmt (TREE_TYPE (gimple_call_lhs (stmt
)));
3026 debug_generic_stmt (TREE_TYPE (fntype
));
3030 if (gimple_call_chain (stmt
)
3031 && !is_gimple_val (gimple_call_chain (stmt
)))
3033 error ("invalid static chain in gimple call");
3034 debug_generic_stmt (gimple_call_chain (stmt
));
3038 /* If there is a static chain argument, this should not be an indirect
3039 call, and the decl should have DECL_STATIC_CHAIN set. */
3040 if (gimple_call_chain (stmt
))
3042 if (!gimple_call_fndecl (stmt
))
3044 error ("static chain in indirect gimple call");
3047 fn
= TREE_OPERAND (fn
, 0);
3049 if (!DECL_STATIC_CHAIN (fn
))
3051 error ("static chain with function that doesn%'t use one");
3056 /* ??? The C frontend passes unpromoted arguments in case it
3057 didn't see a function declaration before the call. So for now
3058 leave the call arguments mostly unverified. Once we gimplify
3059 unit-at-a-time we have a chance to fix this. */
3061 for (i
= 0; i
< gimple_call_num_args (stmt
); ++i
)
3063 tree arg
= gimple_call_arg (stmt
, i
);
3064 if ((is_gimple_reg_type (TREE_TYPE (arg
))
3065 && !is_gimple_val (arg
))
3066 || (!is_gimple_reg_type (TREE_TYPE (arg
))
3067 && !is_gimple_lvalue (arg
)))
3069 error ("invalid argument to gimple call");
3070 debug_generic_expr (arg
);
3078 /* Verifies the gimple comparison with the result type TYPE and
3079 the operands OP0 and OP1. */
3082 verify_gimple_comparison (tree type
, tree op0
, tree op1
)
3084 tree op0_type
= TREE_TYPE (op0
);
3085 tree op1_type
= TREE_TYPE (op1
);
3087 if (!is_gimple_val (op0
) || !is_gimple_val (op1
))
3089 error ("invalid operands in gimple comparison");
3093 /* For comparisons we do not have the operations type as the
3094 effective type the comparison is carried out in. Instead
3095 we require that either the first operand is trivially
3096 convertible into the second, or the other way around.
3097 Because we special-case pointers to void we allow
3098 comparisons of pointers with the same mode as well. */
3099 if (!useless_type_conversion_p (op0_type
, op1_type
)
3100 && !useless_type_conversion_p (op1_type
, op0_type
)
3101 && (!POINTER_TYPE_P (op0_type
)
3102 || !POINTER_TYPE_P (op1_type
)
3103 || TYPE_MODE (op0_type
) != TYPE_MODE (op1_type
)))
3105 error ("mismatching comparison operand types");
3106 debug_generic_expr (op0_type
);
3107 debug_generic_expr (op1_type
);
3111 /* The resulting type of a comparison may be an effective boolean type. */
3112 if (INTEGRAL_TYPE_P (type
)
3113 && (TREE_CODE (type
) == BOOLEAN_TYPE
3114 || TYPE_PRECISION (type
) == 1))
3116 if (TREE_CODE (op0_type
) == VECTOR_TYPE
3117 || TREE_CODE (op1_type
) == VECTOR_TYPE
)
3119 error ("vector comparison returning a boolean");
3120 debug_generic_expr (op0_type
);
3121 debug_generic_expr (op1_type
);
3125 /* Or an integer vector type with the same size and element count
3126 as the comparison operand types. */
3127 else if (TREE_CODE (type
) == VECTOR_TYPE
3128 && TREE_CODE (TREE_TYPE (type
)) == INTEGER_TYPE
)
3130 if (TREE_CODE (op0_type
) != VECTOR_TYPE
3131 || TREE_CODE (op1_type
) != VECTOR_TYPE
)
3133 error ("non-vector operands in vector comparison");
3134 debug_generic_expr (op0_type
);
3135 debug_generic_expr (op1_type
);
3139 if (TYPE_VECTOR_SUBPARTS (type
) != TYPE_VECTOR_SUBPARTS (op0_type
)
3140 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (type
)))
3141 != GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0_type
))))
3142 /* The result of a vector comparison is of signed
3144 || TYPE_UNSIGNED (TREE_TYPE (type
)))
3146 error ("invalid vector comparison resulting type");
3147 debug_generic_expr (type
);
3153 error ("bogus comparison result type");
3154 debug_generic_expr (type
);
3161 /* Verify a gimple assignment statement STMT with an unary rhs.
3162 Returns true if anything is wrong. */
3165 verify_gimple_assign_unary (gimple stmt
)
3167 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3168 tree lhs
= gimple_assign_lhs (stmt
);
3169 tree lhs_type
= TREE_TYPE (lhs
);
3170 tree rhs1
= gimple_assign_rhs1 (stmt
);
3171 tree rhs1_type
= TREE_TYPE (rhs1
);
3173 if (!is_gimple_reg (lhs
))
3175 error ("non-register as LHS of unary operation");
3179 if (!is_gimple_val (rhs1
))
3181 error ("invalid operand in unary operation");
3185 /* First handle conversions. */
3190 /* Allow conversions from pointer type to integral type only if
3191 there is no sign or zero extension involved.
3192 For targets were the precision of ptrofftype doesn't match that
3193 of pointers we need to allow arbitrary conversions to ptrofftype. */
3194 if ((POINTER_TYPE_P (lhs_type
)
3195 && INTEGRAL_TYPE_P (rhs1_type
))
3196 || (POINTER_TYPE_P (rhs1_type
)
3197 && INTEGRAL_TYPE_P (lhs_type
)
3198 && (TYPE_PRECISION (rhs1_type
) >= TYPE_PRECISION (lhs_type
)
3199 || ptrofftype_p (sizetype
))))
3202 /* Allow conversion from integral to offset type and vice versa. */
3203 if ((TREE_CODE (lhs_type
) == OFFSET_TYPE
3204 && INTEGRAL_TYPE_P (rhs1_type
))
3205 || (INTEGRAL_TYPE_P (lhs_type
)
3206 && TREE_CODE (rhs1_type
) == OFFSET_TYPE
))
3209 /* Otherwise assert we are converting between types of the
3211 if (INTEGRAL_TYPE_P (lhs_type
) != INTEGRAL_TYPE_P (rhs1_type
))
3213 error ("invalid types in nop conversion");
3214 debug_generic_expr (lhs_type
);
3215 debug_generic_expr (rhs1_type
);
3222 case ADDR_SPACE_CONVERT_EXPR
:
3224 if (!POINTER_TYPE_P (rhs1_type
) || !POINTER_TYPE_P (lhs_type
)
3225 || (TYPE_ADDR_SPACE (TREE_TYPE (rhs1_type
))
3226 == TYPE_ADDR_SPACE (TREE_TYPE (lhs_type
))))
3228 error ("invalid types in address space conversion");
3229 debug_generic_expr (lhs_type
);
3230 debug_generic_expr (rhs1_type
);
3237 case FIXED_CONVERT_EXPR
:
3239 if (!valid_fixed_convert_types_p (lhs_type
, rhs1_type
)
3240 && !valid_fixed_convert_types_p (rhs1_type
, lhs_type
))
3242 error ("invalid types in fixed-point conversion");
3243 debug_generic_expr (lhs_type
);
3244 debug_generic_expr (rhs1_type
);
3253 if ((!INTEGRAL_TYPE_P (rhs1_type
) || !SCALAR_FLOAT_TYPE_P (lhs_type
))
3254 && (!VECTOR_INTEGER_TYPE_P (rhs1_type
)
3255 || !VECTOR_FLOAT_TYPE_P (lhs_type
)))
3257 error ("invalid types in conversion to floating point");
3258 debug_generic_expr (lhs_type
);
3259 debug_generic_expr (rhs1_type
);
3266 case FIX_TRUNC_EXPR
:
3268 if ((!INTEGRAL_TYPE_P (lhs_type
) || !SCALAR_FLOAT_TYPE_P (rhs1_type
))
3269 && (!VECTOR_INTEGER_TYPE_P (lhs_type
)
3270 || !VECTOR_FLOAT_TYPE_P (rhs1_type
)))
3272 error ("invalid types in conversion to integer");
3273 debug_generic_expr (lhs_type
);
3274 debug_generic_expr (rhs1_type
);
3281 case VEC_UNPACK_HI_EXPR
:
3282 case VEC_UNPACK_LO_EXPR
:
3283 case REDUC_MAX_EXPR
:
3284 case REDUC_MIN_EXPR
:
3285 case REDUC_PLUS_EXPR
:
3286 case VEC_UNPACK_FLOAT_HI_EXPR
:
3287 case VEC_UNPACK_FLOAT_LO_EXPR
:
3295 case NON_LVALUE_EXPR
:
3303 /* For the remaining codes assert there is no conversion involved. */
3304 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3306 error ("non-trivial conversion in unary operation");
3307 debug_generic_expr (lhs_type
);
3308 debug_generic_expr (rhs1_type
);
3315 /* Verify a gimple assignment statement STMT with a binary rhs.
3316 Returns true if anything is wrong. */
3319 verify_gimple_assign_binary (gimple stmt
)
3321 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3322 tree lhs
= gimple_assign_lhs (stmt
);
3323 tree lhs_type
= TREE_TYPE (lhs
);
3324 tree rhs1
= gimple_assign_rhs1 (stmt
);
3325 tree rhs1_type
= TREE_TYPE (rhs1
);
3326 tree rhs2
= gimple_assign_rhs2 (stmt
);
3327 tree rhs2_type
= TREE_TYPE (rhs2
);
3329 if (!is_gimple_reg (lhs
))
3331 error ("non-register as LHS of binary operation");
3335 if (!is_gimple_val (rhs1
)
3336 || !is_gimple_val (rhs2
))
3338 error ("invalid operands in binary operation");
3342 /* First handle operations that involve different types. */
3347 if (TREE_CODE (lhs_type
) != COMPLEX_TYPE
3348 || !(INTEGRAL_TYPE_P (rhs1_type
)
3349 || SCALAR_FLOAT_TYPE_P (rhs1_type
))
3350 || !(INTEGRAL_TYPE_P (rhs2_type
)
3351 || SCALAR_FLOAT_TYPE_P (rhs2_type
)))
3353 error ("type mismatch in complex expression");
3354 debug_generic_expr (lhs_type
);
3355 debug_generic_expr (rhs1_type
);
3356 debug_generic_expr (rhs2_type
);
3368 /* Shifts and rotates are ok on integral types, fixed point
3369 types and integer vector types. */
3370 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3371 && !FIXED_POINT_TYPE_P (rhs1_type
)
3372 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3373 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))))
3374 || (!INTEGRAL_TYPE_P (rhs2_type
)
3375 /* Vector shifts of vectors are also ok. */
3376 && !(TREE_CODE (rhs1_type
) == VECTOR_TYPE
3377 && INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3378 && TREE_CODE (rhs2_type
) == VECTOR_TYPE
3379 && INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3380 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3382 error ("type mismatch in shift expression");
3383 debug_generic_expr (lhs_type
);
3384 debug_generic_expr (rhs1_type
);
3385 debug_generic_expr (rhs2_type
);
3392 case VEC_LSHIFT_EXPR
:
3393 case VEC_RSHIFT_EXPR
:
3395 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3396 || !(INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3397 || POINTER_TYPE_P (TREE_TYPE (rhs1_type
))
3398 || FIXED_POINT_TYPE_P (TREE_TYPE (rhs1_type
))
3399 || SCALAR_FLOAT_TYPE_P (TREE_TYPE (rhs1_type
)))
3400 || (!INTEGRAL_TYPE_P (rhs2_type
)
3401 && (TREE_CODE (rhs2_type
) != VECTOR_TYPE
3402 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs2_type
))))
3403 || !useless_type_conversion_p (lhs_type
, rhs1_type
))
3405 error ("type mismatch in vector shift expression");
3406 debug_generic_expr (lhs_type
);
3407 debug_generic_expr (rhs1_type
);
3408 debug_generic_expr (rhs2_type
);
3411 /* For shifting a vector of non-integral components we
3412 only allow shifting by a constant multiple of the element size. */
3413 if (!INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3414 && (TREE_CODE (rhs2
) != INTEGER_CST
3415 || !div_if_zero_remainder (EXACT_DIV_EXPR
, rhs2
,
3416 TYPE_SIZE (TREE_TYPE (rhs1_type
)))))
3418 error ("non-element sized vector shift of floating point vector");
3425 case WIDEN_LSHIFT_EXPR
:
3427 if (!INTEGRAL_TYPE_P (lhs_type
)
3428 || !INTEGRAL_TYPE_P (rhs1_type
)
3429 || TREE_CODE (rhs2
) != INTEGER_CST
3430 || (2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)))
3432 error ("type mismatch in widening vector shift expression");
3433 debug_generic_expr (lhs_type
);
3434 debug_generic_expr (rhs1_type
);
3435 debug_generic_expr (rhs2_type
);
3442 case VEC_WIDEN_LSHIFT_HI_EXPR
:
3443 case VEC_WIDEN_LSHIFT_LO_EXPR
:
3445 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3446 || TREE_CODE (lhs_type
) != VECTOR_TYPE
3447 || !INTEGRAL_TYPE_P (TREE_TYPE (rhs1_type
))
3448 || !INTEGRAL_TYPE_P (TREE_TYPE (lhs_type
))
3449 || TREE_CODE (rhs2
) != INTEGER_CST
3450 || (2 * TYPE_PRECISION (TREE_TYPE (rhs1_type
))
3451 > TYPE_PRECISION (TREE_TYPE (lhs_type
))))
3453 error ("type mismatch in widening vector shift expression");
3454 debug_generic_expr (lhs_type
);
3455 debug_generic_expr (rhs1_type
);
3456 debug_generic_expr (rhs2_type
);
3466 tree lhs_etype
= lhs_type
;
3467 tree rhs1_etype
= rhs1_type
;
3468 tree rhs2_etype
= rhs2_type
;
3469 if (TREE_CODE (lhs_type
) == VECTOR_TYPE
)
3471 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3472 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
)
3474 error ("invalid non-vector operands to vector valued plus");
3477 lhs_etype
= TREE_TYPE (lhs_type
);
3478 rhs1_etype
= TREE_TYPE (rhs1_type
);
3479 rhs2_etype
= TREE_TYPE (rhs2_type
);
3481 if (POINTER_TYPE_P (lhs_etype
)
3482 || POINTER_TYPE_P (rhs1_etype
)
3483 || POINTER_TYPE_P (rhs2_etype
))
3485 error ("invalid (pointer) operands to plus/minus");
3489 /* Continue with generic binary expression handling. */
3493 case POINTER_PLUS_EXPR
:
3495 if (!POINTER_TYPE_P (rhs1_type
)
3496 || !useless_type_conversion_p (lhs_type
, rhs1_type
)
3497 || !ptrofftype_p (rhs2_type
))
3499 error ("type mismatch in pointer plus expression");
3500 debug_generic_stmt (lhs_type
);
3501 debug_generic_stmt (rhs1_type
);
3502 debug_generic_stmt (rhs2_type
);
3509 case TRUTH_ANDIF_EXPR
:
3510 case TRUTH_ORIF_EXPR
:
3511 case TRUTH_AND_EXPR
:
3513 case TRUTH_XOR_EXPR
:
3523 case UNORDERED_EXPR
:
3531 /* Comparisons are also binary, but the result type is not
3532 connected to the operand types. */
3533 return verify_gimple_comparison (lhs_type
, rhs1
, rhs2
);
3535 case WIDEN_MULT_EXPR
:
3536 if (TREE_CODE (lhs_type
) != INTEGER_TYPE
)
3538 return ((2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
))
3539 || (TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
)));
3541 case WIDEN_SUM_EXPR
:
3542 case VEC_WIDEN_MULT_HI_EXPR
:
3543 case VEC_WIDEN_MULT_LO_EXPR
:
3544 case VEC_WIDEN_MULT_EVEN_EXPR
:
3545 case VEC_WIDEN_MULT_ODD_EXPR
:
3546 case VEC_PACK_TRUNC_EXPR
:
3547 case VEC_PACK_SAT_EXPR
:
3548 case VEC_PACK_FIX_TRUNC_EXPR
:
3553 case MULT_HIGHPART_EXPR
:
3554 case TRUNC_DIV_EXPR
:
3556 case FLOOR_DIV_EXPR
:
3557 case ROUND_DIV_EXPR
:
3558 case TRUNC_MOD_EXPR
:
3560 case FLOOR_MOD_EXPR
:
3561 case ROUND_MOD_EXPR
:
3563 case EXACT_DIV_EXPR
:
3569 /* Continue with generic binary expression handling. */
3576 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3577 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
3579 error ("type mismatch in binary expression");
3580 debug_generic_stmt (lhs_type
);
3581 debug_generic_stmt (rhs1_type
);
3582 debug_generic_stmt (rhs2_type
);
3589 /* Verify a gimple assignment statement STMT with a ternary rhs.
3590 Returns true if anything is wrong. */
3593 verify_gimple_assign_ternary (gimple stmt
)
3595 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3596 tree lhs
= gimple_assign_lhs (stmt
);
3597 tree lhs_type
= TREE_TYPE (lhs
);
3598 tree rhs1
= gimple_assign_rhs1 (stmt
);
3599 tree rhs1_type
= TREE_TYPE (rhs1
);
3600 tree rhs2
= gimple_assign_rhs2 (stmt
);
3601 tree rhs2_type
= TREE_TYPE (rhs2
);
3602 tree rhs3
= gimple_assign_rhs3 (stmt
);
3603 tree rhs3_type
= TREE_TYPE (rhs3
);
3605 if (!is_gimple_reg (lhs
))
3607 error ("non-register as LHS of ternary operation");
3611 if (((rhs_code
== VEC_COND_EXPR
|| rhs_code
== COND_EXPR
)
3612 ? !is_gimple_condexpr (rhs1
) : !is_gimple_val (rhs1
))
3613 || !is_gimple_val (rhs2
)
3614 || !is_gimple_val (rhs3
))
3616 error ("invalid operands in ternary operation");
3620 /* First handle operations that involve different types. */
3623 case WIDEN_MULT_PLUS_EXPR
:
3624 case WIDEN_MULT_MINUS_EXPR
:
3625 if ((!INTEGRAL_TYPE_P (rhs1_type
)
3626 && !FIXED_POINT_TYPE_P (rhs1_type
))
3627 || !useless_type_conversion_p (rhs1_type
, rhs2_type
)
3628 || !useless_type_conversion_p (lhs_type
, rhs3_type
)
3629 || 2 * TYPE_PRECISION (rhs1_type
) > TYPE_PRECISION (lhs_type
)
3630 || TYPE_PRECISION (rhs1_type
) != TYPE_PRECISION (rhs2_type
))
3632 error ("type mismatch in widening multiply-accumulate expression");
3633 debug_generic_expr (lhs_type
);
3634 debug_generic_expr (rhs1_type
);
3635 debug_generic_expr (rhs2_type
);
3636 debug_generic_expr (rhs3_type
);
3642 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3643 || !useless_type_conversion_p (lhs_type
, rhs2_type
)
3644 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
3646 error ("type mismatch in fused multiply-add expression");
3647 debug_generic_expr (lhs_type
);
3648 debug_generic_expr (rhs1_type
);
3649 debug_generic_expr (rhs2_type
);
3650 debug_generic_expr (rhs3_type
);
3657 if (!useless_type_conversion_p (lhs_type
, rhs2_type
)
3658 || !useless_type_conversion_p (lhs_type
, rhs3_type
))
3660 error ("type mismatch in conditional expression");
3661 debug_generic_expr (lhs_type
);
3662 debug_generic_expr (rhs2_type
);
3663 debug_generic_expr (rhs3_type
);
3669 if (!useless_type_conversion_p (lhs_type
, rhs1_type
)
3670 || !useless_type_conversion_p (lhs_type
, rhs2_type
))
3672 error ("type mismatch in vector permute expression");
3673 debug_generic_expr (lhs_type
);
3674 debug_generic_expr (rhs1_type
);
3675 debug_generic_expr (rhs2_type
);
3676 debug_generic_expr (rhs3_type
);
3680 if (TREE_CODE (rhs1_type
) != VECTOR_TYPE
3681 || TREE_CODE (rhs2_type
) != VECTOR_TYPE
3682 || TREE_CODE (rhs3_type
) != VECTOR_TYPE
)
3684 error ("vector types expected in vector permute expression");
3685 debug_generic_expr (lhs_type
);
3686 debug_generic_expr (rhs1_type
);
3687 debug_generic_expr (rhs2_type
);
3688 debug_generic_expr (rhs3_type
);
3692 if (TYPE_VECTOR_SUBPARTS (rhs1_type
) != TYPE_VECTOR_SUBPARTS (rhs2_type
)
3693 || TYPE_VECTOR_SUBPARTS (rhs2_type
)
3694 != TYPE_VECTOR_SUBPARTS (rhs3_type
)
3695 || TYPE_VECTOR_SUBPARTS (rhs3_type
)
3696 != TYPE_VECTOR_SUBPARTS (lhs_type
))
3698 error ("vectors with different element number found "
3699 "in vector permute expression");
3700 debug_generic_expr (lhs_type
);
3701 debug_generic_expr (rhs1_type
);
3702 debug_generic_expr (rhs2_type
);
3703 debug_generic_expr (rhs3_type
);
3707 if (TREE_CODE (TREE_TYPE (rhs3_type
)) != INTEGER_TYPE
3708 || GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs3_type
)))
3709 != GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (rhs1_type
))))
3711 error ("invalid mask type in vector permute expression");
3712 debug_generic_expr (lhs_type
);
3713 debug_generic_expr (rhs1_type
);
3714 debug_generic_expr (rhs2_type
);
3715 debug_generic_expr (rhs3_type
);
3722 case REALIGN_LOAD_EXPR
:
3732 /* Verify a gimple assignment statement STMT with a single rhs.
3733 Returns true if anything is wrong. */
3736 verify_gimple_assign_single (gimple stmt
)
3738 enum tree_code rhs_code
= gimple_assign_rhs_code (stmt
);
3739 tree lhs
= gimple_assign_lhs (stmt
);
3740 tree lhs_type
= TREE_TYPE (lhs
);
3741 tree rhs1
= gimple_assign_rhs1 (stmt
);
3742 tree rhs1_type
= TREE_TYPE (rhs1
);
3745 if (!useless_type_conversion_p (lhs_type
, rhs1_type
))
3747 error ("non-trivial conversion at assignment");
3748 debug_generic_expr (lhs_type
);
3749 debug_generic_expr (rhs1_type
);
3753 if (gimple_clobber_p (stmt
)
3754 && !(DECL_P (lhs
) || TREE_CODE (lhs
) == MEM_REF
))
3756 error ("non-decl/MEM_REF LHS in clobber statement");
3757 debug_generic_expr (lhs
);
3761 if (handled_component_p (lhs
))
3762 res
|= verify_types_in_gimple_reference (lhs
, true);
3764 /* Special codes we cannot handle via their class. */
3769 tree op
= TREE_OPERAND (rhs1
, 0);
3770 if (!is_gimple_addressable (op
))
3772 error ("invalid operand in unary expression");
3776 /* Technically there is no longer a need for matching types, but
3777 gimple hygiene asks for this check. In LTO we can end up
3778 combining incompatible units and thus end up with addresses
3779 of globals that change their type to a common one. */
3781 && !types_compatible_p (TREE_TYPE (op
),
3782 TREE_TYPE (TREE_TYPE (rhs1
)))
3783 && !one_pointer_to_useless_type_conversion_p (TREE_TYPE (rhs1
),
3786 error ("type mismatch in address expression");
3787 debug_generic_stmt (TREE_TYPE (rhs1
));
3788 debug_generic_stmt (TREE_TYPE (op
));
3792 return verify_types_in_gimple_reference (op
, true);
3797 error ("INDIRECT_REF in gimple IL");
3803 case ARRAY_RANGE_REF
:
3804 case VIEW_CONVERT_EXPR
:
3807 case TARGET_MEM_REF
:
3809 if (!is_gimple_reg (lhs
)
3810 && is_gimple_reg_type (TREE_TYPE (lhs
)))
3812 error ("invalid rhs for gimple memory store");
3813 debug_generic_stmt (lhs
);
3814 debug_generic_stmt (rhs1
);
3817 return res
|| verify_types_in_gimple_reference (rhs1
, false);
3829 /* tcc_declaration */
3834 if (!is_gimple_reg (lhs
)
3835 && !is_gimple_reg (rhs1
)
3836 && is_gimple_reg_type (TREE_TYPE (lhs
)))
3838 error ("invalid rhs for gimple memory store");
3839 debug_generic_stmt (lhs
);
3840 debug_generic_stmt (rhs1
);
3846 if (TREE_CODE (rhs1_type
) == VECTOR_TYPE
)
3849 tree elt_i
, elt_v
, elt_t
= NULL_TREE
;
3851 if (CONSTRUCTOR_NELTS (rhs1
) == 0)
3853 /* For vector CONSTRUCTORs we require that either it is empty
3854 CONSTRUCTOR, or it is a CONSTRUCTOR of smaller vector elements
3855 (then the element count must be correct to cover the whole
3856 outer vector and index must be NULL on all elements, or it is
3857 a CONSTRUCTOR of scalar elements, where we as an exception allow
3858 smaller number of elements (assuming zero filling) and
3859 consecutive indexes as compared to NULL indexes (such
3860 CONSTRUCTORs can appear in the IL from FEs). */
3861 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (rhs1
), i
, elt_i
, elt_v
)
3863 if (elt_t
== NULL_TREE
)
3865 elt_t
= TREE_TYPE (elt_v
);
3866 if (TREE_CODE (elt_t
) == VECTOR_TYPE
)
3868 tree elt_t
= TREE_TYPE (elt_v
);
3869 if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
3872 error ("incorrect type of vector CONSTRUCTOR"
3874 debug_generic_stmt (rhs1
);
3877 else if (CONSTRUCTOR_NELTS (rhs1
)
3878 * TYPE_VECTOR_SUBPARTS (elt_t
)
3879 != TYPE_VECTOR_SUBPARTS (rhs1_type
))
3881 error ("incorrect number of vector CONSTRUCTOR"
3883 debug_generic_stmt (rhs1
);
3887 else if (!useless_type_conversion_p (TREE_TYPE (rhs1_type
),
3890 error ("incorrect type of vector CONSTRUCTOR elements");
3891 debug_generic_stmt (rhs1
);
3894 else if (CONSTRUCTOR_NELTS (rhs1
)
3895 > TYPE_VECTOR_SUBPARTS (rhs1_type
))
3897 error ("incorrect number of vector CONSTRUCTOR elements");
3898 debug_generic_stmt (rhs1
);
3902 else if (!useless_type_conversion_p (elt_t
, TREE_TYPE (elt_v
)))
3904 error ("incorrect type of vector CONSTRUCTOR elements");
3905 debug_generic_stmt (rhs1
);
3908 if (elt_i
!= NULL_TREE
3909 && (TREE_CODE (elt_t
) == VECTOR_TYPE
3910 || TREE_CODE (elt_i
) != INTEGER_CST
3911 || compare_tree_int (elt_i
, i
) != 0))
3913 error ("vector CONSTRUCTOR with non-NULL element index");
3914 debug_generic_stmt (rhs1
);
3922 case WITH_SIZE_EXPR
:
3932 /* Verify the contents of a GIMPLE_ASSIGN STMT. Returns true when there
3933 is a problem, otherwise false. */
3936 verify_gimple_assign (gimple stmt
)
3938 switch (gimple_assign_rhs_class (stmt
))
3940 case GIMPLE_SINGLE_RHS
:
3941 return verify_gimple_assign_single (stmt
);
3943 case GIMPLE_UNARY_RHS
:
3944 return verify_gimple_assign_unary (stmt
);
3946 case GIMPLE_BINARY_RHS
:
3947 return verify_gimple_assign_binary (stmt
);
3949 case GIMPLE_TERNARY_RHS
:
3950 return verify_gimple_assign_ternary (stmt
);
3957 /* Verify the contents of a GIMPLE_RETURN STMT. Returns true when there
3958 is a problem, otherwise false. */
3961 verify_gimple_return (gimple stmt
)
3963 tree op
= gimple_return_retval (stmt
);
3964 tree restype
= TREE_TYPE (TREE_TYPE (cfun
->decl
));
3966 /* We cannot test for present return values as we do not fix up missing
3967 return values from the original source. */
3971 if (!is_gimple_val (op
)
3972 && TREE_CODE (op
) != RESULT_DECL
)
3974 error ("invalid operand in return statement");
3975 debug_generic_stmt (op
);
3979 if ((TREE_CODE (op
) == RESULT_DECL
3980 && DECL_BY_REFERENCE (op
))
3981 || (TREE_CODE (op
) == SSA_NAME
3982 && SSA_NAME_VAR (op
)
3983 && TREE_CODE (SSA_NAME_VAR (op
)) == RESULT_DECL
3984 && DECL_BY_REFERENCE (SSA_NAME_VAR (op
))))
3985 op
= TREE_TYPE (op
);
3987 if (!useless_type_conversion_p (restype
, TREE_TYPE (op
)))
3989 error ("invalid conversion in return statement");
3990 debug_generic_stmt (restype
);
3991 debug_generic_stmt (TREE_TYPE (op
));
3999 /* Verify the contents of a GIMPLE_GOTO STMT. Returns true when there
4000 is a problem, otherwise false. */
4003 verify_gimple_goto (gimple stmt
)
4005 tree dest
= gimple_goto_dest (stmt
);
4007 /* ??? We have two canonical forms of direct goto destinations, a
4008 bare LABEL_DECL and an ADDR_EXPR of a LABEL_DECL. */
4009 if (TREE_CODE (dest
) != LABEL_DECL
4010 && (!is_gimple_val (dest
)
4011 || !POINTER_TYPE_P (TREE_TYPE (dest
))))
4013 error ("goto destination is neither a label nor a pointer");
4020 /* Verify the contents of a GIMPLE_SWITCH STMT. Returns true when there
4021 is a problem, otherwise false. */
4024 verify_gimple_switch (gimple stmt
)
4027 tree elt
, prev_upper_bound
= NULL_TREE
;
4028 tree index_type
, elt_type
= NULL_TREE
;
4030 if (!is_gimple_val (gimple_switch_index (stmt
)))
4032 error ("invalid operand to switch statement");
4033 debug_generic_stmt (gimple_switch_index (stmt
));
4037 index_type
= TREE_TYPE (gimple_switch_index (stmt
));
4038 if (! INTEGRAL_TYPE_P (index_type
))
4040 error ("non-integral type switch statement");
4041 debug_generic_expr (index_type
);
4045 elt
= gimple_switch_label (stmt
, 0);
4046 if (CASE_LOW (elt
) != NULL_TREE
|| CASE_HIGH (elt
) != NULL_TREE
)
4048 error ("invalid default case label in switch statement");
4049 debug_generic_expr (elt
);
4053 n
= gimple_switch_num_labels (stmt
);
4054 for (i
= 1; i
< n
; i
++)
4056 elt
= gimple_switch_label (stmt
, i
);
4058 if (! CASE_LOW (elt
))
4060 error ("invalid case label in switch statement");
4061 debug_generic_expr (elt
);
4065 && ! tree_int_cst_lt (CASE_LOW (elt
), CASE_HIGH (elt
)))
4067 error ("invalid case range in switch statement");
4068 debug_generic_expr (elt
);
4074 if (TREE_TYPE (CASE_LOW (elt
)) != elt_type
4075 || (CASE_HIGH (elt
) && TREE_TYPE (CASE_HIGH (elt
)) != elt_type
))
4077 error ("type mismatch for case label in switch statement");
4078 debug_generic_expr (elt
);
4084 elt_type
= TREE_TYPE (CASE_LOW (elt
));
4085 if (TYPE_PRECISION (index_type
) < TYPE_PRECISION (elt_type
))
4087 error ("type precision mismatch in switch statement");
4092 if (prev_upper_bound
)
4094 if (! tree_int_cst_lt (prev_upper_bound
, CASE_LOW (elt
)))
4096 error ("case labels not sorted in switch statement");
4101 prev_upper_bound
= CASE_HIGH (elt
);
4102 if (! prev_upper_bound
)
4103 prev_upper_bound
= CASE_LOW (elt
);
4109 /* Verify a gimple debug statement STMT.
4110 Returns true if anything is wrong. */
4113 verify_gimple_debug (gimple stmt ATTRIBUTE_UNUSED
)
4115 /* There isn't much that could be wrong in a gimple debug stmt. A
4116 gimple debug bind stmt, for example, maps a tree, that's usually
4117 a VAR_DECL or a PARM_DECL, but that could also be some scalarized
4118 component or member of an aggregate type, to another tree, that
4119 can be an arbitrary expression. These stmts expand into debug
4120 insns, and are converted to debug notes by var-tracking.c. */
4124 /* Verify a gimple label statement STMT.
4125 Returns true if anything is wrong. */
4128 verify_gimple_label (gimple stmt
)
4130 tree decl
= gimple_label_label (stmt
);
4134 if (TREE_CODE (decl
) != LABEL_DECL
)
4136 if (!DECL_NONLOCAL (decl
) && !FORCED_LABEL (decl
)
4137 && DECL_CONTEXT (decl
) != current_function_decl
)
4139 error ("label's context is not the current function decl");
4143 uid
= LABEL_DECL_UID (decl
);
4145 && (uid
== -1 || (*label_to_block_map
)[uid
] != gimple_bb (stmt
)))
4147 error ("incorrect entry in label_to_block_map");
4151 uid
= EH_LANDING_PAD_NR (decl
);
4154 eh_landing_pad lp
= get_eh_landing_pad_from_number (uid
);
4155 if (decl
!= lp
->post_landing_pad
)
4157 error ("incorrect setting of landing pad number");
4165 /* Verify the GIMPLE statement STMT. Returns true if there is an
4166 error, otherwise false. */
4169 verify_gimple_stmt (gimple stmt
)
4171 switch (gimple_code (stmt
))
4174 return verify_gimple_assign (stmt
);
4177 return verify_gimple_label (stmt
);
4180 return verify_gimple_call (stmt
);
4183 if (TREE_CODE_CLASS (gimple_cond_code (stmt
)) != tcc_comparison
)
4185 error ("invalid comparison code in gimple cond");
4188 if (!(!gimple_cond_true_label (stmt
)
4189 || TREE_CODE (gimple_cond_true_label (stmt
)) == LABEL_DECL
)
4190 || !(!gimple_cond_false_label (stmt
)
4191 || TREE_CODE (gimple_cond_false_label (stmt
)) == LABEL_DECL
))
4193 error ("invalid labels in gimple cond");
4197 return verify_gimple_comparison (boolean_type_node
,
4198 gimple_cond_lhs (stmt
),
4199 gimple_cond_rhs (stmt
));
4202 return verify_gimple_goto (stmt
);
4205 return verify_gimple_switch (stmt
);
4208 return verify_gimple_return (stmt
);
4213 case GIMPLE_TRANSACTION
:
4214 return verify_gimple_transaction (stmt
);
4216 /* Tuples that do not have tree operands. */
4218 case GIMPLE_PREDICT
:
4220 case GIMPLE_EH_DISPATCH
:
4221 case GIMPLE_EH_MUST_NOT_THROW
:
4225 /* OpenMP directives are validated by the FE and never operated
4226 on by the optimizers. Furthermore, GIMPLE_OMP_FOR may contain
4227 non-gimple expressions when the main index variable has had
4228 its address taken. This does not affect the loop itself
4229 because the header of an GIMPLE_OMP_FOR is merely used to determine
4230 how to setup the parallel iteration. */
4234 return verify_gimple_debug (stmt
);
4241 /* Verify the contents of a GIMPLE_PHI. Returns true if there is a problem,
4242 and false otherwise. */
4245 verify_gimple_phi (gimple phi
)
4249 tree phi_result
= gimple_phi_result (phi
);
4254 error ("invalid PHI result");
4258 virtual_p
= virtual_operand_p (phi_result
);
4259 if (TREE_CODE (phi_result
) != SSA_NAME
4261 && SSA_NAME_VAR (phi_result
) != gimple_vop (cfun
)))
4263 error ("invalid PHI result");
4267 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4269 tree t
= gimple_phi_arg_def (phi
, i
);
4273 error ("missing PHI def");
4277 /* Addressable variables do have SSA_NAMEs but they
4278 are not considered gimple values. */
4279 else if ((TREE_CODE (t
) == SSA_NAME
4280 && virtual_p
!= virtual_operand_p (t
))
4282 && (TREE_CODE (t
) != SSA_NAME
4283 || SSA_NAME_VAR (t
) != gimple_vop (cfun
)))
4285 && !is_gimple_val (t
)))
4287 error ("invalid PHI argument");
4288 debug_generic_expr (t
);
4291 #ifdef ENABLE_TYPES_CHECKING
4292 if (!useless_type_conversion_p (TREE_TYPE (phi_result
), TREE_TYPE (t
)))
4294 error ("incompatible types in PHI argument %u", i
);
4295 debug_generic_stmt (TREE_TYPE (phi_result
));
4296 debug_generic_stmt (TREE_TYPE (t
));
4305 /* Verify the GIMPLE statements inside the sequence STMTS. */
4308 verify_gimple_in_seq_2 (gimple_seq stmts
)
4310 gimple_stmt_iterator ittr
;
4313 for (ittr
= gsi_start (stmts
); !gsi_end_p (ittr
); gsi_next (&ittr
))
4315 gimple stmt
= gsi_stmt (ittr
);
4317 switch (gimple_code (stmt
))
4320 err
|= verify_gimple_in_seq_2 (gimple_bind_body (stmt
));
4324 err
|= verify_gimple_in_seq_2 (gimple_try_eval (stmt
));
4325 err
|= verify_gimple_in_seq_2 (gimple_try_cleanup (stmt
));
4328 case GIMPLE_EH_FILTER
:
4329 err
|= verify_gimple_in_seq_2 (gimple_eh_filter_failure (stmt
));
4332 case GIMPLE_EH_ELSE
:
4333 err
|= verify_gimple_in_seq_2 (gimple_eh_else_n_body (stmt
));
4334 err
|= verify_gimple_in_seq_2 (gimple_eh_else_e_body (stmt
));
4338 err
|= verify_gimple_in_seq_2 (gimple_catch_handler (stmt
));
4341 case GIMPLE_TRANSACTION
:
4342 err
|= verify_gimple_transaction (stmt
);
4347 bool err2
= verify_gimple_stmt (stmt
);
4349 debug_gimple_stmt (stmt
);
4358 /* Verify the contents of a GIMPLE_TRANSACTION. Returns true if there
4359 is a problem, otherwise false. */
4362 verify_gimple_transaction (gimple stmt
)
4364 tree lab
= gimple_transaction_label (stmt
);
4365 if (lab
!= NULL
&& TREE_CODE (lab
) != LABEL_DECL
)
4367 return verify_gimple_in_seq_2 (gimple_transaction_body (stmt
));
4371 /* Verify the GIMPLE statements inside the statement list STMTS. */
4374 verify_gimple_in_seq (gimple_seq stmts
)
4376 timevar_push (TV_TREE_STMT_VERIFY
);
4377 if (verify_gimple_in_seq_2 (stmts
))
4378 internal_error ("verify_gimple failed");
4379 timevar_pop (TV_TREE_STMT_VERIFY
);
4382 /* Return true when the T can be shared. */
4385 tree_node_can_be_shared (tree t
)
4387 if (IS_TYPE_OR_DECL_P (t
)
4388 || is_gimple_min_invariant (t
)
4389 || TREE_CODE (t
) == SSA_NAME
4390 || t
== error_mark_node
4391 || TREE_CODE (t
) == IDENTIFIER_NODE
)
4394 if (TREE_CODE (t
) == CASE_LABEL_EXPR
)
4403 /* Called via walk_tree. Verify tree sharing. */
4406 verify_node_sharing_1 (tree
*tp
, int *walk_subtrees
, void *data
)
4408 struct pointer_set_t
*visited
= (struct pointer_set_t
*) data
;
4410 if (tree_node_can_be_shared (*tp
))
4412 *walk_subtrees
= false;
4416 if (pointer_set_insert (visited
, *tp
))
4422 /* Called via walk_gimple_stmt. Verify tree sharing. */
4425 verify_node_sharing (tree
*tp
, int *walk_subtrees
, void *data
)
4427 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4428 return verify_node_sharing_1 (tp
, walk_subtrees
, wi
->info
);
4431 static bool eh_error_found
;
4433 verify_eh_throw_stmt_node (void **slot
, void *data
)
4435 struct throw_stmt_node
*node
= (struct throw_stmt_node
*)*slot
;
4436 struct pointer_set_t
*visited
= (struct pointer_set_t
*) data
;
4438 if (!pointer_set_contains (visited
, node
->stmt
))
4440 error ("dead STMT in EH table");
4441 debug_gimple_stmt (node
->stmt
);
4442 eh_error_found
= true;
4447 /* Verify if the location LOCs block is in BLOCKS. */
4450 verify_location (pointer_set_t
*blocks
, location_t loc
)
4452 tree block
= LOCATION_BLOCK (loc
);
4453 if (block
!= NULL_TREE
4454 && !pointer_set_contains (blocks
, block
))
4456 error ("location references block not in block tree");
4459 if (block
!= NULL_TREE
)
4460 return verify_location (blocks
, BLOCK_SOURCE_LOCATION (block
));
4464 /* Called via walk_tree. Verify that expressions have no blocks. */
4467 verify_expr_no_block (tree
*tp
, int *walk_subtrees
, void *)
4471 *walk_subtrees
= false;
4475 location_t loc
= EXPR_LOCATION (*tp
);
4476 if (LOCATION_BLOCK (loc
) != NULL
)
4482 /* Called via walk_tree. Verify locations of expressions. */
4485 verify_expr_location_1 (tree
*tp
, int *walk_subtrees
, void *data
)
4487 struct pointer_set_t
*blocks
= (struct pointer_set_t
*) data
;
4489 if (TREE_CODE (*tp
) == VAR_DECL
4490 && DECL_HAS_DEBUG_EXPR_P (*tp
))
4492 tree t
= DECL_DEBUG_EXPR (*tp
);
4493 tree addr
= walk_tree (&t
, verify_expr_no_block
, NULL
, NULL
);
4497 if ((TREE_CODE (*tp
) == VAR_DECL
4498 || TREE_CODE (*tp
) == PARM_DECL
4499 || TREE_CODE (*tp
) == RESULT_DECL
)
4500 && DECL_HAS_VALUE_EXPR_P (*tp
))
4502 tree t
= DECL_VALUE_EXPR (*tp
);
4503 tree addr
= walk_tree (&t
, verify_expr_no_block
, NULL
, NULL
);
4510 *walk_subtrees
= false;
4514 location_t loc
= EXPR_LOCATION (*tp
);
4515 if (verify_location (blocks
, loc
))
4521 /* Called via walk_gimple_op. Verify locations of expressions. */
4524 verify_expr_location (tree
*tp
, int *walk_subtrees
, void *data
)
4526 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
4527 return verify_expr_location_1 (tp
, walk_subtrees
, wi
->info
);
4530 /* Insert all subblocks of BLOCK into BLOCKS and recurse. */
4533 collect_subblocks (pointer_set_t
*blocks
, tree block
)
4536 for (t
= BLOCK_SUBBLOCKS (block
); t
; t
= BLOCK_CHAIN (t
))
4538 pointer_set_insert (blocks
, t
);
4539 collect_subblocks (blocks
, t
);
4543 /* Verify the GIMPLE statements in the CFG of FN. */
4546 verify_gimple_in_cfg (struct function
*fn
)
4550 struct pointer_set_t
*visited
, *visited_stmts
, *blocks
;
4552 timevar_push (TV_TREE_STMT_VERIFY
);
4553 visited
= pointer_set_create ();
4554 visited_stmts
= pointer_set_create ();
4556 /* Collect all BLOCKs referenced by the BLOCK tree of FN. */
4557 blocks
= pointer_set_create ();
4558 if (DECL_INITIAL (fn
->decl
))
4560 pointer_set_insert (blocks
, DECL_INITIAL (fn
->decl
));
4561 collect_subblocks (blocks
, DECL_INITIAL (fn
->decl
));
4564 FOR_EACH_BB_FN (bb
, fn
)
4566 gimple_stmt_iterator gsi
;
4568 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4570 gimple phi
= gsi_stmt (gsi
);
4574 pointer_set_insert (visited_stmts
, phi
);
4576 if (gimple_bb (phi
) != bb
)
4578 error ("gimple_bb (phi) is set to a wrong basic block");
4582 err2
|= verify_gimple_phi (phi
);
4584 /* Only PHI arguments have locations. */
4585 if (gimple_location (phi
) != UNKNOWN_LOCATION
)
4587 error ("PHI node with location");
4591 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
4593 tree arg
= gimple_phi_arg_def (phi
, i
);
4594 tree addr
= walk_tree (&arg
, verify_node_sharing_1
,
4598 error ("incorrect sharing of tree nodes");
4599 debug_generic_expr (addr
);
4602 location_t loc
= gimple_phi_arg_location (phi
, i
);
4603 if (virtual_operand_p (gimple_phi_result (phi
))
4604 && loc
!= UNKNOWN_LOCATION
)
4606 error ("virtual PHI with argument locations");
4609 addr
= walk_tree (&arg
, verify_expr_location_1
, blocks
, NULL
);
4612 debug_generic_expr (addr
);
4615 err2
|= verify_location (blocks
, loc
);
4619 debug_gimple_stmt (phi
);
4623 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4625 gimple stmt
= gsi_stmt (gsi
);
4627 struct walk_stmt_info wi
;
4631 pointer_set_insert (visited_stmts
, stmt
);
4633 if (gimple_bb (stmt
) != bb
)
4635 error ("gimple_bb (stmt) is set to a wrong basic block");
4639 err2
|= verify_gimple_stmt (stmt
);
4640 err2
|= verify_location (blocks
, gimple_location (stmt
));
4642 memset (&wi
, 0, sizeof (wi
));
4643 wi
.info
= (void *) visited
;
4644 addr
= walk_gimple_op (stmt
, verify_node_sharing
, &wi
);
4647 error ("incorrect sharing of tree nodes");
4648 debug_generic_expr (addr
);
4652 memset (&wi
, 0, sizeof (wi
));
4653 wi
.info
= (void *) blocks
;
4654 addr
= walk_gimple_op (stmt
, verify_expr_location
, &wi
);
4657 debug_generic_expr (addr
);
4661 /* ??? Instead of not checking these stmts at all the walker
4662 should know its context via wi. */
4663 if (!is_gimple_debug (stmt
)
4664 && !is_gimple_omp (stmt
))
4666 memset (&wi
, 0, sizeof (wi
));
4667 addr
= walk_gimple_op (stmt
, verify_expr
, &wi
);
4670 debug_generic_expr (addr
);
4671 inform (gimple_location (stmt
), "in statement");
4676 /* If the statement is marked as part of an EH region, then it is
4677 expected that the statement could throw. Verify that when we
4678 have optimizations that simplify statements such that we prove
4679 that they cannot throw, that we update other data structures
4681 lp_nr
= lookup_stmt_eh_lp (stmt
);
4684 if (!stmt_could_throw_p (stmt
))
4686 error ("statement marked for throw, but doesn%'t");
4690 && !gsi_one_before_end_p (gsi
)
4691 && stmt_can_throw_internal (stmt
))
4693 error ("statement marked for throw in middle of block");
4699 debug_gimple_stmt (stmt
);
4704 eh_error_found
= false;
4705 if (get_eh_throw_stmt_table (cfun
))
4706 htab_traverse (get_eh_throw_stmt_table (cfun
),
4707 verify_eh_throw_stmt_node
,
4710 if (err
|| eh_error_found
)
4711 internal_error ("verify_gimple failed");
4713 pointer_set_destroy (visited
);
4714 pointer_set_destroy (visited_stmts
);
4715 pointer_set_destroy (blocks
);
4716 verify_histograms ();
4717 timevar_pop (TV_TREE_STMT_VERIFY
);
4721 /* Verifies that the flow information is OK. */
4724 gimple_verify_flow_info (void)
4728 gimple_stmt_iterator gsi
;
4733 if (ENTRY_BLOCK_PTR
->il
.gimple
.seq
|| ENTRY_BLOCK_PTR
->il
.gimple
.phi_nodes
)
4735 error ("ENTRY_BLOCK has IL associated with it");
4739 if (EXIT_BLOCK_PTR
->il
.gimple
.seq
|| EXIT_BLOCK_PTR
->il
.gimple
.phi_nodes
)
4741 error ("EXIT_BLOCK has IL associated with it");
4745 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
4746 if (e
->flags
& EDGE_FALLTHRU
)
4748 error ("fallthru to exit from bb %d", e
->src
->index
);
4754 bool found_ctrl_stmt
= false;
4758 /* Skip labels on the start of basic block. */
4759 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
4762 gimple prev_stmt
= stmt
;
4764 stmt
= gsi_stmt (gsi
);
4766 if (gimple_code (stmt
) != GIMPLE_LABEL
)
4769 label
= gimple_label_label (stmt
);
4770 if (prev_stmt
&& DECL_NONLOCAL (label
))
4772 error ("nonlocal label ");
4773 print_generic_expr (stderr
, label
, 0);
4774 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
4779 if (prev_stmt
&& EH_LANDING_PAD_NR (label
) != 0)
4781 error ("EH landing pad label ");
4782 print_generic_expr (stderr
, label
, 0);
4783 fprintf (stderr
, " is not first in a sequence of labels in bb %d",
4788 if (label_to_block (label
) != bb
)
4791 print_generic_expr (stderr
, label
, 0);
4792 fprintf (stderr
, " to block does not match in bb %d",
4797 if (decl_function_context (label
) != current_function_decl
)
4800 print_generic_expr (stderr
, label
, 0);
4801 fprintf (stderr
, " has incorrect context in bb %d",
4807 /* Verify that body of basic block BB is free of control flow. */
4808 for (; !gsi_end_p (gsi
); gsi_next (&gsi
))
4810 gimple stmt
= gsi_stmt (gsi
);
4812 if (found_ctrl_stmt
)
4814 error ("control flow in the middle of basic block %d",
4819 if (stmt_ends_bb_p (stmt
))
4820 found_ctrl_stmt
= true;
4822 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4825 print_generic_expr (stderr
, gimple_label_label (stmt
), 0);
4826 fprintf (stderr
, " in the middle of basic block %d", bb
->index
);
4831 gsi
= gsi_last_bb (bb
);
4832 if (gsi_end_p (gsi
))
4835 stmt
= gsi_stmt (gsi
);
4837 if (gimple_code (stmt
) == GIMPLE_LABEL
)
4840 err
|= verify_eh_edges (stmt
);
4842 if (is_ctrl_stmt (stmt
))
4844 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4845 if (e
->flags
& EDGE_FALLTHRU
)
4847 error ("fallthru edge after a control statement in bb %d",
4853 if (gimple_code (stmt
) != GIMPLE_COND
)
4855 /* Verify that there are no edges with EDGE_TRUE/FALSE_FLAG set
4856 after anything else but if statement. */
4857 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4858 if (e
->flags
& (EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
))
4860 error ("true/false edge after a non-GIMPLE_COND in bb %d",
4866 switch (gimple_code (stmt
))
4873 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
4877 || !(true_edge
->flags
& EDGE_TRUE_VALUE
)
4878 || !(false_edge
->flags
& EDGE_FALSE_VALUE
)
4879 || (true_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
4880 || (false_edge
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
))
4881 || EDGE_COUNT (bb
->succs
) >= 3)
4883 error ("wrong outgoing edge flags at end of bb %d",
4891 if (simple_goto_p (stmt
))
4893 error ("explicit goto at end of bb %d", bb
->index
);
4898 /* FIXME. We should double check that the labels in the
4899 destination blocks have their address taken. */
4900 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4901 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_TRUE_VALUE
4902 | EDGE_FALSE_VALUE
))
4903 || !(e
->flags
& EDGE_ABNORMAL
))
4905 error ("wrong outgoing edge flags at end of bb %d",
4913 if (!gimple_call_builtin_p (stmt
, BUILT_IN_RETURN
))
4915 /* ... fallthru ... */
4917 if (!single_succ_p (bb
)
4918 || (single_succ_edge (bb
)->flags
4919 & (EDGE_FALLTHRU
| EDGE_ABNORMAL
4920 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
4922 error ("wrong outgoing edge flags at end of bb %d", bb
->index
);
4925 if (single_succ (bb
) != EXIT_BLOCK_PTR
)
4927 error ("return edge does not point to exit in bb %d",
4939 n
= gimple_switch_num_labels (stmt
);
4941 /* Mark all the destination basic blocks. */
4942 for (i
= 0; i
< n
; ++i
)
4944 tree lab
= CASE_LABEL (gimple_switch_label (stmt
, i
));
4945 basic_block label_bb
= label_to_block (lab
);
4946 gcc_assert (!label_bb
->aux
|| label_bb
->aux
== (void *)1);
4947 label_bb
->aux
= (void *)1;
4950 /* Verify that the case labels are sorted. */
4951 prev
= gimple_switch_label (stmt
, 0);
4952 for (i
= 1; i
< n
; ++i
)
4954 tree c
= gimple_switch_label (stmt
, i
);
4957 error ("found default case not at the start of "
4963 && !tree_int_cst_lt (CASE_LOW (prev
), CASE_LOW (c
)))
4965 error ("case labels not sorted: ");
4966 print_generic_expr (stderr
, prev
, 0);
4967 fprintf (stderr
," is greater than ");
4968 print_generic_expr (stderr
, c
, 0);
4969 fprintf (stderr
," but comes before it.\n");
4974 /* VRP will remove the default case if it can prove it will
4975 never be executed. So do not verify there always exists
4976 a default case here. */
4978 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
4982 error ("extra outgoing edge %d->%d",
4983 bb
->index
, e
->dest
->index
);
4987 e
->dest
->aux
= (void *)2;
4988 if ((e
->flags
& (EDGE_FALLTHRU
| EDGE_ABNORMAL
4989 | EDGE_TRUE_VALUE
| EDGE_FALSE_VALUE
)))
4991 error ("wrong outgoing edge flags at end of bb %d",
4997 /* Check that we have all of them. */
4998 for (i
= 0; i
< n
; ++i
)
5000 tree lab
= CASE_LABEL (gimple_switch_label (stmt
, i
));
5001 basic_block label_bb
= label_to_block (lab
);
5003 if (label_bb
->aux
!= (void *)2)
5005 error ("missing edge %i->%i", bb
->index
, label_bb
->index
);
5010 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5011 e
->dest
->aux
= (void *)0;
5015 case GIMPLE_EH_DISPATCH
:
5016 err
|= verify_eh_dispatch_edge (stmt
);
5024 if (dom_info_state (CDI_DOMINATORS
) >= DOM_NO_FAST_QUERY
)
5025 verify_dominators (CDI_DOMINATORS
);
5031 /* Updates phi nodes after creating a forwarder block joined
5032 by edge FALLTHRU. */
5035 gimple_make_forwarder_block (edge fallthru
)
5039 basic_block dummy
, bb
;
5041 gimple_stmt_iterator gsi
;
5043 dummy
= fallthru
->src
;
5044 bb
= fallthru
->dest
;
5046 if (single_pred_p (bb
))
5049 /* If we redirected a branch we must create new PHI nodes at the
5051 for (gsi
= gsi_start_phis (dummy
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5053 gimple phi
, new_phi
;
5055 phi
= gsi_stmt (gsi
);
5056 var
= gimple_phi_result (phi
);
5057 new_phi
= create_phi_node (var
, bb
);
5058 gimple_phi_set_result (phi
, copy_ssa_name (var
, phi
));
5059 add_phi_arg (new_phi
, gimple_phi_result (phi
), fallthru
,
5063 /* Add the arguments we have stored on edges. */
5064 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
5069 flush_pending_stmts (e
);
5074 /* Return a non-special label in the head of basic block BLOCK.
5075 Create one if it doesn't exist. */
5078 gimple_block_label (basic_block bb
)
5080 gimple_stmt_iterator i
, s
= gsi_start_bb (bb
);
5085 for (i
= s
; !gsi_end_p (i
); first
= false, gsi_next (&i
))
5087 stmt
= gsi_stmt (i
);
5088 if (gimple_code (stmt
) != GIMPLE_LABEL
)
5090 label
= gimple_label_label (stmt
);
5091 if (!DECL_NONLOCAL (label
))
5094 gsi_move_before (&i
, &s
);
5099 label
= create_artificial_label (UNKNOWN_LOCATION
);
5100 stmt
= gimple_build_label (label
);
5101 gsi_insert_before (&s
, stmt
, GSI_NEW_STMT
);
5106 /* Attempt to perform edge redirection by replacing a possibly complex
5107 jump instruction by a goto or by removing the jump completely.
5108 This can apply only if all edges now point to the same block. The
5109 parameters and return values are equivalent to
5110 redirect_edge_and_branch. */
5113 gimple_try_redirect_by_replacing_jump (edge e
, basic_block target
)
5115 basic_block src
= e
->src
;
5116 gimple_stmt_iterator i
;
5119 /* We can replace or remove a complex jump only when we have exactly
5121 if (EDGE_COUNT (src
->succs
) != 2
5122 /* Verify that all targets will be TARGET. Specifically, the
5123 edge that is not E must also go to TARGET. */
5124 || EDGE_SUCC (src
, EDGE_SUCC (src
, 0) == e
)->dest
!= target
)
5127 i
= gsi_last_bb (src
);
5131 stmt
= gsi_stmt (i
);
5133 if (gimple_code (stmt
) == GIMPLE_COND
|| gimple_code (stmt
) == GIMPLE_SWITCH
)
5135 gsi_remove (&i
, true);
5136 e
= ssa_redirect_edge (e
, target
);
5137 e
->flags
= EDGE_FALLTHRU
;
5145 /* Redirect E to DEST. Return NULL on failure. Otherwise, return the
5146 edge representing the redirected branch. */
5149 gimple_redirect_edge_and_branch (edge e
, basic_block dest
)
5151 basic_block bb
= e
->src
;
5152 gimple_stmt_iterator gsi
;
5156 if (e
->flags
& EDGE_ABNORMAL
)
5159 if (e
->dest
== dest
)
5162 if (e
->flags
& EDGE_EH
)
5163 return redirect_eh_edge (e
, dest
);
5165 if (e
->src
!= ENTRY_BLOCK_PTR
)
5167 ret
= gimple_try_redirect_by_replacing_jump (e
, dest
);
5172 gsi
= gsi_last_bb (bb
);
5173 stmt
= gsi_end_p (gsi
) ? NULL
: gsi_stmt (gsi
);
5175 switch (stmt
? gimple_code (stmt
) : GIMPLE_ERROR_MARK
)
5178 /* For COND_EXPR, we only need to redirect the edge. */
5182 /* No non-abnormal edges should lead from a non-simple goto, and
5183 simple ones should be represented implicitly. */
5188 tree label
= gimple_block_label (dest
);
5189 tree cases
= get_cases_for_edge (e
, stmt
);
5191 /* If we have a list of cases associated with E, then use it
5192 as it's a lot faster than walking the entire case vector. */
5195 edge e2
= find_edge (e
->src
, dest
);
5202 CASE_LABEL (cases
) = label
;
5203 cases
= CASE_CHAIN (cases
);
5206 /* If there was already an edge in the CFG, then we need
5207 to move all the cases associated with E to E2. */
5210 tree cases2
= get_cases_for_edge (e2
, stmt
);
5212 CASE_CHAIN (last
) = CASE_CHAIN (cases2
);
5213 CASE_CHAIN (cases2
) = first
;
5215 bitmap_set_bit (touched_switch_bbs
, gimple_bb (stmt
)->index
);
5219 size_t i
, n
= gimple_switch_num_labels (stmt
);
5221 for (i
= 0; i
< n
; i
++)
5223 tree elt
= gimple_switch_label (stmt
, i
);
5224 if (label_to_block (CASE_LABEL (elt
)) == e
->dest
)
5225 CASE_LABEL (elt
) = label
;
5233 int i
, n
= gimple_asm_nlabels (stmt
);
5236 for (i
= 0; i
< n
; ++i
)
5238 tree cons
= gimple_asm_label_op (stmt
, i
);
5239 if (label_to_block (TREE_VALUE (cons
)) == e
->dest
)
5242 label
= gimple_block_label (dest
);
5243 TREE_VALUE (cons
) = label
;
5247 /* If we didn't find any label matching the former edge in the
5248 asm labels, we must be redirecting the fallthrough
5250 gcc_assert (label
|| (e
->flags
& EDGE_FALLTHRU
));
5255 gsi_remove (&gsi
, true);
5256 e
->flags
|= EDGE_FALLTHRU
;
5259 case GIMPLE_OMP_RETURN
:
5260 case GIMPLE_OMP_CONTINUE
:
5261 case GIMPLE_OMP_SECTIONS_SWITCH
:
5262 case GIMPLE_OMP_FOR
:
5263 /* The edges from OMP constructs can be simply redirected. */
5266 case GIMPLE_EH_DISPATCH
:
5267 if (!(e
->flags
& EDGE_FALLTHRU
))
5268 redirect_eh_dispatch_edge (stmt
, e
, dest
);
5271 case GIMPLE_TRANSACTION
:
5272 /* The ABORT edge has a stored label associated with it, otherwise
5273 the edges are simply redirectable. */
5275 gimple_transaction_set_label (stmt
, gimple_block_label (dest
));
5279 /* Otherwise it must be a fallthru edge, and we don't need to
5280 do anything besides redirecting it. */
5281 gcc_assert (e
->flags
& EDGE_FALLTHRU
);
5285 /* Update/insert PHI nodes as necessary. */
5287 /* Now update the edges in the CFG. */
5288 e
= ssa_redirect_edge (e
, dest
);
5293 /* Returns true if it is possible to remove edge E by redirecting
5294 it to the destination of the other edge from E->src. */
5297 gimple_can_remove_branch_p (const_edge e
)
5299 if (e
->flags
& (EDGE_ABNORMAL
| EDGE_EH
))
5305 /* Simple wrapper, as we can always redirect fallthru edges. */
5308 gimple_redirect_edge_and_branch_force (edge e
, basic_block dest
)
5310 e
= gimple_redirect_edge_and_branch (e
, dest
);
5317 /* Splits basic block BB after statement STMT (but at least after the
5318 labels). If STMT is NULL, BB is split just after the labels. */
5321 gimple_split_block (basic_block bb
, void *stmt
)
5323 gimple_stmt_iterator gsi
;
5324 gimple_stmt_iterator gsi_tgt
;
5331 new_bb
= create_empty_bb (bb
);
5333 /* Redirect the outgoing edges. */
5334 new_bb
->succs
= bb
->succs
;
5336 FOR_EACH_EDGE (e
, ei
, new_bb
->succs
)
5339 if (stmt
&& gimple_code ((gimple
) stmt
) == GIMPLE_LABEL
)
5342 /* Move everything from GSI to the new basic block. */
5343 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5345 act
= gsi_stmt (gsi
);
5346 if (gimple_code (act
) == GIMPLE_LABEL
)
5359 if (gsi_end_p (gsi
))
5362 /* Split the statement list - avoid re-creating new containers as this
5363 brings ugly quadratic memory consumption in the inliner.
5364 (We are still quadratic since we need to update stmt BB pointers,
5366 gsi_split_seq_before (&gsi
, &list
);
5367 set_bb_seq (new_bb
, list
);
5368 for (gsi_tgt
= gsi_start (list
);
5369 !gsi_end_p (gsi_tgt
); gsi_next (&gsi_tgt
))
5370 gimple_set_bb (gsi_stmt (gsi_tgt
), new_bb
);
5376 /* Moves basic block BB after block AFTER. */
5379 gimple_move_block_after (basic_block bb
, basic_block after
)
5381 if (bb
->prev_bb
== after
)
5385 link_block (bb
, after
);
5391 /* Return TRUE if block BB has no executable statements, otherwise return
5395 gimple_empty_block_p (basic_block bb
)
5397 /* BB must have no executable statements. */
5398 gimple_stmt_iterator gsi
= gsi_after_labels (bb
);
5401 if (gsi_end_p (gsi
))
5403 if (is_gimple_debug (gsi_stmt (gsi
)))
5404 gsi_next_nondebug (&gsi
);
5405 return gsi_end_p (gsi
);
5409 /* Split a basic block if it ends with a conditional branch and if the
5410 other part of the block is not empty. */
5413 gimple_split_block_before_cond_jump (basic_block bb
)
5415 gimple last
, split_point
;
5416 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
5417 if (gsi_end_p (gsi
))
5419 last
= gsi_stmt (gsi
);
5420 if (gimple_code (last
) != GIMPLE_COND
5421 && gimple_code (last
) != GIMPLE_SWITCH
)
5423 gsi_prev_nondebug (&gsi
);
5424 split_point
= gsi_stmt (gsi
);
5425 return split_block (bb
, split_point
)->dest
;
5429 /* Return true if basic_block can be duplicated. */
5432 gimple_can_duplicate_bb_p (const_basic_block bb ATTRIBUTE_UNUSED
)
5437 /* Create a duplicate of the basic block BB. NOTE: This does not
5438 preserve SSA form. */
5441 gimple_duplicate_bb (basic_block bb
)
5444 gimple_stmt_iterator gsi
, gsi_tgt
;
5445 gimple_seq phis
= phi_nodes (bb
);
5446 gimple phi
, stmt
, copy
;
5448 new_bb
= create_empty_bb (EXIT_BLOCK_PTR
->prev_bb
);
5450 /* Copy the PHI nodes. We ignore PHI node arguments here because
5451 the incoming edges have not been setup yet. */
5452 for (gsi
= gsi_start (phis
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5454 phi
= gsi_stmt (gsi
);
5455 copy
= create_phi_node (NULL_TREE
, new_bb
);
5456 create_new_def_for (gimple_phi_result (phi
), copy
,
5457 gimple_phi_result_ptr (copy
));
5458 gimple_set_uid (copy
, gimple_uid (phi
));
5461 gsi_tgt
= gsi_start_bb (new_bb
);
5462 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
5464 def_operand_p def_p
;
5465 ssa_op_iter op_iter
;
5468 stmt
= gsi_stmt (gsi
);
5469 if (gimple_code (stmt
) == GIMPLE_LABEL
)
5472 /* Don't duplicate label debug stmts. */
5473 if (gimple_debug_bind_p (stmt
)
5474 && TREE_CODE (gimple_debug_bind_get_var (stmt
))
5478 /* Create a new copy of STMT and duplicate STMT's virtual
5480 copy
= gimple_copy (stmt
);
5481 gsi_insert_after (&gsi_tgt
, copy
, GSI_NEW_STMT
);
5483 maybe_duplicate_eh_stmt (copy
, stmt
);
5484 gimple_duplicate_stmt_histograms (cfun
, copy
, cfun
, stmt
);
5486 /* When copying around a stmt writing into a local non-user
5487 aggregate, make sure it won't share stack slot with other
5489 lhs
= gimple_get_lhs (stmt
);
5490 if (lhs
&& TREE_CODE (lhs
) != SSA_NAME
)
5492 tree base
= get_base_address (lhs
);
5494 && (TREE_CODE (base
) == VAR_DECL
5495 || TREE_CODE (base
) == RESULT_DECL
)
5496 && DECL_IGNORED_P (base
)
5497 && !TREE_STATIC (base
)
5498 && !DECL_EXTERNAL (base
)
5499 && (TREE_CODE (base
) != VAR_DECL
5500 || !DECL_HAS_VALUE_EXPR_P (base
)))
5501 DECL_NONSHAREABLE (base
) = 1;
5504 /* Create new names for all the definitions created by COPY and
5505 add replacement mappings for each new name. */
5506 FOR_EACH_SSA_DEF_OPERAND (def_p
, copy
, op_iter
, SSA_OP_ALL_DEFS
)
5507 create_new_def_for (DEF_FROM_PTR (def_p
), copy
, def_p
);
5513 /* Adds phi node arguments for edge E_COPY after basic block duplication. */
5516 add_phi_args_after_copy_edge (edge e_copy
)
5518 basic_block bb
, bb_copy
= e_copy
->src
, dest
;
5521 gimple phi
, phi_copy
;
5523 gimple_stmt_iterator psi
, psi_copy
;
5525 if (gimple_seq_empty_p (phi_nodes (e_copy
->dest
)))
5528 bb
= bb_copy
->flags
& BB_DUPLICATED
? get_bb_original (bb_copy
) : bb_copy
;
5530 if (e_copy
->dest
->flags
& BB_DUPLICATED
)
5531 dest
= get_bb_original (e_copy
->dest
);
5533 dest
= e_copy
->dest
;
5535 e
= find_edge (bb
, dest
);
5538 /* During loop unrolling the target of the latch edge is copied.
5539 In this case we are not looking for edge to dest, but to
5540 duplicated block whose original was dest. */
5541 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
5543 if ((e
->dest
->flags
& BB_DUPLICATED
)
5544 && get_bb_original (e
->dest
) == dest
)
5548 gcc_assert (e
!= NULL
);
5551 for (psi
= gsi_start_phis (e
->dest
),
5552 psi_copy
= gsi_start_phis (e_copy
->dest
);
5554 gsi_next (&psi
), gsi_next (&psi_copy
))
5556 phi
= gsi_stmt (psi
);
5557 phi_copy
= gsi_stmt (psi_copy
);
5558 def
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
5559 add_phi_arg (phi_copy
, def
, e_copy
,
5560 gimple_phi_arg_location_from_edge (phi
, e
));
5565 /* Basic block BB_COPY was created by code duplication. Add phi node
5566 arguments for edges going out of BB_COPY. The blocks that were
5567 duplicated have BB_DUPLICATED set. */
5570 add_phi_args_after_copy_bb (basic_block bb_copy
)
5575 FOR_EACH_EDGE (e_copy
, ei
, bb_copy
->succs
)
5577 add_phi_args_after_copy_edge (e_copy
);
5581 /* Blocks in REGION_COPY array of length N_REGION were created by
5582 duplication of basic blocks. Add phi node arguments for edges
5583 going from these blocks. If E_COPY is not NULL, also add
5584 phi node arguments for its destination.*/
5587 add_phi_args_after_copy (basic_block
*region_copy
, unsigned n_region
,
5592 for (i
= 0; i
< n_region
; i
++)
5593 region_copy
[i
]->flags
|= BB_DUPLICATED
;
5595 for (i
= 0; i
< n_region
; i
++)
5596 add_phi_args_after_copy_bb (region_copy
[i
]);
5598 add_phi_args_after_copy_edge (e_copy
);
5600 for (i
= 0; i
< n_region
; i
++)
5601 region_copy
[i
]->flags
&= ~BB_DUPLICATED
;
5604 /* Duplicates a REGION (set of N_REGION basic blocks) with just a single
5605 important exit edge EXIT. By important we mean that no SSA name defined
5606 inside region is live over the other exit edges of the region. All entry
5607 edges to the region must go to ENTRY->dest. The edge ENTRY is redirected
5608 to the duplicate of the region. Dominance and loop information is
5609 updated if UPDATE_DOMINANCE is true, but not the SSA web. If
5610 UPDATE_DOMINANCE is false then we assume that the caller will update the
5611 dominance information after calling this function. The new basic
5612 blocks are stored to REGION_COPY in the same order as they had in REGION,
5613 provided that REGION_COPY is not NULL.
5614 The function returns false if it is unable to copy the region,
5618 gimple_duplicate_sese_region (edge entry
, edge exit
,
5619 basic_block
*region
, unsigned n_region
,
5620 basic_block
*region_copy
,
5621 bool update_dominance
)
5624 bool free_region_copy
= false, copying_header
= false;
5625 struct loop
*loop
= entry
->dest
->loop_father
;
5627 vec
<basic_block
> doms
;
5629 int total_freq
= 0, entry_freq
= 0;
5630 gcov_type total_count
= 0, entry_count
= 0;
5632 if (!can_copy_bbs_p (region
, n_region
))
5635 /* Some sanity checking. Note that we do not check for all possible
5636 missuses of the functions. I.e. if you ask to copy something weird,
5637 it will work, but the state of structures probably will not be
5639 for (i
= 0; i
< n_region
; i
++)
5641 /* We do not handle subloops, i.e. all the blocks must belong to the
5643 if (region
[i
]->loop_father
!= loop
)
5646 if (region
[i
] != entry
->dest
5647 && region
[i
] == loop
->header
)
5651 set_loop_copy (loop
, loop
);
5653 /* In case the function is used for loop header copying (which is the primary
5654 use), ensure that EXIT and its copy will be new latch and entry edges. */
5655 if (loop
->header
== entry
->dest
)
5657 copying_header
= true;
5658 set_loop_copy (loop
, loop_outer (loop
));
5660 if (!dominated_by_p (CDI_DOMINATORS
, loop
->latch
, exit
->src
))
5663 for (i
= 0; i
< n_region
; i
++)
5664 if (region
[i
] != exit
->src
5665 && dominated_by_p (CDI_DOMINATORS
, region
[i
], exit
->src
))
5671 region_copy
= XNEWVEC (basic_block
, n_region
);
5672 free_region_copy
= true;
5675 initialize_original_copy_tables ();
5677 /* Record blocks outside the region that are dominated by something
5679 if (update_dominance
)
5682 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
5685 if (entry
->dest
->count
)
5687 total_count
= entry
->dest
->count
;
5688 entry_count
= entry
->count
;
5689 /* Fix up corner cases, to avoid division by zero or creation of negative
5691 if (entry_count
> total_count
)
5692 entry_count
= total_count
;
5696 total_freq
= entry
->dest
->frequency
;
5697 entry_freq
= EDGE_FREQUENCY (entry
);
5698 /* Fix up corner cases, to avoid division by zero or creation of negative
5700 if (total_freq
== 0)
5702 else if (entry_freq
> total_freq
)
5703 entry_freq
= total_freq
;
5706 copy_bbs (region
, n_region
, region_copy
, &exit
, 1, &exit_copy
, loop
,
5707 split_edge_bb_loc (entry
), update_dominance
);
5710 scale_bbs_frequencies_gcov_type (region
, n_region
,
5711 total_count
- entry_count
,
5713 scale_bbs_frequencies_gcov_type (region_copy
, n_region
, entry_count
,
5718 scale_bbs_frequencies_int (region
, n_region
, total_freq
- entry_freq
,
5720 scale_bbs_frequencies_int (region_copy
, n_region
, entry_freq
, total_freq
);
5725 loop
->header
= exit
->dest
;
5726 loop
->latch
= exit
->src
;
5729 /* Redirect the entry and add the phi node arguments. */
5730 redirected
= redirect_edge_and_branch (entry
, get_bb_copy (entry
->dest
));
5731 gcc_assert (redirected
!= NULL
);
5732 flush_pending_stmts (entry
);
5734 /* Concerning updating of dominators: We must recount dominators
5735 for entry block and its copy. Anything that is outside of the
5736 region, but was dominated by something inside needs recounting as
5738 if (update_dominance
)
5740 set_immediate_dominator (CDI_DOMINATORS
, entry
->dest
, entry
->src
);
5741 doms
.safe_push (get_bb_original (entry
->dest
));
5742 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
5746 /* Add the other PHI node arguments. */
5747 add_phi_args_after_copy (region_copy
, n_region
, NULL
);
5749 if (free_region_copy
)
5752 free_original_copy_tables ();
5756 /* Checks if BB is part of the region defined by N_REGION BBS. */
5758 bb_part_of_region_p (basic_block bb
, basic_block
* bbs
, unsigned n_region
)
5762 for (n
= 0; n
< n_region
; n
++)
5770 /* Duplicates REGION consisting of N_REGION blocks. The new blocks
5771 are stored to REGION_COPY in the same order in that they appear
5772 in REGION, if REGION_COPY is not NULL. ENTRY is the entry to
5773 the region, EXIT an exit from it. The condition guarding EXIT
5774 is moved to ENTRY. Returns true if duplication succeeds, false
5800 gimple_duplicate_sese_tail (edge entry ATTRIBUTE_UNUSED
, edge exit ATTRIBUTE_UNUSED
,
5801 basic_block
*region ATTRIBUTE_UNUSED
, unsigned n_region ATTRIBUTE_UNUSED
,
5802 basic_block
*region_copy ATTRIBUTE_UNUSED
)
5805 bool free_region_copy
= false;
5806 struct loop
*loop
= exit
->dest
->loop_father
;
5807 struct loop
*orig_loop
= entry
->dest
->loop_father
;
5808 basic_block switch_bb
, entry_bb
, nentry_bb
;
5809 vec
<basic_block
> doms
;
5810 int total_freq
= 0, exit_freq
= 0;
5811 gcov_type total_count
= 0, exit_count
= 0;
5812 edge exits
[2], nexits
[2], e
;
5813 gimple_stmt_iterator gsi
;
5816 basic_block exit_bb
;
5817 gimple_stmt_iterator psi
;
5820 struct loop
*target
, *aloop
, *cloop
;
5822 gcc_assert (EDGE_COUNT (exit
->src
->succs
) == 2);
5824 exits
[1] = EDGE_SUCC (exit
->src
, EDGE_SUCC (exit
->src
, 0) == exit
);
5826 if (!can_copy_bbs_p (region
, n_region
))
5829 initialize_original_copy_tables ();
5830 set_loop_copy (orig_loop
, loop
);
5833 for (aloop
= orig_loop
->inner
; aloop
; aloop
= aloop
->next
)
5835 if (bb_part_of_region_p (aloop
->header
, region
, n_region
))
5837 cloop
= duplicate_loop (aloop
, target
);
5838 duplicate_subloops (aloop
, cloop
);
5844 region_copy
= XNEWVEC (basic_block
, n_region
);
5845 free_region_copy
= true;
5848 gcc_assert (!need_ssa_update_p (cfun
));
5850 /* Record blocks outside the region that are dominated by something
5852 doms
= get_dominated_by_region (CDI_DOMINATORS
, region
, n_region
);
5854 if (exit
->src
->count
)
5856 total_count
= exit
->src
->count
;
5857 exit_count
= exit
->count
;
5858 /* Fix up corner cases, to avoid division by zero or creation of negative
5860 if (exit_count
> total_count
)
5861 exit_count
= total_count
;
5865 total_freq
= exit
->src
->frequency
;
5866 exit_freq
= EDGE_FREQUENCY (exit
);
5867 /* Fix up corner cases, to avoid division by zero or creation of negative
5869 if (total_freq
== 0)
5871 if (exit_freq
> total_freq
)
5872 exit_freq
= total_freq
;
5875 copy_bbs (region
, n_region
, region_copy
, exits
, 2, nexits
, orig_loop
,
5876 split_edge_bb_loc (exit
), true);
5879 scale_bbs_frequencies_gcov_type (region
, n_region
,
5880 total_count
- exit_count
,
5882 scale_bbs_frequencies_gcov_type (region_copy
, n_region
, exit_count
,
5887 scale_bbs_frequencies_int (region
, n_region
, total_freq
- exit_freq
,
5889 scale_bbs_frequencies_int (region_copy
, n_region
, exit_freq
, total_freq
);
5892 /* Create the switch block, and put the exit condition to it. */
5893 entry_bb
= entry
->dest
;
5894 nentry_bb
= get_bb_copy (entry_bb
);
5895 if (!last_stmt (entry
->src
)
5896 || !stmt_ends_bb_p (last_stmt (entry
->src
)))
5897 switch_bb
= entry
->src
;
5899 switch_bb
= split_edge (entry
);
5900 set_immediate_dominator (CDI_DOMINATORS
, nentry_bb
, switch_bb
);
5902 gsi
= gsi_last_bb (switch_bb
);
5903 cond_stmt
= last_stmt (exit
->src
);
5904 gcc_assert (gimple_code (cond_stmt
) == GIMPLE_COND
);
5905 cond_stmt
= gimple_copy (cond_stmt
);
5907 gsi_insert_after (&gsi
, cond_stmt
, GSI_NEW_STMT
);
5909 sorig
= single_succ_edge (switch_bb
);
5910 sorig
->flags
= exits
[1]->flags
;
5911 snew
= make_edge (switch_bb
, nentry_bb
, exits
[0]->flags
);
5913 /* Register the new edge from SWITCH_BB in loop exit lists. */
5914 rescan_loop_exit (snew
, true, false);
5916 /* Add the PHI node arguments. */
5917 add_phi_args_after_copy (region_copy
, n_region
, snew
);
5919 /* Get rid of now superfluous conditions and associated edges (and phi node
5921 exit_bb
= exit
->dest
;
5923 e
= redirect_edge_and_branch (exits
[0], exits
[1]->dest
);
5924 PENDING_STMT (e
) = NULL
;
5926 /* The latch of ORIG_LOOP was copied, and so was the backedge
5927 to the original header. We redirect this backedge to EXIT_BB. */
5928 for (i
= 0; i
< n_region
; i
++)
5929 if (get_bb_original (region_copy
[i
]) == orig_loop
->latch
)
5931 gcc_assert (single_succ_edge (region_copy
[i
]));
5932 e
= redirect_edge_and_branch (single_succ_edge (region_copy
[i
]), exit_bb
);
5933 PENDING_STMT (e
) = NULL
;
5934 for (psi
= gsi_start_phis (exit_bb
);
5938 phi
= gsi_stmt (psi
);
5939 def
= PHI_ARG_DEF (phi
, nexits
[0]->dest_idx
);
5940 add_phi_arg (phi
, def
, e
, gimple_phi_arg_location_from_edge (phi
, e
));
5943 e
= redirect_edge_and_branch (nexits
[1], nexits
[0]->dest
);
5944 PENDING_STMT (e
) = NULL
;
5946 /* Anything that is outside of the region, but was dominated by something
5947 inside needs to update dominance info. */
5948 iterate_fix_dominators (CDI_DOMINATORS
, doms
, false);
5950 /* Update the SSA web. */
5951 update_ssa (TODO_update_ssa
);
5953 if (free_region_copy
)
5956 free_original_copy_tables ();
5960 /* Add all the blocks dominated by ENTRY to the array BBS_P. Stop
5961 adding blocks when the dominator traversal reaches EXIT. This
5962 function silently assumes that ENTRY strictly dominates EXIT. */
5965 gather_blocks_in_sese_region (basic_block entry
, basic_block exit
,
5966 vec
<basic_block
> *bbs_p
)
5970 for (son
= first_dom_son (CDI_DOMINATORS
, entry
);
5972 son
= next_dom_son (CDI_DOMINATORS
, son
))
5974 bbs_p
->safe_push (son
);
5976 gather_blocks_in_sese_region (son
, exit
, bbs_p
);
5980 /* Replaces *TP with a duplicate (belonging to function TO_CONTEXT).
5981 The duplicates are recorded in VARS_MAP. */
5984 replace_by_duplicate_decl (tree
*tp
, struct pointer_map_t
*vars_map
,
5987 tree t
= *tp
, new_t
;
5988 struct function
*f
= DECL_STRUCT_FUNCTION (to_context
);
5991 if (DECL_CONTEXT (t
) == to_context
)
5994 loc
= pointer_map_contains (vars_map
, t
);
5998 loc
= pointer_map_insert (vars_map
, t
);
6002 new_t
= copy_var_decl (t
, DECL_NAME (t
), TREE_TYPE (t
));
6003 add_local_decl (f
, new_t
);
6007 gcc_assert (TREE_CODE (t
) == CONST_DECL
);
6008 new_t
= copy_node (t
);
6010 DECL_CONTEXT (new_t
) = to_context
;
6015 new_t
= (tree
) *loc
;
6021 /* Creates an ssa name in TO_CONTEXT equivalent to NAME.
6022 VARS_MAP maps old ssa names and var_decls to the new ones. */
6025 replace_ssa_name (tree name
, struct pointer_map_t
*vars_map
,
6031 gcc_assert (!virtual_operand_p (name
));
6033 loc
= pointer_map_contains (vars_map
, name
);
6037 tree decl
= SSA_NAME_VAR (name
);
6040 replace_by_duplicate_decl (&decl
, vars_map
, to_context
);
6041 new_name
= make_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6042 decl
, SSA_NAME_DEF_STMT (name
));
6043 if (SSA_NAME_IS_DEFAULT_DEF (name
))
6044 set_ssa_default_def (DECL_STRUCT_FUNCTION (to_context
),
6048 new_name
= copy_ssa_name_fn (DECL_STRUCT_FUNCTION (to_context
),
6049 name
, SSA_NAME_DEF_STMT (name
));
6051 loc
= pointer_map_insert (vars_map
, name
);
6055 new_name
= (tree
) *loc
;
6066 struct pointer_map_t
*vars_map
;
6067 htab_t new_label_map
;
6068 struct pointer_map_t
*eh_map
;
6072 /* Helper for move_block_to_fn. Set TREE_BLOCK in every expression
6073 contained in *TP if it has been ORIG_BLOCK previously and change the
6074 DECL_CONTEXT of every local variable referenced in *TP. */
6077 move_stmt_op (tree
*tp
, int *walk_subtrees
, void *data
)
6079 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) data
;
6080 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6085 tree block
= TREE_BLOCK (t
);
6086 if (block
== p
->orig_block
6087 || (p
->orig_block
== NULL_TREE
6088 && block
!= NULL_TREE
))
6089 TREE_SET_BLOCK (t
, p
->new_block
);
6090 #ifdef ENABLE_CHECKING
6091 else if (block
!= NULL_TREE
)
6093 while (block
&& TREE_CODE (block
) == BLOCK
&& block
!= p
->orig_block
)
6094 block
= BLOCK_SUPERCONTEXT (block
);
6095 gcc_assert (block
== p
->orig_block
);
6099 else if (DECL_P (t
) || TREE_CODE (t
) == SSA_NAME
)
6101 if (TREE_CODE (t
) == SSA_NAME
)
6102 *tp
= replace_ssa_name (t
, p
->vars_map
, p
->to_context
);
6103 else if (TREE_CODE (t
) == LABEL_DECL
)
6105 if (p
->new_label_map
)
6107 struct tree_map in
, *out
;
6109 out
= (struct tree_map
*)
6110 htab_find_with_hash (p
->new_label_map
, &in
, DECL_UID (t
));
6115 DECL_CONTEXT (t
) = p
->to_context
;
6117 else if (p
->remap_decls_p
)
6119 /* Replace T with its duplicate. T should no longer appear in the
6120 parent function, so this looks wasteful; however, it may appear
6121 in referenced_vars, and more importantly, as virtual operands of
6122 statements, and in alias lists of other variables. It would be
6123 quite difficult to expunge it from all those places. ??? It might
6124 suffice to do this for addressable variables. */
6125 if ((TREE_CODE (t
) == VAR_DECL
6126 && !is_global_var (t
))
6127 || TREE_CODE (t
) == CONST_DECL
)
6128 replace_by_duplicate_decl (tp
, p
->vars_map
, p
->to_context
);
6132 else if (TYPE_P (t
))
6138 /* Helper for move_stmt_r. Given an EH region number for the source
6139 function, map that to the duplicate EH regio number in the dest. */
6142 move_stmt_eh_region_nr (int old_nr
, struct move_stmt_d
*p
)
6144 eh_region old_r
, new_r
;
6147 old_r
= get_eh_region_from_number (old_nr
);
6148 slot
= pointer_map_contains (p
->eh_map
, old_r
);
6149 new_r
= (eh_region
) *slot
;
6151 return new_r
->index
;
6154 /* Similar, but operate on INTEGER_CSTs. */
6157 move_stmt_eh_region_tree_nr (tree old_t_nr
, struct move_stmt_d
*p
)
6161 old_nr
= tree_low_cst (old_t_nr
, 0);
6162 new_nr
= move_stmt_eh_region_nr (old_nr
, p
);
6164 return build_int_cst (integer_type_node
, new_nr
);
6167 /* Like move_stmt_op, but for gimple statements.
6169 Helper for move_block_to_fn. Set GIMPLE_BLOCK in every expression
6170 contained in the current statement in *GSI_P and change the
6171 DECL_CONTEXT of every local variable referenced in the current
6175 move_stmt_r (gimple_stmt_iterator
*gsi_p
, bool *handled_ops_p
,
6176 struct walk_stmt_info
*wi
)
6178 struct move_stmt_d
*p
= (struct move_stmt_d
*) wi
->info
;
6179 gimple stmt
= gsi_stmt (*gsi_p
);
6180 tree block
= gimple_block (stmt
);
6182 if (block
== p
->orig_block
6183 || (p
->orig_block
== NULL_TREE
6184 && block
!= NULL_TREE
))
6185 gimple_set_block (stmt
, p
->new_block
);
6187 switch (gimple_code (stmt
))
6190 /* Remap the region numbers for __builtin_eh_{pointer,filter}. */
6192 tree r
, fndecl
= gimple_call_fndecl (stmt
);
6193 if (fndecl
&& DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
)
6194 switch (DECL_FUNCTION_CODE (fndecl
))
6196 case BUILT_IN_EH_COPY_VALUES
:
6197 r
= gimple_call_arg (stmt
, 1);
6198 r
= move_stmt_eh_region_tree_nr (r
, p
);
6199 gimple_call_set_arg (stmt
, 1, r
);
6202 case BUILT_IN_EH_POINTER
:
6203 case BUILT_IN_EH_FILTER
:
6204 r
= gimple_call_arg (stmt
, 0);
6205 r
= move_stmt_eh_region_tree_nr (r
, p
);
6206 gimple_call_set_arg (stmt
, 0, r
);
6217 int r
= gimple_resx_region (stmt
);
6218 r
= move_stmt_eh_region_nr (r
, p
);
6219 gimple_resx_set_region (stmt
, r
);
6223 case GIMPLE_EH_DISPATCH
:
6225 int r
= gimple_eh_dispatch_region (stmt
);
6226 r
= move_stmt_eh_region_nr (r
, p
);
6227 gimple_eh_dispatch_set_region (stmt
, r
);
6231 case GIMPLE_OMP_RETURN
:
6232 case GIMPLE_OMP_CONTINUE
:
6235 if (is_gimple_omp (stmt
))
6237 /* Do not remap variables inside OMP directives. Variables
6238 referenced in clauses and directive header belong to the
6239 parent function and should not be moved into the child
6241 bool save_remap_decls_p
= p
->remap_decls_p
;
6242 p
->remap_decls_p
= false;
6243 *handled_ops_p
= true;
6245 walk_gimple_seq_mod (gimple_omp_body_ptr (stmt
), move_stmt_r
,
6248 p
->remap_decls_p
= save_remap_decls_p
;
6256 /* Move basic block BB from function CFUN to function DEST_FN. The
6257 block is moved out of the original linked list and placed after
6258 block AFTER in the new list. Also, the block is removed from the
6259 original array of blocks and placed in DEST_FN's array of blocks.
6260 If UPDATE_EDGE_COUNT_P is true, the edge counts on both CFGs is
6261 updated to reflect the moved edges.
6263 The local variables are remapped to new instances, VARS_MAP is used
6264 to record the mapping. */
6267 move_block_to_fn (struct function
*dest_cfun
, basic_block bb
,
6268 basic_block after
, bool update_edge_count_p
,
6269 struct move_stmt_d
*d
)
6271 struct control_flow_graph
*cfg
;
6274 gimple_stmt_iterator si
;
6275 unsigned old_len
, new_len
;
6277 /* Remove BB from dominance structures. */
6278 delete_from_dominance_info (CDI_DOMINATORS
, bb
);
6280 /* Move BB from its current loop to the copy in the new function. */
6283 struct loop
*new_loop
= (struct loop
*)bb
->loop_father
->aux
;
6285 bb
->loop_father
= new_loop
;
6288 /* Link BB to the new linked list. */
6289 move_block_after (bb
, after
);
6291 /* Update the edge count in the corresponding flowgraphs. */
6292 if (update_edge_count_p
)
6293 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6295 cfun
->cfg
->x_n_edges
--;
6296 dest_cfun
->cfg
->x_n_edges
++;
6299 /* Remove BB from the original basic block array. */
6300 (*cfun
->cfg
->x_basic_block_info
)[bb
->index
] = NULL
;
6301 cfun
->cfg
->x_n_basic_blocks
--;
6303 /* Grow DEST_CFUN's basic block array if needed. */
6304 cfg
= dest_cfun
->cfg
;
6305 cfg
->x_n_basic_blocks
++;
6306 if (bb
->index
>= cfg
->x_last_basic_block
)
6307 cfg
->x_last_basic_block
= bb
->index
+ 1;
6309 old_len
= vec_safe_length (cfg
->x_basic_block_info
);
6310 if ((unsigned) cfg
->x_last_basic_block
>= old_len
)
6312 new_len
= cfg
->x_last_basic_block
+ (cfg
->x_last_basic_block
+ 3) / 4;
6313 vec_safe_grow_cleared (cfg
->x_basic_block_info
, new_len
);
6316 (*cfg
->x_basic_block_info
)[bb
->index
] = bb
;
6318 /* Remap the variables in phi nodes. */
6319 for (si
= gsi_start_phis (bb
); !gsi_end_p (si
); )
6321 gimple phi
= gsi_stmt (si
);
6323 tree op
= PHI_RESULT (phi
);
6327 if (virtual_operand_p (op
))
6329 /* Remove the phi nodes for virtual operands (alias analysis will be
6330 run for the new function, anyway). */
6331 remove_phi_node (&si
, true);
6335 SET_PHI_RESULT (phi
,
6336 replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
6337 FOR_EACH_PHI_ARG (use
, phi
, oi
, SSA_OP_USE
)
6339 op
= USE_FROM_PTR (use
);
6340 if (TREE_CODE (op
) == SSA_NAME
)
6341 SET_USE (use
, replace_ssa_name (op
, d
->vars_map
, dest_cfun
->decl
));
6344 for (i
= 0; i
< EDGE_COUNT (bb
->preds
); i
++)
6346 location_t locus
= gimple_phi_arg_location (phi
, i
);
6347 tree block
= LOCATION_BLOCK (locus
);
6349 if (locus
== UNKNOWN_LOCATION
)
6351 if (d
->orig_block
== NULL_TREE
|| block
== d
->orig_block
)
6353 if (d
->new_block
== NULL_TREE
)
6354 locus
= LOCATION_LOCUS (locus
);
6356 locus
= COMBINE_LOCATION_DATA (line_table
, locus
, d
->new_block
);
6357 gimple_phi_arg_set_location (phi
, i
, locus
);
6364 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6366 gimple stmt
= gsi_stmt (si
);
6367 struct walk_stmt_info wi
;
6369 memset (&wi
, 0, sizeof (wi
));
6371 walk_gimple_stmt (&si
, move_stmt_r
, move_stmt_op
, &wi
);
6373 if (gimple_code (stmt
) == GIMPLE_LABEL
)
6375 tree label
= gimple_label_label (stmt
);
6376 int uid
= LABEL_DECL_UID (label
);
6378 gcc_assert (uid
> -1);
6380 old_len
= vec_safe_length (cfg
->x_label_to_block_map
);
6381 if (old_len
<= (unsigned) uid
)
6383 new_len
= 3 * uid
/ 2 + 1;
6384 vec_safe_grow_cleared (cfg
->x_label_to_block_map
, new_len
);
6387 (*cfg
->x_label_to_block_map
)[uid
] = bb
;
6388 (*cfun
->cfg
->x_label_to_block_map
)[uid
] = NULL
;
6390 gcc_assert (DECL_CONTEXT (label
) == dest_cfun
->decl
);
6392 if (uid
>= dest_cfun
->cfg
->last_label_uid
)
6393 dest_cfun
->cfg
->last_label_uid
= uid
+ 1;
6396 maybe_duplicate_eh_stmt_fn (dest_cfun
, stmt
, cfun
, stmt
, d
->eh_map
, 0);
6397 remove_stmt_from_eh_lp_fn (cfun
, stmt
);
6399 gimple_duplicate_stmt_histograms (dest_cfun
, stmt
, cfun
, stmt
);
6400 gimple_remove_stmt_histograms (cfun
, stmt
);
6402 /* We cannot leave any operands allocated from the operand caches of
6403 the current function. */
6404 free_stmt_operands (stmt
);
6405 push_cfun (dest_cfun
);
6410 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6411 if (e
->goto_locus
!= UNKNOWN_LOCATION
)
6413 tree block
= LOCATION_BLOCK (e
->goto_locus
);
6414 if (d
->orig_block
== NULL_TREE
6415 || block
== d
->orig_block
)
6416 e
->goto_locus
= d
->new_block
?
6417 COMBINE_LOCATION_DATA (line_table
, e
->goto_locus
, d
->new_block
) :
6418 LOCATION_LOCUS (e
->goto_locus
);
6422 /* Examine the statements in BB (which is in SRC_CFUN); find and return
6423 the outermost EH region. Use REGION as the incoming base EH region. */
6426 find_outermost_region_in_block (struct function
*src_cfun
,
6427 basic_block bb
, eh_region region
)
6429 gimple_stmt_iterator si
;
6431 for (si
= gsi_start_bb (bb
); !gsi_end_p (si
); gsi_next (&si
))
6433 gimple stmt
= gsi_stmt (si
);
6434 eh_region stmt_region
;
6437 lp_nr
= lookup_stmt_eh_lp_fn (src_cfun
, stmt
);
6438 stmt_region
= get_eh_region_from_lp_number_fn (src_cfun
, lp_nr
);
6442 region
= stmt_region
;
6443 else if (stmt_region
!= region
)
6445 region
= eh_region_outermost (src_cfun
, stmt_region
, region
);
6446 gcc_assert (region
!= NULL
);
6455 new_label_mapper (tree decl
, void *data
)
6457 htab_t hash
= (htab_t
) data
;
6461 gcc_assert (TREE_CODE (decl
) == LABEL_DECL
);
6463 m
= XNEW (struct tree_map
);
6464 m
->hash
= DECL_UID (decl
);
6465 m
->base
.from
= decl
;
6466 m
->to
= create_artificial_label (UNKNOWN_LOCATION
);
6467 LABEL_DECL_UID (m
->to
) = LABEL_DECL_UID (decl
);
6468 if (LABEL_DECL_UID (m
->to
) >= cfun
->cfg
->last_label_uid
)
6469 cfun
->cfg
->last_label_uid
= LABEL_DECL_UID (m
->to
) + 1;
6471 slot
= htab_find_slot_with_hash (hash
, m
, m
->hash
, INSERT
);
6472 gcc_assert (*slot
== NULL
);
6479 /* Change DECL_CONTEXT of all BLOCK_VARS in block, including
6483 replace_block_vars_by_duplicates (tree block
, struct pointer_map_t
*vars_map
,
6488 for (tp
= &BLOCK_VARS (block
); *tp
; tp
= &DECL_CHAIN (*tp
))
6491 if (TREE_CODE (t
) != VAR_DECL
&& TREE_CODE (t
) != CONST_DECL
)
6493 replace_by_duplicate_decl (&t
, vars_map
, to_context
);
6496 if (TREE_CODE (*tp
) == VAR_DECL
&& DECL_HAS_VALUE_EXPR_P (*tp
))
6498 SET_DECL_VALUE_EXPR (t
, DECL_VALUE_EXPR (*tp
));
6499 DECL_HAS_VALUE_EXPR_P (t
) = 1;
6501 DECL_CHAIN (t
) = DECL_CHAIN (*tp
);
6506 for (block
= BLOCK_SUBBLOCKS (block
); block
; block
= BLOCK_CHAIN (block
))
6507 replace_block_vars_by_duplicates (block
, vars_map
, to_context
);
6510 /* Fixup the loop arrays and numbers after moving LOOP and its subloops
6514 fixup_loop_arrays_after_move (struct function
*fn1
, struct function
*fn2
,
6517 /* Discard it from the old loop array. */
6518 (*get_loops (fn1
))[loop
->num
] = NULL
;
6520 /* Place it in the new loop array, assigning it a new number. */
6521 loop
->num
= number_of_loops (fn2
);
6522 vec_safe_push (loops_for_fn (fn2
)->larray
, loop
);
6524 /* Recurse to children. */
6525 for (loop
= loop
->inner
; loop
; loop
= loop
->next
)
6526 fixup_loop_arrays_after_move (fn1
, fn2
, loop
);
6529 /* Move a single-entry, single-exit region delimited by ENTRY_BB and
6530 EXIT_BB to function DEST_CFUN. The whole region is replaced by a
6531 single basic block in the original CFG and the new basic block is
6532 returned. DEST_CFUN must not have a CFG yet.
6534 Note that the region need not be a pure SESE region. Blocks inside
6535 the region may contain calls to abort/exit. The only restriction
6536 is that ENTRY_BB should be the only entry point and it must
6539 Change TREE_BLOCK of all statements in ORIG_BLOCK to the new
6540 functions outermost BLOCK, move all subblocks of ORIG_BLOCK
6541 to the new function.
6543 All local variables referenced in the region are assumed to be in
6544 the corresponding BLOCK_VARS and unexpanded variable lists
6545 associated with DEST_CFUN. */
6548 move_sese_region_to_fn (struct function
*dest_cfun
, basic_block entry_bb
,
6549 basic_block exit_bb
, tree orig_block
)
6551 vec
<basic_block
> bbs
, dom_bbs
;
6552 basic_block dom_entry
= get_immediate_dominator (CDI_DOMINATORS
, entry_bb
);
6553 basic_block after
, bb
, *entry_pred
, *exit_succ
, abb
;
6554 struct function
*saved_cfun
= cfun
;
6555 int *entry_flag
, *exit_flag
;
6556 unsigned *entry_prob
, *exit_prob
;
6557 unsigned i
, num_entry_edges
, num_exit_edges
, num_nodes
;
6560 htab_t new_label_map
;
6561 struct pointer_map_t
*vars_map
, *eh_map
;
6562 struct loop
*loop
= entry_bb
->loop_father
;
6563 struct loop
*loop0
= get_loop (saved_cfun
, 0);
6564 struct move_stmt_d d
;
6566 /* If ENTRY does not strictly dominate EXIT, this cannot be an SESE
6568 gcc_assert (entry_bb
!= exit_bb
6570 || dominated_by_p (CDI_DOMINATORS
, exit_bb
, entry_bb
)));
6572 /* Collect all the blocks in the region. Manually add ENTRY_BB
6573 because it won't be added by dfs_enumerate_from. */
6575 bbs
.safe_push (entry_bb
);
6576 gather_blocks_in_sese_region (entry_bb
, exit_bb
, &bbs
);
6578 /* The blocks that used to be dominated by something in BBS will now be
6579 dominated by the new block. */
6580 dom_bbs
= get_dominated_by_region (CDI_DOMINATORS
,
6584 /* Detach ENTRY_BB and EXIT_BB from CFUN->CFG. We need to remember
6585 the predecessor edges to ENTRY_BB and the successor edges to
6586 EXIT_BB so that we can re-attach them to the new basic block that
6587 will replace the region. */
6588 num_entry_edges
= EDGE_COUNT (entry_bb
->preds
);
6589 entry_pred
= XNEWVEC (basic_block
, num_entry_edges
);
6590 entry_flag
= XNEWVEC (int, num_entry_edges
);
6591 entry_prob
= XNEWVEC (unsigned, num_entry_edges
);
6593 for (ei
= ei_start (entry_bb
->preds
); (e
= ei_safe_edge (ei
)) != NULL
;)
6595 entry_prob
[i
] = e
->probability
;
6596 entry_flag
[i
] = e
->flags
;
6597 entry_pred
[i
++] = e
->src
;
6603 num_exit_edges
= EDGE_COUNT (exit_bb
->succs
);
6604 exit_succ
= XNEWVEC (basic_block
, num_exit_edges
);
6605 exit_flag
= XNEWVEC (int, num_exit_edges
);
6606 exit_prob
= XNEWVEC (unsigned, num_exit_edges
);
6608 for (ei
= ei_start (exit_bb
->succs
); (e
= ei_safe_edge (ei
)) != NULL
;)
6610 exit_prob
[i
] = e
->probability
;
6611 exit_flag
[i
] = e
->flags
;
6612 exit_succ
[i
++] = e
->dest
;
6624 /* Switch context to the child function to initialize DEST_FN's CFG. */
6625 gcc_assert (dest_cfun
->cfg
== NULL
);
6626 push_cfun (dest_cfun
);
6628 init_empty_tree_cfg ();
6630 /* Initialize EH information for the new function. */
6632 new_label_map
= NULL
;
6635 eh_region region
= NULL
;
6637 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6638 region
= find_outermost_region_in_block (saved_cfun
, bb
, region
);
6640 init_eh_for_function ();
6643 new_label_map
= htab_create (17, tree_map_hash
, tree_map_eq
, free
);
6644 eh_map
= duplicate_eh_regions (saved_cfun
, region
, 0,
6645 new_label_mapper
, new_label_map
);
6649 /* Initialize an empty loop tree. */
6650 struct loops
*loops
= ggc_alloc_cleared_loops ();
6651 init_loops_structure (dest_cfun
, loops
, 1);
6652 loops
->state
= LOOPS_MAY_HAVE_MULTIPLE_LATCHES
;
6653 set_loops_for_fn (dest_cfun
, loops
);
6655 /* Move the outlined loop tree part. */
6656 num_nodes
= bbs
.length ();
6657 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6659 if (bb
->loop_father
->header
== bb
)
6661 struct loop
*this_loop
= bb
->loop_father
;
6662 struct loop
*outer
= loop_outer (this_loop
);
6664 /* If the SESE region contains some bbs ending with
6665 a noreturn call, those are considered to belong
6666 to the outermost loop in saved_cfun, rather than
6667 the entry_bb's loop_father. */
6671 num_nodes
-= this_loop
->num_nodes
;
6672 flow_loop_tree_node_remove (bb
->loop_father
);
6673 flow_loop_tree_node_add (get_loop (dest_cfun
, 0), this_loop
);
6674 fixup_loop_arrays_after_move (saved_cfun
, cfun
, this_loop
);
6677 else if (bb
->loop_father
== loop0
&& loop0
!= loop
)
6680 /* Remove loop exits from the outlined region. */
6681 if (loops_for_fn (saved_cfun
)->exits
)
6682 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
6684 void **slot
= htab_find_slot_with_hash
6685 (loops_for_fn (saved_cfun
)->exits
, e
,
6686 htab_hash_pointer (e
), NO_INSERT
);
6688 htab_clear_slot (loops_for_fn (saved_cfun
)->exits
, slot
);
6693 /* Adjust the number of blocks in the tree root of the outlined part. */
6694 get_loop (dest_cfun
, 0)->num_nodes
= bbs
.length () + 2;
6696 /* Setup a mapping to be used by move_block_to_fn. */
6697 loop
->aux
= current_loops
->tree_root
;
6698 loop0
->aux
= current_loops
->tree_root
;
6702 /* Move blocks from BBS into DEST_CFUN. */
6703 gcc_assert (bbs
.length () >= 2);
6704 after
= dest_cfun
->cfg
->x_entry_block_ptr
;
6705 vars_map
= pointer_map_create ();
6707 memset (&d
, 0, sizeof (d
));
6708 d
.orig_block
= orig_block
;
6709 d
.new_block
= DECL_INITIAL (dest_cfun
->decl
);
6710 d
.from_context
= cfun
->decl
;
6711 d
.to_context
= dest_cfun
->decl
;
6712 d
.vars_map
= vars_map
;
6713 d
.new_label_map
= new_label_map
;
6715 d
.remap_decls_p
= true;
6717 FOR_EACH_VEC_ELT (bbs
, i
, bb
)
6719 /* No need to update edge counts on the last block. It has
6720 already been updated earlier when we detached the region from
6721 the original CFG. */
6722 move_block_to_fn (dest_cfun
, bb
, after
, bb
!= exit_bb
, &d
);
6728 /* Loop sizes are no longer correct, fix them up. */
6729 loop
->num_nodes
-= num_nodes
;
6730 for (struct loop
*outer
= loop_outer (loop
);
6731 outer
; outer
= loop_outer (outer
))
6732 outer
->num_nodes
-= num_nodes
;
6733 loop0
->num_nodes
-= bbs
.length () - num_nodes
;
6735 if (saved_cfun
->has_simduid_loops
|| saved_cfun
->has_force_vect_loops
)
6738 for (i
= 0; vec_safe_iterate (loops
->larray
, i
, &aloop
); i
++)
6743 replace_by_duplicate_decl (&aloop
->simduid
, d
.vars_map
,
6745 dest_cfun
->has_simduid_loops
= true;
6747 if (aloop
->force_vect
)
6748 dest_cfun
->has_force_vect_loops
= true;
6752 /* Rewire BLOCK_SUBBLOCKS of orig_block. */
6756 gcc_assert (BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
6758 BLOCK_SUBBLOCKS (DECL_INITIAL (dest_cfun
->decl
))
6759 = BLOCK_SUBBLOCKS (orig_block
);
6760 for (block
= BLOCK_SUBBLOCKS (orig_block
);
6761 block
; block
= BLOCK_CHAIN (block
))
6762 BLOCK_SUPERCONTEXT (block
) = DECL_INITIAL (dest_cfun
->decl
);
6763 BLOCK_SUBBLOCKS (orig_block
) = NULL_TREE
;
6766 replace_block_vars_by_duplicates (DECL_INITIAL (dest_cfun
->decl
),
6767 vars_map
, dest_cfun
->decl
);
6770 htab_delete (new_label_map
);
6772 pointer_map_destroy (eh_map
);
6773 pointer_map_destroy (vars_map
);
6775 /* Rewire the entry and exit blocks. The successor to the entry
6776 block turns into the successor of DEST_FN's ENTRY_BLOCK_PTR in
6777 the child function. Similarly, the predecessor of DEST_FN's
6778 EXIT_BLOCK_PTR turns into the predecessor of EXIT_BLOCK_PTR. We
6779 need to switch CFUN between DEST_CFUN and SAVED_CFUN so that the
6780 various CFG manipulation function get to the right CFG.
6782 FIXME, this is silly. The CFG ought to become a parameter to
6784 push_cfun (dest_cfun
);
6785 make_edge (ENTRY_BLOCK_PTR
, entry_bb
, EDGE_FALLTHRU
);
6787 make_edge (exit_bb
, EXIT_BLOCK_PTR
, 0);
6790 /* Back in the original function, the SESE region has disappeared,
6791 create a new basic block in its place. */
6792 bb
= create_empty_bb (entry_pred
[0]);
6794 add_bb_to_loop (bb
, loop
);
6795 for (i
= 0; i
< num_entry_edges
; i
++)
6797 e
= make_edge (entry_pred
[i
], bb
, entry_flag
[i
]);
6798 e
->probability
= entry_prob
[i
];
6801 for (i
= 0; i
< num_exit_edges
; i
++)
6803 e
= make_edge (bb
, exit_succ
[i
], exit_flag
[i
]);
6804 e
->probability
= exit_prob
[i
];
6807 set_immediate_dominator (CDI_DOMINATORS
, bb
, dom_entry
);
6808 FOR_EACH_VEC_ELT (dom_bbs
, i
, abb
)
6809 set_immediate_dominator (CDI_DOMINATORS
, abb
, bb
);
6827 /* Dump FUNCTION_DECL FN to file FILE using FLAGS (see TDF_* in dumpfile.h)
6831 dump_function_to_file (tree fndecl
, FILE *file
, int flags
)
6833 tree arg
, var
, old_current_fndecl
= current_function_decl
;
6834 struct function
*dsf
;
6835 bool ignore_topmost_bind
= false, any_var
= false;
6838 bool tmclone
= (TREE_CODE (fndecl
) == FUNCTION_DECL
6839 && decl_is_tm_clone (fndecl
));
6840 struct function
*fun
= DECL_STRUCT_FUNCTION (fndecl
);
6842 current_function_decl
= fndecl
;
6843 fprintf (file
, "%s %s(", function_name (fun
), tmclone
? "[tm-clone] " : "");
6845 arg
= DECL_ARGUMENTS (fndecl
);
6848 print_generic_expr (file
, TREE_TYPE (arg
), dump_flags
);
6849 fprintf (file
, " ");
6850 print_generic_expr (file
, arg
, dump_flags
);
6851 if (flags
& TDF_VERBOSE
)
6852 print_node (file
, "", arg
, 4);
6853 if (DECL_CHAIN (arg
))
6854 fprintf (file
, ", ");
6855 arg
= DECL_CHAIN (arg
);
6857 fprintf (file
, ")\n");
6859 if (flags
& TDF_VERBOSE
)
6860 print_node (file
, "", fndecl
, 2);
6862 dsf
= DECL_STRUCT_FUNCTION (fndecl
);
6863 if (dsf
&& (flags
& TDF_EH
))
6864 dump_eh_tree (file
, dsf
);
6866 if (flags
& TDF_RAW
&& !gimple_has_body_p (fndecl
))
6868 dump_node (fndecl
, TDF_SLIM
| flags
, file
);
6869 current_function_decl
= old_current_fndecl
;
6873 /* When GIMPLE is lowered, the variables are no longer available in
6874 BIND_EXPRs, so display them separately. */
6875 if (fun
&& fun
->decl
== fndecl
&& (fun
->curr_properties
& PROP_gimple_lcf
))
6878 ignore_topmost_bind
= true;
6880 fprintf (file
, "{\n");
6881 if (!vec_safe_is_empty (fun
->local_decls
))
6882 FOR_EACH_LOCAL_DECL (fun
, ix
, var
)
6884 print_generic_decl (file
, var
, flags
);
6885 if (flags
& TDF_VERBOSE
)
6886 print_node (file
, "", var
, 4);
6887 fprintf (file
, "\n");
6891 if (gimple_in_ssa_p (cfun
))
6892 for (ix
= 1; ix
< num_ssa_names
; ++ix
)
6894 tree name
= ssa_name (ix
);
6895 if (name
&& !SSA_NAME_VAR (name
))
6897 fprintf (file
, " ");
6898 print_generic_expr (file
, TREE_TYPE (name
), flags
);
6899 fprintf (file
, " ");
6900 print_generic_expr (file
, name
, flags
);
6901 fprintf (file
, ";\n");
6908 if (fun
&& fun
->decl
== fndecl
6910 && basic_block_info_for_function (fun
))
6912 /* If the CFG has been built, emit a CFG-based dump. */
6913 if (!ignore_topmost_bind
)
6914 fprintf (file
, "{\n");
6916 if (any_var
&& n_basic_blocks_for_function (fun
))
6917 fprintf (file
, "\n");
6919 FOR_EACH_BB_FN (bb
, fun
)
6920 dump_bb (file
, bb
, 2, flags
| TDF_COMMENT
);
6922 fprintf (file
, "}\n");
6924 else if (DECL_SAVED_TREE (fndecl
) == NULL
)
6926 /* The function is now in GIMPLE form but the CFG has not been
6927 built yet. Emit the single sequence of GIMPLE statements
6928 that make up its body. */
6929 gimple_seq body
= gimple_body (fndecl
);
6931 if (gimple_seq_first_stmt (body
)
6932 && gimple_seq_first_stmt (body
) == gimple_seq_last_stmt (body
)
6933 && gimple_code (gimple_seq_first_stmt (body
)) == GIMPLE_BIND
)
6934 print_gimple_seq (file
, body
, 0, flags
);
6937 if (!ignore_topmost_bind
)
6938 fprintf (file
, "{\n");
6941 fprintf (file
, "\n");
6943 print_gimple_seq (file
, body
, 2, flags
);
6944 fprintf (file
, "}\n");
6951 /* Make a tree based dump. */
6952 chain
= DECL_SAVED_TREE (fndecl
);
6953 if (chain
&& TREE_CODE (chain
) == BIND_EXPR
)
6955 if (ignore_topmost_bind
)
6957 chain
= BIND_EXPR_BODY (chain
);
6965 if (!ignore_topmost_bind
)
6966 fprintf (file
, "{\n");
6971 fprintf (file
, "\n");
6973 print_generic_stmt_indented (file
, chain
, flags
, indent
);
6974 if (ignore_topmost_bind
)
6975 fprintf (file
, "}\n");
6978 if (flags
& TDF_ENUMERATE_LOCALS
)
6979 dump_enumerated_decls (file
, flags
);
6980 fprintf (file
, "\n\n");
6982 current_function_decl
= old_current_fndecl
;
6985 /* Dump FUNCTION_DECL FN to stderr using FLAGS (see TDF_* in tree.h) */
6988 debug_function (tree fn
, int flags
)
6990 dump_function_to_file (fn
, stderr
, flags
);
6994 /* Print on FILE the indexes for the predecessors of basic_block BB. */
6997 print_pred_bbs (FILE *file
, basic_block bb
)
7002 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
7003 fprintf (file
, "bb_%d ", e
->src
->index
);
7007 /* Print on FILE the indexes for the successors of basic_block BB. */
7010 print_succ_bbs (FILE *file
, basic_block bb
)
7015 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7016 fprintf (file
, "bb_%d ", e
->dest
->index
);
7019 /* Print to FILE the basic block BB following the VERBOSITY level. */
7022 print_loops_bb (FILE *file
, basic_block bb
, int indent
, int verbosity
)
7024 char *s_indent
= (char *) alloca ((size_t) indent
+ 1);
7025 memset ((void *) s_indent
, ' ', (size_t) indent
);
7026 s_indent
[indent
] = '\0';
7028 /* Print basic_block's header. */
7031 fprintf (file
, "%s bb_%d (preds = {", s_indent
, bb
->index
);
7032 print_pred_bbs (file
, bb
);
7033 fprintf (file
, "}, succs = {");
7034 print_succ_bbs (file
, bb
);
7035 fprintf (file
, "})\n");
7038 /* Print basic_block's body. */
7041 fprintf (file
, "%s {\n", s_indent
);
7042 dump_bb (file
, bb
, indent
+ 4, TDF_VOPS
|TDF_MEMSYMS
);
7043 fprintf (file
, "%s }\n", s_indent
);
7047 static void print_loop_and_siblings (FILE *, struct loop
*, int, int);
7049 /* Pretty print LOOP on FILE, indented INDENT spaces. Following
7050 VERBOSITY level this outputs the contents of the loop, or just its
7054 print_loop (FILE *file
, struct loop
*loop
, int indent
, int verbosity
)
7062 s_indent
= (char *) alloca ((size_t) indent
+ 1);
7063 memset ((void *) s_indent
, ' ', (size_t) indent
);
7064 s_indent
[indent
] = '\0';
7066 /* Print loop's header. */
7067 fprintf (file
, "%sloop_%d (", s_indent
, loop
->num
);
7069 fprintf (file
, "header = %d", loop
->header
->index
);
7072 fprintf (file
, "deleted)\n");
7076 fprintf (file
, ", latch = %d", loop
->latch
->index
);
7078 fprintf (file
, ", multiple latches");
7079 fprintf (file
, ", niter = ");
7080 print_generic_expr (file
, loop
->nb_iterations
, 0);
7082 if (loop
->any_upper_bound
)
7084 fprintf (file
, ", upper_bound = ");
7085 dump_double_int (file
, loop
->nb_iterations_upper_bound
, true);
7088 if (loop
->any_estimate
)
7090 fprintf (file
, ", estimate = ");
7091 dump_double_int (file
, loop
->nb_iterations_estimate
, true);
7093 fprintf (file
, ")\n");
7095 /* Print loop's body. */
7098 fprintf (file
, "%s{\n", s_indent
);
7100 if (bb
->loop_father
== loop
)
7101 print_loops_bb (file
, bb
, indent
, verbosity
);
7103 print_loop_and_siblings (file
, loop
->inner
, indent
+ 2, verbosity
);
7104 fprintf (file
, "%s}\n", s_indent
);
7108 /* Print the LOOP and its sibling loops on FILE, indented INDENT
7109 spaces. Following VERBOSITY level this outputs the contents of the
7110 loop, or just its structure. */
7113 print_loop_and_siblings (FILE *file
, struct loop
*loop
, int indent
,
7119 print_loop (file
, loop
, indent
, verbosity
);
7120 print_loop_and_siblings (file
, loop
->next
, indent
, verbosity
);
7123 /* Follow a CFG edge from the entry point of the program, and on entry
7124 of a loop, pretty print the loop structure on FILE. */
7127 print_loops (FILE *file
, int verbosity
)
7131 bb
= ENTRY_BLOCK_PTR
;
7132 if (bb
&& bb
->loop_father
)
7133 print_loop_and_siblings (file
, bb
->loop_father
, 0, verbosity
);
7139 debug (struct loop
&ref
)
7141 print_loop (stderr
, &ref
, 0, /*verbosity*/0);
7145 debug (struct loop
*ptr
)
7150 fprintf (stderr
, "<nil>\n");
7153 /* Dump a loop verbosely. */
7156 debug_verbose (struct loop
&ref
)
7158 print_loop (stderr
, &ref
, 0, /*verbosity*/3);
7162 debug_verbose (struct loop
*ptr
)
7167 fprintf (stderr
, "<nil>\n");
7171 /* Debugging loops structure at tree level, at some VERBOSITY level. */
7174 debug_loops (int verbosity
)
7176 print_loops (stderr
, verbosity
);
7179 /* Print on stderr the code of LOOP, at some VERBOSITY level. */
7182 debug_loop (struct loop
*loop
, int verbosity
)
7184 print_loop (stderr
, loop
, 0, verbosity
);
7187 /* Print on stderr the code of loop number NUM, at some VERBOSITY
7191 debug_loop_num (unsigned num
, int verbosity
)
7193 debug_loop (get_loop (cfun
, num
), verbosity
);
7196 /* Return true if BB ends with a call, possibly followed by some
7197 instructions that must stay with the call. Return false,
7201 gimple_block_ends_with_call_p (basic_block bb
)
7203 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
7204 return !gsi_end_p (gsi
) && is_gimple_call (gsi_stmt (gsi
));
7208 /* Return true if BB ends with a conditional branch. Return false,
7212 gimple_block_ends_with_condjump_p (const_basic_block bb
)
7214 gimple stmt
= last_stmt (CONST_CAST_BB (bb
));
7215 return (stmt
&& gimple_code (stmt
) == GIMPLE_COND
);
7219 /* Return true if we need to add fake edge to exit at statement T.
7220 Helper function for gimple_flow_call_edges_add. */
7223 need_fake_edge_p (gimple t
)
7225 tree fndecl
= NULL_TREE
;
7228 /* NORETURN and LONGJMP calls already have an edge to exit.
7229 CONST and PURE calls do not need one.
7230 We don't currently check for CONST and PURE here, although
7231 it would be a good idea, because those attributes are
7232 figured out from the RTL in mark_constant_function, and
7233 the counter incrementation code from -fprofile-arcs
7234 leads to different results from -fbranch-probabilities. */
7235 if (is_gimple_call (t
))
7237 fndecl
= gimple_call_fndecl (t
);
7238 call_flags
= gimple_call_flags (t
);
7241 if (is_gimple_call (t
)
7243 && DECL_BUILT_IN (fndecl
)
7244 && (call_flags
& ECF_NOTHROW
)
7245 && !(call_flags
& ECF_RETURNS_TWICE
)
7246 /* fork() doesn't really return twice, but the effect of
7247 wrapping it in __gcov_fork() which calls __gcov_flush()
7248 and clears the counters before forking has the same
7249 effect as returning twice. Force a fake edge. */
7250 && !(DECL_BUILT_IN_CLASS (fndecl
) == BUILT_IN_NORMAL
7251 && DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_FORK
))
7254 if (is_gimple_call (t
))
7260 if (!(call_flags
& ECF_NORETURN
))
7264 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7265 if ((e
->flags
& EDGE_FAKE
) == 0)
7269 if (gimple_code (t
) == GIMPLE_ASM
7270 && (gimple_asm_volatile_p (t
) || gimple_asm_input_p (t
)))
7277 /* Add fake edges to the function exit for any non constant and non
7278 noreturn calls (or noreturn calls with EH/abnormal edges),
7279 volatile inline assembly in the bitmap of blocks specified by BLOCKS
7280 or to the whole CFG if BLOCKS is zero. Return the number of blocks
7283 The goal is to expose cases in which entering a basic block does
7284 not imply that all subsequent instructions must be executed. */
7287 gimple_flow_call_edges_add (sbitmap blocks
)
7290 int blocks_split
= 0;
7291 int last_bb
= last_basic_block
;
7292 bool check_last_block
= false;
7294 if (n_basic_blocks
== NUM_FIXED_BLOCKS
)
7298 check_last_block
= true;
7300 check_last_block
= bitmap_bit_p (blocks
, EXIT_BLOCK_PTR
->prev_bb
->index
);
7302 /* In the last basic block, before epilogue generation, there will be
7303 a fallthru edge to EXIT. Special care is required if the last insn
7304 of the last basic block is a call because make_edge folds duplicate
7305 edges, which would result in the fallthru edge also being marked
7306 fake, which would result in the fallthru edge being removed by
7307 remove_fake_edges, which would result in an invalid CFG.
7309 Moreover, we can't elide the outgoing fake edge, since the block
7310 profiler needs to take this into account in order to solve the minimal
7311 spanning tree in the case that the call doesn't return.
7313 Handle this by adding a dummy instruction in a new last basic block. */
7314 if (check_last_block
)
7316 basic_block bb
= EXIT_BLOCK_PTR
->prev_bb
;
7317 gimple_stmt_iterator gsi
= gsi_last_nondebug_bb (bb
);
7320 if (!gsi_end_p (gsi
))
7323 if (t
&& need_fake_edge_p (t
))
7327 e
= find_edge (bb
, EXIT_BLOCK_PTR
);
7330 gsi_insert_on_edge (e
, gimple_build_nop ());
7331 gsi_commit_edge_inserts ();
7336 /* Now add fake edges to the function exit for any non constant
7337 calls since there is no way that we can determine if they will
7339 for (i
= 0; i
< last_bb
; i
++)
7341 basic_block bb
= BASIC_BLOCK (i
);
7342 gimple_stmt_iterator gsi
;
7343 gimple stmt
, last_stmt
;
7348 if (blocks
&& !bitmap_bit_p (blocks
, i
))
7351 gsi
= gsi_last_nondebug_bb (bb
);
7352 if (!gsi_end_p (gsi
))
7354 last_stmt
= gsi_stmt (gsi
);
7357 stmt
= gsi_stmt (gsi
);
7358 if (need_fake_edge_p (stmt
))
7362 /* The handling above of the final block before the
7363 epilogue should be enough to verify that there is
7364 no edge to the exit block in CFG already.
7365 Calling make_edge in such case would cause us to
7366 mark that edge as fake and remove it later. */
7367 #ifdef ENABLE_CHECKING
7368 if (stmt
== last_stmt
)
7370 e
= find_edge (bb
, EXIT_BLOCK_PTR
);
7371 gcc_assert (e
== NULL
);
7375 /* Note that the following may create a new basic block
7376 and renumber the existing basic blocks. */
7377 if (stmt
!= last_stmt
)
7379 e
= split_block (bb
, stmt
);
7383 make_edge (bb
, EXIT_BLOCK_PTR
, EDGE_FAKE
);
7387 while (!gsi_end_p (gsi
));
7392 verify_flow_info ();
7394 return blocks_split
;
7397 /* Removes edge E and all the blocks dominated by it, and updates dominance
7398 information. The IL in E->src needs to be updated separately.
7399 If dominance info is not available, only the edge E is removed.*/
7402 remove_edge_and_dominated_blocks (edge e
)
7404 vec
<basic_block
> bbs_to_remove
= vNULL
;
7405 vec
<basic_block
> bbs_to_fix_dom
= vNULL
;
7409 bool none_removed
= false;
7411 basic_block bb
, dbb
;
7414 if (!dom_info_available_p (CDI_DOMINATORS
))
7420 /* No updating is needed for edges to exit. */
7421 if (e
->dest
== EXIT_BLOCK_PTR
)
7423 if (cfgcleanup_altered_bbs
)
7424 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
7429 /* First, we find the basic blocks to remove. If E->dest has a predecessor
7430 that is not dominated by E->dest, then this set is empty. Otherwise,
7431 all the basic blocks dominated by E->dest are removed.
7433 Also, to DF_IDOM we store the immediate dominators of the blocks in
7434 the dominance frontier of E (i.e., of the successors of the
7435 removed blocks, if there are any, and of E->dest otherwise). */
7436 FOR_EACH_EDGE (f
, ei
, e
->dest
->preds
)
7441 if (!dominated_by_p (CDI_DOMINATORS
, f
->src
, e
->dest
))
7443 none_removed
= true;
7448 df
= BITMAP_ALLOC (NULL
);
7449 df_idom
= BITMAP_ALLOC (NULL
);
7452 bitmap_set_bit (df_idom
,
7453 get_immediate_dominator (CDI_DOMINATORS
, e
->dest
)->index
);
7456 bbs_to_remove
= get_all_dominated_blocks (CDI_DOMINATORS
, e
->dest
);
7457 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
7459 FOR_EACH_EDGE (f
, ei
, bb
->succs
)
7461 if (f
->dest
!= EXIT_BLOCK_PTR
)
7462 bitmap_set_bit (df
, f
->dest
->index
);
7465 FOR_EACH_VEC_ELT (bbs_to_remove
, i
, bb
)
7466 bitmap_clear_bit (df
, bb
->index
);
7468 EXECUTE_IF_SET_IN_BITMAP (df
, 0, i
, bi
)
7470 bb
= BASIC_BLOCK (i
);
7471 bitmap_set_bit (df_idom
,
7472 get_immediate_dominator (CDI_DOMINATORS
, bb
)->index
);
7476 if (cfgcleanup_altered_bbs
)
7478 /* Record the set of the altered basic blocks. */
7479 bitmap_set_bit (cfgcleanup_altered_bbs
, e
->src
->index
);
7480 bitmap_ior_into (cfgcleanup_altered_bbs
, df
);
7483 /* Remove E and the cancelled blocks. */
7488 /* Walk backwards so as to get a chance to substitute all
7489 released DEFs into debug stmts. See
7490 eliminate_unnecessary_stmts() in tree-ssa-dce.c for more
7492 for (i
= bbs_to_remove
.length (); i
-- > 0; )
7493 delete_basic_block (bbs_to_remove
[i
]);
7496 /* Update the dominance information. The immediate dominator may change only
7497 for blocks whose immediate dominator belongs to DF_IDOM:
7499 Suppose that idom(X) = Y before removal of E and idom(X) != Y after the
7500 removal. Let Z the arbitrary block such that idom(Z) = Y and
7501 Z dominates X after the removal. Before removal, there exists a path P
7502 from Y to X that avoids Z. Let F be the last edge on P that is
7503 removed, and let W = F->dest. Before removal, idom(W) = Y (since Y
7504 dominates W, and because of P, Z does not dominate W), and W belongs to
7505 the dominance frontier of E. Therefore, Y belongs to DF_IDOM. */
7506 EXECUTE_IF_SET_IN_BITMAP (df_idom
, 0, i
, bi
)
7508 bb
= BASIC_BLOCK (i
);
7509 for (dbb
= first_dom_son (CDI_DOMINATORS
, bb
);
7511 dbb
= next_dom_son (CDI_DOMINATORS
, dbb
))
7512 bbs_to_fix_dom
.safe_push (dbb
);
7515 iterate_fix_dominators (CDI_DOMINATORS
, bbs_to_fix_dom
, true);
7518 BITMAP_FREE (df_idom
);
7519 bbs_to_remove
.release ();
7520 bbs_to_fix_dom
.release ();
7523 /* Purge dead EH edges from basic block BB. */
7526 gimple_purge_dead_eh_edges (basic_block bb
)
7528 bool changed
= false;
7531 gimple stmt
= last_stmt (bb
);
7533 if (stmt
&& stmt_can_throw_internal (stmt
))
7536 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
7538 if (e
->flags
& EDGE_EH
)
7540 remove_edge_and_dominated_blocks (e
);
7550 /* Purge dead EH edges from basic block listed in BLOCKS. */
7553 gimple_purge_all_dead_eh_edges (const_bitmap blocks
)
7555 bool changed
= false;
7559 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
7561 basic_block bb
= BASIC_BLOCK (i
);
7563 /* Earlier gimple_purge_dead_eh_edges could have removed
7564 this basic block already. */
7565 gcc_assert (bb
|| changed
);
7567 changed
|= gimple_purge_dead_eh_edges (bb
);
7573 /* Purge dead abnormal call edges from basic block BB. */
7576 gimple_purge_dead_abnormal_call_edges (basic_block bb
)
7578 bool changed
= false;
7581 gimple stmt
= last_stmt (bb
);
7583 if (!cfun
->has_nonlocal_label
7584 && !cfun
->calls_setjmp
)
7587 if (stmt
&& stmt_can_make_abnormal_goto (stmt
))
7590 for (ei
= ei_start (bb
->succs
); (e
= ei_safe_edge (ei
)); )
7592 if (e
->flags
& EDGE_ABNORMAL
)
7594 if (e
->flags
& EDGE_FALLTHRU
)
7595 e
->flags
&= ~EDGE_ABNORMAL
;
7597 remove_edge_and_dominated_blocks (e
);
7607 /* Purge dead abnormal call edges from basic block listed in BLOCKS. */
7610 gimple_purge_all_dead_abnormal_call_edges (const_bitmap blocks
)
7612 bool changed
= false;
7616 EXECUTE_IF_SET_IN_BITMAP (blocks
, 0, i
, bi
)
7618 basic_block bb
= BASIC_BLOCK (i
);
7620 /* Earlier gimple_purge_dead_abnormal_call_edges could have removed
7621 this basic block already. */
7622 gcc_assert (bb
|| changed
);
7624 changed
|= gimple_purge_dead_abnormal_call_edges (bb
);
7630 /* This function is called whenever a new edge is created or
7634 gimple_execute_on_growing_pred (edge e
)
7636 basic_block bb
= e
->dest
;
7638 if (!gimple_seq_empty_p (phi_nodes (bb
)))
7639 reserve_phi_args_for_new_edge (bb
);
7642 /* This function is called immediately before edge E is removed from
7643 the edge vector E->dest->preds. */
7646 gimple_execute_on_shrinking_pred (edge e
)
7648 if (!gimple_seq_empty_p (phi_nodes (e
->dest
)))
7649 remove_phi_args (e
);
7652 /*---------------------------------------------------------------------------
7653 Helper functions for Loop versioning
7654 ---------------------------------------------------------------------------*/
7656 /* Adjust phi nodes for 'first' basic block. 'second' basic block is a copy
7657 of 'first'. Both of them are dominated by 'new_head' basic block. When
7658 'new_head' was created by 'second's incoming edge it received phi arguments
7659 on the edge by split_edge(). Later, additional edge 'e' was created to
7660 connect 'new_head' and 'first'. Now this routine adds phi args on this
7661 additional edge 'e' that new_head to second edge received as part of edge
7665 gimple_lv_adjust_loop_header_phi (basic_block first
, basic_block second
,
7666 basic_block new_head
, edge e
)
7669 gimple_stmt_iterator psi1
, psi2
;
7671 edge e2
= find_edge (new_head
, second
);
7673 /* Because NEW_HEAD has been created by splitting SECOND's incoming
7674 edge, we should always have an edge from NEW_HEAD to SECOND. */
7675 gcc_assert (e2
!= NULL
);
7677 /* Browse all 'second' basic block phi nodes and add phi args to
7678 edge 'e' for 'first' head. PHI args are always in correct order. */
7680 for (psi2
= gsi_start_phis (second
),
7681 psi1
= gsi_start_phis (first
);
7682 !gsi_end_p (psi2
) && !gsi_end_p (psi1
);
7683 gsi_next (&psi2
), gsi_next (&psi1
))
7685 phi1
= gsi_stmt (psi1
);
7686 phi2
= gsi_stmt (psi2
);
7687 def
= PHI_ARG_DEF (phi2
, e2
->dest_idx
);
7688 add_phi_arg (phi1
, def
, e
, gimple_phi_arg_location_from_edge (phi2
, e2
));
7693 /* Adds a if else statement to COND_BB with condition COND_EXPR.
7694 SECOND_HEAD is the destination of the THEN and FIRST_HEAD is
7695 the destination of the ELSE part. */
7698 gimple_lv_add_condition_to_bb (basic_block first_head ATTRIBUTE_UNUSED
,
7699 basic_block second_head ATTRIBUTE_UNUSED
,
7700 basic_block cond_bb
, void *cond_e
)
7702 gimple_stmt_iterator gsi
;
7703 gimple new_cond_expr
;
7704 tree cond_expr
= (tree
) cond_e
;
7707 /* Build new conditional expr */
7708 new_cond_expr
= gimple_build_cond_from_tree (cond_expr
,
7709 NULL_TREE
, NULL_TREE
);
7711 /* Add new cond in cond_bb. */
7712 gsi
= gsi_last_bb (cond_bb
);
7713 gsi_insert_after (&gsi
, new_cond_expr
, GSI_NEW_STMT
);
7715 /* Adjust edges appropriately to connect new head with first head
7716 as well as second head. */
7717 e0
= single_succ_edge (cond_bb
);
7718 e0
->flags
&= ~EDGE_FALLTHRU
;
7719 e0
->flags
|= EDGE_FALSE_VALUE
;
7723 /* Do book-keeping of basic block BB for the profile consistency checker.
7724 If AFTER_PASS is 0, do pre-pass accounting, or if AFTER_PASS is 1
7725 then do post-pass accounting. Store the counting in RECORD. */
7727 gimple_account_profile_record (basic_block bb
, int after_pass
,
7728 struct profile_record
*record
)
7730 gimple_stmt_iterator i
;
7731 for (i
= gsi_start_bb (bb
); !gsi_end_p (i
); gsi_next (&i
))
7733 record
->size
[after_pass
]
7734 += estimate_num_insns (gsi_stmt (i
), &eni_size_weights
);
7735 if (profile_status
== PROFILE_READ
)
7736 record
->time
[after_pass
]
7737 += estimate_num_insns (gsi_stmt (i
),
7738 &eni_time_weights
) * bb
->count
;
7739 else if (profile_status
== PROFILE_GUESSED
)
7740 record
->time
[after_pass
]
7741 += estimate_num_insns (gsi_stmt (i
),
7742 &eni_time_weights
) * bb
->frequency
;
7746 struct cfg_hooks gimple_cfg_hooks
= {
7748 gimple_verify_flow_info
,
7749 gimple_dump_bb
, /* dump_bb */
7750 gimple_dump_bb_for_graph
, /* dump_bb_for_graph */
7751 create_bb
, /* create_basic_block */
7752 gimple_redirect_edge_and_branch
, /* redirect_edge_and_branch */
7753 gimple_redirect_edge_and_branch_force
, /* redirect_edge_and_branch_force */
7754 gimple_can_remove_branch_p
, /* can_remove_branch_p */
7755 remove_bb
, /* delete_basic_block */
7756 gimple_split_block
, /* split_block */
7757 gimple_move_block_after
, /* move_block_after */
7758 gimple_can_merge_blocks_p
, /* can_merge_blocks_p */
7759 gimple_merge_blocks
, /* merge_blocks */
7760 gimple_predict_edge
, /* predict_edge */
7761 gimple_predicted_by_p
, /* predicted_by_p */
7762 gimple_can_duplicate_bb_p
, /* can_duplicate_block_p */
7763 gimple_duplicate_bb
, /* duplicate_block */
7764 gimple_split_edge
, /* split_edge */
7765 gimple_make_forwarder_block
, /* make_forward_block */
7766 NULL
, /* tidy_fallthru_edge */
7767 NULL
, /* force_nonfallthru */
7768 gimple_block_ends_with_call_p
,/* block_ends_with_call_p */
7769 gimple_block_ends_with_condjump_p
, /* block_ends_with_condjump_p */
7770 gimple_flow_call_edges_add
, /* flow_call_edges_add */
7771 gimple_execute_on_growing_pred
, /* execute_on_growing_pred */
7772 gimple_execute_on_shrinking_pred
, /* execute_on_shrinking_pred */
7773 gimple_duplicate_loop_to_header_edge
, /* duplicate loop for trees */
7774 gimple_lv_add_condition_to_bb
, /* lv_add_condition_to_bb */
7775 gimple_lv_adjust_loop_header_phi
, /* lv_adjust_loop_header_phi*/
7776 extract_true_false_edges_from_block
, /* extract_cond_bb_edges */
7777 flush_pending_stmts
, /* flush_pending_stmts */
7778 gimple_empty_block_p
, /* block_empty_p */
7779 gimple_split_block_before_cond_jump
, /* split_block_before_cond_jump */
7780 gimple_account_profile_record
,
7784 /* Split all critical edges. */
7787 split_critical_edges (void)
7793 /* split_edge can redirect edges out of SWITCH_EXPRs, which can get
7794 expensive. So we want to enable recording of edge to CASE_LABEL_EXPR
7795 mappings around the calls to split_edge. */
7796 start_recording_case_labels ();
7799 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
7801 if (EDGE_CRITICAL_P (e
) && !(e
->flags
& EDGE_ABNORMAL
))
7803 /* PRE inserts statements to edges and expects that
7804 since split_critical_edges was done beforehand, committing edge
7805 insertions will not split more edges. In addition to critical
7806 edges we must split edges that have multiple successors and
7807 end by control flow statements, such as RESX.
7808 Go ahead and split them too. This matches the logic in
7809 gimple_find_edge_insert_loc. */
7810 else if ((!single_pred_p (e
->dest
)
7811 || !gimple_seq_empty_p (phi_nodes (e
->dest
))
7812 || e
->dest
== EXIT_BLOCK_PTR
)
7813 && e
->src
!= ENTRY_BLOCK_PTR
7814 && !(e
->flags
& EDGE_ABNORMAL
))
7816 gimple_stmt_iterator gsi
;
7818 gsi
= gsi_last_bb (e
->src
);
7819 if (!gsi_end_p (gsi
)
7820 && stmt_ends_bb_p (gsi_stmt (gsi
))
7821 && (gimple_code (gsi_stmt (gsi
)) != GIMPLE_RETURN
7822 && !gimple_call_builtin_p (gsi_stmt (gsi
),
7828 end_recording_case_labels ();
7834 const pass_data pass_data_split_crit_edges
=
7836 GIMPLE_PASS
, /* type */
7837 "crited", /* name */
7838 OPTGROUP_NONE
, /* optinfo_flags */
7839 false, /* has_gate */
7840 true, /* has_execute */
7841 TV_TREE_SPLIT_EDGES
, /* tv_id */
7842 PROP_cfg
, /* properties_required */
7843 PROP_no_crit_edges
, /* properties_provided */
7844 0, /* properties_destroyed */
7845 0, /* todo_flags_start */
7846 TODO_verify_flow
, /* todo_flags_finish */
7849 class pass_split_crit_edges
: public gimple_opt_pass
7852 pass_split_crit_edges (gcc::context
*ctxt
)
7853 : gimple_opt_pass (pass_data_split_crit_edges
, ctxt
)
7856 /* opt_pass methods: */
7857 unsigned int execute () { return split_critical_edges (); }
7859 opt_pass
* clone () { return new pass_split_crit_edges (m_ctxt
); }
7860 }; // class pass_split_crit_edges
7865 make_pass_split_crit_edges (gcc::context
*ctxt
)
7867 return new pass_split_crit_edges (ctxt
);
7871 /* Build a ternary operation and gimplify it. Emit code before GSI.
7872 Return the gimple_val holding the result. */
7875 gimplify_build3 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
7876 tree type
, tree a
, tree b
, tree c
)
7879 location_t loc
= gimple_location (gsi_stmt (*gsi
));
7881 ret
= fold_build3_loc (loc
, code
, type
, a
, b
, c
);
7884 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
7888 /* Build a binary operation and gimplify it. Emit code before GSI.
7889 Return the gimple_val holding the result. */
7892 gimplify_build2 (gimple_stmt_iterator
*gsi
, enum tree_code code
,
7893 tree type
, tree a
, tree b
)
7897 ret
= fold_build2_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
, b
);
7900 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
7904 /* Build a unary operation and gimplify it. Emit code before GSI.
7905 Return the gimple_val holding the result. */
7908 gimplify_build1 (gimple_stmt_iterator
*gsi
, enum tree_code code
, tree type
,
7913 ret
= fold_build1_loc (gimple_location (gsi_stmt (*gsi
)), code
, type
, a
);
7916 return force_gimple_operand_gsi (gsi
, ret
, true, NULL
, true,
7922 /* Emit return warnings. */
7925 execute_warn_function_return (void)
7927 source_location location
;
7932 if (!targetm
.warn_func_return (cfun
->decl
))
7935 /* If we have a path to EXIT, then we do return. */
7936 if (TREE_THIS_VOLATILE (cfun
->decl
)
7937 && EDGE_COUNT (EXIT_BLOCK_PTR
->preds
) > 0)
7939 location
= UNKNOWN_LOCATION
;
7940 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
7942 last
= last_stmt (e
->src
);
7943 if ((gimple_code (last
) == GIMPLE_RETURN
7944 || gimple_call_builtin_p (last
, BUILT_IN_RETURN
))
7945 && (location
= gimple_location (last
)) != UNKNOWN_LOCATION
)
7948 if (location
== UNKNOWN_LOCATION
)
7949 location
= cfun
->function_end_locus
;
7950 warning_at (location
, 0, "%<noreturn%> function does return");
7953 /* If we see "return;" in some basic block, then we do reach the end
7954 without returning a value. */
7955 else if (warn_return_type
7956 && !TREE_NO_WARNING (cfun
->decl
)
7957 && EDGE_COUNT (EXIT_BLOCK_PTR
->preds
) > 0
7958 && !VOID_TYPE_P (TREE_TYPE (TREE_TYPE (cfun
->decl
))))
7960 FOR_EACH_EDGE (e
, ei
, EXIT_BLOCK_PTR
->preds
)
7962 gimple last
= last_stmt (e
->src
);
7963 if (gimple_code (last
) == GIMPLE_RETURN
7964 && gimple_return_retval (last
) == NULL
7965 && !gimple_no_warning_p (last
))
7967 location
= gimple_location (last
);
7968 if (location
== UNKNOWN_LOCATION
)
7969 location
= cfun
->function_end_locus
;
7970 warning_at (location
, OPT_Wreturn_type
, "control reaches end of non-void function");
7971 TREE_NO_WARNING (cfun
->decl
) = 1;
7980 /* Given a basic block B which ends with a conditional and has
7981 precisely two successors, determine which of the edges is taken if
7982 the conditional is true and which is taken if the conditional is
7983 false. Set TRUE_EDGE and FALSE_EDGE appropriately. */
7986 extract_true_false_edges_from_block (basic_block b
,
7990 edge e
= EDGE_SUCC (b
, 0);
7992 if (e
->flags
& EDGE_TRUE_VALUE
)
7995 *false_edge
= EDGE_SUCC (b
, 1);
8000 *true_edge
= EDGE_SUCC (b
, 1);
8006 const pass_data pass_data_warn_function_return
=
8008 GIMPLE_PASS
, /* type */
8009 "*warn_function_return", /* name */
8010 OPTGROUP_NONE
, /* optinfo_flags */
8011 false, /* has_gate */
8012 true, /* has_execute */
8013 TV_NONE
, /* tv_id */
8014 PROP_cfg
, /* properties_required */
8015 0, /* properties_provided */
8016 0, /* properties_destroyed */
8017 0, /* todo_flags_start */
8018 0, /* todo_flags_finish */
8021 class pass_warn_function_return
: public gimple_opt_pass
8024 pass_warn_function_return (gcc::context
*ctxt
)
8025 : gimple_opt_pass (pass_data_warn_function_return
, ctxt
)
8028 /* opt_pass methods: */
8029 unsigned int execute () { return execute_warn_function_return (); }
8031 }; // class pass_warn_function_return
8036 make_pass_warn_function_return (gcc::context
*ctxt
)
8038 return new pass_warn_function_return (ctxt
);
8041 /* Walk a gimplified function and warn for functions whose return value is
8042 ignored and attribute((warn_unused_result)) is set. This is done before
8043 inlining, so we don't have to worry about that. */
8046 do_warn_unused_result (gimple_seq seq
)
8049 gimple_stmt_iterator i
;
8051 for (i
= gsi_start (seq
); !gsi_end_p (i
); gsi_next (&i
))
8053 gimple g
= gsi_stmt (i
);
8055 switch (gimple_code (g
))
8058 do_warn_unused_result (gimple_bind_body (g
));
8061 do_warn_unused_result (gimple_try_eval (g
));
8062 do_warn_unused_result (gimple_try_cleanup (g
));
8065 do_warn_unused_result (gimple_catch_handler (g
));
8067 case GIMPLE_EH_FILTER
:
8068 do_warn_unused_result (gimple_eh_filter_failure (g
));
8072 if (gimple_call_lhs (g
))
8074 if (gimple_call_internal_p (g
))
8077 /* This is a naked call, as opposed to a GIMPLE_CALL with an
8078 LHS. All calls whose value is ignored should be
8079 represented like this. Look for the attribute. */
8080 fdecl
= gimple_call_fndecl (g
);
8081 ftype
= gimple_call_fntype (g
);
8083 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype
)))
8085 location_t loc
= gimple_location (g
);
8088 warning_at (loc
, OPT_Wunused_result
,
8089 "ignoring return value of %qD, "
8090 "declared with attribute warn_unused_result",
8093 warning_at (loc
, OPT_Wunused_result
,
8094 "ignoring return value of function "
8095 "declared with attribute warn_unused_result");
8100 /* Not a container, not a call, or a call whose value is used. */
8107 run_warn_unused_result (void)
8109 do_warn_unused_result (gimple_body (current_function_decl
));
8114 gate_warn_unused_result (void)
8116 return flag_warn_unused_result
;
8121 const pass_data pass_data_warn_unused_result
=
8123 GIMPLE_PASS
, /* type */
8124 "*warn_unused_result", /* name */
8125 OPTGROUP_NONE
, /* optinfo_flags */
8126 true, /* has_gate */
8127 true, /* has_execute */
8128 TV_NONE
, /* tv_id */
8129 PROP_gimple_any
, /* properties_required */
8130 0, /* properties_provided */
8131 0, /* properties_destroyed */
8132 0, /* todo_flags_start */
8133 0, /* todo_flags_finish */
8136 class pass_warn_unused_result
: public gimple_opt_pass
8139 pass_warn_unused_result (gcc::context
*ctxt
)
8140 : gimple_opt_pass (pass_data_warn_unused_result
, ctxt
)
8143 /* opt_pass methods: */
8144 bool gate () { return gate_warn_unused_result (); }
8145 unsigned int execute () { return run_warn_unused_result (); }
8147 }; // class pass_warn_unused_result
8152 make_pass_warn_unused_result (gcc::context
*ctxt
)
8154 return new pass_warn_unused_result (ctxt
);
8157 /* IPA passes, compilation of earlier functions or inlining
8158 might have changed some properties, such as marked functions nothrow,
8159 pure, const or noreturn.
8160 Remove redundant edges and basic blocks, and create new ones if necessary.
8162 This pass can't be executed as stand alone pass from pass manager, because
8163 in between inlining and this fixup the verify_flow_info would fail. */
8166 execute_fixup_cfg (void)
8169 gimple_stmt_iterator gsi
;
8170 int todo
= gimple_in_ssa_p (cfun
) ? TODO_verify_ssa
: 0;
8171 gcov_type count_scale
;
8176 = GCOV_COMPUTE_SCALE (cgraph_get_node (current_function_decl
)->count
,
8177 ENTRY_BLOCK_PTR
->count
);
8179 ENTRY_BLOCK_PTR
->count
= cgraph_get_node (current_function_decl
)->count
;
8180 EXIT_BLOCK_PTR
->count
= apply_scale (EXIT_BLOCK_PTR
->count
,
8183 FOR_EACH_EDGE (e
, ei
, ENTRY_BLOCK_PTR
->succs
)
8184 e
->count
= apply_scale (e
->count
, count_scale
);
8188 bb
->count
= apply_scale (bb
->count
, count_scale
);
8189 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
8191 gimple stmt
= gsi_stmt (gsi
);
8192 tree decl
= is_gimple_call (stmt
)
8193 ? gimple_call_fndecl (stmt
)
8197 int flags
= gimple_call_flags (stmt
);
8198 if (flags
& (ECF_CONST
| ECF_PURE
| ECF_LOOPING_CONST_OR_PURE
))
8200 if (gimple_purge_dead_abnormal_call_edges (bb
))
8201 todo
|= TODO_cleanup_cfg
;
8203 if (gimple_in_ssa_p (cfun
))
8205 todo
|= TODO_update_ssa
| TODO_cleanup_cfg
;
8210 if (flags
& ECF_NORETURN
8211 && fixup_noreturn_call (stmt
))
8212 todo
|= TODO_cleanup_cfg
;
8215 if (maybe_clean_eh_stmt (stmt
)
8216 && gimple_purge_dead_eh_edges (bb
))
8217 todo
|= TODO_cleanup_cfg
;
8220 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
8221 e
->count
= apply_scale (e
->count
, count_scale
);
8223 /* If we have a basic block with no successors that does not
8224 end with a control statement or a noreturn call end it with
8225 a call to __builtin_unreachable. This situation can occur
8226 when inlining a noreturn call that does in fact return. */
8227 if (EDGE_COUNT (bb
->succs
) == 0)
8229 gimple stmt
= last_stmt (bb
);
8231 || (!is_ctrl_stmt (stmt
)
8232 && (!is_gimple_call (stmt
)
8233 || (gimple_call_flags (stmt
) & ECF_NORETURN
) == 0)))
8235 stmt
= gimple_build_call
8236 (builtin_decl_implicit (BUILT_IN_UNREACHABLE
), 0);
8237 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
8238 gsi_insert_after (&gsi
, stmt
, GSI_NEW_STMT
);
8242 if (count_scale
!= REG_BR_PROB_BASE
)
8243 compute_function_frequency ();
8245 /* We just processed all calls. */
8246 if (cfun
->gimple_df
)
8247 vec_free (MODIFIED_NORETURN_CALLS (cfun
));
8249 /* Dump a textual representation of the flowgraph. */
8251 gimple_dump_cfg (dump_file
, dump_flags
);
8254 && (todo
& TODO_cleanup_cfg
))
8255 loops_state_set (LOOPS_NEED_FIXUP
);
8262 const pass_data pass_data_fixup_cfg
=
8264 GIMPLE_PASS
, /* type */
8265 "*free_cfg_annotations", /* name */
8266 OPTGROUP_NONE
, /* optinfo_flags */
8267 false, /* has_gate */
8268 true, /* has_execute */
8269 TV_NONE
, /* tv_id */
8270 PROP_cfg
, /* properties_required */
8271 0, /* properties_provided */
8272 0, /* properties_destroyed */
8273 0, /* todo_flags_start */
8274 0, /* todo_flags_finish */
8277 class pass_fixup_cfg
: public gimple_opt_pass
8280 pass_fixup_cfg (gcc::context
*ctxt
)
8281 : gimple_opt_pass (pass_data_fixup_cfg
, ctxt
)
8284 /* opt_pass methods: */
8285 opt_pass
* clone () { return new pass_fixup_cfg (m_ctxt
); }
8286 unsigned int execute () { return execute_fixup_cfg (); }
8288 }; // class pass_fixup_cfg
8293 make_pass_fixup_cfg (gcc::context
*ctxt
)
8295 return new pass_fixup_cfg (ctxt
);
8298 /* Garbage collection support for edge_def. */
8300 extern void gt_ggc_mx (tree
&);
8301 extern void gt_ggc_mx (gimple
&);
8302 extern void gt_ggc_mx (rtx
&);
8303 extern void gt_ggc_mx (basic_block
&);
8306 gt_ggc_mx (edge_def
*e
)
8308 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8310 gt_ggc_mx (e
->dest
);
8311 if (current_ir_type () == IR_GIMPLE
)
8312 gt_ggc_mx (e
->insns
.g
);
8314 gt_ggc_mx (e
->insns
.r
);
8318 /* PCH support for edge_def. */
8320 extern void gt_pch_nx (tree
&);
8321 extern void gt_pch_nx (gimple
&);
8322 extern void gt_pch_nx (rtx
&);
8323 extern void gt_pch_nx (basic_block
&);
8326 gt_pch_nx (edge_def
*e
)
8328 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8330 gt_pch_nx (e
->dest
);
8331 if (current_ir_type () == IR_GIMPLE
)
8332 gt_pch_nx (e
->insns
.g
);
8334 gt_pch_nx (e
->insns
.r
);
8339 gt_pch_nx (edge_def
*e
, gt_pointer_operator op
, void *cookie
)
8341 tree block
= LOCATION_BLOCK (e
->goto_locus
);
8342 op (&(e
->src
), cookie
);
8343 op (&(e
->dest
), cookie
);
8344 if (current_ir_type () == IR_GIMPLE
)
8345 op (&(e
->insns
.g
), cookie
);
8347 op (&(e
->insns
.r
), cookie
);
8348 op (&(block
), cookie
);