2 Copyright (C) 2005-2014 Free Software Foundation, Inc.
3 Contributed by Jeff Law <law@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"
28 #include "basic-block.h"
34 #include "hard-reg-set.h"
39 #include "tree-ssa-alias.h"
40 #include "internal-fn.h"
41 #include "gimple-expr.h"
44 #include "gimple-iterator.h"
45 #include "gimple-ssa.h"
47 #include "tree-phinodes.h"
48 #include "ssa-iterators.h"
49 #include "stringpool.h"
50 #include "tree-ssanames.h"
51 #include "tree-ssa-propagate.h"
52 #include "tree-ssa-threadupdate.h"
53 #include "langhooks.h"
55 #include "tree-ssa-threadedge.h"
58 /* To avoid code explosion due to jump threading, we limit the
59 number of statements we are going to copy. This variable
60 holds the number of statements currently seen that we'll have
61 to copy as part of the jump threading process. */
62 static int stmt_count
;
64 /* Array to record value-handles per SSA_NAME. */
65 vec
<tree
> ssa_name_values
;
67 /* Set the value for the SSA name NAME to VALUE. */
70 set_ssa_name_value (tree name
, tree value
)
72 if (SSA_NAME_VERSION (name
) >= ssa_name_values
.length ())
73 ssa_name_values
.safe_grow_cleared (SSA_NAME_VERSION (name
) + 1);
74 if (value
&& TREE_OVERFLOW_P (value
))
75 value
= drop_tree_overflow (value
);
76 ssa_name_values
[SSA_NAME_VERSION (name
)] = value
;
79 /* Initialize the per SSA_NAME value-handles array. Returns it. */
81 threadedge_initialize_values (void)
83 gcc_assert (!ssa_name_values
.exists ());
84 ssa_name_values
.create (num_ssa_names
);
87 /* Free the per SSA_NAME value-handle array. */
89 threadedge_finalize_values (void)
91 ssa_name_values
.release ();
94 /* Return TRUE if we may be able to thread an incoming edge into
95 BB to an outgoing edge from BB. Return FALSE otherwise. */
98 potentially_threadable_block (basic_block bb
)
100 gimple_stmt_iterator gsi
;
102 /* If BB has a single successor or a single predecessor, then
103 there is no threading opportunity. */
104 if (single_succ_p (bb
) || single_pred_p (bb
))
107 /* If BB does not end with a conditional, switch or computed goto,
108 then there is no threading opportunity. */
109 gsi
= gsi_last_bb (bb
);
112 || (gimple_code (gsi_stmt (gsi
)) != GIMPLE_COND
113 && gimple_code (gsi_stmt (gsi
)) != GIMPLE_GOTO
114 && gimple_code (gsi_stmt (gsi
)) != GIMPLE_SWITCH
))
120 /* Return the LHS of any ASSERT_EXPR where OP appears as the first
121 argument to the ASSERT_EXPR and in which the ASSERT_EXPR dominates
122 BB. If no such ASSERT_EXPR is found, return OP. */
125 lhs_of_dominating_assert (tree op
, basic_block bb
, gimple stmt
)
127 imm_use_iterator imm_iter
;
131 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
133 use_stmt
= USE_STMT (use_p
);
135 && gimple_assign_single_p (use_stmt
)
136 && TREE_CODE (gimple_assign_rhs1 (use_stmt
)) == ASSERT_EXPR
137 && TREE_OPERAND (gimple_assign_rhs1 (use_stmt
), 0) == op
138 && dominated_by_p (CDI_DOMINATORS
, bb
, gimple_bb (use_stmt
)))
140 return gimple_assign_lhs (use_stmt
);
146 /* We record temporary equivalences created by PHI nodes or
147 statements within the target block. Doing so allows us to
148 identify more jump threading opportunities, even in blocks
151 We keep track of those temporary equivalences in a stack
152 structure so that we can unwind them when we're done processing
153 a particular edge. This routine handles unwinding the data
157 remove_temporary_equivalences (vec
<tree
> *stack
)
159 while (stack
->length () > 0)
161 tree prev_value
, dest
;
163 dest
= stack
->pop ();
165 /* A NULL value indicates we should stop unwinding, otherwise
166 pop off the next entry as they're recorded in pairs. */
170 prev_value
= stack
->pop ();
171 set_ssa_name_value (dest
, prev_value
);
175 /* Record a temporary equivalence, saving enough information so that
176 we can restore the state of recorded equivalences when we're
177 done processing the current edge. */
180 record_temporary_equivalence (tree x
, tree y
, vec
<tree
> *stack
)
182 tree prev_x
= SSA_NAME_VALUE (x
);
184 /* Y may be NULL if we are invalidating entries in the table. */
185 if (y
&& TREE_CODE (y
) == SSA_NAME
)
187 tree tmp
= SSA_NAME_VALUE (y
);
191 set_ssa_name_value (x
, y
);
193 stack
->quick_push (prev_x
);
194 stack
->quick_push (x
);
197 /* Record temporary equivalences created by PHIs at the target of the
198 edge E. Record unwind information for the equivalences onto STACK.
200 If a PHI which prevents threading is encountered, then return FALSE
201 indicating we should not thread this edge, else return TRUE.
203 If SRC_MAP/DST_MAP exist, then mark the source and destination SSA_NAMEs
204 of any equivalences recorded. We use this to make invalidation after
205 traversing back edges less painful. */
208 record_temporary_equivalences_from_phis (edge e
, vec
<tree
> *stack
)
210 gimple_stmt_iterator gsi
;
212 /* Each PHI creates a temporary equivalence, record them.
213 These are context sensitive equivalences and will be removed
215 for (gsi
= gsi_start_phis (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
217 gimple phi
= gsi_stmt (gsi
);
218 tree src
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
219 tree dst
= gimple_phi_result (phi
);
221 /* If the desired argument is not the same as this PHI's result
222 and it is set by a PHI in E->dest, then we can not thread
225 && TREE_CODE (src
) == SSA_NAME
226 && gimple_code (SSA_NAME_DEF_STMT (src
)) == GIMPLE_PHI
227 && gimple_bb (SSA_NAME_DEF_STMT (src
)) == e
->dest
)
230 /* We consider any non-virtual PHI as a statement since it
231 count result in a constant assignment or copy operation. */
232 if (!virtual_operand_p (dst
))
235 record_temporary_equivalence (dst
, src
, stack
);
240 /* Fold the RHS of an assignment statement and return it as a tree.
241 May return NULL_TREE if no simplification is possible. */
244 fold_assignment_stmt (gimple stmt
)
246 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
248 switch (get_gimple_rhs_class (subcode
))
250 case GIMPLE_SINGLE_RHS
:
251 return fold (gimple_assign_rhs1 (stmt
));
253 case GIMPLE_UNARY_RHS
:
255 tree lhs
= gimple_assign_lhs (stmt
);
256 tree op0
= gimple_assign_rhs1 (stmt
);
257 return fold_unary (subcode
, TREE_TYPE (lhs
), op0
);
260 case GIMPLE_BINARY_RHS
:
262 tree lhs
= gimple_assign_lhs (stmt
);
263 tree op0
= gimple_assign_rhs1 (stmt
);
264 tree op1
= gimple_assign_rhs2 (stmt
);
265 return fold_binary (subcode
, TREE_TYPE (lhs
), op0
, op1
);
268 case GIMPLE_TERNARY_RHS
:
270 tree lhs
= gimple_assign_lhs (stmt
);
271 tree op0
= gimple_assign_rhs1 (stmt
);
272 tree op1
= gimple_assign_rhs2 (stmt
);
273 tree op2
= gimple_assign_rhs3 (stmt
);
275 /* Sadly, we have to handle conditional assignments specially
276 here, because fold expects all the operands of an expression
277 to be folded before the expression itself is folded, but we
278 can't just substitute the folded condition here. */
279 if (gimple_assign_rhs_code (stmt
) == COND_EXPR
)
282 return fold_ternary (subcode
, TREE_TYPE (lhs
), op0
, op1
, op2
);
290 /* A new value has been assigned to LHS. If necessary, invalidate any
291 equivalences that are no longer valid. */
293 invalidate_equivalences (tree lhs
, vec
<tree
> *stack
)
296 for (unsigned int i
= 1; i
< num_ssa_names
; i
++)
297 if (ssa_name (i
) && SSA_NAME_VALUE (ssa_name (i
)) == lhs
)
298 record_temporary_equivalence (ssa_name (i
), NULL_TREE
, stack
);
300 if (SSA_NAME_VALUE (lhs
))
301 record_temporary_equivalence (lhs
, NULL_TREE
, stack
);
304 /* Try to simplify each statement in E->dest, ultimately leading to
305 a simplification of the COND_EXPR at the end of E->dest.
307 Record unwind information for temporary equivalences onto STACK.
309 Use SIMPLIFY (a pointer to a callback function) to further simplify
310 statements using pass specific information.
312 We might consider marking just those statements which ultimately
313 feed the COND_EXPR. It's not clear if the overhead of bookkeeping
314 would be recovered by trying to simplify fewer statements.
316 If we are able to simplify a statement into the form
317 SSA_NAME = (SSA_NAME | gimple invariant), then we can record
318 a context sensitive equivalence which may help us simplify
319 later statements in E->dest. */
322 record_temporary_equivalences_from_stmts_at_dest (edge e
,
324 tree (*simplify
) (gimple
,
329 gimple_stmt_iterator gsi
;
332 max_stmt_count
= PARAM_VALUE (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS
);
334 /* Walk through each statement in the block recording equivalences
335 we discover. Note any equivalences we discover are context
336 sensitive (ie, are dependent on traversing E) and must be unwound
337 when we're finished processing E. */
338 for (gsi
= gsi_start_bb (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
340 tree cached_lhs
= NULL
;
342 stmt
= gsi_stmt (gsi
);
344 /* Ignore empty statements and labels. */
345 if (gimple_code (stmt
) == GIMPLE_NOP
346 || gimple_code (stmt
) == GIMPLE_LABEL
347 || is_gimple_debug (stmt
))
350 /* If the statement has volatile operands, then we assume we
351 can not thread through this block. This is overly
352 conservative in some ways. */
353 if (gimple_code (stmt
) == GIMPLE_ASM
&& gimple_asm_volatile_p (stmt
))
356 /* If duplicating this block is going to cause too much code
357 expansion, then do not thread through this block. */
359 if (stmt_count
> max_stmt_count
)
362 /* If this is not a statement that sets an SSA_NAME to a new
363 value, then do not try to simplify this statement as it will
364 not simplify in any way that is helpful for jump threading. */
365 if ((gimple_code (stmt
) != GIMPLE_ASSIGN
366 || TREE_CODE (gimple_assign_lhs (stmt
)) != SSA_NAME
)
367 && (gimple_code (stmt
) != GIMPLE_CALL
368 || gimple_call_lhs (stmt
) == NULL_TREE
369 || TREE_CODE (gimple_call_lhs (stmt
)) != SSA_NAME
))
371 /* STMT might still have DEFS and we need to invalidate any known
372 equivalences for them.
374 Consider if STMT is a GIMPLE_ASM with one or more outputs that
375 feeds a conditional inside a loop. We might derive an equivalence
376 due to the conditional. */
381 FOR_EACH_SSA_TREE_OPERAND (op
, stmt
, iter
, SSA_OP_DEF
)
382 invalidate_equivalences (op
, stack
);
387 /* The result of __builtin_object_size depends on all the arguments
388 of a phi node. Temporarily using only one edge produces invalid
397 r = PHI <&w[2].a[1](2), &a.a[6](3)>
398 __builtin_object_size (r, 0)
400 The result of __builtin_object_size is defined to be the maximum of
401 remaining bytes. If we use only one edge on the phi, the result will
402 change to be the remaining bytes for the corresponding phi argument.
404 Similarly for __builtin_constant_p:
407 __builtin_constant_p (r)
409 Both PHI arguments are constant, but x ? 1 : 2 is still not
412 if (is_gimple_call (stmt
))
414 tree fndecl
= gimple_call_fndecl (stmt
);
416 && (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_OBJECT_SIZE
417 || DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CONSTANT_P
))
421 tree lhs
= gimple_get_lhs (stmt
);
422 invalidate_equivalences (lhs
, stack
);
428 /* At this point we have a statement which assigns an RHS to an
429 SSA_VAR on the LHS. We want to try and simplify this statement
430 to expose more context sensitive equivalences which in turn may
431 allow us to simplify the condition at the end of the loop.
433 Handle simple copy operations as well as implied copies from
435 if (gimple_assign_single_p (stmt
)
436 && TREE_CODE (gimple_assign_rhs1 (stmt
)) == SSA_NAME
)
437 cached_lhs
= gimple_assign_rhs1 (stmt
);
438 else if (gimple_assign_single_p (stmt
)
439 && TREE_CODE (gimple_assign_rhs1 (stmt
)) == ASSERT_EXPR
)
440 cached_lhs
= TREE_OPERAND (gimple_assign_rhs1 (stmt
), 0);
443 /* A statement that is not a trivial copy or ASSERT_EXPR.
444 We're going to temporarily copy propagate the operands
445 and see if that allows us to simplify this statement. */
449 unsigned int num
, i
= 0;
451 num
= NUM_SSA_OPERANDS (stmt
, (SSA_OP_USE
| SSA_OP_VUSE
));
452 copy
= XCNEWVEC (tree
, num
);
454 /* Make a copy of the uses & vuses into USES_COPY, then cprop into
456 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
| SSA_OP_VUSE
)
459 tree use
= USE_FROM_PTR (use_p
);
462 if (TREE_CODE (use
) == SSA_NAME
)
463 tmp
= SSA_NAME_VALUE (use
);
465 SET_USE (use_p
, tmp
);
468 /* Try to fold/lookup the new expression. Inserting the
469 expression into the hash table is unlikely to help. */
470 if (is_gimple_call (stmt
))
471 cached_lhs
= fold_call_stmt (stmt
, false);
473 cached_lhs
= fold_assignment_stmt (stmt
);
476 || (TREE_CODE (cached_lhs
) != SSA_NAME
477 && !is_gimple_min_invariant (cached_lhs
)))
478 cached_lhs
= (*simplify
) (stmt
, stmt
);
480 /* Restore the statement's original uses/defs. */
482 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
| SSA_OP_VUSE
)
483 SET_USE (use_p
, copy
[i
++]);
488 /* Record the context sensitive equivalence if we were able
489 to simplify this statement.
491 If we have traversed a backedge at some point during threading,
492 then always enter something here. Either a real equivalence,
493 or a NULL_TREE equivalence which is effectively invalidation of
494 prior equivalences. */
496 && (TREE_CODE (cached_lhs
) == SSA_NAME
497 || is_gimple_min_invariant (cached_lhs
)))
498 record_temporary_equivalence (gimple_get_lhs (stmt
), cached_lhs
, stack
);
499 else if (backedge_seen
)
500 invalidate_equivalences (gimple_get_lhs (stmt
), stack
);
505 /* Once we have passed a backedge in the CFG when threading, we do not want to
506 utilize edge equivalences for simplification purpose. They are no longer
507 necessarily valid. We use this callback rather than the ones provided by
508 DOM/VRP to achieve that effect. */
510 dummy_simplify (gimple stmt1 ATTRIBUTE_UNUSED
, gimple stmt2 ATTRIBUTE_UNUSED
)
515 /* Simplify the control statement at the end of the block E->dest.
517 To avoid allocating memory unnecessarily, a scratch GIMPLE_COND
518 is available to use/clobber in DUMMY_COND.
520 Use SIMPLIFY (a pointer to a callback function) to further simplify
521 a condition using pass specific information.
523 Return the simplified condition or NULL if simplification could
527 simplify_control_stmt_condition (edge e
,
530 tree (*simplify
) (gimple
, gimple
),
531 bool handle_dominating_asserts
)
533 tree cond
, cached_lhs
;
534 enum gimple_code code
= gimple_code (stmt
);
536 /* For comparisons, we have to update both operands, then try
537 to simplify the comparison. */
538 if (code
== GIMPLE_COND
)
541 enum tree_code cond_code
;
543 op0
= gimple_cond_lhs (stmt
);
544 op1
= gimple_cond_rhs (stmt
);
545 cond_code
= gimple_cond_code (stmt
);
547 /* Get the current value of both operands. */
548 if (TREE_CODE (op0
) == SSA_NAME
)
550 for (int i
= 0; i
< 2; i
++)
552 if (TREE_CODE (op0
) == SSA_NAME
553 && SSA_NAME_VALUE (op0
))
554 op0
= SSA_NAME_VALUE (op0
);
560 if (TREE_CODE (op1
) == SSA_NAME
)
562 for (int i
= 0; i
< 2; i
++)
564 if (TREE_CODE (op1
) == SSA_NAME
565 && SSA_NAME_VALUE (op1
))
566 op1
= SSA_NAME_VALUE (op1
);
572 if (handle_dominating_asserts
)
574 /* Now see if the operand was consumed by an ASSERT_EXPR
575 which dominates E->src. If so, we want to replace the
576 operand with the LHS of the ASSERT_EXPR. */
577 if (TREE_CODE (op0
) == SSA_NAME
)
578 op0
= lhs_of_dominating_assert (op0
, e
->src
, stmt
);
580 if (TREE_CODE (op1
) == SSA_NAME
)
581 op1
= lhs_of_dominating_assert (op1
, e
->src
, stmt
);
584 /* We may need to canonicalize the comparison. For
585 example, op0 might be a constant while op1 is an
586 SSA_NAME. Failure to canonicalize will cause us to
587 miss threading opportunities. */
588 if (tree_swap_operands_p (op0
, op1
, false))
591 cond_code
= swap_tree_comparison (cond_code
);
597 /* Stuff the operator and operands into our dummy conditional
599 gimple_cond_set_code (dummy_cond
, cond_code
);
600 gimple_cond_set_lhs (dummy_cond
, op0
);
601 gimple_cond_set_rhs (dummy_cond
, op1
);
603 /* We absolutely do not care about any type conversions
604 we only care about a zero/nonzero value. */
605 fold_defer_overflow_warnings ();
607 cached_lhs
= fold_binary (cond_code
, boolean_type_node
, op0
, op1
);
609 while (CONVERT_EXPR_P (cached_lhs
))
610 cached_lhs
= TREE_OPERAND (cached_lhs
, 0);
612 fold_undefer_overflow_warnings ((cached_lhs
613 && is_gimple_min_invariant (cached_lhs
)),
614 stmt
, WARN_STRICT_OVERFLOW_CONDITIONAL
);
616 /* If we have not simplified the condition down to an invariant,
617 then use the pass specific callback to simplify the condition. */
619 || !is_gimple_min_invariant (cached_lhs
))
620 cached_lhs
= (*simplify
) (dummy_cond
, stmt
);
625 if (code
== GIMPLE_SWITCH
)
626 cond
= gimple_switch_index (stmt
);
627 else if (code
== GIMPLE_GOTO
)
628 cond
= gimple_goto_dest (stmt
);
632 /* We can have conditionals which just test the state of a variable
633 rather than use a relational operator. These are simpler to handle. */
634 if (TREE_CODE (cond
) == SSA_NAME
)
638 /* Get the variable's current value from the equivalence chains.
640 It is possible to get loops in the SSA_NAME_VALUE chains
641 (consider threading the backedge of a loop where we have
642 a loop invariant SSA_NAME used in the condition. */
645 for (int i
= 0; i
< 2; i
++)
647 if (TREE_CODE (cached_lhs
) == SSA_NAME
648 && SSA_NAME_VALUE (cached_lhs
))
649 cached_lhs
= SSA_NAME_VALUE (cached_lhs
);
655 /* If we're dominated by a suitable ASSERT_EXPR, then
656 update CACHED_LHS appropriately. */
657 if (handle_dominating_asserts
&& TREE_CODE (cached_lhs
) == SSA_NAME
)
658 cached_lhs
= lhs_of_dominating_assert (cached_lhs
, e
->src
, stmt
);
660 /* If we haven't simplified to an invariant yet, then use the
661 pass specific callback to try and simplify it further. */
662 if (cached_lhs
&& ! is_gimple_min_invariant (cached_lhs
))
663 cached_lhs
= (*simplify
) (stmt
, stmt
);
671 /* Copy debug stmts from DEST's chain of single predecessors up to
672 SRC, so that we don't lose the bindings as PHI nodes are introduced
673 when DEST gains new predecessors. */
675 propagate_threaded_block_debug_into (basic_block dest
, basic_block src
)
677 if (!MAY_HAVE_DEBUG_STMTS
)
680 if (!single_pred_p (dest
))
683 gcc_checking_assert (dest
!= src
);
685 gimple_stmt_iterator gsi
= gsi_after_labels (dest
);
687 const int alloc_count
= 16; // ?? Should this be a PARAM?
689 /* Estimate the number of debug vars overridden in the beginning of
690 DEST, to tell how many we're going to need to begin with. */
691 for (gimple_stmt_iterator si
= gsi
;
692 i
* 4 <= alloc_count
* 3 && !gsi_end_p (si
); gsi_next (&si
))
694 gimple stmt
= gsi_stmt (si
);
695 if (!is_gimple_debug (stmt
))
700 auto_vec
<tree
, alloc_count
> fewvars
;
701 hash_set
<tree
> *vars
= NULL
;
703 /* If we're already starting with 3/4 of alloc_count, go for a
704 hash_set, otherwise start with an unordered stack-allocated
706 if (i
* 4 > alloc_count
* 3)
707 vars
= new hash_set
<tree
>;
709 /* Now go through the initial debug stmts in DEST again, this time
710 actually inserting in VARS or FEWVARS. Don't bother checking for
711 duplicates in FEWVARS. */
712 for (gimple_stmt_iterator si
= gsi
; !gsi_end_p (si
); gsi_next (&si
))
714 gimple stmt
= gsi_stmt (si
);
715 if (!is_gimple_debug (stmt
))
720 if (gimple_debug_bind_p (stmt
))
721 var
= gimple_debug_bind_get_var (stmt
);
722 else if (gimple_debug_source_bind_p (stmt
))
723 var
= gimple_debug_source_bind_get_var (stmt
);
730 fewvars
.quick_push (var
);
733 basic_block bb
= dest
;
737 bb
= single_pred (bb
);
738 for (gimple_stmt_iterator si
= gsi_last_bb (bb
);
739 !gsi_end_p (si
); gsi_prev (&si
))
741 gimple stmt
= gsi_stmt (si
);
742 if (!is_gimple_debug (stmt
))
747 if (gimple_debug_bind_p (stmt
))
748 var
= gimple_debug_bind_get_var (stmt
);
749 else if (gimple_debug_source_bind_p (stmt
))
750 var
= gimple_debug_source_bind_get_var (stmt
);
754 /* Discard debug bind overlaps. ??? Unlike stmts from src,
755 copied into a new block that will precede BB, debug bind
756 stmts in bypassed BBs may actually be discarded if
757 they're overwritten by subsequent debug bind stmts, which
758 might be a problem once we introduce stmt frontier notes
759 or somesuch. Adding `&& bb == src' to the condition
760 below will preserve all potentially relevant debug
762 if (vars
&& vars
->add (var
))
766 int i
= fewvars
.length ();
768 if (fewvars
[i
] == var
)
773 if (fewvars
.length () < (unsigned) alloc_count
)
774 fewvars
.quick_push (var
);
777 vars
= new hash_set
<tree
>;
778 for (i
= 0; i
< alloc_count
; i
++)
779 vars
->add (fewvars
[i
]);
785 stmt
= gimple_copy (stmt
);
786 /* ??? Should we drop the location of the copy to denote
787 they're artificial bindings? */
788 gsi_insert_before (&gsi
, stmt
, GSI_NEW_STMT
);
791 while (bb
!= src
&& single_pred_p (bb
));
795 else if (fewvars
.exists ())
799 /* See if TAKEN_EDGE->dest is a threadable block with no side effecs (ie, it
800 need not be duplicated as part of the CFG/SSA updating process).
802 If it is threadable, add it to PATH and VISITED and recurse, ultimately
803 returning TRUE from the toplevel call. Otherwise do nothing and
806 DUMMY_COND, HANDLE_DOMINATING_ASSERTS and SIMPLIFY are used to
807 try and simplify the condition at the end of TAKEN_EDGE->dest. */
809 thread_around_empty_blocks (edge taken_edge
,
811 bool handle_dominating_asserts
,
812 tree (*simplify
) (gimple
, gimple
),
814 vec
<jump_thread_edge
*> *path
,
815 bool *backedge_seen_p
)
817 basic_block bb
= taken_edge
->dest
;
818 gimple_stmt_iterator gsi
;
822 /* The key property of these blocks is that they need not be duplicated
823 when threading. Thus they can not have visible side effects such
825 if (!gsi_end_p (gsi_start_phis (bb
)))
828 /* Skip over DEBUG statements at the start of the block. */
829 gsi
= gsi_start_nondebug_bb (bb
);
831 /* If the block has no statements, but does have a single successor, then
832 it's just a forwarding block and we can thread through it trivially.
834 However, note that just threading through empty blocks with single
835 successors is not inherently profitable. For the jump thread to
836 be profitable, we must avoid a runtime conditional.
838 By taking the return value from the recursive call, we get the
839 desired effect of returning TRUE when we found a profitable jump
840 threading opportunity and FALSE otherwise.
842 This is particularly important when this routine is called after
843 processing a joiner block. Returning TRUE too aggressively in
844 that case results in pointless duplication of the joiner block. */
847 if (single_succ_p (bb
))
849 taken_edge
= single_succ_edge (bb
);
850 if (!bitmap_bit_p (visited
, taken_edge
->dest
->index
))
853 = new jump_thread_edge (taken_edge
, EDGE_NO_COPY_SRC_BLOCK
);
855 bitmap_set_bit (visited
, taken_edge
->dest
->index
);
856 *backedge_seen_p
|= ((taken_edge
->flags
& EDGE_DFS_BACK
) != 0);
857 if (*backedge_seen_p
)
858 simplify
= dummy_simplify
;
859 return thread_around_empty_blocks (taken_edge
,
861 handle_dominating_asserts
,
869 /* We have a block with no statements, but multiple successors? */
873 /* The only real statements this block can have are a control
874 flow altering statement. Anything else stops the thread. */
875 stmt
= gsi_stmt (gsi
);
876 if (gimple_code (stmt
) != GIMPLE_COND
877 && gimple_code (stmt
) != GIMPLE_GOTO
878 && gimple_code (stmt
) != GIMPLE_SWITCH
)
881 /* If we have traversed a backedge, then we do not want to look
882 at certain expressions in the table that can not be relied upon.
883 Luckily the only code that looked at those expressions is the
884 SIMPLIFY callback, which we replace if we can no longer use it. */
885 if (*backedge_seen_p
)
886 simplify
= dummy_simplify
;
888 /* Extract and simplify the condition. */
889 cond
= simplify_control_stmt_condition (taken_edge
, stmt
, dummy_cond
,
890 simplify
, handle_dominating_asserts
);
892 /* If the condition can be statically computed and we have not already
893 visited the destination edge, then add the taken edge to our thread
895 if (cond
&& is_gimple_min_invariant (cond
))
897 taken_edge
= find_taken_edge (bb
, cond
);
899 if (bitmap_bit_p (visited
, taken_edge
->dest
->index
))
901 bitmap_set_bit (visited
, taken_edge
->dest
->index
);
904 = new jump_thread_edge (taken_edge
, EDGE_NO_COPY_SRC_BLOCK
);
906 *backedge_seen_p
|= ((taken_edge
->flags
& EDGE_DFS_BACK
) != 0);
907 if (*backedge_seen_p
)
908 simplify
= dummy_simplify
;
910 thread_around_empty_blocks (taken_edge
,
912 handle_dominating_asserts
,
923 /* We are exiting E->src, see if E->dest ends with a conditional
924 jump which has a known value when reached via E.
926 E->dest can have arbitrary side effects which, if threading is
927 successful, will be maintained.
929 Special care is necessary if E is a back edge in the CFG as we
930 may have already recorded equivalences for E->dest into our
931 various tables, including the result of the conditional at
932 the end of E->dest. Threading opportunities are severely
933 limited in that case to avoid short-circuiting the loop
936 DUMMY_COND is a shared cond_expr used by condition simplification as scratch,
937 to avoid allocating memory.
939 HANDLE_DOMINATING_ASSERTS is true if we should try to replace operands of
940 the simplified condition with left-hand sides of ASSERT_EXPRs they are
943 STACK is used to undo temporary equivalences created during the walk of
946 SIMPLIFY is a pass-specific function used to simplify statements.
948 Our caller is responsible for restoring the state of the expression
949 and const_and_copies stacks.
951 Positive return value is success. Zero return value is failure, but
952 the block can still be duplicated as a joiner in a jump thread path,
953 negative indicates the block should not be duplicated and thus is not
954 suitable for a joiner in a jump threading path. */
957 thread_through_normal_block (edge e
,
959 bool handle_dominating_asserts
,
961 tree (*simplify
) (gimple
, gimple
),
962 vec
<jump_thread_edge
*> *path
,
964 bool *backedge_seen_p
)
966 /* If we have traversed a backedge, then we do not want to look
967 at certain expressions in the table that can not be relied upon.
968 Luckily the only code that looked at those expressions is the
969 SIMPLIFY callback, which we replace if we can no longer use it. */
970 if (*backedge_seen_p
)
971 simplify
= dummy_simplify
;
973 /* PHIs create temporary equivalences.
974 Note that if we found a PHI that made the block non-threadable, then
975 we need to bubble that up to our caller in the same manner we do
976 when we prematurely stop processing statements below. */
977 if (!record_temporary_equivalences_from_phis (e
, stack
))
980 /* Now walk each statement recording any context sensitive
981 temporary equivalences we can detect. */
983 = record_temporary_equivalences_from_stmts_at_dest (e
, stack
, simplify
,
986 /* If we didn't look at all the statements, the most likely reason is
987 there were too many and thus duplicating this block is not profitable.
989 Also note if we do not look at all the statements, then we may not
990 have invalidated equivalences that are no longer valid if we threaded
991 around a loop. Thus we must signal to our caller that this block
992 is not suitable for use as a joiner in a threading path. */
996 /* If we stopped at a COND_EXPR or SWITCH_EXPR, see if we know which arm
998 if (gimple_code (stmt
) == GIMPLE_COND
999 || gimple_code (stmt
) == GIMPLE_GOTO
1000 || gimple_code (stmt
) == GIMPLE_SWITCH
)
1004 /* Extract and simplify the condition. */
1005 cond
= simplify_control_stmt_condition (e
, stmt
, dummy_cond
, simplify
,
1006 handle_dominating_asserts
);
1008 if (cond
&& is_gimple_min_invariant (cond
))
1010 edge taken_edge
= find_taken_edge (e
->dest
, cond
);
1011 basic_block dest
= (taken_edge
? taken_edge
->dest
: NULL
);
1013 /* DEST could be NULL for a computed jump to an absolute
1017 || bitmap_bit_p (visited
, dest
->index
))
1020 /* Only push the EDGE_START_JUMP_THREAD marker if this is
1021 first edge on the path. */
1022 if (path
->length () == 0)
1025 = new jump_thread_edge (e
, EDGE_START_JUMP_THREAD
);
1026 path
->safe_push (x
);
1027 *backedge_seen_p
|= ((e
->flags
& EDGE_DFS_BACK
) != 0);
1031 = new jump_thread_edge (taken_edge
, EDGE_COPY_SRC_BLOCK
);
1032 path
->safe_push (x
);
1033 *backedge_seen_p
|= ((taken_edge
->flags
& EDGE_DFS_BACK
) != 0);
1034 if (*backedge_seen_p
)
1035 simplify
= dummy_simplify
;
1037 /* See if we can thread through DEST as well, this helps capture
1038 secondary effects of threading without having to re-run DOM or
1041 We don't want to thread back to a block we have already
1042 visited. This may be overly conservative. */
1043 bitmap_set_bit (visited
, dest
->index
);
1044 bitmap_set_bit (visited
, e
->dest
->index
);
1045 thread_around_empty_blocks (taken_edge
,
1047 handle_dominating_asserts
,
1058 /* We are exiting E->src, see if E->dest ends with a conditional
1059 jump which has a known value when reached via E.
1061 Special care is necessary if E is a back edge in the CFG as we
1062 may have already recorded equivalences for E->dest into our
1063 various tables, including the result of the conditional at
1064 the end of E->dest. Threading opportunities are severely
1065 limited in that case to avoid short-circuiting the loop
1068 Note it is quite common for the first block inside a loop to
1069 end with a conditional which is either always true or always
1070 false when reached via the loop backedge. Thus we do not want
1071 to blindly disable threading across a loop backedge.
1073 DUMMY_COND is a shared cond_expr used by condition simplification as scratch,
1074 to avoid allocating memory.
1076 HANDLE_DOMINATING_ASSERTS is true if we should try to replace operands of
1077 the simplified condition with left-hand sides of ASSERT_EXPRs they are
1080 STACK is used to undo temporary equivalences created during the walk of
1083 SIMPLIFY is a pass-specific function used to simplify statements. */
1086 thread_across_edge (gimple dummy_cond
,
1088 bool handle_dominating_asserts
,
1090 tree (*simplify
) (gimple
, gimple
))
1092 bitmap visited
= BITMAP_ALLOC (NULL
);
1097 vec
<jump_thread_edge
*> *path
= new vec
<jump_thread_edge
*> ();
1098 bitmap_clear (visited
);
1099 bitmap_set_bit (visited
, e
->src
->index
);
1100 bitmap_set_bit (visited
, e
->dest
->index
);
1101 backedge_seen
= ((e
->flags
& EDGE_DFS_BACK
) != 0);
1103 simplify
= dummy_simplify
;
1105 int threaded
= thread_through_normal_block (e
, dummy_cond
,
1106 handle_dominating_asserts
,
1107 stack
, simplify
, path
,
1108 visited
, &backedge_seen
);
1111 propagate_threaded_block_debug_into (path
->last ()->e
->dest
,
1113 remove_temporary_equivalences (stack
);
1114 BITMAP_FREE (visited
);
1115 register_jump_thread (path
);
1120 /* Negative and zero return values indicate no threading was possible,
1121 thus there should be no edges on the thread path and no need to walk
1122 through the vector entries. */
1123 gcc_assert (path
->length () == 0);
1126 /* A negative status indicates the target block was deemed too big to
1127 duplicate. Just quit now rather than trying to use the block as
1128 a joiner in a jump threading path.
1130 This prevents unnecessary code growth, but more importantly if we
1131 do not look at all the statements in the block, then we may have
1132 missed some invalidations if we had traversed a backedge! */
1135 BITMAP_FREE (visited
);
1136 remove_temporary_equivalences (stack
);
1141 /* We were unable to determine what out edge from E->dest is taken. However,
1142 we might still be able to thread through successors of E->dest. This
1143 often occurs when E->dest is a joiner block which then fans back out
1144 based on redundant tests.
1146 If so, we'll copy E->dest and redirect the appropriate predecessor to
1147 the copy. Within the copy of E->dest, we'll thread one or more edges
1148 to points deeper in the CFG.
1150 This is a stopgap until we have a more structured approach to path
1157 /* If E->dest has abnormal outgoing edges, then there's no guarantee
1158 we can safely redirect any of the edges. Just punt those cases. */
1159 FOR_EACH_EDGE (taken_edge
, ei
, e
->dest
->succs
)
1160 if (taken_edge
->flags
& EDGE_ABNORMAL
)
1162 remove_temporary_equivalences (stack
);
1163 BITMAP_FREE (visited
);
1167 /* Look at each successor of E->dest to see if we can thread through it. */
1168 FOR_EACH_EDGE (taken_edge
, ei
, e
->dest
->succs
)
1170 /* Push a fresh marker so we can unwind the equivalences created
1171 for each of E->dest's successors. */
1172 stack
->safe_push (NULL_TREE
);
1174 /* Avoid threading to any block we have already visited. */
1175 bitmap_clear (visited
);
1176 bitmap_set_bit (visited
, e
->src
->index
);
1177 bitmap_set_bit (visited
, e
->dest
->index
);
1178 bitmap_set_bit (visited
, taken_edge
->dest
->index
);
1179 vec
<jump_thread_edge
*> *path
= new vec
<jump_thread_edge
*> ();
1181 /* Record whether or not we were able to thread through a successor
1183 jump_thread_edge
*x
= new jump_thread_edge (e
, EDGE_START_JUMP_THREAD
);
1184 path
->safe_push (x
);
1186 x
= new jump_thread_edge (taken_edge
, EDGE_COPY_SRC_JOINER_BLOCK
);
1187 path
->safe_push (x
);
1189 backedge_seen
= ((e
->flags
& EDGE_DFS_BACK
) != 0);
1190 backedge_seen
|= ((taken_edge
->flags
& EDGE_DFS_BACK
) != 0);
1192 simplify
= dummy_simplify
;
1193 found
= thread_around_empty_blocks (taken_edge
,
1195 handle_dominating_asserts
,
1202 simplify
= dummy_simplify
;
1205 found
= thread_through_normal_block (path
->last ()->e
, dummy_cond
,
1206 handle_dominating_asserts
,
1207 stack
, simplify
, path
, visited
,
1208 &backedge_seen
) > 0;
1210 /* If we were able to thread through a successor of E->dest, then
1211 record the jump threading opportunity. */
1214 propagate_threaded_block_debug_into (path
->last ()->e
->dest
,
1216 register_jump_thread (path
);
1220 delete_jump_thread_path (path
);
1223 /* And unwind the equivalence table. */
1224 remove_temporary_equivalences (stack
);
1226 BITMAP_FREE (visited
);
1229 remove_temporary_equivalences (stack
);