1 /* Combining of if-expressions on trees. 2 Copyright (C) 2007, 2008 Free Software Foundation, Inc. 3 Contributed by Richard Guenther <rguenther@suse.de> 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 "basic-block.h" 27 #include "timevar.h" 28 #include "diagnostic.h" 29 #include "tree-flow.h" 30 #include "tree-pass.h" 31 #include "tree-dump.h" 32 33 /* This pass combines COND_EXPRs to simplify control flow. It 34 currently recognizes bit tests and comparisons in chains that 35 represent logical and or logical or of two COND_EXPRs. 36 37 It does so by walking basic blocks in a approximate reverse 38 post-dominator order and trying to match CFG patterns that 39 represent logical and or logical or of two COND_EXPRs. 40 Transformations are done if the COND_EXPR conditions match 41 either 42 43 1. two single bit tests X & (1 << Yn) (for logical and) 44 45 2. two bit tests X & Yn (for logical or) 46 47 3. two comparisons X OPn Y (for logical or) 48 49 To simplify this pass, removing basic blocks and dead code 50 is left to CFG cleanup and DCE. */ 51 52 53 /* Recognize a if-then-else CFG pattern starting to match with the 54 COND_BB basic-block containing the COND_EXPR. The recognized 55 then end else blocks are stored to *THEN_BB and *ELSE_BB. If 56 *THEN_BB and/or *ELSE_BB are already set, they are required to 57 match the then and else basic-blocks to make the pattern match. 58 Returns true if the pattern matched, false otherwise. */ 59 60 static bool 61 recognize_if_then_else (basic_block cond_bb, 62 basic_block *then_bb, basic_block *else_bb) 63 { 64 edge t, e; 65 66 if (EDGE_COUNT (cond_bb->succs) != 2) 67 return false; 68 69 /* Find the then/else edges. */ 70 t = EDGE_SUCC (cond_bb, 0); 71 e = EDGE_SUCC (cond_bb, 1); 72 if (!(t->flags & EDGE_TRUE_VALUE)) 73 { 74 edge tmp = t; 75 t = e; 76 e = tmp; 77 } 78 if (!(t->flags & EDGE_TRUE_VALUE) 79 || !(e->flags & EDGE_FALSE_VALUE)) 80 return false; 81 82 /* Check if the edge destinations point to the required block. */ 83 if (*then_bb 84 && t->dest != *then_bb) 85 return false; 86 if (*else_bb 87 && e->dest != *else_bb) 88 return false; 89 90 if (!*then_bb) 91 *then_bb = t->dest; 92 if (!*else_bb) 93 *else_bb = e->dest; 94 95 return true; 96 } 97 98 /* Verify if the basic block BB does not have side-effects. Return 99 true in this case, else false. */ 100 101 static bool 102 bb_no_side_effects_p (basic_block bb) 103 { 104 gimple_stmt_iterator gsi; 105 106 for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi)) 107 { 108 gimple stmt = gsi_stmt (gsi); 109 110 if (gimple_has_volatile_ops (stmt) 111 || gimple_vuse (stmt)) 112 return false; 113 } 114 115 return true; 116 } 117 118 /* Verify if all PHI node arguments in DEST for edges from BB1 or 119 BB2 to DEST are the same. This makes the CFG merge point 120 free from side-effects. Return true in this case, else false. */ 121 122 static bool 123 same_phi_args_p (basic_block bb1, basic_block bb2, basic_block dest) 124 { 125 edge e1 = find_edge (bb1, dest); 126 edge e2 = find_edge (bb2, dest); 127 gimple_stmt_iterator gsi; 128 gimple phi; 129 130 for (gsi = gsi_start_phis (dest); !gsi_end_p (gsi); gsi_next (&gsi)) 131 { 132 phi = gsi_stmt (gsi); 133 if (!operand_equal_p (PHI_ARG_DEF_FROM_EDGE (phi, e1), 134 PHI_ARG_DEF_FROM_EDGE (phi, e2), 0)) 135 return false; 136 } 137 138 return true; 139 } 140 141 /* Return the best representative SSA name for CANDIDATE which is used 142 in a bit test. */ 143 144 static tree 145 get_name_for_bit_test (tree candidate) 146 { 147 /* Skip single-use names in favor of using the name from a 148 non-widening conversion definition. */ 149 if (TREE_CODE (candidate) == SSA_NAME 150 && has_single_use (candidate)) 151 { 152 gimple def_stmt = SSA_NAME_DEF_STMT (candidate); 153 if (is_gimple_assign (def_stmt) 154 && CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (def_stmt))) 155 { 156 if (TYPE_PRECISION (TREE_TYPE (candidate)) 157 <= TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (def_stmt)))) 158 return gimple_assign_rhs1 (def_stmt); 159 } 160 } 161 162 return candidate; 163 } 164 165 /* Recognize a single bit test pattern in GIMPLE_COND and its defining 166 statements. Store the name being tested in *NAME and the bit 167 in *BIT. The GIMPLE_COND computes *NAME & (1 << *BIT). 168 Returns true if the pattern matched, false otherwise. */ 169 170 static bool 171 recognize_single_bit_test (gimple cond, tree *name, tree *bit) 172 { 173 gimple stmt; 174 175 /* Get at the definition of the result of the bit test. */ 176 if (gimple_cond_code (cond) != NE_EXPR 177 || TREE_CODE (gimple_cond_lhs (cond)) != SSA_NAME 178 || !integer_zerop (gimple_cond_rhs (cond))) 179 return false; 180 stmt = SSA_NAME_DEF_STMT (gimple_cond_lhs (cond)); 181 if (!is_gimple_assign (stmt)) 182 return false; 183 184 /* Look at which bit is tested. One form to recognize is 185 D.1985_5 = state_3(D) >> control1_4(D); 186 D.1986_6 = (int) D.1985_5; 187 D.1987_7 = op0 & 1; 188 if (D.1987_7 != 0) */ 189 if (gimple_assign_rhs_code (stmt) == BIT_AND_EXPR 190 && integer_onep (gimple_assign_rhs2 (stmt)) 191 && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME) 192 { 193 tree orig_name = gimple_assign_rhs1 (stmt); 194 195 /* Look through copies and conversions to eventually 196 find the stmt that computes the shift. */ 197 stmt = SSA_NAME_DEF_STMT (orig_name); 198 199 while (is_gimple_assign (stmt) 200 && ((CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (stmt)) 201 && (TYPE_PRECISION (TREE_TYPE (gimple_assign_lhs (stmt))) 202 <= TYPE_PRECISION (TREE_TYPE (gimple_assign_rhs1 (stmt))))) 203 || gimple_assign_ssa_name_copy_p (stmt))) 204 stmt = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt)); 205 206 /* If we found such, decompose it. */ 207 if (is_gimple_assign (stmt) 208 && gimple_assign_rhs_code (stmt) == RSHIFT_EXPR) 209 { 210 /* op0 & (1 << op1) */ 211 *bit = gimple_assign_rhs2 (stmt); 212 *name = gimple_assign_rhs1 (stmt); 213 } 214 else 215 { 216 /* t & 1 */ 217 *bit = integer_zero_node; 218 *name = get_name_for_bit_test (orig_name); 219 } 220 221 return true; 222 } 223 224 /* Another form is 225 D.1987_7 = op0 & (1 << CST) 226 if (D.1987_7 != 0) */ 227 if (gimple_assign_rhs_code (stmt) == BIT_AND_EXPR 228 && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME 229 && integer_pow2p (gimple_assign_rhs2 (stmt))) 230 { 231 *name = gimple_assign_rhs1 (stmt); 232 *bit = build_int_cst (integer_type_node, 233 tree_log2 (gimple_assign_rhs2 (stmt))); 234 return true; 235 } 236 237 /* Another form is 238 D.1986_6 = 1 << control1_4(D) 239 D.1987_7 = op0 & D.1986_6 240 if (D.1987_7 != 0) */ 241 if (gimple_assign_rhs_code (stmt) == BIT_AND_EXPR 242 && TREE_CODE (gimple_assign_rhs1 (stmt)) == SSA_NAME 243 && TREE_CODE (gimple_assign_rhs2 (stmt)) == SSA_NAME) 244 { 245 gimple tmp; 246 247 /* Both arguments of the BIT_AND_EXPR can be the single-bit 248 specifying expression. */ 249 tmp = SSA_NAME_DEF_STMT (gimple_assign_rhs1 (stmt)); 250 if (is_gimple_assign (tmp) 251 && gimple_assign_rhs_code (tmp) == LSHIFT_EXPR 252 && integer_onep (gimple_assign_rhs1 (tmp))) 253 { 254 *name = gimple_assign_rhs2 (stmt); 255 *bit = gimple_assign_rhs2 (tmp); 256 return true; 257 } 258 259 tmp = SSA_NAME_DEF_STMT (gimple_assign_rhs2 (stmt)); 260 if (is_gimple_assign (tmp) 261 && gimple_assign_rhs_code (tmp) == LSHIFT_EXPR 262 && integer_onep (gimple_assign_rhs1 (tmp))) 263 { 264 *name = gimple_assign_rhs1 (stmt); 265 *bit = gimple_assign_rhs2 (tmp); 266 return true; 267 } 268 } 269 270 return false; 271 } 272 273 /* Recognize a bit test pattern in a GIMPLE_COND and its defining 274 statements. Store the name being tested in *NAME and the bits 275 in *BITS. The COND_EXPR computes *NAME & *BITS. 276 Returns true if the pattern matched, false otherwise. */ 277 278 static bool 279 recognize_bits_test (gimple cond, tree *name, tree *bits) 280 { 281 gimple stmt; 282 283 /* Get at the definition of the result of the bit test. */ 284 if (gimple_cond_code (cond) != NE_EXPR 285 || TREE_CODE (gimple_cond_lhs (cond)) != SSA_NAME 286 || !integer_zerop (gimple_cond_rhs (cond))) 287 return false; 288 stmt = SSA_NAME_DEF_STMT (gimple_cond_lhs (cond)); 289 if (!is_gimple_assign (stmt) 290 || gimple_assign_rhs_code (stmt) != BIT_AND_EXPR) 291 return false; 292 293 *name = get_name_for_bit_test (gimple_assign_rhs1 (stmt)); 294 *bits = gimple_assign_rhs2 (stmt); 295 296 return true; 297 } 298 299 /* If-convert on a and pattern with a common else block. The inner 300 if is specified by its INNER_COND_BB, the outer by OUTER_COND_BB. 301 Returns true if the edges to the common else basic-block were merged. */ 302 303 static bool 304 ifcombine_ifandif (basic_block inner_cond_bb, basic_block outer_cond_bb) 305 { 306 gimple_stmt_iterator gsi; 307 gimple inner_cond, outer_cond; 308 tree name1, name2, bit1, bit2; 309 310 inner_cond = last_stmt (inner_cond_bb); 311 if (!inner_cond 312 || gimple_code (inner_cond) != GIMPLE_COND) 313 return false; 314 315 outer_cond = last_stmt (outer_cond_bb); 316 if (!outer_cond 317 || gimple_code (outer_cond) != GIMPLE_COND) 318 return false; 319 320 /* See if we test a single bit of the same name in both tests. In 321 that case remove the outer test, merging both else edges, 322 and change the inner one to test for 323 name & (bit1 | bit2) == (bit1 | bit2). */ 324 if (recognize_single_bit_test (inner_cond, &name1, &bit1) 325 && recognize_single_bit_test (outer_cond, &name2, &bit2) 326 && name1 == name2) 327 { 328 tree t, t2; 329 330 /* Do it. */ 331 gsi = gsi_for_stmt (inner_cond); 332 t = fold_build2 (LSHIFT_EXPR, TREE_TYPE (name1), 333 build_int_cst (TREE_TYPE (name1), 1), bit1); 334 t2 = fold_build2 (LSHIFT_EXPR, TREE_TYPE (name1), 335 build_int_cst (TREE_TYPE (name1), 1), bit2); 336 t = fold_build2 (BIT_IOR_EXPR, TREE_TYPE (name1), t, t2); 337 t = force_gimple_operand_gsi (&gsi, t, true, NULL_TREE, 338 true, GSI_SAME_STMT); 339 t2 = fold_build2 (BIT_AND_EXPR, TREE_TYPE (name1), name1, t); 340 t2 = force_gimple_operand_gsi (&gsi, t2, true, NULL_TREE, 341 true, GSI_SAME_STMT); 342 t = fold_build2 (EQ_EXPR, boolean_type_node, t2, t); 343 t = canonicalize_cond_expr_cond (t); 344 if (!t) 345 return false; 346 gimple_cond_set_condition_from_tree (inner_cond, t); 347 update_stmt (inner_cond); 348 349 /* Leave CFG optimization to cfg_cleanup. */ 350 gimple_cond_set_condition_from_tree (outer_cond, boolean_true_node); 351 update_stmt (outer_cond); 352 353 if (dump_file) 354 { 355 fprintf (dump_file, "optimizing double bit test to "); 356 print_generic_expr (dump_file, name1, 0); 357 fprintf (dump_file, " & T == T\nwith temporary T = (1 << "); 358 print_generic_expr (dump_file, bit1, 0); 359 fprintf (dump_file, ") | (1 << "); 360 print_generic_expr (dump_file, bit2, 0); 361 fprintf (dump_file, ")\n"); 362 } 363 364 return true; 365 } 366 367 /* See if we have two comparisons that we can merge into one. */ 368 else if (TREE_CODE_CLASS (gimple_cond_code (inner_cond)) == tcc_comparison 369 && TREE_CODE_CLASS (gimple_cond_code (outer_cond)) == tcc_comparison 370 && operand_equal_p (gimple_cond_lhs (inner_cond), 371 gimple_cond_lhs (outer_cond), 0) 372 && operand_equal_p (gimple_cond_rhs (inner_cond), 373 gimple_cond_rhs (outer_cond), 0)) 374 { 375 enum tree_code code1 = gimple_cond_code (inner_cond); 376 enum tree_code code2 = gimple_cond_code (outer_cond); 377 tree t; 378 379 if (!(t = combine_comparisons (UNKNOWN_LOCATION, 380 TRUTH_ANDIF_EXPR, code1, code2, 381 boolean_type_node, 382 gimple_cond_lhs (outer_cond), 383 gimple_cond_rhs (outer_cond)))) 384 return false; 385 t = canonicalize_cond_expr_cond (t); 386 if (!t) 387 return false; 388 gimple_cond_set_condition_from_tree (inner_cond, t); 389 update_stmt (inner_cond); 390 391 /* Leave CFG optimization to cfg_cleanup. */ 392 gimple_cond_set_condition_from_tree (outer_cond, boolean_true_node); 393 update_stmt (outer_cond); 394 395 if (dump_file) 396 { 397 fprintf (dump_file, "optimizing two comparisons to "); 398 print_generic_expr (dump_file, t, 0); 399 fprintf (dump_file, "\n"); 400 } 401 402 return true; 403 } 404 405 return false; 406 } 407 408 /* If-convert on a or pattern with a common then block. The inner 409 if is specified by its INNER_COND_BB, the outer by OUTER_COND_BB. 410 Returns true, if the edges leading to the common then basic-block 411 were merged. */ 412 413 static bool 414 ifcombine_iforif (basic_block inner_cond_bb, basic_block outer_cond_bb) 415 { 416 gimple inner_cond, outer_cond; 417 tree name1, name2, bits1, bits2; 418 419 inner_cond = last_stmt (inner_cond_bb); 420 if (!inner_cond 421 || gimple_code (inner_cond) != GIMPLE_COND) 422 return false; 423 424 outer_cond = last_stmt (outer_cond_bb); 425 if (!outer_cond 426 || gimple_code (outer_cond) != GIMPLE_COND) 427 return false; 428 429 /* See if we have two bit tests of the same name in both tests. 430 In that case remove the outer test and change the inner one to 431 test for name & (bits1 | bits2) != 0. */ 432 if (recognize_bits_test (inner_cond, &name1, &bits1) 433 && recognize_bits_test (outer_cond, &name2, &bits2)) 434 { 435 gimple_stmt_iterator gsi; 436 tree t; 437 438 /* Find the common name which is bit-tested. */ 439 if (name1 == name2) 440 ; 441 else if (bits1 == bits2) 442 { 443 t = name2; 444 name2 = bits2; 445 bits2 = t; 446 t = name1; 447 name1 = bits1; 448 bits1 = t; 449 } 450 else if (name1 == bits2) 451 { 452 t = name2; 453 name2 = bits2; 454 bits2 = t; 455 } 456 else if (bits1 == name2) 457 { 458 t = name1; 459 name1 = bits1; 460 bits1 = t; 461 } 462 else 463 return false; 464 465 /* As we strip non-widening conversions in finding a common 466 name that is tested make sure to end up with an integral 467 type for building the bit operations. */ 468 if (TYPE_PRECISION (TREE_TYPE (bits1)) 469 >= TYPE_PRECISION (TREE_TYPE (bits2))) 470 { 471 bits1 = fold_convert (unsigned_type_for (TREE_TYPE (bits1)), bits1); 472 name1 = fold_convert (TREE_TYPE (bits1), name1); 473 bits2 = fold_convert (unsigned_type_for (TREE_TYPE (bits2)), bits2); 474 bits2 = fold_convert (TREE_TYPE (bits1), bits2); 475 } 476 else 477 { 478 bits2 = fold_convert (unsigned_type_for (TREE_TYPE (bits2)), bits2); 479 name1 = fold_convert (TREE_TYPE (bits2), name1); 480 bits1 = fold_convert (unsigned_type_for (TREE_TYPE (bits1)), bits1); 481 bits1 = fold_convert (TREE_TYPE (bits2), bits1); 482 } 483 484 /* Do it. */ 485 gsi = gsi_for_stmt (inner_cond); 486 t = fold_build2 (BIT_IOR_EXPR, TREE_TYPE (name1), bits1, bits2); 487 t = force_gimple_operand_gsi (&gsi, t, true, NULL_TREE, 488 true, GSI_SAME_STMT); 489 t = fold_build2 (BIT_AND_EXPR, TREE_TYPE (name1), name1, t); 490 t = force_gimple_operand_gsi (&gsi, t, true, NULL_TREE, 491 true, GSI_SAME_STMT); 492 t = fold_build2 (NE_EXPR, boolean_type_node, t, 493 build_int_cst (TREE_TYPE (t), 0)); 494 t = canonicalize_cond_expr_cond (t); 495 if (!t) 496 return false; 497 gimple_cond_set_condition_from_tree (inner_cond, t); 498 update_stmt (inner_cond); 499 500 /* Leave CFG optimization to cfg_cleanup. */ 501 gimple_cond_set_condition_from_tree (outer_cond, boolean_false_node); 502 update_stmt (outer_cond); 503 504 if (dump_file) 505 { 506 fprintf (dump_file, "optimizing bits or bits test to "); 507 print_generic_expr (dump_file, name1, 0); 508 fprintf (dump_file, " & T != 0\nwith temporary T = "); 509 print_generic_expr (dump_file, bits1, 0); 510 fprintf (dump_file, " | "); 511 print_generic_expr (dump_file, bits2, 0); 512 fprintf (dump_file, "\n"); 513 } 514 515 return true; 516 } 517 518 /* See if we have two comparisons that we can merge into one. 519 This happens for C++ operator overloading where for example 520 GE_EXPR is implemented as GT_EXPR || EQ_EXPR. */ 521 else if (TREE_CODE_CLASS (gimple_cond_code (inner_cond)) == tcc_comparison 522 && TREE_CODE_CLASS (gimple_cond_code (outer_cond)) == tcc_comparison 523 && operand_equal_p (gimple_cond_lhs (inner_cond), 524 gimple_cond_lhs (outer_cond), 0) 525 && operand_equal_p (gimple_cond_rhs (inner_cond), 526 gimple_cond_rhs (outer_cond), 0)) 527 { 528 enum tree_code code1 = gimple_cond_code (inner_cond); 529 enum tree_code code2 = gimple_cond_code (outer_cond); 530 tree t; 531 532 if (!(t = combine_comparisons (UNKNOWN_LOCATION, 533 TRUTH_ORIF_EXPR, code1, code2, 534 boolean_type_node, 535 gimple_cond_lhs (outer_cond), 536 gimple_cond_rhs (outer_cond)))) 537 return false; 538 t = canonicalize_cond_expr_cond (t); 539 if (!t) 540 return false; 541 gimple_cond_set_condition_from_tree (inner_cond, t); 542 update_stmt (inner_cond); 543 544 /* Leave CFG optimization to cfg_cleanup. */ 545 gimple_cond_set_condition_from_tree (outer_cond, boolean_false_node); 546 update_stmt (outer_cond); 547 548 if (dump_file) 549 { 550 fprintf (dump_file, "optimizing two comparisons to "); 551 print_generic_expr (dump_file, t, 0); 552 fprintf (dump_file, "\n"); 553 } 554 555 return true; 556 } 557 558 return false; 559 } 560 561 /* Recognize a CFG pattern and dispatch to the appropriate 562 if-conversion helper. We start with BB as the innermost 563 worker basic-block. Returns true if a transformation was done. */ 564 565 static bool 566 tree_ssa_ifcombine_bb (basic_block inner_cond_bb) 567 { 568 basic_block then_bb = NULL, else_bb = NULL; 569 570 if (!recognize_if_then_else (inner_cond_bb, &then_bb, &else_bb)) 571 return false; 572 573 /* Recognize && and || of two conditions with a common 574 then/else block which entry edges we can merge. That is: 575 if (a || b) 576 ; 577 and 578 if (a && b) 579 ; 580 This requires a single predecessor of the inner cond_bb. */ 581 if (single_pred_p (inner_cond_bb)) 582 { 583 basic_block outer_cond_bb = single_pred (inner_cond_bb); 584 585 /* The && form is characterized by a common else_bb with 586 the two edges leading to it mergable. The latter is 587 guaranteed by matching PHI arguments in the else_bb and 588 the inner cond_bb having no side-effects. */ 589 if (recognize_if_then_else (outer_cond_bb, &inner_cond_bb, &else_bb) 590 && same_phi_args_p (outer_cond_bb, inner_cond_bb, else_bb) 591 && bb_no_side_effects_p (inner_cond_bb)) 592 { 593 /* We have 594 <outer_cond_bb> 595 if (q) goto inner_cond_bb; else goto else_bb; 596 <inner_cond_bb> 597 if (p) goto ...; else goto else_bb; 598 ... 599 <else_bb> 600 ... 601 */ 602 return ifcombine_ifandif (inner_cond_bb, outer_cond_bb); 603 } 604 605 /* The || form is characterized by a common then_bb with the 606 two edges leading to it mergable. The latter is guaranteed 607 by matching PHI arguments in the then_bb and the inner cond_bb 608 having no side-effects. */ 609 if (recognize_if_then_else (outer_cond_bb, &then_bb, &inner_cond_bb) 610 && same_phi_args_p (outer_cond_bb, inner_cond_bb, then_bb) 611 && bb_no_side_effects_p (inner_cond_bb)) 612 { 613 /* We have 614 <outer_cond_bb> 615 if (q) goto then_bb; else goto inner_cond_bb; 616 <inner_cond_bb> 617 if (q) goto then_bb; else goto ...; 618 <then_bb> 619 ... 620 */ 621 return ifcombine_iforif (inner_cond_bb, outer_cond_bb); 622 } 623 } 624 625 return false; 626 } 627 628 /* Main entry for the tree if-conversion pass. */ 629 630 static unsigned int 631 tree_ssa_ifcombine (void) 632 { 633 basic_block *bbs; 634 bool cfg_changed = false; 635 int i; 636 637 bbs = blocks_in_phiopt_order (); 638 639 for (i = 0; i < n_basic_blocks - NUM_FIXED_BLOCKS; ++i) 640 { 641 basic_block bb = bbs[i]; 642 gimple stmt = last_stmt (bb); 643 644 if (stmt 645 && gimple_code (stmt) == GIMPLE_COND) 646 cfg_changed |= tree_ssa_ifcombine_bb (bb); 647 } 648 649 free (bbs); 650 651 return cfg_changed ? TODO_cleanup_cfg : 0; 652 } 653 654 static bool 655 gate_ifcombine (void) 656 { 657 return 1; 658 } 659 660 struct gimple_opt_pass pass_tree_ifcombine = 661 { 662 { 663 GIMPLE_PASS, 664 "ifcombine", /* name */ 665 gate_ifcombine, /* gate */ 666 tree_ssa_ifcombine, /* execute */ 667 NULL, /* sub */ 668 NULL, /* next */ 669 0, /* static_pass_number */ 670 TV_TREE_IFCOMBINE, /* tv_id */ 671 PROP_cfg | PROP_ssa, /* properties_required */ 672 0, /* properties_provided */ 673 0, /* properties_destroyed */ 674 0, /* todo_flags_start */ 675 TODO_dump_func 676 | TODO_ggc_collect 677 | TODO_update_ssa 678 | TODO_verify_ssa /* todo_flags_finish */ 679 } 680 }; 681