1 /* Interprocedural Identical Code Folding pass 2 Copyright (C) 2014-2019 Free Software Foundation, Inc. 3 4 Contributed by Jan Hubicka <hubicka@ucw.cz> and Martin Liska <mliska@suse.cz> 5 6 This file is part of GCC. 7 8 GCC is free software; you can redistribute it and/or modify it under 9 the terms of the GNU General Public License as published by the Free 10 Software Foundation; either version 3, or (at your option) any later 11 version. 12 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16 for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GCC; see the file COPYING3. If not see 20 <http://www.gnu.org/licenses/>. */ 21 22 #include "config.h" 23 #include "system.h" 24 #include "coretypes.h" 25 #include "backend.h" 26 #include "rtl.h" 27 #include "tree.h" 28 #include "gimple.h" 29 #include "tree-pass.h" 30 #include "ssa.h" 31 #include "cgraph.h" 32 #include "data-streamer.h" 33 #include "gimple-pretty-print.h" 34 #include "alias.h" 35 #include "fold-const.h" 36 #include "gimple-iterator.h" 37 #include "ipa-utils.h" 38 #include "tree-eh.h" 39 #include "builtins.h" 40 41 #include "ipa-icf-gimple.h" 42 43 namespace ipa_icf_gimple { 44 45 /* Initialize internal structures for a given SOURCE_FUNC_DECL and 46 TARGET_FUNC_DECL. Strict polymorphic comparison is processed if 47 an option COMPARE_POLYMORPHIC is true. For special cases, one can 48 set IGNORE_LABELS to skip label comparison. 49 Similarly, IGNORE_SOURCE_DECLS and IGNORE_TARGET_DECLS are sets 50 of declarations that can be skipped. */ 51 52 func_checker::func_checker (tree source_func_decl, tree target_func_decl, 53 bool compare_polymorphic, 54 bool ignore_labels, 55 hash_set<symtab_node *> *ignored_source_nodes, 56 hash_set<symtab_node *> *ignored_target_nodes) 57 : m_source_func_decl (source_func_decl), m_target_func_decl (target_func_decl), 58 m_ignored_source_nodes (ignored_source_nodes), 59 m_ignored_target_nodes (ignored_target_nodes), 60 m_compare_polymorphic (compare_polymorphic), 61 m_ignore_labels (ignore_labels) 62 { 63 function *source_func = DECL_STRUCT_FUNCTION (source_func_decl); 64 function *target_func = DECL_STRUCT_FUNCTION (target_func_decl); 65 66 unsigned ssa_source = SSANAMES (source_func)->length (); 67 unsigned ssa_target = SSANAMES (target_func)->length (); 68 69 m_source_ssa_names.create (ssa_source); 70 m_target_ssa_names.create (ssa_target); 71 72 for (unsigned i = 0; i < ssa_source; i++) 73 m_source_ssa_names.safe_push (-1); 74 75 for (unsigned i = 0; i < ssa_target; i++) 76 m_target_ssa_names.safe_push (-1); 77 } 78 79 /* Memory release routine. */ 80 81 func_checker::~func_checker () 82 { 83 m_source_ssa_names.release(); 84 m_target_ssa_names.release(); 85 } 86 87 /* Verifies that trees T1 and T2 are equivalent from perspective of ICF. */ 88 89 bool 90 func_checker::compare_ssa_name (tree t1, tree t2) 91 { 92 gcc_assert (TREE_CODE (t1) == SSA_NAME); 93 gcc_assert (TREE_CODE (t2) == SSA_NAME); 94 95 unsigned i1 = SSA_NAME_VERSION (t1); 96 unsigned i2 = SSA_NAME_VERSION (t2); 97 98 if (m_source_ssa_names[i1] == -1) 99 m_source_ssa_names[i1] = i2; 100 else if (m_source_ssa_names[i1] != (int) i2) 101 return false; 102 103 if(m_target_ssa_names[i2] == -1) 104 m_target_ssa_names[i2] = i1; 105 else if (m_target_ssa_names[i2] != (int) i1) 106 return false; 107 108 if (SSA_NAME_IS_DEFAULT_DEF (t1)) 109 { 110 tree b1 = SSA_NAME_VAR (t1); 111 tree b2 = SSA_NAME_VAR (t2); 112 113 if (b1 == NULL && b2 == NULL) 114 return true; 115 116 if (b1 == NULL || b2 == NULL || TREE_CODE (b1) != TREE_CODE (b2)) 117 return return_false (); 118 119 return compare_cst_or_decl (b1, b2); 120 } 121 122 return true; 123 } 124 125 /* Verification function for edges E1 and E2. */ 126 127 bool 128 func_checker::compare_edge (edge e1, edge e2) 129 { 130 if (e1->flags != e2->flags) 131 return false; 132 133 bool existed_p; 134 135 edge &slot = m_edge_map.get_or_insert (e1, &existed_p); 136 if (existed_p) 137 return return_with_debug (slot == e2); 138 else 139 slot = e2; 140 141 /* TODO: filter edge probabilities for profile feedback match. */ 142 143 return true; 144 } 145 146 /* Verification function for declaration trees T1 and T2 that 147 come from functions FUNC1 and FUNC2. */ 148 149 bool 150 func_checker::compare_decl (tree t1, tree t2) 151 { 152 if (!auto_var_in_fn_p (t1, m_source_func_decl) 153 || !auto_var_in_fn_p (t2, m_target_func_decl)) 154 return return_with_debug (t1 == t2); 155 156 tree_code t = TREE_CODE (t1); 157 if ((t == VAR_DECL || t == PARM_DECL || t == RESULT_DECL) 158 && DECL_BY_REFERENCE (t1) != DECL_BY_REFERENCE (t2)) 159 return return_false_with_msg ("DECL_BY_REFERENCE flags are different"); 160 161 if (!compatible_types_p (TREE_TYPE (t1), TREE_TYPE (t2))) 162 return return_false (); 163 164 /* TODO: we are actually too strict here. We only need to compare if 165 T1 can be used in polymorphic call. */ 166 if (TREE_ADDRESSABLE (t1) 167 && m_compare_polymorphic 168 && !compatible_polymorphic_types_p (TREE_TYPE (t1), TREE_TYPE (t2), 169 false)) 170 return return_false (); 171 172 if ((t == VAR_DECL || t == PARM_DECL || t == RESULT_DECL) 173 && DECL_BY_REFERENCE (t1) 174 && m_compare_polymorphic 175 && !compatible_polymorphic_types_p (TREE_TYPE (t1), TREE_TYPE (t2), 176 true)) 177 return return_false (); 178 179 bool existed_p; 180 181 tree &slot = m_decl_map.get_or_insert (t1, &existed_p); 182 if (existed_p) 183 return return_with_debug (slot == t2); 184 else 185 slot = t2; 186 187 return true; 188 } 189 190 /* Return true if T1 and T2 are same for purposes of ipa-polymorphic-call 191 analysis. COMPARE_PTR indicates if types of pointers needs to be 192 considered. */ 193 194 bool 195 func_checker::compatible_polymorphic_types_p (tree t1, tree t2, 196 bool compare_ptr) 197 { 198 gcc_assert (TREE_CODE (t1) != FUNCTION_TYPE && TREE_CODE (t1) != METHOD_TYPE); 199 200 /* Pointer types generally give no information. */ 201 if (POINTER_TYPE_P (t1)) 202 { 203 if (!compare_ptr) 204 return true; 205 return func_checker::compatible_polymorphic_types_p (TREE_TYPE (t1), 206 TREE_TYPE (t2), 207 false); 208 } 209 210 /* If types contain a polymorphic types, match them. */ 211 bool c1 = contains_polymorphic_type_p (t1); 212 bool c2 = contains_polymorphic_type_p (t2); 213 if (!c1 && !c2) 214 return true; 215 if (!c1 || !c2) 216 return return_false_with_msg ("one type is not polymorphic"); 217 if (!types_must_be_same_for_odr (t1, t2)) 218 return return_false_with_msg ("types are not same for ODR"); 219 return true; 220 } 221 222 /* Return true if types are compatible from perspective of ICF. */ 223 bool 224 func_checker::compatible_types_p (tree t1, tree t2) 225 { 226 if (TREE_CODE (t1) != TREE_CODE (t2)) 227 return return_false_with_msg ("different tree types"); 228 229 if (TYPE_RESTRICT (t1) != TYPE_RESTRICT (t2)) 230 return return_false_with_msg ("restrict flags are different"); 231 232 if (!types_compatible_p (t1, t2)) 233 return return_false_with_msg ("types are not compatible"); 234 235 /* We do a lot of unnecesary matching of types that are not being 236 accessed and thus do not need to be compatible. In longer term we should 237 remove these checks on all types which are not accessed as memory 238 locations. 239 240 For time being just avoid calling get_alias_set on types that are not 241 having alias sets defined at all. */ 242 if (type_with_alias_set_p (t1) && type_with_alias_set_p (t2) 243 && get_alias_set (t1) != get_alias_set (t2)) 244 return return_false_with_msg ("alias sets are different"); 245 246 return true; 247 } 248 249 /* Function compare for equality given memory operands T1 and T2. */ 250 251 bool 252 func_checker::compare_memory_operand (tree t1, tree t2) 253 { 254 if (!t1 && !t2) 255 return true; 256 else if (!t1 || !t2) 257 return false; 258 259 ao_ref r1, r2; 260 ao_ref_init (&r1, t1); 261 ao_ref_init (&r2, t2); 262 263 tree b1 = ao_ref_base (&r1); 264 tree b2 = ao_ref_base (&r2); 265 266 bool source_is_memop = DECL_P (b1) || INDIRECT_REF_P (b1) 267 || TREE_CODE (b1) == MEM_REF 268 || TREE_CODE (b1) == TARGET_MEM_REF; 269 270 bool target_is_memop = DECL_P (b2) || INDIRECT_REF_P (b2) 271 || TREE_CODE (b2) == MEM_REF 272 || TREE_CODE (b2) == TARGET_MEM_REF; 273 274 /* Compare alias sets for memory operands. */ 275 if (source_is_memop && target_is_memop) 276 { 277 if (TREE_THIS_VOLATILE (t1) != TREE_THIS_VOLATILE (t2)) 278 return return_false_with_msg ("different operand volatility"); 279 280 if (ao_ref_alias_set (&r1) != ao_ref_alias_set (&r2) 281 || ao_ref_base_alias_set (&r1) != ao_ref_base_alias_set (&r2)) 282 return return_false_with_msg ("ao alias sets are different"); 283 284 /* We can't simply use get_object_alignment_1 on the full 285 reference as for accesses with variable indexes this reports 286 too conservative alignment. We also can't use the ao_ref_base 287 base objects as ao_ref_base happily strips MEM_REFs around 288 decls even though that may carry alignment info. */ 289 b1 = t1; 290 while (handled_component_p (b1)) 291 b1 = TREE_OPERAND (b1, 0); 292 b2 = t2; 293 while (handled_component_p (b2)) 294 b2 = TREE_OPERAND (b2, 0); 295 unsigned int align1, align2; 296 unsigned HOST_WIDE_INT tem; 297 get_object_alignment_1 (b1, &align1, &tem); 298 get_object_alignment_1 (b2, &align2, &tem); 299 if (align1 != align2) 300 return return_false_with_msg ("different access alignment"); 301 302 /* Similarly we have to compare dependence info where equality 303 tells us we are safe (even some unequal values would be safe 304 but then we have to maintain a map of bases and cliques). */ 305 unsigned short clique1 = 0, base1 = 0, clique2 = 0, base2 = 0; 306 if (TREE_CODE (b1) == MEM_REF) 307 { 308 clique1 = MR_DEPENDENCE_CLIQUE (b1); 309 base1 = MR_DEPENDENCE_BASE (b1); 310 } 311 if (TREE_CODE (b2) == MEM_REF) 312 { 313 clique2 = MR_DEPENDENCE_CLIQUE (b2); 314 base2 = MR_DEPENDENCE_BASE (b2); 315 } 316 if (clique1 != clique2 || base1 != base2) 317 return return_false_with_msg ("different dependence info"); 318 } 319 320 return compare_operand (t1, t2); 321 } 322 323 /* Function compare for equality given trees T1 and T2 which 324 can be either a constant or a declaration type. */ 325 326 bool 327 func_checker::compare_cst_or_decl (tree t1, tree t2) 328 { 329 bool ret; 330 331 switch (TREE_CODE (t1)) 332 { 333 case INTEGER_CST: 334 case COMPLEX_CST: 335 case VECTOR_CST: 336 case STRING_CST: 337 case REAL_CST: 338 { 339 ret = compatible_types_p (TREE_TYPE (t1), TREE_TYPE (t2)) 340 && operand_equal_p (t1, t2, OEP_ONLY_CONST); 341 return return_with_debug (ret); 342 } 343 case FUNCTION_DECL: 344 /* All function decls are in the symbol table and known to match 345 before we start comparing bodies. */ 346 return true; 347 case VAR_DECL: 348 return return_with_debug (compare_variable_decl (t1, t2)); 349 case FIELD_DECL: 350 { 351 tree offset1 = DECL_FIELD_OFFSET (t1); 352 tree offset2 = DECL_FIELD_OFFSET (t2); 353 354 tree bit_offset1 = DECL_FIELD_BIT_OFFSET (t1); 355 tree bit_offset2 = DECL_FIELD_BIT_OFFSET (t2); 356 357 ret = compare_operand (offset1, offset2) 358 && compare_operand (bit_offset1, bit_offset2); 359 360 return return_with_debug (ret); 361 } 362 case LABEL_DECL: 363 { 364 if (t1 == t2) 365 return true; 366 367 int *bb1 = m_label_bb_map.get (t1); 368 int *bb2 = m_label_bb_map.get (t2); 369 370 /* Labels can point to another function (non-local GOTOs). */ 371 return return_with_debug (bb1 != NULL && bb2 != NULL && *bb1 == *bb2); 372 } 373 case PARM_DECL: 374 case RESULT_DECL: 375 case CONST_DECL: 376 { 377 ret = compare_decl (t1, t2); 378 return return_with_debug (ret); 379 } 380 default: 381 gcc_unreachable (); 382 } 383 } 384 385 /* Function responsible for comparison of various operands T1 and T2. 386 If these components, from functions FUNC1 and FUNC2, are equal, true 387 is returned. */ 388 389 bool 390 func_checker::compare_operand (tree t1, tree t2) 391 { 392 tree x1, x2, y1, y2, z1, z2; 393 bool ret; 394 395 if (!t1 && !t2) 396 return true; 397 else if (!t1 || !t2) 398 return false; 399 400 tree tt1 = TREE_TYPE (t1); 401 tree tt2 = TREE_TYPE (t2); 402 403 if (!func_checker::compatible_types_p (tt1, tt2)) 404 return false; 405 406 if (TREE_CODE (t1) != TREE_CODE (t2)) 407 return return_false (); 408 409 switch (TREE_CODE (t1)) 410 { 411 case CONSTRUCTOR: 412 { 413 unsigned length1 = CONSTRUCTOR_NELTS (t1); 414 unsigned length2 = CONSTRUCTOR_NELTS (t2); 415 416 if (length1 != length2) 417 return return_false (); 418 419 for (unsigned i = 0; i < length1; i++) 420 if (!compare_operand (CONSTRUCTOR_ELT (t1, i)->value, 421 CONSTRUCTOR_ELT (t2, i)->value)) 422 return return_false(); 423 424 return true; 425 } 426 case ARRAY_REF: 427 case ARRAY_RANGE_REF: 428 /* First argument is the array, second is the index. */ 429 x1 = TREE_OPERAND (t1, 0); 430 x2 = TREE_OPERAND (t2, 0); 431 y1 = TREE_OPERAND (t1, 1); 432 y2 = TREE_OPERAND (t2, 1); 433 434 if (!compare_operand (array_ref_low_bound (t1), 435 array_ref_low_bound (t2))) 436 return return_false_with_msg (""); 437 if (!compare_operand (array_ref_element_size (t1), 438 array_ref_element_size (t2))) 439 return return_false_with_msg (""); 440 441 if (!compare_operand (x1, x2)) 442 return return_false_with_msg (""); 443 return compare_operand (y1, y2); 444 case MEM_REF: 445 { 446 x1 = TREE_OPERAND (t1, 0); 447 x2 = TREE_OPERAND (t2, 0); 448 y1 = TREE_OPERAND (t1, 1); 449 y2 = TREE_OPERAND (t2, 1); 450 451 /* See if operand is an memory access (the test originate from 452 gimple_load_p). 453 454 In this case the alias set of the function being replaced must 455 be subset of the alias set of the other function. At the moment 456 we seek for equivalency classes, so simply require inclussion in 457 both directions. */ 458 459 if (!func_checker::compatible_types_p (TREE_TYPE (x1), TREE_TYPE (x2))) 460 return return_false (); 461 462 if (!compare_operand (x1, x2)) 463 return return_false_with_msg (""); 464 465 /* Type of the offset on MEM_REF does not matter. */ 466 return known_eq (wi::to_poly_offset (y1), wi::to_poly_offset (y2)); 467 } 468 case COMPONENT_REF: 469 { 470 x1 = TREE_OPERAND (t1, 0); 471 x2 = TREE_OPERAND (t2, 0); 472 y1 = TREE_OPERAND (t1, 1); 473 y2 = TREE_OPERAND (t2, 1); 474 475 ret = compare_operand (x1, x2) 476 && compare_cst_or_decl (y1, y2); 477 478 return return_with_debug (ret); 479 } 480 /* Virtual table call. */ 481 case OBJ_TYPE_REF: 482 { 483 if (!compare_ssa_name (OBJ_TYPE_REF_EXPR (t1), OBJ_TYPE_REF_EXPR (t2))) 484 return return_false (); 485 if (opt_for_fn (m_source_func_decl, flag_devirtualize) 486 && virtual_method_call_p (t1)) 487 { 488 if (tree_to_uhwi (OBJ_TYPE_REF_TOKEN (t1)) 489 != tree_to_uhwi (OBJ_TYPE_REF_TOKEN (t2))) 490 return return_false_with_msg ("OBJ_TYPE_REF token mismatch"); 491 if (!types_same_for_odr (obj_type_ref_class (t1), 492 obj_type_ref_class (t2))) 493 return return_false_with_msg ("OBJ_TYPE_REF OTR type mismatch"); 494 if (!compare_operand (OBJ_TYPE_REF_OBJECT (t1), 495 OBJ_TYPE_REF_OBJECT (t2))) 496 return return_false_with_msg ("OBJ_TYPE_REF object mismatch"); 497 } 498 499 return return_with_debug (true); 500 } 501 case IMAGPART_EXPR: 502 case REALPART_EXPR: 503 case ADDR_EXPR: 504 { 505 x1 = TREE_OPERAND (t1, 0); 506 x2 = TREE_OPERAND (t2, 0); 507 508 ret = compare_operand (x1, x2); 509 return return_with_debug (ret); 510 } 511 case BIT_FIELD_REF: 512 { 513 x1 = TREE_OPERAND (t1, 0); 514 x2 = TREE_OPERAND (t2, 0); 515 y1 = TREE_OPERAND (t1, 1); 516 y2 = TREE_OPERAND (t2, 1); 517 z1 = TREE_OPERAND (t1, 2); 518 z2 = TREE_OPERAND (t2, 2); 519 520 ret = compare_operand (x1, x2) 521 && compare_cst_or_decl (y1, y2) 522 && compare_cst_or_decl (z1, z2); 523 524 return return_with_debug (ret); 525 } 526 case SSA_NAME: 527 return compare_ssa_name (t1, t2); 528 case INTEGER_CST: 529 case COMPLEX_CST: 530 case VECTOR_CST: 531 case STRING_CST: 532 case REAL_CST: 533 case FUNCTION_DECL: 534 case VAR_DECL: 535 case FIELD_DECL: 536 case LABEL_DECL: 537 case PARM_DECL: 538 case RESULT_DECL: 539 case CONST_DECL: 540 return compare_cst_or_decl (t1, t2); 541 default: 542 return return_false_with_msg ("Unknown TREE code reached"); 543 } 544 } 545 546 bool 547 func_checker::compare_asm_inputs_outputs (tree t1, tree t2) 548 { 549 gcc_assert (TREE_CODE (t1) == TREE_LIST); 550 gcc_assert (TREE_CODE (t2) == TREE_LIST); 551 552 for (; t1; t1 = TREE_CHAIN (t1)) 553 { 554 if (!t2) 555 return false; 556 557 if (!compare_operand (TREE_VALUE (t1), TREE_VALUE (t2))) 558 return return_false (); 559 560 tree p1 = TREE_PURPOSE (t1); 561 tree p2 = TREE_PURPOSE (t2); 562 563 gcc_assert (TREE_CODE (p1) == TREE_LIST); 564 gcc_assert (TREE_CODE (p2) == TREE_LIST); 565 566 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (p1)), 567 TREE_STRING_POINTER (TREE_VALUE (p2))) != 0) 568 return return_false (); 569 570 t2 = TREE_CHAIN (t2); 571 } 572 573 if (t2) 574 return return_false (); 575 576 return true; 577 } 578 579 /* Verifies that trees T1 and T2 do correspond. */ 580 581 bool 582 func_checker::compare_variable_decl (tree t1, tree t2) 583 { 584 bool ret = false; 585 586 if (t1 == t2) 587 return true; 588 589 if (DECL_ALIGN (t1) != DECL_ALIGN (t2)) 590 return return_false_with_msg ("alignments are different"); 591 592 if (DECL_HARD_REGISTER (t1) != DECL_HARD_REGISTER (t2)) 593 return return_false_with_msg ("DECL_HARD_REGISTER are different"); 594 595 if (DECL_HARD_REGISTER (t1) 596 && DECL_ASSEMBLER_NAME (t1) != DECL_ASSEMBLER_NAME (t2)) 597 return return_false_with_msg ("HARD REGISTERS are different"); 598 599 /* Symbol table variables are known to match before we start comparing 600 bodies. */ 601 if (decl_in_symtab_p (t1)) 602 return decl_in_symtab_p (t2); 603 ret = compare_decl (t1, t2); 604 605 return return_with_debug (ret); 606 } 607 608 609 /* Function visits all gimple labels and creates corresponding 610 mapping between basic blocks and labels. */ 611 612 void 613 func_checker::parse_labels (sem_bb *bb) 614 { 615 for (gimple_stmt_iterator gsi = gsi_start_bb (bb->bb); !gsi_end_p (gsi); 616 gsi_next (&gsi)) 617 { 618 gimple *stmt = gsi_stmt (gsi); 619 620 if (glabel *label_stmt = dyn_cast <glabel *> (stmt)) 621 { 622 tree t = gimple_label_label (label_stmt); 623 gcc_assert (TREE_CODE (t) == LABEL_DECL); 624 625 m_label_bb_map.put (t, bb->bb->index); 626 } 627 } 628 } 629 630 /* Basic block equivalence comparison function that returns true if 631 basic blocks BB1 and BB2 (from functions FUNC1 and FUNC2) correspond. 632 633 In general, a collection of equivalence dictionaries is built for types 634 like SSA names, declarations (VAR_DECL, PARM_DECL, ..). This infrastructure 635 is utilized by every statement-by-statement comparison function. */ 636 637 bool 638 func_checker::compare_bb (sem_bb *bb1, sem_bb *bb2) 639 { 640 gimple_stmt_iterator gsi1, gsi2; 641 gimple *s1, *s2; 642 643 gsi1 = gsi_start_nondebug_bb (bb1->bb); 644 gsi2 = gsi_start_nondebug_bb (bb2->bb); 645 646 while (!gsi_end_p (gsi1)) 647 { 648 if (gsi_end_p (gsi2)) 649 return return_false (); 650 651 s1 = gsi_stmt (gsi1); 652 s2 = gsi_stmt (gsi2); 653 654 int eh1 = lookup_stmt_eh_lp_fn 655 (DECL_STRUCT_FUNCTION (m_source_func_decl), s1); 656 int eh2 = lookup_stmt_eh_lp_fn 657 (DECL_STRUCT_FUNCTION (m_target_func_decl), s2); 658 659 if (eh1 != eh2) 660 return return_false_with_msg ("EH regions are different"); 661 662 if (gimple_code (s1) != gimple_code (s2)) 663 return return_false_with_msg ("gimple codes are different"); 664 665 switch (gimple_code (s1)) 666 { 667 case GIMPLE_CALL: 668 if (!compare_gimple_call (as_a <gcall *> (s1), 669 as_a <gcall *> (s2))) 670 return return_different_stmts (s1, s2, "GIMPLE_CALL"); 671 break; 672 case GIMPLE_ASSIGN: 673 if (!compare_gimple_assign (s1, s2)) 674 return return_different_stmts (s1, s2, "GIMPLE_ASSIGN"); 675 break; 676 case GIMPLE_COND: 677 if (!compare_gimple_cond (s1, s2)) 678 return return_different_stmts (s1, s2, "GIMPLE_COND"); 679 break; 680 case GIMPLE_SWITCH: 681 if (!compare_gimple_switch (as_a <gswitch *> (s1), 682 as_a <gswitch *> (s2))) 683 return return_different_stmts (s1, s2, "GIMPLE_SWITCH"); 684 break; 685 case GIMPLE_DEBUG: 686 break; 687 case GIMPLE_EH_DISPATCH: 688 if (gimple_eh_dispatch_region (as_a <geh_dispatch *> (s1)) 689 != gimple_eh_dispatch_region (as_a <geh_dispatch *> (s2))) 690 return return_different_stmts (s1, s2, "GIMPLE_EH_DISPATCH"); 691 break; 692 case GIMPLE_RESX: 693 if (!compare_gimple_resx (as_a <gresx *> (s1), 694 as_a <gresx *> (s2))) 695 return return_different_stmts (s1, s2, "GIMPLE_RESX"); 696 break; 697 case GIMPLE_LABEL: 698 if (!compare_gimple_label (as_a <glabel *> (s1), 699 as_a <glabel *> (s2))) 700 return return_different_stmts (s1, s2, "GIMPLE_LABEL"); 701 break; 702 case GIMPLE_RETURN: 703 if (!compare_gimple_return (as_a <greturn *> (s1), 704 as_a <greturn *> (s2))) 705 return return_different_stmts (s1, s2, "GIMPLE_RETURN"); 706 break; 707 case GIMPLE_GOTO: 708 if (!compare_gimple_goto (s1, s2)) 709 return return_different_stmts (s1, s2, "GIMPLE_GOTO"); 710 break; 711 case GIMPLE_ASM: 712 if (!compare_gimple_asm (as_a <gasm *> (s1), 713 as_a <gasm *> (s2))) 714 return return_different_stmts (s1, s2, "GIMPLE_ASM"); 715 break; 716 case GIMPLE_PREDICT: 717 case GIMPLE_NOP: 718 break; 719 default: 720 return return_false_with_msg ("Unknown GIMPLE code reached"); 721 } 722 723 gsi_next_nondebug (&gsi1); 724 gsi_next_nondebug (&gsi2); 725 } 726 727 if (!gsi_end_p (gsi2)) 728 return return_false (); 729 730 return true; 731 } 732 733 /* Verifies for given GIMPLEs S1 and S2 that 734 call statements are semantically equivalent. */ 735 736 bool 737 func_checker::compare_gimple_call (gcall *s1, gcall *s2) 738 { 739 unsigned i; 740 tree t1, t2; 741 742 if (gimple_call_num_args (s1) != gimple_call_num_args (s2)) 743 return false; 744 745 t1 = gimple_call_fn (s1); 746 t2 = gimple_call_fn (s2); 747 if (!compare_operand (t1, t2)) 748 return return_false (); 749 750 /* Compare flags. */ 751 if (gimple_call_internal_p (s1) != gimple_call_internal_p (s2) 752 || gimple_call_ctrl_altering_p (s1) != gimple_call_ctrl_altering_p (s2) 753 || gimple_call_tail_p (s1) != gimple_call_tail_p (s2) 754 || gimple_call_return_slot_opt_p (s1) != gimple_call_return_slot_opt_p (s2) 755 || gimple_call_from_thunk_p (s1) != gimple_call_from_thunk_p (s2) 756 || gimple_call_va_arg_pack_p (s1) != gimple_call_va_arg_pack_p (s2) 757 || gimple_call_alloca_for_var_p (s1) != gimple_call_alloca_for_var_p (s2)) 758 return false; 759 760 if (gimple_call_internal_p (s1) 761 && gimple_call_internal_fn (s1) != gimple_call_internal_fn (s2)) 762 return false; 763 764 tree fntype1 = gimple_call_fntype (s1); 765 tree fntype2 = gimple_call_fntype (s2); 766 if ((fntype1 && !fntype2) 767 || (!fntype1 && fntype2) 768 || (fntype1 && !types_compatible_p (fntype1, fntype2))) 769 return return_false_with_msg ("call function types are not compatible"); 770 771 tree chain1 = gimple_call_chain (s1); 772 tree chain2 = gimple_call_chain (s2); 773 if ((chain1 && !chain2) 774 || (!chain1 && chain2) 775 || !compare_operand (chain1, chain2)) 776 return return_false_with_msg ("static call chains are different"); 777 778 /* Checking of argument. */ 779 for (i = 0; i < gimple_call_num_args (s1); ++i) 780 { 781 t1 = gimple_call_arg (s1, i); 782 t2 = gimple_call_arg (s2, i); 783 784 if (!compare_memory_operand (t1, t2)) 785 return return_false_with_msg ("memory operands are different"); 786 } 787 788 /* Return value checking. */ 789 t1 = gimple_get_lhs (s1); 790 t2 = gimple_get_lhs (s2); 791 792 return compare_memory_operand (t1, t2); 793 } 794 795 796 /* Verifies for given GIMPLEs S1 and S2 that 797 assignment statements are semantically equivalent. */ 798 799 bool 800 func_checker::compare_gimple_assign (gimple *s1, gimple *s2) 801 { 802 tree arg1, arg2; 803 tree_code code1, code2; 804 unsigned i; 805 806 code1 = gimple_expr_code (s1); 807 code2 = gimple_expr_code (s2); 808 809 if (code1 != code2) 810 return false; 811 812 code1 = gimple_assign_rhs_code (s1); 813 code2 = gimple_assign_rhs_code (s2); 814 815 if (code1 != code2) 816 return false; 817 818 for (i = 0; i < gimple_num_ops (s1); i++) 819 { 820 arg1 = gimple_op (s1, i); 821 arg2 = gimple_op (s2, i); 822 823 if (!compare_memory_operand (arg1, arg2)) 824 return return_false_with_msg ("memory operands are different"); 825 } 826 827 828 return true; 829 } 830 831 /* Verifies for given GIMPLEs S1 and S2 that 832 condition statements are semantically equivalent. */ 833 834 bool 835 func_checker::compare_gimple_cond (gimple *s1, gimple *s2) 836 { 837 tree t1, t2; 838 tree_code code1, code2; 839 840 code1 = gimple_expr_code (s1); 841 code2 = gimple_expr_code (s2); 842 843 if (code1 != code2) 844 return false; 845 846 t1 = gimple_cond_lhs (s1); 847 t2 = gimple_cond_lhs (s2); 848 849 if (!compare_operand (t1, t2)) 850 return false; 851 852 t1 = gimple_cond_rhs (s1); 853 t2 = gimple_cond_rhs (s2); 854 855 return compare_operand (t1, t2); 856 } 857 858 /* Verifies that tree labels T1 and T2 correspond in FUNC1 and FUNC2. */ 859 860 bool 861 func_checker::compare_tree_ssa_label (tree t1, tree t2) 862 { 863 return compare_operand (t1, t2); 864 } 865 866 /* Verifies for given GIMPLE_LABEL stmts S1 and S2 that 867 label statements are semantically equivalent. */ 868 869 bool 870 func_checker::compare_gimple_label (const glabel *g1, const glabel *g2) 871 { 872 if (m_ignore_labels) 873 return true; 874 875 tree t1 = gimple_label_label (g1); 876 tree t2 = gimple_label_label (g2); 877 878 if (FORCED_LABEL (t1) || FORCED_LABEL (t2)) 879 return return_false_with_msg ("FORCED_LABEL"); 880 881 /* As the pass build BB to label mapping, no further check is needed. */ 882 return true; 883 } 884 885 /* Verifies for given GIMPLE_SWITCH stmts S1 and S2 that 886 switch statements are semantically equivalent. */ 887 888 bool 889 func_checker::compare_gimple_switch (const gswitch *g1, const gswitch *g2) 890 { 891 unsigned lsize1, lsize2, i; 892 893 lsize1 = gimple_switch_num_labels (g1); 894 lsize2 = gimple_switch_num_labels (g2); 895 896 if (lsize1 != lsize2) 897 return false; 898 899 tree t1 = gimple_switch_index (g1); 900 tree t2 = gimple_switch_index (g2); 901 902 if (!compare_operand (t1, t2)) 903 return false; 904 905 for (i = 0; i < lsize1; i++) 906 { 907 tree label1 = gimple_switch_label (g1, i); 908 tree label2 = gimple_switch_label (g2, i); 909 910 /* Label LOW and HIGH comparison. */ 911 tree low1 = CASE_LOW (label1); 912 tree low2 = CASE_LOW (label2); 913 914 if (!tree_int_cst_equal (low1, low2)) 915 return return_false_with_msg ("case low values are different"); 916 917 tree high1 = CASE_HIGH (label1); 918 tree high2 = CASE_HIGH (label2); 919 920 if (!tree_int_cst_equal (high1, high2)) 921 return return_false_with_msg ("case high values are different"); 922 923 if (TREE_CODE (label1) == CASE_LABEL_EXPR 924 && TREE_CODE (label2) == CASE_LABEL_EXPR) 925 { 926 label1 = CASE_LABEL (label1); 927 label2 = CASE_LABEL (label2); 928 929 if (!compare_operand (label1, label2)) 930 return return_false_with_msg ("switch label_exprs are different"); 931 } 932 else if (!tree_int_cst_equal (label1, label2)) 933 return return_false_with_msg ("switch labels are different"); 934 } 935 936 return true; 937 } 938 939 /* Verifies for given GIMPLE_RETURN stmts S1 and S2 that 940 return statements are semantically equivalent. */ 941 942 bool 943 func_checker::compare_gimple_return (const greturn *g1, const greturn *g2) 944 { 945 tree t1, t2; 946 947 t1 = gimple_return_retval (g1); 948 t2 = gimple_return_retval (g2); 949 950 /* Void return type. */ 951 if (t1 == NULL && t2 == NULL) 952 return true; 953 else 954 return compare_operand (t1, t2); 955 } 956 957 /* Verifies for given GIMPLEs S1 and S2 that 958 goto statements are semantically equivalent. */ 959 960 bool 961 func_checker::compare_gimple_goto (gimple *g1, gimple *g2) 962 { 963 tree dest1, dest2; 964 965 dest1 = gimple_goto_dest (g1); 966 dest2 = gimple_goto_dest (g2); 967 968 if (TREE_CODE (dest1) != TREE_CODE (dest2) || TREE_CODE (dest1) != SSA_NAME) 969 return false; 970 971 return compare_operand (dest1, dest2); 972 } 973 974 /* Verifies for given GIMPLE_RESX stmts S1 and S2 that 975 resx statements are semantically equivalent. */ 976 977 bool 978 func_checker::compare_gimple_resx (const gresx *g1, const gresx *g2) 979 { 980 return gimple_resx_region (g1) == gimple_resx_region (g2); 981 } 982 983 /* Verifies for given GIMPLEs S1 and S2 that ASM statements are equivalent. 984 For the beginning, the pass only supports equality for 985 '__asm__ __volatile__ ("", "", "", "memory")'. */ 986 987 bool 988 func_checker::compare_gimple_asm (const gasm *g1, const gasm *g2) 989 { 990 if (gimple_asm_volatile_p (g1) != gimple_asm_volatile_p (g2)) 991 return false; 992 993 if (gimple_asm_input_p (g1) != gimple_asm_input_p (g2)) 994 return false; 995 996 if (gimple_asm_inline_p (g1) != gimple_asm_inline_p (g2)) 997 return false; 998 999 if (gimple_asm_ninputs (g1) != gimple_asm_ninputs (g2)) 1000 return false; 1001 1002 if (gimple_asm_noutputs (g1) != gimple_asm_noutputs (g2)) 1003 return false; 1004 1005 /* We do not suppport goto ASM statement comparison. */ 1006 if (gimple_asm_nlabels (g1) || gimple_asm_nlabels (g2)) 1007 return false; 1008 1009 if (gimple_asm_nclobbers (g1) != gimple_asm_nclobbers (g2)) 1010 return false; 1011 1012 if (strcmp (gimple_asm_string (g1), gimple_asm_string (g2)) != 0) 1013 return return_false_with_msg ("ASM strings are different"); 1014 1015 for (unsigned i = 0; i < gimple_asm_ninputs (g1); i++) 1016 { 1017 tree input1 = gimple_asm_input_op (g1, i); 1018 tree input2 = gimple_asm_input_op (g2, i); 1019 1020 if (!compare_asm_inputs_outputs (input1, input2)) 1021 return return_false_with_msg ("ASM input is different"); 1022 } 1023 1024 for (unsigned i = 0; i < gimple_asm_noutputs (g1); i++) 1025 { 1026 tree output1 = gimple_asm_output_op (g1, i); 1027 tree output2 = gimple_asm_output_op (g2, i); 1028 1029 if (!compare_asm_inputs_outputs (output1, output2)) 1030 return return_false_with_msg ("ASM output is different"); 1031 } 1032 1033 for (unsigned i = 0; i < gimple_asm_nclobbers (g1); i++) 1034 { 1035 tree clobber1 = gimple_asm_clobber_op (g1, i); 1036 tree clobber2 = gimple_asm_clobber_op (g2, i); 1037 1038 if (!operand_equal_p (TREE_VALUE (clobber1), TREE_VALUE (clobber2), 1039 OEP_ONLY_CONST)) 1040 return return_false_with_msg ("ASM clobber is different"); 1041 } 1042 1043 return true; 1044 } 1045 1046 } // ipa_icf_gimple namespace 1047