gcc/tree-ssa-threadedge.c

   1 /* SSA Jump Threading
   2    Copyright (C) 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
   3    Contributed by Jeff Law  <law@redhat.com>
   4
   5 This file is part of GCC.
   6
   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)
  10 any later version.
  11
  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.
  16
  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/>.  */
  20
  21 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "tree.h"
  26 #include "flags.h"
  27 #include "rtl.h"
  28 #include "tm_p.h"
  29 #include "ggc.h"
  30 #include "basic-block.h"
  31 #include "cfgloop.h"
  32 #include "output.h"
  33 #include "expr.h"
  34 #include "function.h"
  35 #include "diagnostic.h"
  36 #include "timevar.h"
  37 #include "tree-dump.h"
  38 #include "tree-flow.h"
  39 #include "real.h"
  40 #include "tree-pass.h"
  41 #include "tree-ssa-propagate.h"
  42 #include "langhooks.h"
  43 #include "params.h"
  44
  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;
  50
  51 /* Array to record value-handles per SSA_NAME.  */
  52 VEC(tree,heap) *ssa_name_values;
  53
  54 /* Set the value for the SSA name NAME to VALUE.  */
  55
  56 void
  57 set_ssa_name_value (tree name, tree value)
  58 {
  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);
  63 }
  64
  65 /* Initialize the per SSA_NAME value-handles array.  Returns it.  */
  66 void
  67 threadedge_initialize_values (void)
  68 {
  69   gcc_assert (ssa_name_values == NULL);
  70   ssa_name_values = VEC_alloc(tree, heap, num_ssa_names);
  71 }
  72
  73 /* Free the per SSA_NAME value-handle array.  */
  74 void
  75 threadedge_finalize_values (void)
  76 {
  77   VEC_free(tree, heap, ssa_name_values);
  78 }
  79
  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.  */
  82
  83 bool
  84 potentially_threadable_block (basic_block bb)
  85 {
  86   gimple_stmt_iterator gsi;
  87
  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))
  91     return false;
  92
  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);
  96   if (gsi_end_p (gsi)
  97       || ! gsi_stmt (gsi)
  98       || (gimple_code (gsi_stmt (gsi)) != GIMPLE_COND
  99           && gimple_code (gsi_stmt (gsi)) != GIMPLE_GOTO
 100           && gimple_code (gsi_stmt (gsi)) != GIMPLE_SWITCH))
 101     return false;
 102
 103   return true;
 104 }
 105
 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.  */
 109
 110 static tree
 111 lhs_of_dominating_assert (tree op, basic_block bb, gimple stmt)
 112 {
 113   imm_use_iterator imm_iter;
 114   gimple use_stmt;
 115   use_operand_p use_p;
 116
 117   FOR_EACH_IMM_USE_FAST (use_p, imm_iter, op)
 118     {
 119       use_stmt = USE_STMT (use_p);
 120       if (use_stmt != stmt
 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)))
 125         {
 126           return gimple_assign_lhs (use_stmt);
 127         }
 128     }
 129   return op;
 130 }
 131
 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
 135    with side effects.
 136
 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
 140    structures.  */
 141
 142 static void
 143 remove_temporary_equivalences (VEC(tree, heap) **stack)
 144 {
 145   while (VEC_length (tree, *stack) > 0)
 146     {
 147       tree prev_value, dest;
 148
 149       dest = VEC_pop (tree, *stack);
 150
 151       /* A NULL value indicates we should stop unwinding, otherwise
 152          pop off the next entry as they're recorded in pairs.  */
 153       if (dest == NULL)
 154         break;
 155
 156       prev_value = VEC_pop (tree, *stack);
 157       set_ssa_name_value (dest, prev_value);
 158     }
 159 }
 160
 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.  */
 164
 165 static void
 166 record_temporary_equivalence (tree x, tree y, VEC(tree, heap) **stack)
 167 {
 168   tree prev_x = SSA_NAME_VALUE (x);
 169
 170   if (TREE_CODE (y) == SSA_NAME)
 171     {
 172       tree tmp = SSA_NAME_VALUE (y);
 173       y = tmp ? tmp : y;
 174     }
 175
 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);
 180 }
 181
 182 /* Record temporary equivalences created by PHIs at the target of the
 183    edge E.  Record unwind information for the equivalences onto STACK.
 184
 185    If a PHI which prevents threading is encountered, then return FALSE
 186    indicating we should not thread this edge, else return TRUE.  */
 187
 188 static bool
 189 record_temporary_equivalences_from_phis (edge e, VEC(tree, heap) **stack)
 190 {
 191   gimple_stmt_iterator gsi;
 192
 193   /* Each PHI creates a temporary equivalence, record them.
 194      These are context sensitive equivalences and will be removed
 195      later.  */
 196   for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
 197     {
 198       gimple phi = gsi_stmt (gsi);
 199       tree src = PHI_ARG_DEF_FROM_EDGE (phi, e);
 200       tree dst = gimple_phi_result (phi);
 201
 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
 204          through E->dest.  */
 205       if (src != dst
 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)
 209         return false;
 210
 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))
 214         stmt_count++;
 215
 216       record_temporary_equivalence (dst, src, stack);
 217     }
 218   return true;
 219 }
 220
 221 /* Fold the RHS of an assignment statement and return it as a tree.
 222    May return NULL_TREE if no simplification is possible.  */
 223
 224 static tree
 225 fold_assignment_stmt (gimple stmt)
 226 {
 227   enum tree_code subcode = gimple_assign_rhs_code (stmt);
 228
 229   switch (get_gimple_rhs_class (subcode))
 230     {
 231     case GIMPLE_SINGLE_RHS:
 232       {
 233         tree rhs = gimple_assign_rhs1 (stmt);
 234
 235         if (TREE_CODE (rhs) == COND_EXPR)
 236           {
 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);
 246           }
 247
 248         return fold (rhs);
 249       }
 250       break;
 251     case GIMPLE_UNARY_RHS:
 252       {
 253         tree lhs = gimple_assign_lhs (stmt);
 254         tree op0 = gimple_assign_rhs1 (stmt);
 255         return fold_unary (subcode, TREE_TYPE (lhs), op0);
 256       }
 257       break;
 258     case GIMPLE_BINARY_RHS:
 259       {
 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);
 264       }
 265       break;
 266     default:
 267       gcc_unreachable ();
 268     }
 269 }
 270
 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.
 273
 274    Record unwind information for temporary equivalences onto STACK.
 275
 276    Use SIMPLIFY (a pointer to a callback function) to further simplify
 277    statements using pass specific information.
 278
 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.
 282
 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.  */
 287
 288 static gimple
 289 record_temporary_equivalences_from_stmts_at_dest (edge e,
 290                                                   VEC(tree, heap) **stack,
 291                                                   tree (*simplify) (gimple,
 292                                                                     gimple))
 293 {
 294   gimple stmt = NULL;
 295   gimple_stmt_iterator gsi;
 296   int max_stmt_count;
 297
 298   max_stmt_count = PARAM_VALUE (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS);
 299
 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))
 305     {
 306       tree cached_lhs = NULL;
 307
 308       stmt = gsi_stmt (gsi);
 309
 310       /* Ignore empty statements and labels.  */
 311       if (gimple_code (stmt) == GIMPLE_NOP || gimple_code (stmt) == GIMPLE_LABEL)
 312         continue;
 313
 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))
 318         return NULL;
 319
 320       /* If duplicating this block is going to cause too much code
 321          expansion, then do not thread through this block.  */
 322       stmt_count++;
 323       if (stmt_count > max_stmt_count)
 324         return NULL;
 325
 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))
 334         continue;
 335
 336       /* The result of __builtin_object_size depends on all the arguments
 337          of a phi node. Temporarily using only one edge produces invalid
 338          results. For example
 339
 340          if (x < 6)
 341            goto l;
 342          else
 343            goto l;
 344
 345          l:
 346          r = PHI <&w[2].a[1](2), &a.a[6](3)>
 347          __builtin_object_size (r, 0)
 348
 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.
 352
 353          Similarly for __builtin_constant_p:
 354
 355          r = PHI <1(2), 2(3)>
 356          __builtin_constant_p (r)
 357
 358          Both PHI arguments are constant, but x ? 1 : 2 is still not
 359          constant.  */
 360
 361       if (is_gimple_call (stmt))
 362         {
 363           tree fndecl = gimple_call_fndecl (stmt);
 364           if (fndecl
 365               && (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_OBJECT_SIZE
 366                   || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P))
 367             continue;
 368         }
 369
 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.
 374
 375          Handle simple copy operations as well as implied copies from
 376          ASSERT_EXPRs.  */
 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);
 383       else
 384         {
 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.  */
 388           tree *copy;
 389           ssa_op_iter iter;
 390           use_operand_p use_p;
 391           unsigned int num, i = 0;
 392
 393           num = NUM_SSA_OPERANDS (stmt, (SSA_OP_USE | SSA_OP_VUSE));
 394           copy = XCNEWVEC (tree, num);
 395
 396           /* Make a copy of the uses & vuses into USES_COPY, then cprop into
 397              the operands.  */
 398           FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE | SSA_OP_VUSE)
 399             {
 400               tree tmp = NULL;
 401               tree use = USE_FROM_PTR (use_p);
 402
 403               copy[i++] = use;
 404               if (TREE_CODE (use) == SSA_NAME)
 405                 tmp = SSA_NAME_VALUE (use);
 406               if (tmp)
 407                 SET_USE (use_p, tmp);
 408             }
 409
 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);
 414           else
 415             cached_lhs = fold_assignment_stmt (stmt);
 416
 417           if (!cached_lhs
 418               || (TREE_CODE (cached_lhs) != SSA_NAME
 419                   && !is_gimple_min_invariant (cached_lhs)))
 420             cached_lhs = (*simplify) (stmt, stmt);
 421
 422           /* Restore the statement's original uses/defs.  */
 423           i = 0;
 424           FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE | SSA_OP_VUSE)
 425             SET_USE (use_p, copy[i++]);
 426
 427           free (copy);
 428         }
 429
 430       /* Record the context sensitive equivalence if we were able
 431          to simplify this statement.  */
 432       if (cached_lhs
 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);
 436     }
 437   return stmt;
 438 }
 439
 440 /* Simplify the control statement at the end of the block E->dest.
 441
 442    To avoid allocating memory unnecessarily, a scratch GIMPLE_COND
 443    is available to use/clobber in DUMMY_COND.
 444
 445    Use SIMPLIFY (a pointer to a callback function) to further simplify
 446    a condition using pass specific information.
 447
 448    Return the simplified condition or NULL if simplification could
 449    not be performed.  */
 450
 451 static tree
 452 simplify_control_stmt_condition (edge e,
 453                                  gimple stmt,
 454                                  gimple dummy_cond,
 455                                  tree (*simplify) (gimple, gimple),
 456                                  bool handle_dominating_asserts)
 457 {
 458   tree cond, cached_lhs;
 459   enum gimple_code code = gimple_code (stmt);
 460
 461   /* For comparisons, we have to update both operands, then try
 462      to simplify the comparison.  */
 463   if (code == GIMPLE_COND)
 464     {
 465       tree op0, op1;
 466       enum tree_code cond_code;
 467
 468       op0 = gimple_cond_lhs (stmt);
 469       op1 = gimple_cond_rhs (stmt);
 470       cond_code = gimple_cond_code (stmt);
 471
 472       /* Get the current value of both operands.  */
 473       if (TREE_CODE (op0) == SSA_NAME)
 474         {
 475           tree tmp = SSA_NAME_VALUE (op0);
 476           if (tmp)
 477             op0 = tmp;
 478         }
 479
 480       if (TREE_CODE (op1) == SSA_NAME)
 481         {
 482           tree tmp = SSA_NAME_VALUE (op1);
 483           if (tmp)
 484             op1 = tmp;
 485         }
 486
 487       if (handle_dominating_asserts)
 488         {
 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);
 494
 495           if (TREE_CODE (op1) == SSA_NAME)
 496             op1 = lhs_of_dominating_assert (op1, e->src, stmt);
 497         }
 498
 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))
 504         {
 505           tree tmp;
 506           cond_code = swap_tree_comparison (cond_code);
 507           tmp = op0;
 508           op0 = op1;
 509           op1 = tmp;
 510         }
 511
 512       /* Stuff the operator and operands into our dummy conditional
 513          expression.  */
 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);
 517
 518       /* We absolutely do not care about any type conversions
 519          we only care about a zero/nonzero value.  */
 520       fold_defer_overflow_warnings ();
 521
 522       cached_lhs = fold_binary (cond_code, boolean_type_node, op0, op1);
 523       if (cached_lhs)
 524         while (CONVERT_EXPR_P (cached_lhs))
 525           cached_lhs = TREE_OPERAND (cached_lhs, 0);
 526
 527       fold_undefer_overflow_warnings ((cached_lhs
 528                                        && is_gimple_min_invariant (cached_lhs)),
 529                                       stmt, WARN_STRICT_OVERFLOW_CONDITIONAL);
 530
 531       /* If we have not simplified the condition down to an invariant,
 532          then use the pass specific callback to simplify the condition.  */
 533       if (!cached_lhs
 534           || !is_gimple_min_invariant (cached_lhs))
 535         cached_lhs = (*simplify) (dummy_cond, stmt);
 536
 537       return cached_lhs;
 538     }
 539
 540   if (code == GIMPLE_SWITCH)
 541     cond = gimple_switch_index (stmt);
 542   else if (code == GIMPLE_GOTO)
 543     cond = gimple_goto_dest (stmt);
 544   else
 545     gcc_unreachable ();
 546
 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)
 550     {
 551       cached_lhs = cond;
 552
 553       /* Get the variable's current value from the equivalence chains.
 554
 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.  */
 558       if (cached_lhs
 559           && TREE_CODE (cached_lhs) == SSA_NAME
 560           && SSA_NAME_VALUE (cached_lhs))
 561         cached_lhs = SSA_NAME_VALUE (cached_lhs);
 562
 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);
 567
 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);
 572     }
 573   else
 574     cached_lhs = NULL;
 575
 576   return cached_lhs;
 577 }
 578
 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.
 581
 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
 587    incorrectly.
 588
 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.
 593
 594    DUMMY_COND is a shared cond_expr used by condition simplification as scratch,
 595    to avoid allocating memory.
 596
 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
 599    used in.
 600
 601    STACK is used to undo temporary equivalences created during the walk of
 602    E->dest.
 603
 604    SIMPLIFY is a pass-specific function used to simplify statements.  */
 605
 606 void
 607 thread_across_edge (gimple dummy_cond,
 608                     edge e,
 609                     bool handle_dominating_asserts,
 610                     VEC(tree, heap) **stack,
 611                     tree (*simplify) (gimple, gimple))
 612 {
 613   gimple stmt;
 614
 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)
 620     {
 621       ssa_op_iter iter;
 622       use_operand_p use_p;
 623       gimple last = gsi_stmt (gsi_last_bb (e->dest));
 624
 625       FOR_EACH_SSA_USE_OPERAND (use_p, last, iter, SSA_OP_USE | SSA_OP_VUSE)
 626         {
 627           tree use = USE_FROM_PTR (use_p);
 628
 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)
 632             goto fail;
 633         }
 634     }
 635
 636   stmt_count = 0;
 637
 638   /* PHIs create temporary equivalences.  */
 639   if (!record_temporary_equivalences_from_phis (e, stack))
 640     goto fail;
 641
 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);
 645   if (!stmt)
 646     goto fail;
 647
 648   /* If we stopped at a COND_EXPR or SWITCH_EXPR, see if we know which arm
 649      will be taken.  */
 650   if (gimple_code (stmt) == GIMPLE_COND
 651       || gimple_code (stmt) == GIMPLE_GOTO
 652       || gimple_code (stmt) == GIMPLE_SWITCH)
 653     {
 654       tree cond;
 655
 656       /* Extract and simplify the condition.  */
 657       cond = simplify_control_stmt_condition (e, stmt, dummy_cond, simplify, handle_dominating_asserts);
 658
 659       if (cond && is_gimple_min_invariant (cond))
 660         {
 661           edge taken_edge = find_taken_edge (e->dest, cond);
 662           basic_block dest = (taken_edge ? taken_edge->dest : NULL);
 663
 664           if (dest == e->dest)
 665             goto fail;
 666
 667           remove_temporary_equivalences (stack);
 668           register_jump_thread (e, taken_edge);
 669         }
 670     }
 671
 672  fail:
 673   remove_temporary_equivalences (stack);
 674 }