gcc/ipa-icf-gimple.c

   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