1 /* SSA Dominator optimizations for trees
2 Copyright (C) 2001-2018 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"
27 #include "tree-pass.h"
29 #include "gimple-pretty-print.h"
30 #include "fold-const.h"
33 #include "gimple-fold.h"
35 #include "tree-inline.h"
36 #include "gimple-iterator.h"
38 #include "tree-into-ssa.h"
40 #include "tree-ssa-propagate.h"
41 #include "tree-ssa-threadupdate.h"
43 #include "tree-ssa-scopedtables.h"
44 #include "tree-ssa-threadedge.h"
45 #include "tree-ssa-dom.h"
47 #include "tree-cfgcleanup.h"
49 #include "alloc-pool.h"
51 #include "vr-values.h"
52 #include "gimple-ssa-evrp-analyze.h"
54 /* This file implements optimizations on the dominator tree. */
56 /* Structure for recording edge equivalences.
58 Computing and storing the edge equivalences instead of creating
59 them on-demand can save significant amounts of time, particularly
60 for pathological cases involving switch statements.
62 These structures live for a single iteration of the dominator
63 optimizer in the edge's AUX field. At the end of an iteration we
64 free each of these structures. */
68 typedef std::pair
<tree
, tree
> equiv_pair
;
72 /* Record a simple LHS = RHS equivalence. This may trigger
73 calls to derive_equivalences. */
74 void record_simple_equiv (tree
, tree
);
76 /* If traversing this edge creates simple equivalences, we store
77 them as LHS/RHS pairs within this vector. */
78 vec
<equiv_pair
> simple_equivalences
;
80 /* Traversing an edge may also indicate one or more particular conditions
82 vec
<cond_equivalence
> cond_equivalences
;
85 /* Derive equivalences by walking the use-def chains. */
86 void derive_equivalences (tree
, tree
, int);
89 /* Track whether or not we have changed the control flow graph. */
90 static bool cfg_altered
;
92 /* Bitmap of blocks that have had EH statements cleaned. We should
93 remove their dead edges eventually. */
94 static bitmap need_eh_cleanup
;
95 static vec
<gimple
*> need_noreturn_fixup
;
97 /* Statistics for dominator optimizations. */
101 long num_exprs_considered
;
107 static struct opt_stats_d opt_stats
;
109 /* Local functions. */
110 static void record_equality (tree
, tree
, class const_and_copies
*);
111 static void record_equivalences_from_phis (basic_block
);
112 static void record_equivalences_from_incoming_edge (basic_block
,
113 class const_and_copies
*,
114 class avail_exprs_stack
*);
115 static void eliminate_redundant_computations (gimple_stmt_iterator
*,
116 class const_and_copies
*,
117 class avail_exprs_stack
*);
118 static void record_equivalences_from_stmt (gimple
*, int,
119 class avail_exprs_stack
*);
120 static void dump_dominator_optimization_stats (FILE *file
,
121 hash_table
<expr_elt_hasher
> *);
123 /* Constructor for EDGE_INFO. An EDGE_INFO instance is always
124 associated with an edge E. */
126 edge_info::edge_info (edge e
)
128 /* Free the old one associated with E, if it exists and
129 associate our new object with E. */
130 free_dom_edge_info (e
);
133 /* And initialize the embedded vectors. */
134 simple_equivalences
= vNULL
;
135 cond_equivalences
= vNULL
;
138 /* Destructor just needs to release the vectors. */
140 edge_info::~edge_info (void)
142 this->cond_equivalences
.release ();
143 this->simple_equivalences
.release ();
146 /* NAME is known to have the value VALUE, which must be a constant.
148 Walk through its use-def chain to see if there are other equivalences
149 we might be able to derive.
151 RECURSION_LIMIT controls how far back we recurse through the use-def
155 edge_info::derive_equivalences (tree name
, tree value
, int recursion_limit
)
157 if (TREE_CODE (name
) != SSA_NAME
|| TREE_CODE (value
) != INTEGER_CST
)
160 /* This records the equivalence for the toplevel object. Do
161 this before checking the recursion limit. */
162 simple_equivalences
.safe_push (equiv_pair (name
, value
));
164 /* Limit how far up the use-def chains we are willing to walk. */
165 if (recursion_limit
== 0)
168 /* We can walk up the use-def chains to potentially find more
170 gimple
*def_stmt
= SSA_NAME_DEF_STMT (name
);
171 if (is_gimple_assign (def_stmt
))
173 /* We know the result of DEF_STMT was zero. See if that allows
174 us to deduce anything about the SSA_NAMEs used on the RHS. */
175 enum tree_code code
= gimple_assign_rhs_code (def_stmt
);
179 if (integer_zerop (value
))
181 tree rhs1
= gimple_assign_rhs1 (def_stmt
);
182 tree rhs2
= gimple_assign_rhs2 (def_stmt
);
184 value
= build_zero_cst (TREE_TYPE (rhs1
));
185 derive_equivalences (rhs1
, value
, recursion_limit
- 1);
186 value
= build_zero_cst (TREE_TYPE (rhs2
));
187 derive_equivalences (rhs2
, value
, recursion_limit
- 1);
191 /* We know the result of DEF_STMT was one. See if that allows
192 us to deduce anything about the SSA_NAMEs used on the RHS. */
194 if (!integer_zerop (value
))
196 tree rhs1
= gimple_assign_rhs1 (def_stmt
);
197 tree rhs2
= gimple_assign_rhs2 (def_stmt
);
199 /* If either operand has a boolean range, then we
200 know its value must be one, otherwise we just know it
201 is nonzero. The former is clearly useful, I haven't
202 seen cases where the latter is helpful yet. */
203 if (TREE_CODE (rhs1
) == SSA_NAME
)
205 if (ssa_name_has_boolean_range (rhs1
))
207 value
= build_one_cst (TREE_TYPE (rhs1
));
208 derive_equivalences (rhs1
, value
, recursion_limit
- 1);
211 if (TREE_CODE (rhs2
) == SSA_NAME
)
213 if (ssa_name_has_boolean_range (rhs2
))
215 value
= build_one_cst (TREE_TYPE (rhs2
));
216 derive_equivalences (rhs2
, value
, recursion_limit
- 1);
222 /* If LHS is an SSA_NAME and RHS is a constant integer and LHS was
223 set via a widening type conversion, then we may be able to record
224 additional equivalences. */
228 tree rhs
= gimple_assign_rhs1 (def_stmt
);
229 tree rhs_type
= TREE_TYPE (rhs
);
230 if (INTEGRAL_TYPE_P (rhs_type
)
231 && (TYPE_PRECISION (TREE_TYPE (name
))
232 >= TYPE_PRECISION (rhs_type
))
233 && int_fits_type_p (value
, rhs_type
))
234 derive_equivalences (rhs
,
235 fold_convert (rhs_type
, value
),
236 recursion_limit
- 1);
240 /* We can invert the operation of these codes trivially if
241 one of the RHS operands is a constant to produce a known
242 value for the other RHS operand. */
243 case POINTER_PLUS_EXPR
:
246 tree rhs1
= gimple_assign_rhs1 (def_stmt
);
247 tree rhs2
= gimple_assign_rhs2 (def_stmt
);
249 /* If either argument is a constant, then we can compute
250 a constant value for the nonconstant argument. */
251 if (TREE_CODE (rhs1
) == INTEGER_CST
252 && TREE_CODE (rhs2
) == SSA_NAME
)
253 derive_equivalences (rhs2
,
254 fold_binary (MINUS_EXPR
, TREE_TYPE (rhs1
),
256 recursion_limit
- 1);
257 else if (TREE_CODE (rhs2
) == INTEGER_CST
258 && TREE_CODE (rhs1
) == SSA_NAME
)
259 derive_equivalences (rhs1
,
260 fold_binary (MINUS_EXPR
, TREE_TYPE (rhs1
),
262 recursion_limit
- 1);
266 /* If one of the operands is a constant, then we can compute
267 the value of the other operand. If both operands are
268 SSA_NAMEs, then they must be equal if the result is zero. */
271 tree rhs1
= gimple_assign_rhs1 (def_stmt
);
272 tree rhs2
= gimple_assign_rhs2 (def_stmt
);
274 /* If either argument is a constant, then we can compute
275 a constant value for the nonconstant argument. */
276 if (TREE_CODE (rhs1
) == INTEGER_CST
277 && TREE_CODE (rhs2
) == SSA_NAME
)
278 derive_equivalences (rhs2
,
279 fold_binary (MINUS_EXPR
, TREE_TYPE (rhs1
),
281 recursion_limit
- 1);
282 else if (TREE_CODE (rhs2
) == INTEGER_CST
283 && TREE_CODE (rhs1
) == SSA_NAME
)
284 derive_equivalences (rhs1
,
285 fold_binary (PLUS_EXPR
, TREE_TYPE (rhs1
),
287 recursion_limit
- 1);
288 else if (integer_zerop (value
))
290 tree cond
= build2 (EQ_EXPR
, boolean_type_node
,
291 gimple_assign_rhs1 (def_stmt
),
292 gimple_assign_rhs2 (def_stmt
));
293 tree inverted
= invert_truthvalue (cond
);
294 record_conditions (&this->cond_equivalences
, cond
, inverted
);
303 if ((code
== EQ_EXPR
&& integer_onep (value
))
304 || (code
== NE_EXPR
&& integer_zerop (value
)))
306 tree rhs1
= gimple_assign_rhs1 (def_stmt
);
307 tree rhs2
= gimple_assign_rhs2 (def_stmt
);
309 /* If either argument is a constant, then record the
310 other argument as being the same as that constant.
312 If neither operand is a constant, then we have a
313 conditional name == name equivalence. */
314 if (TREE_CODE (rhs1
) == INTEGER_CST
)
315 derive_equivalences (rhs2
, rhs1
, recursion_limit
- 1);
316 else if (TREE_CODE (rhs2
) == INTEGER_CST
)
317 derive_equivalences (rhs1
, rhs2
, recursion_limit
- 1);
321 tree cond
= build2 (code
, boolean_type_node
,
322 gimple_assign_rhs1 (def_stmt
),
323 gimple_assign_rhs2 (def_stmt
));
324 tree inverted
= invert_truthvalue (cond
);
325 if (integer_zerop (value
))
326 std::swap (cond
, inverted
);
327 record_conditions (&this->cond_equivalences
, cond
, inverted
);
332 /* For BIT_NOT and NEGATE, we can just apply the operation to the
333 VALUE to get the new equivalence. It will always be a constant
334 so we can recurse. */
338 tree rhs
= gimple_assign_rhs1 (def_stmt
);
339 tree res
= fold_build1 (code
, TREE_TYPE (rhs
), value
);
340 derive_equivalences (rhs
, res
, recursion_limit
- 1);
346 if (TREE_CODE_CLASS (code
) == tcc_comparison
)
348 tree cond
= build2 (code
, boolean_type_node
,
349 gimple_assign_rhs1 (def_stmt
),
350 gimple_assign_rhs2 (def_stmt
));
351 tree inverted
= invert_truthvalue (cond
);
352 if (integer_zerop (value
))
353 std::swap (cond
, inverted
);
354 record_conditions (&this->cond_equivalences
, cond
, inverted
);
364 edge_info::record_simple_equiv (tree lhs
, tree rhs
)
366 /* If the RHS is a constant, then we may be able to derive
367 further equivalences. Else just record the name = name
369 if (TREE_CODE (rhs
) == INTEGER_CST
)
370 derive_equivalences (lhs
, rhs
, 4);
372 simple_equivalences
.safe_push (equiv_pair (lhs
, rhs
));
375 /* Free the edge_info data attached to E, if it exists. */
378 free_dom_edge_info (edge e
)
380 class edge_info
*edge_info
= (struct edge_info
*)e
->aux
;
386 /* Free all EDGE_INFO structures associated with edges in the CFG.
387 If a particular edge can be threaded, copy the redirection
388 target from the EDGE_INFO structure into the edge's AUX field
389 as required by code to update the CFG and SSA graph for
393 free_all_edge_infos (void)
399 FOR_EACH_BB_FN (bb
, cfun
)
401 FOR_EACH_EDGE (e
, ei
, bb
->preds
)
403 free_dom_edge_info (e
);
409 /* We have finished optimizing BB, record any information implied by
410 taking a specific outgoing edge from BB. */
413 record_edge_info (basic_block bb
)
415 gimple_stmt_iterator gsi
= gsi_last_bb (bb
);
416 class edge_info
*edge_info
;
418 if (! gsi_end_p (gsi
))
420 gimple
*stmt
= gsi_stmt (gsi
);
421 location_t loc
= gimple_location (stmt
);
423 if (gimple_code (stmt
) == GIMPLE_SWITCH
)
425 gswitch
*switch_stmt
= as_a
<gswitch
*> (stmt
);
426 tree index
= gimple_switch_index (switch_stmt
);
428 if (TREE_CODE (index
) == SSA_NAME
)
431 int n_labels
= gimple_switch_num_labels (switch_stmt
);
432 tree
*info
= XCNEWVEC (tree
, last_basic_block_for_fn (cfun
));
436 for (i
= 0; i
< n_labels
; i
++)
438 tree label
= gimple_switch_label (switch_stmt
, i
);
439 basic_block target_bb
= label_to_block (CASE_LABEL (label
));
440 if (CASE_HIGH (label
)
442 || info
[target_bb
->index
])
443 info
[target_bb
->index
] = error_mark_node
;
445 info
[target_bb
->index
] = label
;
448 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
450 basic_block target_bb
= e
->dest
;
451 tree label
= info
[target_bb
->index
];
453 if (label
!= NULL
&& label
!= error_mark_node
)
455 tree x
= fold_convert_loc (loc
, TREE_TYPE (index
),
457 edge_info
= new class edge_info (e
);
458 edge_info
->record_simple_equiv (index
, x
);
465 /* A COND_EXPR may create equivalences too. */
466 if (gimple_code (stmt
) == GIMPLE_COND
)
471 tree op0
= gimple_cond_lhs (stmt
);
472 tree op1
= gimple_cond_rhs (stmt
);
473 enum tree_code code
= gimple_cond_code (stmt
);
475 extract_true_false_edges_from_block (bb
, &true_edge
, &false_edge
);
477 /* Special case comparing booleans against a constant as we
478 know the value of OP0 on both arms of the branch. i.e., we
479 can record an equivalence for OP0 rather than COND.
481 However, don't do this if the constant isn't zero or one.
482 Such conditionals will get optimized more thoroughly during
484 if ((code
== EQ_EXPR
|| code
== NE_EXPR
)
485 && TREE_CODE (op0
) == SSA_NAME
486 && ssa_name_has_boolean_range (op0
)
487 && is_gimple_min_invariant (op1
)
488 && (integer_zerop (op1
) || integer_onep (op1
)))
490 tree true_val
= constant_boolean_node (true, TREE_TYPE (op0
));
491 tree false_val
= constant_boolean_node (false, TREE_TYPE (op0
));
495 edge_info
= new class edge_info (true_edge
);
496 edge_info
->record_simple_equiv (op0
,
498 ? false_val
: true_val
));
499 edge_info
= new class edge_info (false_edge
);
500 edge_info
->record_simple_equiv (op0
,
502 ? true_val
: false_val
));
506 edge_info
= new class edge_info (true_edge
);
507 edge_info
->record_simple_equiv (op0
,
509 ? true_val
: false_val
));
510 edge_info
= new class edge_info (false_edge
);
511 edge_info
->record_simple_equiv (op0
,
513 ? false_val
: true_val
));
516 /* This can show up in the IL as a result of copy propagation
517 it will eventually be canonicalized, but we have to cope
518 with this case within the pass. */
519 else if (is_gimple_min_invariant (op0
)
520 && TREE_CODE (op1
) == SSA_NAME
)
522 tree cond
= build2 (code
, boolean_type_node
, op0
, op1
);
523 tree inverted
= invert_truthvalue_loc (loc
, cond
);
524 bool can_infer_simple_equiv
525 = !(HONOR_SIGNED_ZEROS (op0
)
526 && real_zerop (op0
));
527 struct edge_info
*edge_info
;
529 edge_info
= new class edge_info (true_edge
);
530 record_conditions (&edge_info
->cond_equivalences
, cond
, inverted
);
532 if (can_infer_simple_equiv
&& code
== EQ_EXPR
)
533 edge_info
->record_simple_equiv (op1
, op0
);
535 edge_info
= new class edge_info (false_edge
);
536 record_conditions (&edge_info
->cond_equivalences
, inverted
, cond
);
538 if (can_infer_simple_equiv
&& TREE_CODE (inverted
) == EQ_EXPR
)
539 edge_info
->record_simple_equiv (op1
, op0
);
542 else if (TREE_CODE (op0
) == SSA_NAME
543 && (TREE_CODE (op1
) == SSA_NAME
544 || is_gimple_min_invariant (op1
)))
546 tree cond
= build2 (code
, boolean_type_node
, op0
, op1
);
547 tree inverted
= invert_truthvalue_loc (loc
, cond
);
548 bool can_infer_simple_equiv
549 = !(HONOR_SIGNED_ZEROS (op1
)
550 && (TREE_CODE (op1
) == SSA_NAME
|| real_zerop (op1
)));
551 struct edge_info
*edge_info
;
553 edge_info
= new class edge_info (true_edge
);
554 record_conditions (&edge_info
->cond_equivalences
, cond
, inverted
);
556 if (can_infer_simple_equiv
&& code
== EQ_EXPR
)
557 edge_info
->record_simple_equiv (op0
, op1
);
559 edge_info
= new class edge_info (false_edge
);
560 record_conditions (&edge_info
->cond_equivalences
, inverted
, cond
);
562 if (can_infer_simple_equiv
&& TREE_CODE (inverted
) == EQ_EXPR
)
563 edge_info
->record_simple_equiv (op0
, op1
);
570 class dom_opt_dom_walker
: public dom_walker
573 dom_opt_dom_walker (cdi_direction direction
,
574 class const_and_copies
*const_and_copies
,
575 class avail_exprs_stack
*avail_exprs_stack
,
577 : dom_walker (direction
, REACHABLE_BLOCKS
),
578 m_const_and_copies (const_and_copies
),
579 m_avail_exprs_stack (avail_exprs_stack
),
580 m_dummy_cond (dummy_cond
) { }
582 virtual edge
before_dom_children (basic_block
);
583 virtual void after_dom_children (basic_block
);
587 /* Unwindable equivalences, both const/copy and expression varieties. */
588 class const_and_copies
*m_const_and_copies
;
589 class avail_exprs_stack
*m_avail_exprs_stack
;
592 class evrp_range_analyzer evrp_range_analyzer
;
594 /* Dummy condition to avoid creating lots of throw away statements. */
597 /* Optimize a single statement within a basic block using the
598 various tables mantained by DOM. Returns the taken edge if
599 the statement is a conditional with a statically determined
601 edge
optimize_stmt (basic_block
, gimple_stmt_iterator
);
604 /* Jump threading, redundancy elimination and const/copy propagation.
606 This pass may expose new symbols that need to be renamed into SSA. For
607 every new symbol exposed, its corresponding bit will be set in
612 const pass_data pass_data_dominator
=
614 GIMPLE_PASS
, /* type */
616 OPTGROUP_NONE
, /* optinfo_flags */
617 TV_TREE_SSA_DOMINATOR_OPTS
, /* tv_id */
618 ( PROP_cfg
| PROP_ssa
), /* properties_required */
619 0, /* properties_provided */
620 0, /* properties_destroyed */
621 0, /* todo_flags_start */
622 ( TODO_cleanup_cfg
| TODO_update_ssa
), /* todo_flags_finish */
625 class pass_dominator
: public gimple_opt_pass
628 pass_dominator (gcc::context
*ctxt
)
629 : gimple_opt_pass (pass_data_dominator
, ctxt
),
630 may_peel_loop_headers_p (false)
633 /* opt_pass methods: */
634 opt_pass
* clone () { return new pass_dominator (m_ctxt
); }
635 void set_pass_param (unsigned int n
, bool param
)
638 may_peel_loop_headers_p
= param
;
640 virtual bool gate (function
*) { return flag_tree_dom
!= 0; }
641 virtual unsigned int execute (function
*);
644 /* This flag is used to prevent loops from being peeled repeatedly in jump
645 threading; it will be removed once we preserve loop structures throughout
646 the compilation -- we will be able to mark the affected loops directly in
647 jump threading, and avoid peeling them next time. */
648 bool may_peel_loop_headers_p
;
649 }; // class pass_dominator
652 pass_dominator::execute (function
*fun
)
654 memset (&opt_stats
, 0, sizeof (opt_stats
));
656 /* Create our hash tables. */
657 hash_table
<expr_elt_hasher
> *avail_exprs
658 = new hash_table
<expr_elt_hasher
> (1024);
659 class avail_exprs_stack
*avail_exprs_stack
660 = new class avail_exprs_stack (avail_exprs
);
661 class const_and_copies
*const_and_copies
= new class const_and_copies ();
662 need_eh_cleanup
= BITMAP_ALLOC (NULL
);
663 need_noreturn_fixup
.create (0);
665 calculate_dominance_info (CDI_DOMINATORS
);
668 /* We need to know loop structures in order to avoid destroying them
669 in jump threading. Note that we still can e.g. thread through loop
670 headers to an exit edge, or through loop header to the loop body, assuming
671 that we update the loop info.
673 TODO: We don't need to set LOOPS_HAVE_PREHEADERS generally, but due
674 to several overly conservative bail-outs in jump threading, case
675 gcc.dg/tree-ssa/pr21417.c can't be threaded if loop preheader is
676 missing. We should improve jump threading in future then
677 LOOPS_HAVE_PREHEADERS won't be needed here. */
678 loop_optimizer_init (LOOPS_HAVE_PREHEADERS
| LOOPS_HAVE_SIMPLE_LATCHES
);
680 /* Initialize the value-handle array. */
681 threadedge_initialize_values ();
683 /* We need accurate information regarding back edges in the CFG
684 for jump threading; this may include back edges that are not part of
686 mark_dfs_back_edges ();
688 /* We want to create the edge info structures before the dominator walk
689 so that they'll be in place for the jump threader, particularly when
690 threading through a join block.
692 The conditions will be lazily updated with global equivalences as
693 we reach them during the dominator walk. */
695 FOR_EACH_BB_FN (bb
, fun
)
696 record_edge_info (bb
);
698 gcond
*dummy_cond
= gimple_build_cond (NE_EXPR
, integer_zero_node
,
699 integer_zero_node
, NULL
, NULL
);
701 /* Recursively walk the dominator tree optimizing statements. */
702 dom_opt_dom_walker
walker (CDI_DOMINATORS
, const_and_copies
,
703 avail_exprs_stack
, dummy_cond
);
704 walker
.walk (fun
->cfg
->x_entry_block_ptr
);
706 /* Look for blocks where we cleared EDGE_EXECUTABLE on an outgoing
707 edge. When found, remove jump threads which contain any outgoing
708 edge from the affected block. */
711 FOR_EACH_BB_FN (bb
, fun
)
716 /* First see if there are any edges without EDGE_EXECUTABLE
719 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
721 if ((e
->flags
& EDGE_EXECUTABLE
) == 0)
728 /* If there were any such edges found, then remove jump threads
729 containing any edge leaving BB. */
731 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
732 remove_jump_threads_including (e
);
737 gimple_stmt_iterator gsi
;
739 FOR_EACH_BB_FN (bb
, fun
)
741 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
742 update_stmt_if_modified (gsi_stmt (gsi
));
746 /* If we exposed any new variables, go ahead and put them into
747 SSA form now, before we handle jump threading. This simplifies
748 interactions between rewriting of _DECL nodes into SSA form
749 and rewriting SSA_NAME nodes into SSA form after block
750 duplication and CFG manipulation. */
751 update_ssa (TODO_update_ssa
);
753 free_all_edge_infos ();
755 /* Thread jumps, creating duplicate blocks as needed. */
756 cfg_altered
|= thread_through_all_blocks (may_peel_loop_headers_p
);
759 free_dominance_info (CDI_DOMINATORS
);
761 /* Removal of statements may make some EH edges dead. Purge
762 such edges from the CFG as needed. */
763 if (!bitmap_empty_p (need_eh_cleanup
))
768 /* Jump threading may have created forwarder blocks from blocks
769 needing EH cleanup; the new successor of these blocks, which
770 has inherited from the original block, needs the cleanup.
771 Don't clear bits in the bitmap, as that can break the bitmap
773 EXECUTE_IF_SET_IN_BITMAP (need_eh_cleanup
, 0, i
, bi
)
775 basic_block bb
= BASIC_BLOCK_FOR_FN (fun
, i
);
778 while (single_succ_p (bb
)
779 && (single_succ_edge (bb
)->flags
& EDGE_EH
) == 0)
780 bb
= single_succ (bb
);
781 if (bb
== EXIT_BLOCK_PTR_FOR_FN (fun
))
783 if ((unsigned) bb
->index
!= i
)
784 bitmap_set_bit (need_eh_cleanup
, bb
->index
);
787 gimple_purge_all_dead_eh_edges (need_eh_cleanup
);
788 bitmap_clear (need_eh_cleanup
);
791 /* Fixup stmts that became noreturn calls. This may require splitting
792 blocks and thus isn't possible during the dominator walk or before
793 jump threading finished. Do this in reverse order so we don't
794 inadvertedly remove a stmt we want to fixup by visiting a dominating
795 now noreturn call first. */
796 while (!need_noreturn_fixup
.is_empty ())
798 gimple
*stmt
= need_noreturn_fixup
.pop ();
799 if (dump_file
&& dump_flags
& TDF_DETAILS
)
801 fprintf (dump_file
, "Fixing up noreturn call ");
802 print_gimple_stmt (dump_file
, stmt
, 0);
803 fprintf (dump_file
, "\n");
805 fixup_noreturn_call (stmt
);
808 statistics_counter_event (fun
, "Redundant expressions eliminated",
810 statistics_counter_event (fun
, "Constants propagated",
811 opt_stats
.num_const_prop
);
812 statistics_counter_event (fun
, "Copies propagated",
813 opt_stats
.num_copy_prop
);
815 /* Debugging dumps. */
816 if (dump_file
&& (dump_flags
& TDF_STATS
))
817 dump_dominator_optimization_stats (dump_file
, avail_exprs
);
819 loop_optimizer_finalize ();
821 /* Delete our main hashtable. */
825 /* Free asserted bitmaps and stacks. */
826 BITMAP_FREE (need_eh_cleanup
);
827 need_noreturn_fixup
.release ();
828 delete avail_exprs_stack
;
829 delete const_and_copies
;
831 /* Free the value-handle array. */
832 threadedge_finalize_values ();
840 make_pass_dominator (gcc::context
*ctxt
)
842 return new pass_dominator (ctxt
);
845 /* A hack until we remove threading from tree-vrp.c and bring the
846 simplification routine into the dom_opt_dom_walker class. */
847 static class vr_values
*x_vr_values
;
849 /* A trivial wrapper so that we can present the generic jump
850 threading code with a simple API for simplifying statements. */
852 simplify_stmt_for_jump_threading (gimple
*stmt
,
853 gimple
*within_stmt ATTRIBUTE_UNUSED
,
854 class avail_exprs_stack
*avail_exprs_stack
,
855 basic_block bb ATTRIBUTE_UNUSED
)
857 /* First query our hash table to see if the the expression is available
858 there. A non-NULL return value will be either a constant or another
860 tree cached_lhs
= avail_exprs_stack
->lookup_avail_expr (stmt
, false, true);
864 /* If the hash table query failed, query VRP information. This is
865 essentially the same as tree-vrp's simplification routine. The
866 copy in tree-vrp is scheduled for removal in gcc-9. */
867 if (gcond
*cond_stmt
= dyn_cast
<gcond
*> (stmt
))
870 = x_vr_values
->vrp_evaluate_conditional (gimple_cond_code (cond_stmt
),
871 gimple_cond_lhs (cond_stmt
),
872 gimple_cond_rhs (cond_stmt
),
877 if (gswitch
*switch_stmt
= dyn_cast
<gswitch
*> (stmt
))
879 tree op
= gimple_switch_index (switch_stmt
);
880 if (TREE_CODE (op
) != SSA_NAME
)
883 value_range
*vr
= x_vr_values
->get_value_range (op
);
884 if ((vr
->type
!= VR_RANGE
&& vr
->type
!= VR_ANTI_RANGE
)
885 || symbolic_range_p (vr
))
888 if (vr
->type
== VR_RANGE
)
892 find_case_label_range (switch_stmt
, vr
->min
, vr
->max
, &i
, &j
);
896 tree label
= gimple_switch_label (switch_stmt
, i
);
898 if (CASE_HIGH (label
) != NULL_TREE
899 ? (tree_int_cst_compare (CASE_LOW (label
), vr
->min
) <= 0
900 && tree_int_cst_compare (CASE_HIGH (label
), vr
->max
) >= 0)
901 : (tree_int_cst_equal (CASE_LOW (label
), vr
->min
)
902 && tree_int_cst_equal (vr
->min
, vr
->max
)))
906 return gimple_switch_label (switch_stmt
, 0);
910 if (vr
->type
== VR_ANTI_RANGE
)
912 unsigned n
= gimple_switch_num_labels (switch_stmt
);
913 tree min_label
= gimple_switch_label (switch_stmt
, 1);
914 tree max_label
= gimple_switch_label (switch_stmt
, n
- 1);
916 /* The default label will be taken only if the anti-range of the
917 operand is entirely outside the bounds of all the (non-default)
919 if (tree_int_cst_compare (vr
->min
, CASE_LOW (min_label
)) <= 0
920 && (CASE_HIGH (max_label
) != NULL_TREE
921 ? tree_int_cst_compare (vr
->max
, CASE_HIGH (max_label
)) >= 0
922 : tree_int_cst_compare (vr
->max
, CASE_LOW (max_label
)) >= 0))
923 return gimple_switch_label (switch_stmt
, 0);
928 if (gassign
*assign_stmt
= dyn_cast
<gassign
*> (stmt
))
930 tree lhs
= gimple_assign_lhs (assign_stmt
);
931 if (TREE_CODE (lhs
) == SSA_NAME
932 && (INTEGRAL_TYPE_P (TREE_TYPE (lhs
))
933 || POINTER_TYPE_P (TREE_TYPE (lhs
)))
934 && stmt_interesting_for_vrp (stmt
))
938 value_range new_vr
= VR_INITIALIZER
;
939 x_vr_values
->extract_range_from_stmt (stmt
, &dummy_e
,
940 &dummy_tree
, &new_vr
);
941 if (range_int_cst_singleton_p (&new_vr
))
948 /* Valueize hook for gimple_fold_stmt_to_constant_1. */
951 dom_valueize (tree t
)
953 if (TREE_CODE (t
) == SSA_NAME
)
955 tree tem
= SSA_NAME_VALUE (t
);
962 /* We have just found an equivalence for LHS on an edge E.
963 Look backwards to other uses of LHS and see if we can derive
964 additional equivalences that are valid on edge E. */
966 back_propagate_equivalences (tree lhs
, edge e
,
967 class const_and_copies
*const_and_copies
)
970 imm_use_iterator iter
;
972 basic_block dest
= e
->dest
;
974 /* Iterate over the uses of LHS to see if any dominate E->dest.
975 If so, they may create useful equivalences too.
977 ??? If the code gets re-organized to a worklist to catch more
978 indirect opportunities and it is made to handle PHIs then this
979 should only consider use_stmts in basic-blocks we have already visited. */
980 FOR_EACH_IMM_USE_FAST (use_p
, iter
, lhs
)
982 gimple
*use_stmt
= USE_STMT (use_p
);
984 /* Often the use is in DEST, which we trivially know we can't use.
985 This is cheaper than the dominator set tests below. */
986 if (dest
== gimple_bb (use_stmt
))
989 /* Filter out statements that can never produce a useful
991 tree lhs2
= gimple_get_lhs (use_stmt
);
992 if (!lhs2
|| TREE_CODE (lhs2
) != SSA_NAME
)
995 /* Profiling has shown the domination tests here can be fairly
996 expensive. We get significant improvements by building the
997 set of blocks that dominate BB. We can then just test
998 for set membership below.
1000 We also initialize the set lazily since often the only uses
1001 are going to be in the same block as DEST. */
1004 domby
= BITMAP_ALLOC (NULL
);
1005 basic_block bb
= get_immediate_dominator (CDI_DOMINATORS
, dest
);
1008 bitmap_set_bit (domby
, bb
->index
);
1009 bb
= get_immediate_dominator (CDI_DOMINATORS
, bb
);
1013 /* This tests if USE_STMT does not dominate DEST. */
1014 if (!bitmap_bit_p (domby
, gimple_bb (use_stmt
)->index
))
1017 /* At this point USE_STMT dominates DEST and may result in a
1018 useful equivalence. Try to simplify its RHS to a constant
1020 tree res
= gimple_fold_stmt_to_constant_1 (use_stmt
, dom_valueize
,
1021 no_follow_ssa_edges
);
1022 if (res
&& (TREE_CODE (res
) == SSA_NAME
|| is_gimple_min_invariant (res
)))
1023 record_equality (lhs2
, res
, const_and_copies
);
1027 BITMAP_FREE (domby
);
1030 /* Record into CONST_AND_COPIES and AVAIL_EXPRS_STACK any equivalences implied
1031 by traversing edge E (which are cached in E->aux).
1033 Callers are responsible for managing the unwinding markers. */
1035 record_temporary_equivalences (edge e
,
1036 class const_and_copies
*const_and_copies
,
1037 class avail_exprs_stack
*avail_exprs_stack
)
1040 class edge_info
*edge_info
= (class edge_info
*) e
->aux
;
1042 /* If we have info associated with this edge, record it into
1043 our equivalence tables. */
1046 cond_equivalence
*eq
;
1047 /* If we have 0 = COND or 1 = COND equivalences, record them
1048 into our expression hash tables. */
1049 for (i
= 0; edge_info
->cond_equivalences
.iterate (i
, &eq
); ++i
)
1050 avail_exprs_stack
->record_cond (eq
);
1052 edge_info::equiv_pair
*seq
;
1053 for (i
= 0; edge_info
->simple_equivalences
.iterate (i
, &seq
); ++i
)
1055 tree lhs
= seq
->first
;
1056 if (!lhs
|| TREE_CODE (lhs
) != SSA_NAME
)
1059 /* Record the simple NAME = VALUE equivalence. */
1060 tree rhs
= seq
->second
;
1062 /* If this is a SSA_NAME = SSA_NAME equivalence and one operand is
1063 cheaper to compute than the other, then set up the equivalence
1064 such that we replace the expensive one with the cheap one.
1066 If they are the same cost to compute, then do not record
1068 if (TREE_CODE (lhs
) == SSA_NAME
&& TREE_CODE (rhs
) == SSA_NAME
)
1070 gimple
*rhs_def
= SSA_NAME_DEF_STMT (rhs
);
1071 int rhs_cost
= estimate_num_insns (rhs_def
, &eni_size_weights
);
1073 gimple
*lhs_def
= SSA_NAME_DEF_STMT (lhs
);
1074 int lhs_cost
= estimate_num_insns (lhs_def
, &eni_size_weights
);
1076 if (rhs_cost
> lhs_cost
)
1077 record_equality (rhs
, lhs
, const_and_copies
);
1078 else if (rhs_cost
< lhs_cost
)
1079 record_equality (lhs
, rhs
, const_and_copies
);
1082 record_equality (lhs
, rhs
, const_and_copies
);
1085 /* Any equivalence found for LHS may result in additional
1086 equivalences for other uses of LHS that we have already
1088 back_propagate_equivalences (lhs
, e
, const_and_copies
);
1093 /* PHI nodes can create equivalences too.
1095 Ignoring any alternatives which are the same as the result, if
1096 all the alternatives are equal, then the PHI node creates an
1100 record_equivalences_from_phis (basic_block bb
)
1104 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1106 gphi
*phi
= gsi
.phi ();
1108 tree lhs
= gimple_phi_result (phi
);
1112 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1114 tree t
= gimple_phi_arg_def (phi
, i
);
1116 /* Ignore alternatives which are the same as our LHS. Since
1117 LHS is a PHI_RESULT, it is known to be a SSA_NAME, so we
1118 can simply compare pointers. */
1122 /* If the associated edge is not marked as executable, then it
1124 if ((gimple_phi_arg_edge (phi
, i
)->flags
& EDGE_EXECUTABLE
) == 0)
1127 t
= dom_valueize (t
);
1129 /* If T is an SSA_NAME and its associated edge is a backedge,
1130 then quit as we can not utilize this equivalence. */
1131 if (TREE_CODE (t
) == SSA_NAME
1132 && (gimple_phi_arg_edge (phi
, i
)->flags
& EDGE_DFS_BACK
))
1135 /* If we have not processed an alternative yet, then set
1136 RHS to this alternative. */
1139 /* If we have processed an alternative (stored in RHS), then
1140 see if it is equal to this one. If it isn't, then stop
1142 else if (! operand_equal_for_phi_arg_p (rhs
, t
))
1146 /* If we had no interesting alternatives, then all the RHS alternatives
1147 must have been the same as LHS. */
1151 /* If we managed to iterate through each PHI alternative without
1152 breaking out of the loop, then we have a PHI which may create
1153 a useful equivalence. We do not need to record unwind data for
1154 this, since this is a true assignment and not an equivalence
1155 inferred from a comparison. All uses of this ssa name are dominated
1156 by this assignment, so unwinding just costs time and space. */
1157 if (i
== gimple_phi_num_args (phi
)
1158 && may_propagate_copy (lhs
, rhs
))
1159 set_ssa_name_value (lhs
, rhs
);
1163 /* Record any equivalences created by the incoming edge to BB into
1164 CONST_AND_COPIES and AVAIL_EXPRS_STACK. If BB has more than one
1165 incoming edge, then no equivalence is created. */
1168 record_equivalences_from_incoming_edge (basic_block bb
,
1169 class const_and_copies
*const_and_copies
,
1170 class avail_exprs_stack
*avail_exprs_stack
)
1175 /* If our parent block ended with a control statement, then we may be
1176 able to record some equivalences based on which outgoing edge from
1177 the parent was followed. */
1178 parent
= get_immediate_dominator (CDI_DOMINATORS
, bb
);
1180 e
= single_pred_edge_ignoring_loop_edges (bb
, true);
1182 /* If we had a single incoming edge from our parent block, then enter
1183 any data associated with the edge into our tables. */
1184 if (e
&& e
->src
== parent
)
1185 record_temporary_equivalences (e
, const_and_copies
, avail_exprs_stack
);
1188 /* Dump statistics for the hash table HTAB. */
1191 htab_statistics (FILE *file
, const hash_table
<expr_elt_hasher
> &htab
)
1193 fprintf (file
, "size %ld, %ld elements, %f collision/search ratio\n",
1194 (long) htab
.size (),
1195 (long) htab
.elements (),
1196 htab
.collisions ());
1199 /* Dump SSA statistics on FILE. */
1202 dump_dominator_optimization_stats (FILE *file
,
1203 hash_table
<expr_elt_hasher
> *avail_exprs
)
1205 fprintf (file
, "Total number of statements: %6ld\n\n",
1206 opt_stats
.num_stmts
);
1207 fprintf (file
, "Exprs considered for dominator optimizations: %6ld\n",
1208 opt_stats
.num_exprs_considered
);
1210 fprintf (file
, "\nHash table statistics:\n");
1212 fprintf (file
, " avail_exprs: ");
1213 htab_statistics (file
, *avail_exprs
);
1217 /* Similarly, but assume that X and Y are the two operands of an EQ_EXPR.
1218 This constrains the cases in which we may treat this as assignment. */
1221 record_equality (tree x
, tree y
, class const_and_copies
*const_and_copies
)
1223 tree prev_x
= NULL
, prev_y
= NULL
;
1225 if (tree_swap_operands_p (x
, y
))
1228 /* Most of the time tree_swap_operands_p does what we want. But there
1229 are cases where we know one operand is better for copy propagation than
1230 the other. Given no other code cares about ordering of equality
1231 comparison operators for that purpose, we just handle the special cases
1233 if (TREE_CODE (x
) == SSA_NAME
&& TREE_CODE (y
) == SSA_NAME
)
1235 /* If one operand is a single use operand, then make it
1236 X. This will preserve its single use properly and if this
1237 conditional is eliminated, the computation of X can be
1238 eliminated as well. */
1239 if (has_single_use (y
) && ! has_single_use (x
))
1242 if (TREE_CODE (x
) == SSA_NAME
)
1243 prev_x
= SSA_NAME_VALUE (x
);
1244 if (TREE_CODE (y
) == SSA_NAME
)
1245 prev_y
= SSA_NAME_VALUE (y
);
1247 /* If one of the previous values is invariant, or invariant in more loops
1248 (by depth), then use that.
1249 Otherwise it doesn't matter which value we choose, just so
1250 long as we canonicalize on one value. */
1251 if (is_gimple_min_invariant (y
))
1253 else if (is_gimple_min_invariant (x
))
1254 prev_x
= x
, x
= y
, y
= prev_x
, prev_x
= prev_y
;
1255 else if (prev_x
&& is_gimple_min_invariant (prev_x
))
1256 x
= y
, y
= prev_x
, prev_x
= prev_y
;
1260 /* After the swapping, we must have one SSA_NAME. */
1261 if (TREE_CODE (x
) != SSA_NAME
)
1264 /* For IEEE, -0.0 == 0.0, so we don't necessarily know the sign of a
1265 variable compared against zero. If we're honoring signed zeros,
1266 then we cannot record this value unless we know that the value is
1268 if (HONOR_SIGNED_ZEROS (x
)
1269 && (TREE_CODE (y
) != REAL_CST
1270 || real_equal (&dconst0
, &TREE_REAL_CST (y
))))
1273 const_and_copies
->record_const_or_copy (x
, y
, prev_x
);
1276 /* Returns true when STMT is a simple iv increment. It detects the
1277 following situation:
1279 i_1 = phi (..., i_2)
1280 i_2 = i_1 +/- ... */
1283 simple_iv_increment_p (gimple
*stmt
)
1285 enum tree_code code
;
1290 if (gimple_code (stmt
) != GIMPLE_ASSIGN
)
1293 lhs
= gimple_assign_lhs (stmt
);
1294 if (TREE_CODE (lhs
) != SSA_NAME
)
1297 code
= gimple_assign_rhs_code (stmt
);
1298 if (code
!= PLUS_EXPR
1299 && code
!= MINUS_EXPR
1300 && code
!= POINTER_PLUS_EXPR
)
1303 preinc
= gimple_assign_rhs1 (stmt
);
1304 if (TREE_CODE (preinc
) != SSA_NAME
)
1307 phi
= SSA_NAME_DEF_STMT (preinc
);
1308 if (gimple_code (phi
) != GIMPLE_PHI
)
1311 for (i
= 0; i
< gimple_phi_num_args (phi
); i
++)
1312 if (gimple_phi_arg_def (phi
, i
) == lhs
)
1318 /* Propagate know values from SSA_NAME_VALUE into the PHI nodes of the
1319 successors of BB. */
1322 cprop_into_successor_phis (basic_block bb
,
1323 class const_and_copies
*const_and_copies
)
1328 FOR_EACH_EDGE (e
, ei
, bb
->succs
)
1333 /* If this is an abnormal edge, then we do not want to copy propagate
1334 into the PHI alternative associated with this edge. */
1335 if (e
->flags
& EDGE_ABNORMAL
)
1338 gsi
= gsi_start_phis (e
->dest
);
1339 if (gsi_end_p (gsi
))
1342 /* We may have an equivalence associated with this edge. While
1343 we can not propagate it into non-dominated blocks, we can
1344 propagate them into PHIs in non-dominated blocks. */
1346 /* Push the unwind marker so we can reset the const and copies
1347 table back to its original state after processing this edge. */
1348 const_and_copies
->push_marker ();
1350 /* Extract and record any simple NAME = VALUE equivalences.
1352 Don't bother with [01] = COND equivalences, they're not useful
1354 class edge_info
*edge_info
= (class edge_info
*) e
->aux
;
1358 edge_info::equiv_pair
*seq
;
1359 for (int i
= 0; edge_info
->simple_equivalences
.iterate (i
, &seq
); ++i
)
1361 tree lhs
= seq
->first
;
1362 tree rhs
= seq
->second
;
1364 if (lhs
&& TREE_CODE (lhs
) == SSA_NAME
)
1365 const_and_copies
->record_const_or_copy (lhs
, rhs
);
1371 for ( ; !gsi_end_p (gsi
); gsi_next (&gsi
))
1374 use_operand_p orig_p
;
1376 gphi
*phi
= gsi
.phi ();
1378 /* The alternative may be associated with a constant, so verify
1379 it is an SSA_NAME before doing anything with it. */
1380 orig_p
= gimple_phi_arg_imm_use_ptr (phi
, indx
);
1381 orig_val
= get_use_from_ptr (orig_p
);
1382 if (TREE_CODE (orig_val
) != SSA_NAME
)
1385 /* If we have *ORIG_P in our constant/copy table, then replace
1386 ORIG_P with its value in our constant/copy table. */
1387 new_val
= SSA_NAME_VALUE (orig_val
);
1389 && new_val
!= orig_val
1390 && may_propagate_copy (orig_val
, new_val
))
1391 propagate_value (orig_p
, new_val
);
1394 const_and_copies
->pop_to_marker ();
1399 dom_opt_dom_walker::before_dom_children (basic_block bb
)
1401 gimple_stmt_iterator gsi
;
1403 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1404 fprintf (dump_file
, "\n\nOptimizing block #%d\n\n", bb
->index
);
1406 evrp_range_analyzer
.enter (bb
);
1408 /* Push a marker on the stacks of local information so that we know how
1409 far to unwind when we finalize this block. */
1410 m_avail_exprs_stack
->push_marker ();
1411 m_const_and_copies
->push_marker ();
1413 record_equivalences_from_incoming_edge (bb
, m_const_and_copies
,
1414 m_avail_exprs_stack
);
1416 /* PHI nodes can create equivalences too. */
1417 record_equivalences_from_phis (bb
);
1419 /* Create equivalences from redundant PHIs. PHIs are only truly
1420 redundant when they exist in the same block, so push another
1421 marker and unwind right afterwards. */
1422 m_avail_exprs_stack
->push_marker ();
1423 for (gsi
= gsi_start_phis (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1424 eliminate_redundant_computations (&gsi
, m_const_and_copies
,
1425 m_avail_exprs_stack
);
1426 m_avail_exprs_stack
->pop_to_marker ();
1428 edge taken_edge
= NULL
;
1429 for (gsi
= gsi_start_bb (bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
1431 evrp_range_analyzer
.record_ranges_from_stmt (gsi_stmt (gsi
), false);
1432 taken_edge
= this->optimize_stmt (bb
, gsi
);
1435 /* Now prepare to process dominated blocks. */
1436 record_edge_info (bb
);
1437 cprop_into_successor_phis (bb
, m_const_and_copies
);
1438 if (taken_edge
&& !dbg_cnt (dom_unreachable_edges
))
1444 /* We have finished processing the dominator children of BB, perform
1445 any finalization actions in preparation for leaving this node in
1446 the dominator tree. */
1449 dom_opt_dom_walker::after_dom_children (basic_block bb
)
1451 x_vr_values
= evrp_range_analyzer
.get_vr_values ();
1452 thread_outgoing_edges (bb
, m_dummy_cond
, m_const_and_copies
,
1453 m_avail_exprs_stack
,
1454 &evrp_range_analyzer
,
1455 simplify_stmt_for_jump_threading
);
1458 /* These remove expressions local to BB from the tables. */
1459 m_avail_exprs_stack
->pop_to_marker ();
1460 m_const_and_copies
->pop_to_marker ();
1461 evrp_range_analyzer
.leave (bb
);
1464 /* Search for redundant computations in STMT. If any are found, then
1465 replace them with the variable holding the result of the computation.
1467 If safe, record this expression into AVAIL_EXPRS_STACK and
1468 CONST_AND_COPIES. */
1471 eliminate_redundant_computations (gimple_stmt_iterator
* gsi
,
1472 class const_and_copies
*const_and_copies
,
1473 class avail_exprs_stack
*avail_exprs_stack
)
1479 bool assigns_var_p
= false;
1481 gimple
*stmt
= gsi_stmt (*gsi
);
1483 if (gimple_code (stmt
) == GIMPLE_PHI
)
1484 def
= gimple_phi_result (stmt
);
1486 def
= gimple_get_lhs (stmt
);
1488 /* Certain expressions on the RHS can be optimized away, but can not
1489 themselves be entered into the hash tables. */
1491 || TREE_CODE (def
) != SSA_NAME
1492 || SSA_NAME_OCCURS_IN_ABNORMAL_PHI (def
)
1493 || gimple_vdef (stmt
)
1494 /* Do not record equivalences for increments of ivs. This would create
1495 overlapping live ranges for a very questionable gain. */
1496 || simple_iv_increment_p (stmt
))
1499 /* Check if the expression has been computed before. */
1500 cached_lhs
= avail_exprs_stack
->lookup_avail_expr (stmt
, insert
, true);
1502 opt_stats
.num_exprs_considered
++;
1504 /* Get the type of the expression we are trying to optimize. */
1505 if (is_gimple_assign (stmt
))
1507 expr_type
= TREE_TYPE (gimple_assign_lhs (stmt
));
1508 assigns_var_p
= true;
1510 else if (gimple_code (stmt
) == GIMPLE_COND
)
1511 expr_type
= boolean_type_node
;
1512 else if (is_gimple_call (stmt
))
1514 gcc_assert (gimple_call_lhs (stmt
));
1515 expr_type
= TREE_TYPE (gimple_call_lhs (stmt
));
1516 assigns_var_p
= true;
1518 else if (gswitch
*swtch_stmt
= dyn_cast
<gswitch
*> (stmt
))
1519 expr_type
= TREE_TYPE (gimple_switch_index (swtch_stmt
));
1520 else if (gimple_code (stmt
) == GIMPLE_PHI
)
1521 /* We can't propagate into a phi, so the logic below doesn't apply.
1522 Instead record an equivalence between the cached LHS and the
1523 PHI result of this statement, provided they are in the same block.
1524 This should be sufficient to kill the redundant phi. */
1526 if (def
&& cached_lhs
)
1527 const_and_copies
->record_const_or_copy (def
, cached_lhs
);
1536 /* It is safe to ignore types here since we have already done
1537 type checking in the hashing and equality routines. In fact
1538 type checking here merely gets in the way of constant
1539 propagation. Also, make sure that it is safe to propagate
1540 CACHED_LHS into the expression in STMT. */
1541 if ((TREE_CODE (cached_lhs
) != SSA_NAME
1543 || useless_type_conversion_p (expr_type
, TREE_TYPE (cached_lhs
))))
1544 || may_propagate_copy_into_stmt (stmt
, cached_lhs
))
1546 gcc_checking_assert (TREE_CODE (cached_lhs
) == SSA_NAME
1547 || is_gimple_min_invariant (cached_lhs
));
1549 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1551 fprintf (dump_file
, " Replaced redundant expr '");
1552 print_gimple_expr (dump_file
, stmt
, 0, dump_flags
);
1553 fprintf (dump_file
, "' with '");
1554 print_generic_expr (dump_file
, cached_lhs
, dump_flags
);
1555 fprintf (dump_file
, "'\n");
1561 && !useless_type_conversion_p (expr_type
, TREE_TYPE (cached_lhs
)))
1562 cached_lhs
= fold_convert (expr_type
, cached_lhs
);
1564 propagate_tree_value_into_stmt (gsi
, cached_lhs
);
1566 /* Since it is always necessary to mark the result as modified,
1567 perhaps we should move this into propagate_tree_value_into_stmt
1569 gimple_set_modified (gsi_stmt (*gsi
), true);
1573 /* STMT, a GIMPLE_ASSIGN, may create certain equivalences, in either
1574 the available expressions table or the const_and_copies table.
1575 Detect and record those equivalences into AVAIL_EXPRS_STACK.
1577 We handle only very simple copy equivalences here. The heavy
1578 lifing is done by eliminate_redundant_computations. */
1581 record_equivalences_from_stmt (gimple
*stmt
, int may_optimize_p
,
1582 class avail_exprs_stack
*avail_exprs_stack
)
1585 enum tree_code lhs_code
;
1587 gcc_assert (is_gimple_assign (stmt
));
1589 lhs
= gimple_assign_lhs (stmt
);
1590 lhs_code
= TREE_CODE (lhs
);
1592 if (lhs_code
== SSA_NAME
1593 && gimple_assign_single_p (stmt
))
1595 tree rhs
= gimple_assign_rhs1 (stmt
);
1597 /* If the RHS of the assignment is a constant or another variable that
1598 may be propagated, register it in the CONST_AND_COPIES table. We
1599 do not need to record unwind data for this, since this is a true
1600 assignment and not an equivalence inferred from a comparison. All
1601 uses of this ssa name are dominated by this assignment, so unwinding
1602 just costs time and space. */
1604 && (TREE_CODE (rhs
) == SSA_NAME
1605 || is_gimple_min_invariant (rhs
)))
1607 rhs
= dom_valueize (rhs
);
1609 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1611 fprintf (dump_file
, "==== ASGN ");
1612 print_generic_expr (dump_file
, lhs
);
1613 fprintf (dump_file
, " = ");
1614 print_generic_expr (dump_file
, rhs
);
1615 fprintf (dump_file
, "\n");
1618 set_ssa_name_value (lhs
, rhs
);
1622 /* Make sure we can propagate &x + CST. */
1623 if (lhs_code
== SSA_NAME
1624 && gimple_assign_rhs_code (stmt
) == POINTER_PLUS_EXPR
1625 && TREE_CODE (gimple_assign_rhs1 (stmt
)) == ADDR_EXPR
1626 && TREE_CODE (gimple_assign_rhs2 (stmt
)) == INTEGER_CST
)
1628 tree op0
= gimple_assign_rhs1 (stmt
);
1629 tree op1
= gimple_assign_rhs2 (stmt
);
1631 = build_fold_addr_expr (fold_build2 (MEM_REF
,
1632 TREE_TYPE (TREE_TYPE (op0
)),
1634 fold_convert (ptr_type_node
,
1636 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1638 fprintf (dump_file
, "==== ASGN ");
1639 print_generic_expr (dump_file
, lhs
);
1640 fprintf (dump_file
, " = ");
1641 print_generic_expr (dump_file
, new_rhs
);
1642 fprintf (dump_file
, "\n");
1645 set_ssa_name_value (lhs
, new_rhs
);
1648 /* A memory store, even an aliased store, creates a useful
1649 equivalence. By exchanging the LHS and RHS, creating suitable
1650 vops and recording the result in the available expression table,
1651 we may be able to expose more redundant loads. */
1652 if (!gimple_has_volatile_ops (stmt
)
1653 && gimple_references_memory_p (stmt
)
1654 && gimple_assign_single_p (stmt
)
1655 && (TREE_CODE (gimple_assign_rhs1 (stmt
)) == SSA_NAME
1656 || is_gimple_min_invariant (gimple_assign_rhs1 (stmt
)))
1657 && !is_gimple_reg (lhs
))
1659 tree rhs
= gimple_assign_rhs1 (stmt
);
1662 /* Build a new statement with the RHS and LHS exchanged. */
1663 if (TREE_CODE (rhs
) == SSA_NAME
)
1665 /* NOTE tuples. The call to gimple_build_assign below replaced
1666 a call to build_gimple_modify_stmt, which did not set the
1667 SSA_NAME_DEF_STMT on the LHS of the assignment. Doing so
1668 may cause an SSA validation failure, as the LHS may be a
1669 default-initialized name and should have no definition. I'm
1670 a bit dubious of this, as the artificial statement that we
1671 generate here may in fact be ill-formed, but it is simply
1672 used as an internal device in this pass, and never becomes
1674 gimple
*defstmt
= SSA_NAME_DEF_STMT (rhs
);
1675 new_stmt
= gimple_build_assign (rhs
, lhs
);
1676 SSA_NAME_DEF_STMT (rhs
) = defstmt
;
1679 new_stmt
= gimple_build_assign (rhs
, lhs
);
1681 gimple_set_vuse (new_stmt
, gimple_vdef (stmt
));
1683 /* Finally enter the statement into the available expression
1685 avail_exprs_stack
->lookup_avail_expr (new_stmt
, true, true);
1689 /* Replace *OP_P in STMT with any known equivalent value for *OP_P from
1690 CONST_AND_COPIES. */
1693 cprop_operand (gimple
*stmt
, use_operand_p op_p
)
1696 tree op
= USE_FROM_PTR (op_p
);
1698 /* If the operand has a known constant value or it is known to be a
1699 copy of some other variable, use the value or copy stored in
1700 CONST_AND_COPIES. */
1701 val
= SSA_NAME_VALUE (op
);
1702 if (val
&& val
!= op
)
1704 /* Do not replace hard register operands in asm statements. */
1705 if (gimple_code (stmt
) == GIMPLE_ASM
1706 && !may_propagate_copy_into_asm (op
))
1709 /* Certain operands are not allowed to be copy propagated due
1710 to their interaction with exception handling and some GCC
1712 if (!may_propagate_copy (op
, val
))
1715 /* Do not propagate copies into BIVs.
1716 See PR23821 and PR62217 for how this can disturb IV and
1717 number of iteration analysis. */
1718 if (TREE_CODE (val
) != INTEGER_CST
)
1720 gimple
*def
= SSA_NAME_DEF_STMT (op
);
1721 if (gimple_code (def
) == GIMPLE_PHI
1722 && gimple_bb (def
)->loop_father
->header
== gimple_bb (def
))
1727 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1729 fprintf (dump_file
, " Replaced '");
1730 print_generic_expr (dump_file
, op
, dump_flags
);
1731 fprintf (dump_file
, "' with %s '",
1732 (TREE_CODE (val
) != SSA_NAME
? "constant" : "variable"));
1733 print_generic_expr (dump_file
, val
, dump_flags
);
1734 fprintf (dump_file
, "'\n");
1737 if (TREE_CODE (val
) != SSA_NAME
)
1738 opt_stats
.num_const_prop
++;
1740 opt_stats
.num_copy_prop
++;
1742 propagate_value (op_p
, val
);
1744 /* And note that we modified this statement. This is now
1745 safe, even if we changed virtual operands since we will
1746 rescan the statement and rewrite its operands again. */
1747 gimple_set_modified (stmt
, true);
1751 /* CONST_AND_COPIES is a table which maps an SSA_NAME to the current
1752 known value for that SSA_NAME (or NULL if no value is known).
1754 Propagate values from CONST_AND_COPIES into the uses, vuses and
1755 vdef_ops of STMT. */
1758 cprop_into_stmt (gimple
*stmt
)
1762 tree last_copy_propagated_op
= NULL
;
1764 FOR_EACH_SSA_USE_OPERAND (op_p
, stmt
, iter
, SSA_OP_USE
)
1766 tree old_op
= USE_FROM_PTR (op_p
);
1768 /* If we have A = B and B = A in the copy propagation tables
1769 (due to an equality comparison), avoid substituting B for A
1770 then A for B in the trivially discovered cases. This allows
1771 optimization of statements were A and B appear as input
1773 if (old_op
!= last_copy_propagated_op
)
1775 cprop_operand (stmt
, op_p
);
1777 tree new_op
= USE_FROM_PTR (op_p
);
1778 if (new_op
!= old_op
&& TREE_CODE (new_op
) == SSA_NAME
)
1779 last_copy_propagated_op
= new_op
;
1784 /* If STMT contains a relational test, try to convert it into an
1785 equality test if there is only a single value which can ever
1788 For example, if the expression hash table contains:
1792 And we have a test within statement of i >= 1, then we can safely
1793 rewrite the test as i == 1 since there only a single value where
1796 This is similar to code in VRP. */
1799 test_for_singularity (gimple
*stmt
, gcond
*dummy_cond
,
1800 avail_exprs_stack
*avail_exprs_stack
)
1802 /* We want to support gimple conditionals as well as assignments
1803 where the RHS contains a conditional. */
1804 if (is_gimple_assign (stmt
) || gimple_code (stmt
) == GIMPLE_COND
)
1806 enum tree_code code
= ERROR_MARK
;
1809 /* Extract the condition of interest from both forms we support. */
1810 if (is_gimple_assign (stmt
))
1812 code
= gimple_assign_rhs_code (stmt
);
1813 lhs
= gimple_assign_rhs1 (stmt
);
1814 rhs
= gimple_assign_rhs2 (stmt
);
1816 else if (gimple_code (stmt
) == GIMPLE_COND
)
1818 code
= gimple_cond_code (as_a
<gcond
*> (stmt
));
1819 lhs
= gimple_cond_lhs (as_a
<gcond
*> (stmt
));
1820 rhs
= gimple_cond_rhs (as_a
<gcond
*> (stmt
));
1823 /* We're looking for a relational test using LE/GE. Also note we can
1824 canonicalize LT/GT tests against constants into LE/GT tests. */
1825 if (code
== LE_EXPR
|| code
== GE_EXPR
1826 || ((code
== LT_EXPR
|| code
== GT_EXPR
)
1827 && TREE_CODE (rhs
) == INTEGER_CST
))
1829 /* For LT_EXPR and GT_EXPR, canonicalize to LE_EXPR and GE_EXPR. */
1830 if (code
== LT_EXPR
)
1831 rhs
= fold_build2 (MINUS_EXPR
, TREE_TYPE (rhs
),
1832 rhs
, build_int_cst (TREE_TYPE (rhs
), 1));
1834 if (code
== GT_EXPR
)
1835 rhs
= fold_build2 (PLUS_EXPR
, TREE_TYPE (rhs
),
1836 rhs
, build_int_cst (TREE_TYPE (rhs
), 1));
1838 /* Determine the code we want to check for in the hash table. */
1839 enum tree_code test_code
;
1840 if (code
== GE_EXPR
|| code
== GT_EXPR
)
1841 test_code
= LE_EXPR
;
1843 test_code
= GE_EXPR
;
1845 /* Update the dummy statement so we can query the hash tables. */
1846 gimple_cond_set_code (dummy_cond
, test_code
);
1847 gimple_cond_set_lhs (dummy_cond
, lhs
);
1848 gimple_cond_set_rhs (dummy_cond
, rhs
);
1850 = avail_exprs_stack
->lookup_avail_expr (dummy_cond
, false, false);
1852 /* If the lookup returned 1 (true), then the expression we
1853 queried was in the hash table. As a result there is only
1854 one value that makes the original conditional true. Update
1855 STMT accordingly. */
1856 if (cached_lhs
&& integer_onep (cached_lhs
))
1858 if (is_gimple_assign (stmt
))
1860 gimple_assign_set_rhs_code (stmt
, EQ_EXPR
);
1861 gimple_assign_set_rhs2 (stmt
, rhs
);
1862 gimple_set_modified (stmt
, true);
1866 gimple_set_modified (stmt
, true);
1867 gimple_cond_set_code (as_a
<gcond
*> (stmt
), EQ_EXPR
);
1868 gimple_cond_set_rhs (as_a
<gcond
*> (stmt
), rhs
);
1869 gimple_set_modified (stmt
, true);
1876 /* Optimize the statement in block BB pointed to by iterator SI.
1878 We try to perform some simplistic global redundancy elimination and
1879 constant propagation:
1881 1- To detect global redundancy, we keep track of expressions that have
1882 been computed in this block and its dominators. If we find that the
1883 same expression is computed more than once, we eliminate repeated
1884 computations by using the target of the first one.
1886 2- Constant values and copy assignments. This is used to do very
1887 simplistic constant and copy propagation. When a constant or copy
1888 assignment is found, we map the value on the RHS of the assignment to
1889 the variable in the LHS in the CONST_AND_COPIES table.
1891 3- Very simple redundant store elimination is performed.
1893 4- We can simpify a condition to a constant or from a relational
1894 condition to an equality condition. */
1897 dom_opt_dom_walker::optimize_stmt (basic_block bb
, gimple_stmt_iterator si
)
1899 gimple
*stmt
, *old_stmt
;
1900 bool may_optimize_p
;
1901 bool modified_p
= false;
1905 old_stmt
= stmt
= gsi_stmt (si
);
1906 was_noreturn
= is_gimple_call (stmt
) && gimple_call_noreturn_p (stmt
);
1908 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1910 fprintf (dump_file
, "Optimizing statement ");
1911 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
1914 update_stmt_if_modified (stmt
);
1915 opt_stats
.num_stmts
++;
1917 /* Const/copy propagate into USES, VUSES and the RHS of VDEFs. */
1918 cprop_into_stmt (stmt
);
1920 /* If the statement has been modified with constant replacements,
1921 fold its RHS before checking for redundant computations. */
1922 if (gimple_modified_p (stmt
))
1926 /* Try to fold the statement making sure that STMT is kept
1928 if (fold_stmt (&si
))
1930 stmt
= gsi_stmt (si
);
1931 gimple_set_modified (stmt
, true);
1933 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1935 fprintf (dump_file
, " Folded to: ");
1936 print_gimple_stmt (dump_file
, stmt
, 0, TDF_SLIM
);
1940 /* We only need to consider cases that can yield a gimple operand. */
1941 if (gimple_assign_single_p (stmt
))
1942 rhs
= gimple_assign_rhs1 (stmt
);
1943 else if (gimple_code (stmt
) == GIMPLE_GOTO
)
1944 rhs
= gimple_goto_dest (stmt
);
1945 else if (gswitch
*swtch_stmt
= dyn_cast
<gswitch
*> (stmt
))
1946 /* This should never be an ADDR_EXPR. */
1947 rhs
= gimple_switch_index (swtch_stmt
);
1949 if (rhs
&& TREE_CODE (rhs
) == ADDR_EXPR
)
1950 recompute_tree_invariant_for_addr_expr (rhs
);
1952 /* Indicate that maybe_clean_or_replace_eh_stmt needs to be called,
1953 even if fold_stmt updated the stmt already and thus cleared
1954 gimple_modified_p flag on it. */
1958 /* Check for redundant computations. Do this optimization only
1959 for assignments that have no volatile ops and conditionals. */
1960 may_optimize_p
= (!gimple_has_side_effects (stmt
)
1961 && (is_gimple_assign (stmt
)
1962 || (is_gimple_call (stmt
)
1963 && gimple_call_lhs (stmt
) != NULL_TREE
)
1964 || gimple_code (stmt
) == GIMPLE_COND
1965 || gimple_code (stmt
) == GIMPLE_SWITCH
));
1969 if (gimple_code (stmt
) == GIMPLE_CALL
)
1971 /* Resolve __builtin_constant_p. If it hasn't been
1972 folded to integer_one_node by now, it's fairly
1973 certain that the value simply isn't constant. */
1974 tree callee
= gimple_call_fndecl (stmt
);
1976 && DECL_BUILT_IN_CLASS (callee
) == BUILT_IN_NORMAL
1977 && DECL_FUNCTION_CODE (callee
) == BUILT_IN_CONSTANT_P
)
1979 propagate_tree_value_into_stmt (&si
, integer_zero_node
);
1980 stmt
= gsi_stmt (si
);
1984 if (gimple_code (stmt
) == GIMPLE_COND
)
1986 tree lhs
= gimple_cond_lhs (stmt
);
1987 tree rhs
= gimple_cond_rhs (stmt
);
1989 /* If the LHS has a range [0..1] and the RHS has a range ~[0..1],
1990 then this conditional is computable at compile time. We can just
1991 shove either 0 or 1 into the LHS, mark the statement as modified
1992 and all the right things will just happen below.
1994 Note this would apply to any case where LHS has a range
1995 narrower than its type implies and RHS is outside that
1996 narrower range. Future work. */
1997 if (TREE_CODE (lhs
) == SSA_NAME
1998 && ssa_name_has_boolean_range (lhs
)
1999 && TREE_CODE (rhs
) == INTEGER_CST
2000 && ! (integer_zerop (rhs
) || integer_onep (rhs
)))
2002 gimple_cond_set_lhs (as_a
<gcond
*> (stmt
),
2003 fold_convert (TREE_TYPE (lhs
),
2004 integer_zero_node
));
2005 gimple_set_modified (stmt
, true);
2007 else if (TREE_CODE (lhs
) == SSA_NAME
)
2009 /* Exploiting EVRP data is not yet fully integrated into DOM
2010 but we need to do something for this case to avoid regressing
2011 udr4.f90 and new1.C which have unexecutable blocks with
2012 undefined behavior that get diagnosed if they're left in the
2013 IL because we've attached range information to new
2015 update_stmt_if_modified (stmt
);
2016 edge taken_edge
= NULL
;
2017 evrp_range_analyzer
.vrp_visit_cond_stmt (as_a
<gcond
*> (stmt
),
2021 if (taken_edge
->flags
& EDGE_TRUE_VALUE
)
2022 gimple_cond_make_true (as_a
<gcond
*> (stmt
));
2023 else if (taken_edge
->flags
& EDGE_FALSE_VALUE
)
2024 gimple_cond_make_false (as_a
<gcond
*> (stmt
));
2027 gimple_set_modified (stmt
, true);
2035 update_stmt_if_modified (stmt
);
2036 eliminate_redundant_computations (&si
, m_const_and_copies
,
2037 m_avail_exprs_stack
);
2038 stmt
= gsi_stmt (si
);
2040 /* Perform simple redundant store elimination. */
2041 if (gimple_assign_single_p (stmt
)
2042 && TREE_CODE (gimple_assign_lhs (stmt
)) != SSA_NAME
)
2044 tree lhs
= gimple_assign_lhs (stmt
);
2045 tree rhs
= gimple_assign_rhs1 (stmt
);
2048 rhs
= dom_valueize (rhs
);
2049 /* Build a new statement with the RHS and LHS exchanged. */
2050 if (TREE_CODE (rhs
) == SSA_NAME
)
2052 gimple
*defstmt
= SSA_NAME_DEF_STMT (rhs
);
2053 new_stmt
= gimple_build_assign (rhs
, lhs
);
2054 SSA_NAME_DEF_STMT (rhs
) = defstmt
;
2057 new_stmt
= gimple_build_assign (rhs
, lhs
);
2058 gimple_set_vuse (new_stmt
, gimple_vuse (stmt
));
2059 cached_lhs
= m_avail_exprs_stack
->lookup_avail_expr (new_stmt
, false,
2061 if (cached_lhs
&& operand_equal_p (rhs
, cached_lhs
, 0))
2063 basic_block bb
= gimple_bb (stmt
);
2064 unlink_stmt_vdef (stmt
);
2065 if (gsi_remove (&si
, true))
2067 bitmap_set_bit (need_eh_cleanup
, bb
->index
);
2068 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2069 fprintf (dump_file
, " Flagged to clear EH edges.\n");
2071 release_defs (stmt
);
2076 /* If this statement was not redundant, we may still be able to simplify
2077 it, which may in turn allow other part of DOM or other passes to do
2079 test_for_singularity (stmt
, m_dummy_cond
, m_avail_exprs_stack
);
2082 /* Record any additional equivalences created by this statement. */
2083 if (is_gimple_assign (stmt
))
2084 record_equivalences_from_stmt (stmt
, may_optimize_p
, m_avail_exprs_stack
);
2086 /* If STMT is a COND_EXPR or SWITCH_EXPR and it was modified, then we may
2087 know where it goes. */
2088 if (gimple_modified_p (stmt
) || modified_p
)
2092 if (gimple_code (stmt
) == GIMPLE_COND
)
2093 val
= fold_binary_loc (gimple_location (stmt
),
2094 gimple_cond_code (stmt
), boolean_type_node
,
2095 gimple_cond_lhs (stmt
),
2096 gimple_cond_rhs (stmt
));
2097 else if (gswitch
*swtch_stmt
= dyn_cast
<gswitch
*> (stmt
))
2098 val
= gimple_switch_index (swtch_stmt
);
2100 if (val
&& TREE_CODE (val
) == INTEGER_CST
)
2102 retval
= find_taken_edge (bb
, val
);
2105 /* Fix the condition to be either true or false. */
2106 if (gimple_code (stmt
) == GIMPLE_COND
)
2108 if (integer_zerop (val
))
2109 gimple_cond_make_false (as_a
<gcond
*> (stmt
));
2110 else if (integer_onep (val
))
2111 gimple_cond_make_true (as_a
<gcond
*> (stmt
));
2115 gimple_set_modified (stmt
, true);
2118 /* Further simplifications may be possible. */
2123 update_stmt_if_modified (stmt
);
2125 /* If we simplified a statement in such a way as to be shown that it
2126 cannot trap, update the eh information and the cfg to match. */
2127 if (maybe_clean_or_replace_eh_stmt (old_stmt
, stmt
))
2129 bitmap_set_bit (need_eh_cleanup
, bb
->index
);
2130 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2131 fprintf (dump_file
, " Flagged to clear EH edges.\n");
2135 && is_gimple_call (stmt
) && gimple_call_noreturn_p (stmt
))
2136 need_noreturn_fixup
.safe_push (stmt
);