1 /* Optimization of PHI nodes by converting them into straightline code.
2 Copyright (C) 2004, 2005 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
11 GCC is distributed in the hope that it will be useful, but WITHOUT
12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING. If not, write to the Free
18 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 #include "coretypes.h"
31 #include "basic-block.h"
33 #include "diagnostic.h"
34 #include "tree-flow.h"
35 #include "tree-pass.h"
36 #include "tree-dump.h"
37 #include "langhooks.h"
39 static void tree_ssa_phiopt (void);
40 static bool conditional_replacement (basic_block, basic_block, basic_block,
41 edge, edge, tree, tree, tree);
42 static bool value_replacement (basic_block, basic_block, basic_block,
43 edge, edge, tree, tree, tree);
44 static bool minmax_replacement (basic_block, basic_block, basic_block,
45 edge, edge, tree, tree, tree);
46 static bool abs_replacement (basic_block, basic_block, basic_block,
47 edge, edge, tree, tree, tree);
48 static void replace_phi_edge_with_variable (basic_block, basic_block, edge,
50 static basic_block *blocks_in_phiopt_order (void);
52 /* This pass tries to replaces an if-then-else block with an
53 assignment. We have four kinds of transformations. Some of these
54 transformations are also performed by the ifcvt RTL optimizer.
56 Conditional Replacement
57 -----------------------
59 This transformation, implmented in conditional_replacement,
63 if (cond) goto bb2; else goto bb1;
66 x = PHI <0 (bb1), 1 (bb0), ...>;
74 x = PHI <x' (bb0), ...>;
76 We remove bb1 as it becomes unreachable. This occurs often due to
77 gimplification of conditionals.
82 This transformation, implemented in value_replacement, replaces
85 if (a != b) goto bb2; else goto bb1;
88 x = PHI <a (bb1), b (bb0), ...>;
94 x = PHI <b (bb0), ...>;
96 This opportunity can sometimes occur as a result of other
102 This transformation, implemented in abs_replacement, replaces
105 if (a >= 0) goto bb2; else goto bb1;
109 x = PHI <x (bb1), a (bb0), ...>;
116 x = PHI <x' (bb0), ...>;
121 This transformation, minmax_replacement replaces
124 if (a <= b) goto bb2; else goto bb1;
127 x = PHI <b (bb1), a (bb0), ...>;
134 x = PHI <x' (bb0), ...>;
136 A similar transformtion is done for MAX_EXPR. */
139 tree_ssa_phiopt (void)
142 basic_block *bb_order;
145 /* Search every basic block for COND_EXPR we may be able to optimize.
147 We walk the blocks in order that guarantees that a block with
148 a single predecessor is processed before the predecessor.
149 This ensures that we collapse inner ifs before visiting the
150 outer ones, and also that we do not try to visit a removed
152 bb_order = blocks_in_phiopt_order ();
155 for (i = 0; i < n; i++)
159 basic_block bb1, bb2;
165 cond_expr = last_stmt (bb);
166 /* Check to see if the last statement is a COND_EXPR. */
168 || TREE_CODE (cond_expr) != COND_EXPR)
171 e1 = EDGE_SUCC (bb, 0);
173 e2 = EDGE_SUCC (bb, 1);
176 /* We cannot do the optimization on abnormal edges. */
177 if ((e1->flags & EDGE_ABNORMAL) != 0
178 || (e2->flags & EDGE_ABNORMAL) != 0)
181 /* If either bb1's succ or bb2 or bb2's succ is non NULL. */
182 if (EDGE_COUNT (bb1->succs) == 0
184 || EDGE_COUNT (bb2->succs) == 0)
187 /* Find the bb which is the fall through to the other. */
188 if (EDGE_SUCC (bb1, 0)->dest == bb2)
190 else if (EDGE_SUCC (bb2, 0)->dest == bb1)
192 basic_block bb_tmp = bb1;
202 e1 = EDGE_SUCC (bb1, 0);
204 /* Make sure that bb1 is just a fall through. */
205 if (!single_succ_p (bb1) > 1
206 || (e1->flags & EDGE_FALLTHRU) == 0)
209 /* Also make that bb1 only have one pred and it is bb. */
210 if (!single_pred_p (bb1)
211 || single_pred (bb1) != bb)
214 phi = phi_nodes (bb2);
216 /* Check to make sure that there is only one PHI node.
217 TODO: we could do it with more than one iff the other PHI nodes
218 have the same elements for these two edges. */
219 if (!phi || PHI_CHAIN (phi) != NULL)
222 arg0 = PHI_ARG_DEF_TREE (phi, e1->dest_idx);
223 arg1 = PHI_ARG_DEF_TREE (phi, e2->dest_idx);
225 /* We know something is wrong if we cannot find the edges in the PHI
227 gcc_assert (arg0 != NULL && arg1 != NULL);
229 /* Do the replacement of conditional if it can be done. */
230 if (conditional_replacement (bb, bb1, bb2, e1, e2, phi, arg0, arg1))
232 else if (value_replacement (bb, bb1, bb2, e1, e2, phi, arg0, arg1))
234 else if (abs_replacement (bb, bb1, bb2, e1, e2, phi, arg0, arg1))
237 minmax_replacement (bb, bb1, bb2, e1, e2, phi, arg0, arg1);
243 /* Returns the list of basic blocks in the function in an order that guarantees
244 that if a block X has just a single predecessor Y, then Y is after X in the
248 blocks_in_phiopt_order (void)
251 basic_block *order = xmalloc (sizeof (basic_block) * n_basic_blocks);
252 unsigned n = n_basic_blocks, np, i;
253 sbitmap visited = sbitmap_alloc (last_basic_block + 2);
255 #define MARK_VISITED(BB) (SET_BIT (visited, (BB)->index + 2))
256 #define VISITED_P(BB) (TEST_BIT (visited, (BB)->index + 2))
258 sbitmap_zero (visited);
260 MARK_VISITED (ENTRY_BLOCK_PTR);
266 /* Walk the predecessors of x as long as they have precisely one
267 predecessor and add them to the list, so that they get stored
270 single_pred_p (y) && !VISITED_P (single_pred (y));
273 for (y = x, i = n - np;
274 single_pred_p (y) && !VISITED_P (single_pred (y));
275 y = single_pred (y), i++)
283 gcc_assert (i == n - 1);
287 sbitmap_free (visited);
295 /* Return TRUE if block BB has no executable statements, otherwise return
298 empty_block_p (basic_block bb)
300 block_stmt_iterator bsi;
302 /* BB must have no executable statements. */
303 bsi = bsi_start (bb);
304 while (!bsi_end_p (bsi)
305 && (TREE_CODE (bsi_stmt (bsi)) == LABEL_EXPR
306 || IS_EMPTY_STMT (bsi_stmt (bsi))))
309 if (!bsi_end_p (bsi))
315 /* Replace PHI node element whose edge is E in block BB with variable NEW.
316 Remove the edge from COND_BLOCK which does not lead to BB (COND_BLOCK
317 is known to have two edges, one of which must reach BB). */
320 replace_phi_edge_with_variable (basic_block cond_block, basic_block bb,
321 edge e, tree phi, tree new)
323 basic_block block_to_remove;
324 block_stmt_iterator bsi;
326 /* Change the PHI argument to new. */
327 SET_USE (PHI_ARG_DEF_PTR (phi, e->dest_idx), new);
329 /* Remove the empty basic block. */
330 if (EDGE_SUCC (cond_block, 0)->dest == bb)
332 EDGE_SUCC (cond_block, 0)->flags |= EDGE_FALLTHRU;
333 EDGE_SUCC (cond_block, 0)->flags &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE);
335 block_to_remove = EDGE_SUCC (cond_block, 1)->dest;
339 EDGE_SUCC (cond_block, 1)->flags |= EDGE_FALLTHRU;
340 EDGE_SUCC (cond_block, 1)->flags
341 &= ~(EDGE_TRUE_VALUE | EDGE_FALSE_VALUE);
343 block_to_remove = EDGE_SUCC (cond_block, 0)->dest;
345 delete_basic_block (block_to_remove);
347 /* Eliminate the COND_EXPR at the end of COND_BLOCK. */
348 bsi = bsi_last (cond_block);
351 if (dump_file && (dump_flags & TDF_DETAILS))
353 "COND_EXPR in block %d and PHI in block %d converted to straightline code.\n",
358 /* The function conditional_replacement does the main work of doing the
359 conditional replacement. Return true if the replacement is done.
360 Otherwise return false.
361 BB is the basic block where the replacement is going to be done on. ARG0
362 is argument 0 from PHI. Likewise for ARG1. */
365 conditional_replacement (basic_block cond_bb, basic_block middle_bb,
366 basic_block phi_bb, edge e0, edge e1, tree phi,
367 tree arg0, tree arg1)
370 tree old_result = NULL;
372 block_stmt_iterator bsi;
373 edge true_edge, false_edge;
377 /* The PHI arguments have the constants 0 and 1, then convert
378 it to the conditional. */
379 if ((integer_zerop (arg0) && integer_onep (arg1))
380 || (integer_zerop (arg1) && integer_onep (arg0)))
385 if (!empty_block_p (middle_bb))
388 /* If the condition is not a naked SSA_NAME and its type does not
389 match the type of the result, then we have to create a new
390 variable to optimize this case as it would likely create
391 non-gimple code when the condition was converted to the
393 cond = COND_EXPR_COND (last_stmt (cond_bb));
394 result = PHI_RESULT (phi);
395 if (TREE_CODE (cond) != SSA_NAME
396 && !lang_hooks.types_compatible_p (TREE_TYPE (cond), TREE_TYPE (result)))
398 new_var = make_rename_temp (TREE_TYPE (cond), NULL);
403 /* If the condition was a naked SSA_NAME and the type is not the
404 same as the type of the result, then convert the type of the
406 if (!lang_hooks.types_compatible_p (TREE_TYPE (cond), TREE_TYPE (result)))
407 cond = fold_convert (TREE_TYPE (result), cond);
409 /* We need to know which is the true edge and which is the false
410 edge so that we know when to invert the condition below. */
411 extract_true_false_edges_from_block (cond_bb, &true_edge, &false_edge);
413 /* Insert our new statement at the end of conditional block before the
415 bsi = bsi_last (cond_bb);
416 bsi_insert_before (&bsi, build_empty_stmt (), BSI_NEW_STMT);
421 if (!COMPARISON_CLASS_P (old_result))
424 new1 = build2 (TREE_CODE (old_result), TREE_TYPE (old_result),
425 TREE_OPERAND (old_result, 0),
426 TREE_OPERAND (old_result, 1));
428 new1 = build2 (MODIFY_EXPR, TREE_TYPE (old_result), new_var, new1);
429 bsi_insert_after (&bsi, new1, BSI_NEW_STMT);
432 new_var1 = duplicate_ssa_name (PHI_RESULT (phi), NULL);
435 /* At this point we know we have a COND_EXPR with two successors.
436 One successor is BB, the other successor is an empty block which
437 falls through into BB.
439 There is a single PHI node at the join point (BB) and its arguments
440 are constants (0, 1).
442 So, given the condition COND, and the two PHI arguments, we can
443 rewrite this PHI into non-branching code:
445 dest = (COND) or dest = COND'
447 We use the condition as-is if the argument associated with the
448 true edge has the value one or the argument associated with the
449 false edge as the value zero. Note that those conditions are not
450 the same since only one of the outgoing edges from the COND_EXPR
451 will directly reach BB and thus be associated with an argument. */
452 if ((e0 == true_edge && integer_onep (arg0))
453 || (e0 == false_edge && integer_zerop (arg0))
454 || (e1 == true_edge && integer_onep (arg1))
455 || (e1 == false_edge && integer_zerop (arg1)))
457 new = build2 (MODIFY_EXPR, TREE_TYPE (new_var1), new_var1, cond);
461 tree cond1 = invert_truthvalue (cond);
464 /* If what we get back is a conditional expression, there is no
465 way that it can be gimple. */
466 if (TREE_CODE (cond) == COND_EXPR)
468 release_ssa_name (new_var1);
472 /* If what we get back is not gimple try to create it as gimple by
473 using a temporary variable. */
474 if (is_gimple_cast (cond)
475 && !is_gimple_val (TREE_OPERAND (cond, 0)))
477 tree temp = TREE_OPERAND (cond, 0);
478 tree new_var_1 = make_rename_temp (TREE_TYPE (temp), NULL);
479 new = build2 (MODIFY_EXPR, TREE_TYPE (new_var_1), new_var_1, temp);
480 bsi_insert_after (&bsi, new, BSI_NEW_STMT);
481 cond = fold_convert (TREE_TYPE (result), new_var_1);
484 if (TREE_CODE (cond) == TRUTH_NOT_EXPR
485 && !is_gimple_val (TREE_OPERAND (cond, 0)))
487 release_ssa_name (new_var1);
491 new = build2 (MODIFY_EXPR, TREE_TYPE (new_var1), new_var1, cond);
494 bsi_insert_after (&bsi, new, BSI_NEW_STMT);
496 SSA_NAME_DEF_STMT (new_var1) = new;
498 replace_phi_edge_with_variable (cond_bb, phi_bb, e1, phi, new_var1);
500 /* Note that we optimized this PHI. */
504 /* The function value_replacement does the main work of doing the value
505 replacement. Return true if the replacement is done. Otherwise return
507 BB is the basic block where the replacement is going to be done on. ARG0
508 is argument 0 from the PHI. Likewise for ARG1. */
511 value_replacement (basic_block cond_bb, basic_block middle_bb,
512 basic_block phi_bb, edge e0, edge e1, tree phi,
513 tree arg0, tree arg1)
516 edge true_edge, false_edge;
518 /* If the type says honor signed zeros we cannot do this
520 if (HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
523 if (!empty_block_p (middle_bb))
526 cond = COND_EXPR_COND (last_stmt (cond_bb));
528 /* This transformation is only valid for equality comparisons. */
529 if (TREE_CODE (cond) != NE_EXPR && TREE_CODE (cond) != EQ_EXPR)
532 /* We need to know which is the true edge and which is the false
533 edge so that we know if have abs or negative abs. */
534 extract_true_false_edges_from_block (cond_bb, &true_edge, &false_edge);
536 /* At this point we know we have a COND_EXPR with two successors.
537 One successor is BB, the other successor is an empty block which
538 falls through into BB.
540 The condition for the COND_EXPR is known to be NE_EXPR or EQ_EXPR.
542 There is a single PHI node at the join point (BB) with two arguments.
544 We now need to verify that the two arguments in the PHI node match
545 the two arguments to the equality comparison. */
547 if ((operand_equal_for_phi_arg_p (arg0, TREE_OPERAND (cond, 0))
548 && operand_equal_for_phi_arg_p (arg1, TREE_OPERAND (cond, 1)))
549 || (operand_equal_for_phi_arg_p (arg1, TREE_OPERAND (cond, 0))
550 && operand_equal_for_phi_arg_p (arg0, TREE_OPERAND (cond, 1))))
555 /* For NE_EXPR, we want to build an assignment result = arg where
556 arg is the PHI argument associated with the true edge. For
557 EQ_EXPR we want the PHI argument associated with the false edge. */
558 e = (TREE_CODE (cond) == NE_EXPR ? true_edge : false_edge);
560 /* Unfortunately, E may not reach BB (it may instead have gone to
561 OTHER_BLOCK). If that is the case, then we want the single outgoing
562 edge from OTHER_BLOCK which reaches BB and represents the desired
563 path from COND_BLOCK. */
564 if (e->dest == middle_bb)
565 e = single_succ_edge (e->dest);
567 /* Now we know the incoming edge to BB that has the argument for the
568 RHS of our new assignment statement. */
574 replace_phi_edge_with_variable (cond_bb, phi_bb, e1, phi, arg);
576 /* Note that we optimized this PHI. */
582 /* The function minmax_replacement does the main work of doing the minmax
583 replacement. Return true if the replacement is done. Otherwise return
585 BB is the basic block where the replacement is going to be done on. ARG0
586 is argument 0 from the PHI. Likewise for ARG1. */
589 minmax_replacement (basic_block cond_bb, basic_block middle_bb,
590 basic_block phi_bb, edge e0, edge e1, tree phi,
591 tree arg0, tree arg1)
595 edge true_edge, false_edge;
596 enum tree_code cmp, minmax, ass_code;
597 tree smaller, larger, arg_true, arg_false;
598 block_stmt_iterator bsi, bsi_from;
600 type = TREE_TYPE (PHI_RESULT (phi));
602 /* The optimization may be unsafe due to NaNs. */
603 if (HONOR_NANS (TYPE_MODE (type)))
606 cond = COND_EXPR_COND (last_stmt (cond_bb));
607 cmp = TREE_CODE (cond);
608 result = PHI_RESULT (phi);
610 /* This transformation is only valid for order comparisons. Record which
611 operand is smaller/larger if the result of the comparison is true. */
612 if (cmp == LT_EXPR || cmp == LE_EXPR)
614 smaller = TREE_OPERAND (cond, 0);
615 larger = TREE_OPERAND (cond, 1);
617 else if (cmp == GT_EXPR || cmp == GE_EXPR)
619 smaller = TREE_OPERAND (cond, 1);
620 larger = TREE_OPERAND (cond, 0);
625 /* We need to know which is the true edge and which is the false
626 edge so that we know if have abs or negative abs. */
627 extract_true_false_edges_from_block (cond_bb, &true_edge, &false_edge);
629 /* Forward the edges over the middle basic block. */
630 if (true_edge->dest == middle_bb)
631 true_edge = EDGE_SUCC (true_edge->dest, 0);
632 if (false_edge->dest == middle_bb)
633 false_edge = EDGE_SUCC (false_edge->dest, 0);
637 gcc_assert (false_edge == e1);
643 gcc_assert (false_edge == e0);
644 gcc_assert (true_edge == e1);
649 if (empty_block_p (middle_bb))
651 if (operand_equal_for_phi_arg_p (arg_true, smaller)
652 && operand_equal_for_phi_arg_p (arg_false, larger))
656 if (smaller < larger)
662 else if (operand_equal_for_phi_arg_p (arg_false, smaller)
663 && operand_equal_for_phi_arg_p (arg_true, larger))
670 /* Recognize the following case, assuming d <= u:
676 This is equivalent to
681 tree assign = last_and_only_stmt (middle_bb);
682 tree lhs, rhs, op0, op1, bound;
685 || TREE_CODE (assign) != MODIFY_EXPR)
688 lhs = TREE_OPERAND (assign, 0);
689 rhs = TREE_OPERAND (assign, 1);
690 ass_code = TREE_CODE (rhs);
691 if (ass_code != MAX_EXPR && ass_code != MIN_EXPR)
693 op0 = TREE_OPERAND (rhs, 0);
694 op1 = TREE_OPERAND (rhs, 1);
696 if (true_edge->src == middle_bb)
698 /* We got here if the condition is true, i.e., SMALLER < LARGER. */
699 if (!operand_equal_for_phi_arg_p (lhs, arg_true))
702 if (operand_equal_for_phi_arg_p (arg_false, larger))
706 if (smaller < larger)
708 r' = MAX_EXPR (smaller, bound)
710 r = PHI <r', larger> --> to be turned to MIN_EXPR. */
711 if (ass_code != MAX_EXPR)
715 if (operand_equal_for_phi_arg_p (op0, smaller))
717 else if (operand_equal_for_phi_arg_p (op1, smaller))
722 /* We need BOUND <= LARGER. */
723 if (!integer_nonzerop (fold (build2 (LE_EXPR, boolean_type_node,
727 else if (operand_equal_for_phi_arg_p (arg_false, smaller))
731 if (smaller < larger)
733 r' = MIN_EXPR (larger, bound)
735 r = PHI <r', smaller> --> to be turned to MAX_EXPR. */
736 if (ass_code != MIN_EXPR)
740 if (operand_equal_for_phi_arg_p (op0, larger))
742 else if (operand_equal_for_phi_arg_p (op1, larger))
747 /* We need BOUND >= SMALLER. */
748 if (!integer_nonzerop (fold (build2 (GE_EXPR, boolean_type_node,
757 /* We got here if the condition is false, i.e., SMALLER > LARGER. */
758 if (!operand_equal_for_phi_arg_p (lhs, arg_false))
761 if (operand_equal_for_phi_arg_p (arg_true, larger))
765 if (smaller > larger)
767 r' = MIN_EXPR (smaller, bound)
769 r = PHI <r', larger> --> to be turned to MAX_EXPR. */
770 if (ass_code != MIN_EXPR)
774 if (operand_equal_for_phi_arg_p (op0, smaller))
776 else if (operand_equal_for_phi_arg_p (op1, smaller))
781 /* We need BOUND >= LARGER. */
782 if (!integer_nonzerop (fold (build2 (GE_EXPR, boolean_type_node,
786 else if (operand_equal_for_phi_arg_p (arg_true, smaller))
790 if (smaller > larger)
792 r' = MAX_EXPR (larger, bound)
794 r = PHI <r', smaller> --> to be turned to MIN_EXPR. */
795 if (ass_code != MAX_EXPR)
799 if (operand_equal_for_phi_arg_p (op0, larger))
801 else if (operand_equal_for_phi_arg_p (op1, larger))
806 /* We need BOUND <= SMALLER. */
807 if (!integer_nonzerop (fold (build2 (LE_EXPR, boolean_type_node,
815 /* Move the statement from the middle block. */
816 bsi = bsi_last (cond_bb);
817 bsi_from = bsi_last (middle_bb);
818 bsi_move_before (&bsi_from, &bsi);
821 /* Emit the statement to compute min/max. */
822 result = duplicate_ssa_name (PHI_RESULT (phi), NULL);
823 new = build2 (MODIFY_EXPR, type, result,
824 build2 (minmax, type, arg0, arg1));
825 SSA_NAME_DEF_STMT (result) = new;
826 bsi = bsi_last (cond_bb);
827 bsi_insert_before (&bsi, new, BSI_NEW_STMT);
829 replace_phi_edge_with_variable (cond_bb, phi_bb, e1, phi, result);
833 /* The function absolute_replacement does the main work of doing the absolute
834 replacement. Return true if the replacement is done. Otherwise return
836 bb is the basic block where the replacement is going to be done on. arg0
837 is argument 0 from the phi. Likewise for arg1. */
840 abs_replacement (basic_block cond_bb, basic_block middle_bb,
841 basic_block phi_bb, edge e0 ATTRIBUTE_UNUSED, edge e1,
842 tree phi, tree arg0, tree arg1)
846 block_stmt_iterator bsi;
847 edge true_edge, false_edge;
852 enum tree_code cond_code;
854 /* If the type says honor signed zeros we cannot do this
856 if (HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg1))))
859 /* OTHER_BLOCK must have only one executable statement which must have the
860 form arg0 = -arg1 or arg1 = -arg0. */
862 assign = last_and_only_stmt (middle_bb);
863 /* If we did not find the proper negation assignment, then we can not
868 /* If we got here, then we have found the only executable statement
869 in OTHER_BLOCK. If it is anything other than arg = -arg1 or
870 arg1 = -arg0, then we can not optimize. */
871 if (TREE_CODE (assign) != MODIFY_EXPR)
874 lhs = TREE_OPERAND (assign, 0);
875 rhs = TREE_OPERAND (assign, 1);
877 if (TREE_CODE (rhs) != NEGATE_EXPR)
880 rhs = TREE_OPERAND (rhs, 0);
882 /* The assignment has to be arg0 = -arg1 or arg1 = -arg0. */
883 if (!(lhs == arg0 && rhs == arg1)
884 && !(lhs == arg1 && rhs == arg0))
887 cond = COND_EXPR_COND (last_stmt (cond_bb));
888 result = PHI_RESULT (phi);
890 /* Only relationals comparing arg[01] against zero are interesting. */
891 cond_code = TREE_CODE (cond);
892 if (cond_code != GT_EXPR && cond_code != GE_EXPR
893 && cond_code != LT_EXPR && cond_code != LE_EXPR)
896 /* Make sure the conditional is arg[01] OP y. */
897 if (TREE_OPERAND (cond, 0) != rhs)
900 if (FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (cond, 1)))
901 ? real_zerop (TREE_OPERAND (cond, 1))
902 : integer_zerop (TREE_OPERAND (cond, 1)))
907 /* We need to know which is the true edge and which is the false
908 edge so that we know if have abs or negative abs. */
909 extract_true_false_edges_from_block (cond_bb, &true_edge, &false_edge);
911 /* For GT_EXPR/GE_EXPR, if the true edge goes to OTHER_BLOCK, then we
912 will need to negate the result. Similarly for LT_EXPR/LE_EXPR if
913 the false edge goes to OTHER_BLOCK. */
914 if (cond_code == GT_EXPR || cond_code == GE_EXPR)
919 if (e->dest == middle_bb)
924 result = duplicate_ssa_name (result, NULL);
927 lhs = make_rename_temp (TREE_TYPE (result), NULL);
931 /* Build the modify expression with abs expression. */
932 new = build2 (MODIFY_EXPR, TREE_TYPE (lhs),
933 lhs, build1 (ABS_EXPR, TREE_TYPE (lhs), rhs));
935 bsi = bsi_last (cond_bb);
936 bsi_insert_before (&bsi, new, BSI_NEW_STMT);
940 /* Get the right BSI. We want to insert after the recently
941 added ABS_EXPR statement (which we know is the first statement
943 new = build2 (MODIFY_EXPR, TREE_TYPE (result),
944 result, build1 (NEGATE_EXPR, TREE_TYPE (lhs), lhs));
946 bsi_insert_after (&bsi, new, BSI_NEW_STMT);
949 SSA_NAME_DEF_STMT (result) = new;
950 replace_phi_edge_with_variable (cond_bb, phi_bb, e1, phi, result);
952 /* Note that we optimized this PHI. */
957 /* Always do these optimizations if we have SSA
965 struct tree_opt_pass pass_phiopt =
968 gate_phiopt, /* gate */
969 tree_ssa_phiopt, /* execute */
972 0, /* static_pass_number */
973 TV_TREE_PHIOPT, /* tv_id */
974 PROP_cfg | PROP_ssa | PROP_alias, /* properties_required */
975 0, /* properties_provided */
976 0, /* properties_destroyed */
977 0, /* todo_flags_start */
984 | TODO_verify_stmts, /* todo_flags_finish */