2 Copyright (C) 2005, 2006, 2007, 2008, 2009 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"
30 #include "basic-block.h"
35 #include "diagnostic.h"
37 #include "tree-dump.h"
38 #include "tree-flow.h"
40 #include "tree-pass.h"
41 #include "tree-ssa-propagate.h"
42 #include "langhooks.h"
45 /* To avoid code explosion due to jump threading, we limit the
46 number of statements we are going to copy. This variable
47 holds the number of statements currently seen that we'll have
48 to copy as part of the jump threading process. */
49 static int stmt_count
;
51 /* Array to record value-handles per SSA_NAME. */
52 VEC(tree
,heap
) *ssa_name_values
;
54 /* Set the value for the SSA name NAME to VALUE. */
57 set_ssa_name_value (tree name
, tree value
)
59 if (SSA_NAME_VERSION (name
) >= VEC_length (tree
, ssa_name_values
))
60 VEC_safe_grow_cleared (tree
, heap
, ssa_name_values
,
61 SSA_NAME_VERSION (name
) + 1);
62 VEC_replace (tree
, ssa_name_values
, SSA_NAME_VERSION (name
), value
);
65 /* Initialize the per SSA_NAME value-handles array. Returns it. */
67 threadedge_initialize_values (void)
69 gcc_assert (ssa_name_values
== NULL
);
70 ssa_name_values
= VEC_alloc(tree
, heap
, num_ssa_names
);
73 /* Free the per SSA_NAME value-handle array. */
75 threadedge_finalize_values (void)
77 VEC_free(tree
, heap
, ssa_name_values
);
80 /* Return TRUE if we may be able to thread an incoming edge into
81 BB to an outgoing edge from BB. Return FALSE otherwise. */
84 potentially_threadable_block (basic_block bb
)
86 gimple_stmt_iterator gsi
;
88 /* If BB has a single successor or a single predecessor, then
89 there is no threading opportunity. */
90 if (single_succ_p (bb
) || single_pred_p (bb
))
93 /* If BB does not end with a conditional, switch or computed goto,
94 then there is no threading opportunity. */
95 gsi
= gsi_last_bb (bb
);
98 || (gimple_code (gsi_stmt (gsi
)) != GIMPLE_COND
99 && gimple_code (gsi_stmt (gsi
)) != GIMPLE_GOTO
100 && gimple_code (gsi_stmt (gsi
)) != GIMPLE_SWITCH
))
106 /* Return the LHS of any ASSERT_EXPR where OP appears as the first
107 argument to the ASSERT_EXPR and in which the ASSERT_EXPR dominates
108 BB. If no such ASSERT_EXPR is found, return OP. */
111 lhs_of_dominating_assert (tree op
, basic_block bb
, gimple stmt
)
113 imm_use_iterator imm_iter
;
117 FOR_EACH_IMM_USE_FAST (use_p
, imm_iter
, op
)
119 use_stmt
= USE_STMT (use_p
);
121 && gimple_assign_single_p (use_stmt
)
122 && TREE_CODE (gimple_assign_rhs1 (use_stmt
)) == ASSERT_EXPR
123 && TREE_OPERAND (gimple_assign_rhs1 (use_stmt
), 0) == op
124 && dominated_by_p (CDI_DOMINATORS
, bb
, gimple_bb (use_stmt
)))
126 return gimple_assign_lhs (use_stmt
);
132 /* We record temporary equivalences created by PHI nodes or
133 statements within the target block. Doing so allows us to
134 identify more jump threading opportunities, even in blocks
137 We keep track of those temporary equivalences in a stack
138 structure so that we can unwind them when we're done processing
139 a particular edge. This routine handles unwinding the data
143 remove_temporary_equivalences (VEC(tree
, heap
) **stack
)
145 while (VEC_length (tree
, *stack
) > 0)
147 tree prev_value
, dest
;
149 dest
= VEC_pop (tree
, *stack
);
151 /* A NULL value indicates we should stop unwinding, otherwise
152 pop off the next entry as they're recorded in pairs. */
156 prev_value
= VEC_pop (tree
, *stack
);
157 set_ssa_name_value (dest
, prev_value
);
161 /* Record a temporary equivalence, saving enough information so that
162 we can restore the state of recorded equivalences when we're
163 done processing the current edge. */
166 record_temporary_equivalence (tree x
, tree y
, VEC(tree
, heap
) **stack
)
168 tree prev_x
= SSA_NAME_VALUE (x
);
170 if (TREE_CODE (y
) == SSA_NAME
)
172 tree tmp
= SSA_NAME_VALUE (y
);
176 set_ssa_name_value (x
, y
);
177 VEC_reserve (tree
, heap
, *stack
, 2);
178 VEC_quick_push (tree
, *stack
, prev_x
);
179 VEC_quick_push (tree
, *stack
, x
);
182 /* Record temporary equivalences created by PHIs at the target of the
183 edge E. Record unwind information for the equivalences onto STACK.
185 If a PHI which prevents threading is encountered, then return FALSE
186 indicating we should not thread this edge, else return TRUE. */
189 record_temporary_equivalences_from_phis (edge e
, VEC(tree
, heap
) **stack
)
191 gimple_stmt_iterator gsi
;
193 /* Each PHI creates a temporary equivalence, record them.
194 These are context sensitive equivalences and will be removed
196 for (gsi
= gsi_start_phis (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
198 gimple phi
= gsi_stmt (gsi
);
199 tree src
= PHI_ARG_DEF_FROM_EDGE (phi
, e
);
200 tree dst
= gimple_phi_result (phi
);
202 /* If the desired argument is not the same as this PHI's result
203 and it is set by a PHI in E->dest, then we can not thread
206 && TREE_CODE (src
) == SSA_NAME
207 && gimple_code (SSA_NAME_DEF_STMT (src
)) == GIMPLE_PHI
208 && gimple_bb (SSA_NAME_DEF_STMT (src
)) == e
->dest
)
211 /* We consider any non-virtual PHI as a statement since it
212 count result in a constant assignment or copy operation. */
213 if (is_gimple_reg (dst
))
216 record_temporary_equivalence (dst
, src
, stack
);
221 /* Fold the RHS of an assignment statement and return it as a tree.
222 May return NULL_TREE if no simplification is possible. */
225 fold_assignment_stmt (gimple stmt
)
227 enum tree_code subcode
= gimple_assign_rhs_code (stmt
);
229 switch (get_gimple_rhs_class (subcode
))
231 case GIMPLE_SINGLE_RHS
:
233 tree rhs
= gimple_assign_rhs1 (stmt
);
235 if (TREE_CODE (rhs
) == COND_EXPR
)
237 /* Sadly, we have to handle conditional assignments specially
238 here, because fold expects all the operands of an expression
239 to be folded before the expression itself is folded, but we
240 can't just substitute the folded condition here. */
241 tree cond
= fold (COND_EXPR_COND (rhs
));
242 if (cond
== boolean_true_node
)
243 rhs
= COND_EXPR_THEN (rhs
);
244 else if (cond
== boolean_false_node
)
245 rhs
= COND_EXPR_ELSE (rhs
);
251 case GIMPLE_UNARY_RHS
:
253 tree lhs
= gimple_assign_lhs (stmt
);
254 tree op0
= gimple_assign_rhs1 (stmt
);
255 return fold_unary (subcode
, TREE_TYPE (lhs
), op0
);
258 case GIMPLE_BINARY_RHS
:
260 tree lhs
= gimple_assign_lhs (stmt
);
261 tree op0
= gimple_assign_rhs1 (stmt
);
262 tree op1
= gimple_assign_rhs2 (stmt
);
263 return fold_binary (subcode
, TREE_TYPE (lhs
), op0
, op1
);
271 /* Try to simplify each statement in E->dest, ultimately leading to
272 a simplification of the COND_EXPR at the end of E->dest.
274 Record unwind information for temporary equivalences onto STACK.
276 Use SIMPLIFY (a pointer to a callback function) to further simplify
277 statements using pass specific information.
279 We might consider marking just those statements which ultimately
280 feed the COND_EXPR. It's not clear if the overhead of bookkeeping
281 would be recovered by trying to simplify fewer statements.
283 If we are able to simplify a statement into the form
284 SSA_NAME = (SSA_NAME | gimple invariant), then we can record
285 a context sensitive equivalence which may help us simplify
286 later statements in E->dest. */
289 record_temporary_equivalences_from_stmts_at_dest (edge e
,
290 VEC(tree
, heap
) **stack
,
291 tree (*simplify
) (gimple
,
295 gimple_stmt_iterator gsi
;
298 max_stmt_count
= PARAM_VALUE (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS
);
300 /* Walk through each statement in the block recording equivalences
301 we discover. Note any equivalences we discover are context
302 sensitive (ie, are dependent on traversing E) and must be unwound
303 when we're finished processing E. */
304 for (gsi
= gsi_start_bb (e
->dest
); !gsi_end_p (gsi
); gsi_next (&gsi
))
306 tree cached_lhs
= NULL
;
308 stmt
= gsi_stmt (gsi
);
310 /* Ignore empty statements and labels. */
311 if (gimple_code (stmt
) == GIMPLE_NOP
|| gimple_code (stmt
) == GIMPLE_LABEL
)
314 /* If the statement has volatile operands, then we assume we
315 can not thread through this block. This is overly
316 conservative in some ways. */
317 if (gimple_code (stmt
) == GIMPLE_ASM
&& gimple_asm_volatile_p (stmt
))
320 /* If duplicating this block is going to cause too much code
321 expansion, then do not thread through this block. */
323 if (stmt_count
> max_stmt_count
)
326 /* If this is not a statement that sets an SSA_NAME to a new
327 value, then do not try to simplify this statement as it will
328 not simplify in any way that is helpful for jump threading. */
329 if ((gimple_code (stmt
) != GIMPLE_ASSIGN
330 || TREE_CODE (gimple_assign_lhs (stmt
)) != SSA_NAME
)
331 && (gimple_code (stmt
) != GIMPLE_CALL
332 || gimple_call_lhs (stmt
) == NULL_TREE
333 || TREE_CODE (gimple_call_lhs (stmt
)) != SSA_NAME
))
336 /* The result of __builtin_object_size depends on all the arguments
337 of a phi node. Temporarily using only one edge produces invalid
346 r = PHI <&w[2].a[1](2), &a.a[6](3)>
347 __builtin_object_size (r, 0)
349 The result of __builtin_object_size is defined to be the maximum of
350 remaining bytes. If we use only one edge on the phi, the result will
351 change to be the remaining bytes for the corresponding phi argument.
353 Similarly for __builtin_constant_p:
356 __builtin_constant_p (r)
358 Both PHI arguments are constant, but x ? 1 : 2 is still not
361 if (is_gimple_call (stmt
))
363 tree fndecl
= gimple_call_fndecl (stmt
);
365 && (DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_OBJECT_SIZE
366 || DECL_FUNCTION_CODE (fndecl
) == BUILT_IN_CONSTANT_P
))
370 /* At this point we have a statement which assigns an RHS to an
371 SSA_VAR on the LHS. We want to try and simplify this statement
372 to expose more context sensitive equivalences which in turn may
373 allow us to simplify the condition at the end of the loop.
375 Handle simple copy operations as well as implied copies from
377 if (gimple_assign_single_p (stmt
)
378 && TREE_CODE (gimple_assign_rhs1 (stmt
)) == SSA_NAME
)
379 cached_lhs
= gimple_assign_rhs1 (stmt
);
380 else if (gimple_assign_single_p (stmt
)
381 && TREE_CODE (gimple_assign_rhs1 (stmt
)) == ASSERT_EXPR
)
382 cached_lhs
= TREE_OPERAND (gimple_assign_rhs1 (stmt
), 0);
385 /* A statement that is not a trivial copy or ASSERT_EXPR.
386 We're going to temporarily copy propagate the operands
387 and see if that allows us to simplify this statement. */
391 unsigned int num
, i
= 0;
393 num
= NUM_SSA_OPERANDS (stmt
, (SSA_OP_USE
| SSA_OP_VUSE
));
394 copy
= XCNEWVEC (tree
, num
);
396 /* Make a copy of the uses & vuses into USES_COPY, then cprop into
398 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
| SSA_OP_VUSE
)
401 tree use
= USE_FROM_PTR (use_p
);
404 if (TREE_CODE (use
) == SSA_NAME
)
405 tmp
= SSA_NAME_VALUE (use
);
407 SET_USE (use_p
, tmp
);
410 /* Try to fold/lookup the new expression. Inserting the
411 expression into the hash table is unlikely to help. */
412 if (is_gimple_call (stmt
))
413 cached_lhs
= fold_call_stmt (stmt
, false);
415 cached_lhs
= fold_assignment_stmt (stmt
);
418 || (TREE_CODE (cached_lhs
) != SSA_NAME
419 && !is_gimple_min_invariant (cached_lhs
)))
420 cached_lhs
= (*simplify
) (stmt
, stmt
);
422 /* Restore the statement's original uses/defs. */
424 FOR_EACH_SSA_USE_OPERAND (use_p
, stmt
, iter
, SSA_OP_USE
| SSA_OP_VUSE
)
425 SET_USE (use_p
, copy
[i
++]);
430 /* Record the context sensitive equivalence if we were able
431 to simplify this statement. */
433 && (TREE_CODE (cached_lhs
) == SSA_NAME
434 || is_gimple_min_invariant (cached_lhs
)))
435 record_temporary_equivalence (gimple_get_lhs (stmt
), cached_lhs
, stack
);
440 /* Simplify the control statement at the end of the block E->dest.
442 To avoid allocating memory unnecessarily, a scratch GIMPLE_COND
443 is available to use/clobber in DUMMY_COND.
445 Use SIMPLIFY (a pointer to a callback function) to further simplify
446 a condition using pass specific information.
448 Return the simplified condition or NULL if simplification could
452 simplify_control_stmt_condition (edge e
,
455 tree (*simplify
) (gimple
, gimple
),
456 bool handle_dominating_asserts
)
458 tree cond
, cached_lhs
;
459 enum gimple_code code
= gimple_code (stmt
);
461 /* For comparisons, we have to update both operands, then try
462 to simplify the comparison. */
463 if (code
== GIMPLE_COND
)
466 enum tree_code cond_code
;
468 op0
= gimple_cond_lhs (stmt
);
469 op1
= gimple_cond_rhs (stmt
);
470 cond_code
= gimple_cond_code (stmt
);
472 /* Get the current value of both operands. */
473 if (TREE_CODE (op0
) == SSA_NAME
)
475 tree tmp
= SSA_NAME_VALUE (op0
);
480 if (TREE_CODE (op1
) == SSA_NAME
)
482 tree tmp
= SSA_NAME_VALUE (op1
);
487 if (handle_dominating_asserts
)
489 /* Now see if the operand was consumed by an ASSERT_EXPR
490 which dominates E->src. If so, we want to replace the
491 operand with the LHS of the ASSERT_EXPR. */
492 if (TREE_CODE (op0
) == SSA_NAME
)
493 op0
= lhs_of_dominating_assert (op0
, e
->src
, stmt
);
495 if (TREE_CODE (op1
) == SSA_NAME
)
496 op1
= lhs_of_dominating_assert (op1
, e
->src
, stmt
);
499 /* We may need to canonicalize the comparison. For
500 example, op0 might be a constant while op1 is an
501 SSA_NAME. Failure to canonicalize will cause us to
502 miss threading opportunities. */
503 if (tree_swap_operands_p (op0
, op1
, false))
506 cond_code
= swap_tree_comparison (cond_code
);
512 /* Stuff the operator and operands into our dummy conditional
514 gimple_cond_set_code (dummy_cond
, cond_code
);
515 gimple_cond_set_lhs (dummy_cond
, op0
);
516 gimple_cond_set_rhs (dummy_cond
, op1
);
518 /* We absolutely do not care about any type conversions
519 we only care about a zero/nonzero value. */
520 fold_defer_overflow_warnings ();
522 cached_lhs
= fold_binary (cond_code
, boolean_type_node
, op0
, op1
);
524 while (CONVERT_EXPR_P (cached_lhs
))
525 cached_lhs
= TREE_OPERAND (cached_lhs
, 0);
527 fold_undefer_overflow_warnings ((cached_lhs
528 && is_gimple_min_invariant (cached_lhs
)),
529 stmt
, WARN_STRICT_OVERFLOW_CONDITIONAL
);
531 /* If we have not simplified the condition down to an invariant,
532 then use the pass specific callback to simplify the condition. */
534 || !is_gimple_min_invariant (cached_lhs
))
535 cached_lhs
= (*simplify
) (dummy_cond
, stmt
);
540 if (code
== GIMPLE_SWITCH
)
541 cond
= gimple_switch_index (stmt
);
542 else if (code
== GIMPLE_GOTO
)
543 cond
= gimple_goto_dest (stmt
);
547 /* We can have conditionals which just test the state of a variable
548 rather than use a relational operator. These are simpler to handle. */
549 if (TREE_CODE (cond
) == SSA_NAME
)
553 /* Get the variable's current value from the equivalence chains.
555 It is possible to get loops in the SSA_NAME_VALUE chains
556 (consider threading the backedge of a loop where we have
557 a loop invariant SSA_NAME used in the condition. */
559 && TREE_CODE (cached_lhs
) == SSA_NAME
560 && SSA_NAME_VALUE (cached_lhs
))
561 cached_lhs
= SSA_NAME_VALUE (cached_lhs
);
563 /* If we're dominated by a suitable ASSERT_EXPR, then
564 update CACHED_LHS appropriately. */
565 if (handle_dominating_asserts
&& TREE_CODE (cached_lhs
) == SSA_NAME
)
566 cached_lhs
= lhs_of_dominating_assert (cached_lhs
, e
->src
, stmt
);
568 /* If we haven't simplified to an invariant yet, then use the
569 pass specific callback to try and simplify it further. */
570 if (cached_lhs
&& ! is_gimple_min_invariant (cached_lhs
))
571 cached_lhs
= (*simplify
) (stmt
, stmt
);
579 /* We are exiting E->src, see if E->dest ends with a conditional
580 jump which has a known value when reached via E.
582 Special care is necessary if E is a back edge in the CFG as we
583 may have already recorded equivalences for E->dest into our
584 various tables, including the result of the conditional at
585 the end of E->dest. Threading opportunities are severely
586 limited in that case to avoid short-circuiting the loop
589 Note it is quite common for the first block inside a loop to
590 end with a conditional which is either always true or always
591 false when reached via the loop backedge. Thus we do not want
592 to blindly disable threading across a loop backedge.
594 DUMMY_COND is a shared cond_expr used by condition simplification as scratch,
595 to avoid allocating memory.
597 HANDLE_DOMINATING_ASSERTS is true if we should try to replace operands of
598 the simplified condition with left-hand sides of ASSERT_EXPRs they are
601 STACK is used to undo temporary equivalences created during the walk of
604 SIMPLIFY is a pass-specific function used to simplify statements. */
607 thread_across_edge (gimple dummy_cond
,
609 bool handle_dominating_asserts
,
610 VEC(tree
, heap
) **stack
,
611 tree (*simplify
) (gimple
, gimple
))
615 /* If E is a backedge, then we want to verify that the COND_EXPR,
616 SWITCH_EXPR or GOTO_EXPR at the end of e->dest is not affected
617 by any statements in e->dest. If it is affected, then it is not
618 safe to thread this edge. */
619 if (e
->flags
& EDGE_DFS_BACK
)
623 gimple last
= gsi_stmt (gsi_last_bb (e
->dest
));
625 FOR_EACH_SSA_USE_OPERAND (use_p
, last
, iter
, SSA_OP_USE
| SSA_OP_VUSE
)
627 tree use
= USE_FROM_PTR (use_p
);
629 if (TREE_CODE (use
) == SSA_NAME
630 && gimple_code (SSA_NAME_DEF_STMT (use
)) != GIMPLE_PHI
631 && gimple_bb (SSA_NAME_DEF_STMT (use
)) == e
->dest
)
638 /* PHIs create temporary equivalences. */
639 if (!record_temporary_equivalences_from_phis (e
, stack
))
642 /* Now walk each statement recording any context sensitive
643 temporary equivalences we can detect. */
644 stmt
= record_temporary_equivalences_from_stmts_at_dest (e
, stack
, simplify
);
648 /* If we stopped at a COND_EXPR or SWITCH_EXPR, see if we know which arm
650 if (gimple_code (stmt
) == GIMPLE_COND
651 || gimple_code (stmt
) == GIMPLE_GOTO
652 || gimple_code (stmt
) == GIMPLE_SWITCH
)
656 /* Extract and simplify the condition. */
657 cond
= simplify_control_stmt_condition (e
, stmt
, dummy_cond
, simplify
, handle_dominating_asserts
);
659 if (cond
&& is_gimple_min_invariant (cond
))
661 edge taken_edge
= find_taken_edge (e
->dest
, cond
);
662 basic_block dest
= (taken_edge
? taken_edge
->dest
: NULL
);
667 remove_temporary_equivalences (stack
);
668 register_jump_thread (e
, taken_edge
);
673 remove_temporary_equivalences (stack
);