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 "tm_p.h"
  28 #include "basic-block.h"
  29 #include "cfgloop.h"
  30 #include "output.h"
  31 #include "function.h"
  32 #include "timevar.h"
  33 #include "tree-dump.h"
  34 #include "tree-flow.h"
  35 #include "tree-pass.h"
  36 #include "tree-ssa-propagate.h"
  37 #include "langhooks.h"
  38 #include "params.h"
  39
  40 /* To avoid code explosion due to jump threading, we limit the
  41    number of statements we are going to copy.  This variable
  42    holds the number of statements currently seen that we'll have
  43    to copy as part of the jump threading process.  */
  44 static int stmt_count;
  45
  46 /* Array to record value-handles per SSA_NAME.  */
  47 VEC(tree,heap) *ssa_name_values;
  48
  49 /* Set the value for the SSA name NAME to VALUE.  */
  50
  51 void
  52 set_ssa_name_value (tree name, tree value)
  53 {
  54   if (SSA_NAME_VERSION (name) >= VEC_length (tree, ssa_name_values))
  55     VEC_safe_grow_cleared (tree, heap, ssa_name_values,
  56                            SSA_NAME_VERSION (name) + 1);
  57   VEC_replace (tree, ssa_name_values, SSA_NAME_VERSION (name), value);
  58 }
  59
  60 /* Initialize the per SSA_NAME value-handles array.  Returns it.  */
  61 void
  62 threadedge_initialize_values (void)
  63 {
  64   gcc_assert (ssa_name_values == NULL);
  65   ssa_name_values = VEC_alloc(tree, heap, num_ssa_names);
  66 }
  67
  68 /* Free the per SSA_NAME value-handle array.  */
  69 void
  70 threadedge_finalize_values (void)
  71 {
  72   VEC_free(tree, heap, ssa_name_values);
  73 }
  74
  75 /* Return TRUE if we may be able to thread an incoming edge into
  76    BB to an outgoing edge from BB.  Return FALSE otherwise.  */
  77
  78 bool
  79 potentially_threadable_block (basic_block bb)
  80 {
  81   gimple_stmt_iterator gsi;
  82
  83   /* If BB has a single successor or a single predecessor, then
  84      there is no threading opportunity.  */
  85   if (single_succ_p (bb) || single_pred_p (bb))
  86     return false;
  87
  88   /* If BB does not end with a conditional, switch or computed goto,
  89      then there is no threading opportunity.  */
  90   gsi = gsi_last_bb (bb);
  91   if (gsi_end_p (gsi)
  92       || ! gsi_stmt (gsi)
  93       || (gimple_code (gsi_stmt (gsi)) != GIMPLE_COND
  94           && gimple_code (gsi_stmt (gsi)) != GIMPLE_GOTO
  95           && gimple_code (gsi_stmt (gsi)) != GIMPLE_SWITCH))
  96     return false;
  97
  98   return true;
  99 }
 100
 101 /* Return the LHS of any ASSERT_EXPR where OP appears as the first
 102    argument to the ASSERT_EXPR and in which the ASSERT_EXPR dominates
 103    BB.  If no such ASSERT_EXPR is found, return OP.  */
 104
 105 static tree
 106 lhs_of_dominating_assert (tree op, basic_block bb, gimple stmt)
 107 {
 108   imm_use_iterator imm_iter;
 109   gimple use_stmt;
 110   use_operand_p use_p;
 111
 112   FOR_EACH_IMM_USE_FAST (use_p, imm_iter, op)
 113     {
 114       use_stmt = USE_STMT (use_p);
 115       if (use_stmt != stmt
 116           && gimple_assign_single_p (use_stmt)
 117           && TREE_CODE (gimple_assign_rhs1 (use_stmt)) == ASSERT_EXPR
 118           && TREE_OPERAND (gimple_assign_rhs1 (use_stmt), 0) == op
 119           && dominated_by_p (CDI_DOMINATORS, bb, gimple_bb (use_stmt)))
 120         {
 121           return gimple_assign_lhs (use_stmt);
 122         }
 123     }
 124   return op;
 125 }
 126
 127 /* We record temporary equivalences created by PHI nodes or
 128    statements within the target block.  Doing so allows us to
 129    identify more jump threading opportunities, even in blocks
 130    with side effects.
 131
 132    We keep track of those temporary equivalences in a stack
 133    structure so that we can unwind them when we're done processing
 134    a particular edge.  This routine handles unwinding the data
 135    structures.  */
 136
 137 static void
 138 remove_temporary_equivalences (VEC(tree, heap) **stack)
 139 {
 140   while (VEC_length (tree, *stack) > 0)
 141     {
 142       tree prev_value, dest;
 143
 144       dest = VEC_pop (tree, *stack);
 145
 146       /* A NULL value indicates we should stop unwinding, otherwise
 147          pop off the next entry as they're recorded in pairs.  */
 148       if (dest == NULL)
 149         break;
 150
 151       prev_value = VEC_pop (tree, *stack);
 152       set_ssa_name_value (dest, prev_value);
 153     }
 154 }
 155
 156 /* Record a temporary equivalence, saving enough information so that
 157    we can restore the state of recorded equivalences when we're
 158    done processing the current edge.  */
 159
 160 static void
 161 record_temporary_equivalence (tree x, tree y, VEC(tree, heap) **stack)
 162 {
 163   tree prev_x = SSA_NAME_VALUE (x);
 164
 165   if (TREE_CODE (y) == SSA_NAME)
 166     {
 167       tree tmp = SSA_NAME_VALUE (y);
 168       y = tmp ? tmp : y;
 169     }
 170
 171   set_ssa_name_value (x, y);
 172   VEC_reserve (tree, heap, *stack, 2);
 173   VEC_quick_push (tree, *stack, prev_x);
 174   VEC_quick_push (tree, *stack, x);
 175 }
 176
 177 /* Record temporary equivalences created by PHIs at the target of the
 178    edge E.  Record unwind information for the equivalences onto STACK.
 179
 180    If a PHI which prevents threading is encountered, then return FALSE
 181    indicating we should not thread this edge, else return TRUE.  */
 182
 183 static bool
 184 record_temporary_equivalences_from_phis (edge e, VEC(tree, heap) **stack)
 185 {
 186   gimple_stmt_iterator gsi;
 187
 188   /* Each PHI creates a temporary equivalence, record them.
 189      These are context sensitive equivalences and will be removed
 190      later.  */
 191   for (gsi = gsi_start_phis (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
 192     {
 193       gimple phi = gsi_stmt (gsi);
 194       tree src = PHI_ARG_DEF_FROM_EDGE (phi, e);
 195       tree dst = gimple_phi_result (phi);
 196
 197       /* If the desired argument is not the same as this PHI's result
 198          and it is set by a PHI in E->dest, then we can not thread
 199          through E->dest.  */
 200       if (src != dst
 201           && TREE_CODE (src) == SSA_NAME
 202           && gimple_code (SSA_NAME_DEF_STMT (src)) == GIMPLE_PHI
 203           && gimple_bb (SSA_NAME_DEF_STMT (src)) == e->dest)
 204         return false;
 205
 206       /* We consider any non-virtual PHI as a statement since it
 207          count result in a constant assignment or copy operation.  */
 208       if (is_gimple_reg (dst))
 209         stmt_count++;
 210
 211       record_temporary_equivalence (dst, src, stack);
 212     }
 213   return true;
 214 }
 215
 216 /* Fold the RHS of an assignment statement and return it as a tree.
 217    May return NULL_TREE if no simplification is possible.  */
 218
 219 static tree
 220 fold_assignment_stmt (gimple stmt)
 221 {
 222   enum tree_code subcode = gimple_assign_rhs_code (stmt);
 223
 224   switch (get_gimple_rhs_class (subcode))
 225     {
 226     case GIMPLE_SINGLE_RHS:
 227       {
 228         tree rhs = gimple_assign_rhs1 (stmt);
 229
 230         if (TREE_CODE (rhs) == COND_EXPR)
 231           {
 232             /* Sadly, we have to handle conditional assignments specially
 233                here, because fold expects all the operands of an expression
 234                to be folded before the expression itself is folded, but we
 235                can't just substitute the folded condition here.  */
 236             tree cond = fold (COND_EXPR_COND (rhs));
 237             if (cond == boolean_true_node)
 238               rhs = COND_EXPR_THEN (rhs);
 239             else if (cond == boolean_false_node)
 240               rhs = COND_EXPR_ELSE (rhs);
 241           }
 242
 243         return fold (rhs);
 244       }
 245
 246     case GIMPLE_UNARY_RHS:
 247       {
 248         tree lhs = gimple_assign_lhs (stmt);
 249         tree op0 = gimple_assign_rhs1 (stmt);
 250         return fold_unary (subcode, TREE_TYPE (lhs), op0);
 251       }
 252
 253     case GIMPLE_BINARY_RHS:
 254       {
 255         tree lhs = gimple_assign_lhs (stmt);
 256         tree op0 = gimple_assign_rhs1 (stmt);
 257         tree op1 = gimple_assign_rhs2 (stmt);
 258         return fold_binary (subcode, TREE_TYPE (lhs), op0, op1);
 259       }
 260
 261     case GIMPLE_TERNARY_RHS:
 262       {
 263         tree lhs = gimple_assign_lhs (stmt);
 264         tree op0 = gimple_assign_rhs1 (stmt);
 265         tree op1 = gimple_assign_rhs2 (stmt);
 266         tree op2 = gimple_assign_rhs3 (stmt);
 267         return fold_ternary (subcode, TREE_TYPE (lhs), op0, op1, op2);
 268       }
 269
 270     default:
 271       gcc_unreachable ();
 272     }
 273 }
 274
 275 /* Try to simplify each statement in E->dest, ultimately leading to
 276    a simplification of the COND_EXPR at the end of E->dest.
 277
 278    Record unwind information for temporary equivalences onto STACK.
 279
 280    Use SIMPLIFY (a pointer to a callback function) to further simplify
 281    statements using pass specific information.
 282
 283    We might consider marking just those statements which ultimately
 284    feed the COND_EXPR.  It's not clear if the overhead of bookkeeping
 285    would be recovered by trying to simplify fewer statements.
 286
 287    If we are able to simplify a statement into the form
 288    SSA_NAME = (SSA_NAME | gimple invariant), then we can record
 289    a context sensitive equivalence which may help us simplify
 290    later statements in E->dest.  */
 291
 292 static gimple
 293 record_temporary_equivalences_from_stmts_at_dest (edge e,
 294                                                   VEC(tree, heap) **stack,
 295                                                   tree (*simplify) (gimple,
 296                                                                     gimple))
 297 {
 298   gimple stmt = NULL;
 299   gimple_stmt_iterator gsi;
 300   int max_stmt_count;
 301
 302   max_stmt_count = PARAM_VALUE (PARAM_MAX_JUMP_THREAD_DUPLICATION_STMTS);
 303
 304   /* Walk through each statement in the block recording equivalences
 305      we discover.  Note any equivalences we discover are context
 306      sensitive (ie, are dependent on traversing E) and must be unwound
 307      when we're finished processing E.  */
 308   for (gsi = gsi_start_bb (e->dest); !gsi_end_p (gsi); gsi_next (&gsi))
 309     {
 310       tree cached_lhs = NULL;
 311
 312       stmt = gsi_stmt (gsi);
 313
 314       /* Ignore empty statements and labels.  */
 315       if (gimple_code (stmt) == GIMPLE_NOP
 316           || gimple_code (stmt) == GIMPLE_LABEL
 317           || is_gimple_debug (stmt))
 318         continue;
 319
 320       /* If the statement has volatile operands, then we assume we
 321          can not thread through this block.  This is overly
 322          conservative in some ways.  */
 323       if (gimple_code (stmt) == GIMPLE_ASM && gimple_asm_volatile_p (stmt))
 324         return NULL;
 325
 326       /* If duplicating this block is going to cause too much code
 327          expansion, then do not thread through this block.  */
 328       stmt_count++;
 329       if (stmt_count > max_stmt_count)
 330         return NULL;
 331
 332       /* If this is not a statement that sets an SSA_NAME to a new
 333          value, then do not try to simplify this statement as it will
 334          not simplify in any way that is helpful for jump threading.  */
 335       if ((gimple_code (stmt) != GIMPLE_ASSIGN
 336            || TREE_CODE (gimple_assign_lhs (stmt)) != SSA_NAME)
 337           && (gimple_code (stmt) != GIMPLE_CALL
 338               || gimple_call_lhs (stmt) == NULL_TREE
 339               || TREE_CODE (gimple_call_lhs (stmt)) != SSA_NAME))
 340         continue;
 341
 342       /* The result of __builtin_object_size depends on all the arguments
 343          of a phi node. Temporarily using only one edge produces invalid
 344          results. For example
 345
 346          if (x < 6)
 347            goto l;
 348          else
 349            goto l;
 350
 351          l:
 352          r = PHI <&w[2].a[1](2), &a.a[6](3)>
 353          __builtin_object_size (r, 0)
 354
 355          The result of __builtin_object_size is defined to be the maximum of
 356          remaining bytes. If we use only one edge on the phi, the result will
 357          change to be the remaining bytes for the corresponding phi argument.
 358
 359          Similarly for __builtin_constant_p:
 360
 361          r = PHI <1(2), 2(3)>
 362          __builtin_constant_p (r)
 363
 364          Both PHI arguments are constant, but x ? 1 : 2 is still not
 365          constant.  */
 366
 367       if (is_gimple_call (stmt))
 368         {
 369           tree fndecl = gimple_call_fndecl (stmt);
 370           if (fndecl
 371               && (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_OBJECT_SIZE
 372                   || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_CONSTANT_P))
 373             continue;
 374         }
 375
 376       /* At this point we have a statement which assigns an RHS to an
 377          SSA_VAR on the LHS.  We want to try and simplify this statement
 378          to expose more context sensitive equivalences which in turn may
 379          allow us to simplify the condition at the end of the loop.
 380
 381          Handle simple copy operations as well as implied copies from
 382          ASSERT_EXPRs.  */
 383       if (gimple_assign_single_p (stmt)
 384           && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME)
 385         cached_lhs = gimple_assign_rhs1 (stmt);
 386       else if (gimple_assign_single_p (stmt)
 387                && TREE_CODE (gimple_assign_rhs1 (stmt)) == ASSERT_EXPR)
 388         cached_lhs = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0);
 389       else
 390         {
 391           /* A statement that is not a trivial copy or ASSERT_EXPR.
 392              We're going to temporarily copy propagate the operands
 393              and see if that allows us to simplify this statement.  */
 394           tree *copy;
 395           ssa_op_iter iter;
 396           use_operand_p use_p;
 397           unsigned int num, i = 0;
 398
 399           num = NUM_SSA_OPERANDS (stmt, (SSA_OP_USE | SSA_OP_VUSE));
 400           copy = XCNEWVEC (tree, num);
 401
 402           /* Make a copy of the uses & vuses into USES_COPY, then cprop into
 403              the operands.  */
 404           FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE | SSA_OP_VUSE)
 405             {
 406               tree tmp = NULL;
 407               tree use = USE_FROM_PTR (use_p);
 408
 409               copy[i++] = use;
 410               if (TREE_CODE (use) == SSA_NAME)
 411                 tmp = SSA_NAME_VALUE (use);
 412               if (tmp)
 413                 SET_USE (use_p, tmp);
 414             }
 415
 416           /* Try to fold/lookup the new expression.  Inserting the
 417              expression into the hash table is unlikely to help.  */
 418           if (is_gimple_call (stmt))
 419             cached_lhs = fold_call_stmt (stmt, false);
 420           else
 421             cached_lhs = fold_assignment_stmt (stmt);
 422
 423           if (!cached_lhs
 424               || (TREE_CODE (cached_lhs) != SSA_NAME
 425                   && !is_gimple_min_invariant (cached_lhs)))
 426             cached_lhs = (*simplify) (stmt, stmt);
 427
 428           /* Restore the statement's original uses/defs.  */
 429           i = 0;
 430           FOR_EACH_SSA_USE_OPERAND (use_p, stmt, iter, SSA_OP_USE | SSA_OP_VUSE)
 431             SET_USE (use_p, copy[i++]);
 432
 433           free (copy);
 434         }
 435
 436       /* Record the context sensitive equivalence if we were able
 437          to simplify this statement.  */
 438       if (cached_lhs
 439           && (TREE_CODE (cached_lhs) == SSA_NAME
 440               || is_gimple_min_invariant (cached_lhs)))
 441         record_temporary_equivalence (gimple_get_lhs (stmt), cached_lhs, stack);
 442     }
 443   return stmt;
 444 }
 445
 446 /* Simplify the control statement at the end of the block E->dest.
 447
 448    To avoid allocating memory unnecessarily, a scratch GIMPLE_COND
 449    is available to use/clobber in DUMMY_COND.
 450
 451    Use SIMPLIFY (a pointer to a callback function) to further simplify
 452    a condition using pass specific information.
 453
 454    Return the simplified condition or NULL if simplification could
 455    not be performed.  */
 456
 457 static tree
 458 simplify_control_stmt_condition (edge e,
 459                                  gimple stmt,
 460                                  gimple dummy_cond,
 461                                  tree (*simplify) (gimple, gimple),
 462                                  bool handle_dominating_asserts)
 463 {
 464   tree cond, cached_lhs;
 465   enum gimple_code code = gimple_code (stmt);
 466
 467   /* For comparisons, we have to update both operands, then try
 468      to simplify the comparison.  */
 469   if (code == GIMPLE_COND)
 470     {
 471       tree op0, op1;
 472       enum tree_code cond_code;
 473
 474       op0 = gimple_cond_lhs (stmt);
 475       op1 = gimple_cond_rhs (stmt);
 476       cond_code = gimple_cond_code (stmt);
 477
 478       /* Get the current value of both operands.  */
 479       if (TREE_CODE (op0) == SSA_NAME)
 480         {
 481           tree tmp = SSA_NAME_VALUE (op0);
 482           if (tmp)
 483             op0 = tmp;
 484         }
 485
 486       if (TREE_CODE (op1) == SSA_NAME)
 487         {
 488           tree tmp = SSA_NAME_VALUE (op1);
 489           if (tmp)
 490             op1 = tmp;
 491         }
 492
 493       if (handle_dominating_asserts)
 494         {
 495           /* Now see if the operand was consumed by an ASSERT_EXPR
 496              which dominates E->src.  If so, we want to replace the
 497              operand with the LHS of the ASSERT_EXPR.  */
 498           if (TREE_CODE (op0) == SSA_NAME)
 499             op0 = lhs_of_dominating_assert (op0, e->src, stmt);
 500
 501           if (TREE_CODE (op1) == SSA_NAME)
 502             op1 = lhs_of_dominating_assert (op1, e->src, stmt);
 503         }
 504
 505       /* We may need to canonicalize the comparison.  For
 506          example, op0 might be a constant while op1 is an
 507          SSA_NAME.  Failure to canonicalize will cause us to
 508          miss threading opportunities.  */
 509       if (tree_swap_operands_p (op0, op1, false))
 510         {
 511           tree tmp;
 512           cond_code = swap_tree_comparison (cond_code);
 513           tmp = op0;
 514           op0 = op1;
 515           op1 = tmp;
 516         }
 517
 518       /* Stuff the operator and operands into our dummy conditional
 519          expression.  */
 520       gimple_cond_set_code (dummy_cond, cond_code);
 521       gimple_cond_set_lhs (dummy_cond, op0);
 522       gimple_cond_set_rhs (dummy_cond, op1);
 523
 524       /* We absolutely do not care about any type conversions
 525          we only care about a zero/nonzero value.  */
 526       fold_defer_overflow_warnings ();
 527
 528       cached_lhs = fold_binary (cond_code, boolean_type_node, op0, op1);
 529       if (cached_lhs)
 530         while (CONVERT_EXPR_P (cached_lhs))
 531           cached_lhs = TREE_OPERAND (cached_lhs, 0);
 532
 533       fold_undefer_overflow_warnings ((cached_lhs
 534                                        && is_gimple_min_invariant (cached_lhs)),
 535                                       stmt, WARN_STRICT_OVERFLOW_CONDITIONAL);
 536
 537       /* If we have not simplified the condition down to an invariant,
 538          then use the pass specific callback to simplify the condition.  */
 539       if (!cached_lhs
 540           || !is_gimple_min_invariant (cached_lhs))
 541         cached_lhs = (*simplify) (dummy_cond, stmt);
 542
 543       return cached_lhs;
 544     }
 545
 546   if (code == GIMPLE_SWITCH)
 547     cond = gimple_switch_index (stmt);
 548   else if (code == GIMPLE_GOTO)
 549     cond = gimple_goto_dest (stmt);
 550   else
 551     gcc_unreachable ();
 552
 553   /* We can have conditionals which just test the state of a variable
 554      rather than use a relational operator.  These are simpler to handle.  */
 555   if (TREE_CODE (cond) == SSA_NAME)
 556     {
 557       cached_lhs = cond;
 558
 559       /* Get the variable's current value from the equivalence chains.
 560
 561          It is possible to get loops in the SSA_NAME_VALUE chains
 562          (consider threading the backedge of a loop where we have
 563          a loop invariant SSA_NAME used in the condition.  */
 564       if (cached_lhs
 565           && TREE_CODE (cached_lhs) == SSA_NAME
 566           && SSA_NAME_VALUE (cached_lhs))
 567         cached_lhs = SSA_NAME_VALUE (cached_lhs);
 568
 569       /* If we're dominated by a suitable ASSERT_EXPR, then
 570          update CACHED_LHS appropriately.  */
 571       if (handle_dominating_asserts && TREE_CODE (cached_lhs) == SSA_NAME)
 572         cached_lhs = lhs_of_dominating_assert (cached_lhs, e->src, stmt);
 573
 574       /* If we haven't simplified to an invariant yet, then use the
 575          pass specific callback to try and simplify it further.  */
 576       if (cached_lhs && ! is_gimple_min_invariant (cached_lhs))
 577         cached_lhs = (*simplify) (stmt, stmt);
 578     }
 579   else
 580     cached_lhs = NULL;
 581
 582   return cached_lhs;
 583 }
 584
 585 /* We are exiting E->src, see if E->dest ends with a conditional
 586    jump which has a known value when reached via E.
 587
 588    Special care is necessary if E is a back edge in the CFG as we
 589    may have already recorded equivalences for E->dest into our
 590    various tables, including the result of the conditional at
 591    the end of E->dest.  Threading opportunities are severely
 592    limited in that case to avoid short-circuiting the loop
 593    incorrectly.
 594
 595    Note it is quite common for the first block inside a loop to
 596    end with a conditional which is either always true or always
 597    false when reached via the loop backedge.  Thus we do not want
 598    to blindly disable threading across a loop backedge.
 599
 600    DUMMY_COND is a shared cond_expr used by condition simplification as scratch,
 601    to avoid allocating memory.
 602
 603    HANDLE_DOMINATING_ASSERTS is true if we should try to replace operands of
 604    the simplified condition with left-hand sides of ASSERT_EXPRs they are
 605    used in.
 606
 607    STACK is used to undo temporary equivalences created during the walk of
 608    E->dest.
 609
 610    SIMPLIFY is a pass-specific function used to simplify statements.  */
 611
 612 void
 613 thread_across_edge (gimple dummy_cond,
 614                     edge e,
 615                     bool handle_dominating_asserts,
 616                     VEC(tree, heap) **stack,
 617                     tree (*simplify) (gimple, gimple))
 618 {
 619   gimple stmt;
 620
 621   /* If E is a backedge, then we want to verify that the COND_EXPR,
 622      SWITCH_EXPR or GOTO_EXPR at the end of e->dest is not affected
 623      by any statements in e->dest.  If it is affected, then it is not
 624      safe to thread this edge.  */
 625   if (e->flags & EDGE_DFS_BACK)
 626     {
 627       ssa_op_iter iter;
 628       use_operand_p use_p;
 629       gimple last = gsi_stmt (gsi_last_bb (e->dest));
 630
 631       FOR_EACH_SSA_USE_OPERAND (use_p, last, iter, SSA_OP_USE | SSA_OP_VUSE)
 632         {
 633           tree use = USE_FROM_PTR (use_p);
 634
 635           if (TREE_CODE (use) == SSA_NAME
 636               && gimple_code (SSA_NAME_DEF_STMT (use)) != GIMPLE_PHI
 637               && gimple_bb (SSA_NAME_DEF_STMT (use)) == e->dest)
 638             goto fail;
 639         }
 640     }
 641
 642   stmt_count = 0;
 643
 644   /* PHIs create temporary equivalences.  */
 645   if (!record_temporary_equivalences_from_phis (e, stack))
 646     goto fail;
 647
 648   /* Now walk each statement recording any context sensitive
 649      temporary equivalences we can detect.  */
 650   stmt = record_temporary_equivalences_from_stmts_at_dest (e, stack, simplify);
 651   if (!stmt)
 652     goto fail;
 653
 654   /* If we stopped at a COND_EXPR or SWITCH_EXPR, see if we know which arm
 655      will be taken.  */
 656   if (gimple_code (stmt) == GIMPLE_COND
 657       || gimple_code (stmt) == GIMPLE_GOTO
 658       || gimple_code (stmt) == GIMPLE_SWITCH)
 659     {
 660       tree cond;
 661
 662       /* Extract and simplify the condition.  */
 663       cond = simplify_control_stmt_condition (e, stmt, dummy_cond, simplify, handle_dominating_asserts);
 664
 665       if (cond && is_gimple_min_invariant (cond))
 666         {
 667           edge taken_edge = find_taken_edge (e->dest, cond);
 668           basic_block dest = (taken_edge ? taken_edge->dest : NULL);
 669
 670           if (dest == e->dest)
 671             goto fail;
 672
 673           remove_temporary_equivalences (stack);
 674           register_jump_thread (e, taken_edge);
 675         }
 676     }
 677
 678  fail:
 679   remove_temporary_equivalences (stack);
 680 }