gcc/tree-ssa-threadedge.c

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