1 /* Interprocedural Identical Code Folding pass
2 Copyright (C) 2014-2024 Free Software Foundation, Inc.
4 Contributed by Jan Hubicka <hubicka@ucw.cz> and Martin Liska <mliska@suse.cz>
6 This file is part of GCC.
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
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
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/>. */
24 #include "coretypes.h"
29 #include "tree-pass.h"
32 #include "data-streamer.h"
33 #include "gimple-pretty-print.h"
34 #include "fold-const.h"
35 #include "gimple-iterator.h"
36 #include "ipa-utils.h"
41 #include "gimple-walk.h"
44 #include "tree-ssa-alias-compare.h"
45 #include "alloc-pool.h"
46 #include "symbol-summary.h"
47 #include "ipa-icf-gimple.h"
52 namespace ipa_icf_gimple
{
54 /* Initialize internal structures for a given SOURCE_FUNC_DECL and
55 TARGET_FUNC_DECL. Strict polymorphic comparison is processed if
56 an option COMPARE_POLYMORPHIC is true. For special cases, one can
57 set IGNORE_LABELS to skip label comparison.
58 Similarly, IGNORE_SOURCE_DECLS and IGNORE_TARGET_DECLS are sets
59 of declarations that can be skipped. */
61 func_checker::func_checker (tree source_func_decl
, tree target_func_decl
,
62 bool ignore_labels
, bool tbaa
,
63 hash_set
<symtab_node
*> *ignored_source_nodes
,
64 hash_set
<symtab_node
*> *ignored_target_nodes
)
65 : m_source_func_decl (source_func_decl
), m_target_func_decl (target_func_decl
),
66 m_ignored_source_nodes (ignored_source_nodes
),
67 m_ignored_target_nodes (ignored_target_nodes
),
68 m_ignore_labels (ignore_labels
), m_tbaa (tbaa
),
69 m_total_scalarization_limit_known_p (false)
71 function
*source_func
= DECL_STRUCT_FUNCTION (source_func_decl
);
72 function
*target_func
= DECL_STRUCT_FUNCTION (target_func_decl
);
74 unsigned ssa_source
= SSANAMES (source_func
)->length ();
75 unsigned ssa_target
= SSANAMES (target_func
)->length ();
77 m_source_ssa_names
.create (ssa_source
);
78 m_target_ssa_names
.create (ssa_target
);
80 for (unsigned i
= 0; i
< ssa_source
; i
++)
81 m_source_ssa_names
.safe_push (-1);
83 for (unsigned i
= 0; i
< ssa_target
; i
++)
84 m_target_ssa_names
.safe_push (-1);
87 /* Memory release routine. */
89 func_checker::~func_checker ()
91 m_source_ssa_names
.release();
92 m_target_ssa_names
.release();
95 /* Verifies that trees T1 and T2 are equivalent from perspective of ICF. */
98 func_checker::compare_ssa_name (const_tree t1
, const_tree t2
)
100 gcc_assert (TREE_CODE (t1
) == SSA_NAME
);
101 gcc_assert (TREE_CODE (t2
) == SSA_NAME
);
103 unsigned i1
= SSA_NAME_VERSION (t1
);
104 unsigned i2
= SSA_NAME_VERSION (t2
);
106 if (SSA_NAME_IS_DEFAULT_DEF (t1
) != SSA_NAME_IS_DEFAULT_DEF (t2
))
109 if (m_source_ssa_names
[i1
] == -1)
110 m_source_ssa_names
[i1
] = i2
;
111 else if (m_source_ssa_names
[i1
] != (int) i2
)
114 if(m_target_ssa_names
[i2
] == -1)
115 m_target_ssa_names
[i2
] = i1
;
116 else if (m_target_ssa_names
[i2
] != (int) i1
)
119 if (SSA_NAME_IS_DEFAULT_DEF (t1
))
121 tree b1
= SSA_NAME_VAR (t1
);
122 tree b2
= SSA_NAME_VAR (t2
);
124 return compare_operand (b1
, b2
, OP_NORMAL
);
130 /* Verification function for edges E1 and E2. */
133 func_checker::compare_edge (edge e1
, edge e2
)
135 if (e1
->flags
!= e2
->flags
)
140 edge
&slot
= m_edge_map
.get_or_insert (e1
, &existed_p
);
142 return return_with_debug (slot
== e2
);
146 /* TODO: filter edge probabilities for profile feedback match. */
151 /* Verification function for declaration trees T1 and T2 that
152 come from functions FUNC1 and FUNC2. */
155 func_checker::compare_decl (const_tree t1
, const_tree t2
)
157 if (!auto_var_in_fn_p (t1
, m_source_func_decl
)
158 || !auto_var_in_fn_p (t2
, m_target_func_decl
))
159 return return_with_debug (t1
== t2
);
161 tree_code t
= TREE_CODE (t1
);
162 if ((t
== VAR_DECL
|| t
== PARM_DECL
|| t
== RESULT_DECL
)
163 && DECL_BY_REFERENCE (t1
) != DECL_BY_REFERENCE (t2
))
164 return return_false_with_msg ("DECL_BY_REFERENCE flags are different");
166 /* We do not really need to check types of variables, since they are just
167 blocks of memory and we verify types of the accesses to them.
168 However do compare types of other kinds of decls
169 (parm decls and result decl types may affect ABI convetions). */
172 if (!compatible_types_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
173 return return_false ();
177 if (!operand_equal_p (DECL_SIZE (t1
), DECL_SIZE (t2
),
178 OEP_MATCH_SIDE_EFFECTS
))
179 return return_false_with_msg ("DECL_SIZEs are different");
183 const_tree
&slot
= m_decl_map
.get_or_insert (t1
, &existed_p
);
185 return return_with_debug (slot
== t2
);
192 /* Return true if T1 and T2 are same for purposes of ipa-polymorphic-call
193 analysis. COMPARE_PTR indicates if types of pointers needs to be
197 func_checker::compatible_polymorphic_types_p (tree t1
, tree t2
,
200 gcc_assert (TREE_CODE (t1
) != FUNCTION_TYPE
&& TREE_CODE (t1
) != METHOD_TYPE
);
202 /* Pointer types generally give no information. */
203 if (POINTER_TYPE_P (t1
))
207 return func_checker::compatible_polymorphic_types_p (TREE_TYPE (t1
),
212 /* If types contain a polymorphic types, match them. */
213 bool c1
= contains_polymorphic_type_p (t1
);
214 bool c2
= contains_polymorphic_type_p (t2
);
218 return return_false_with_msg ("one type is not polymorphic");
219 if (!types_must_be_same_for_odr (t1
, t2
))
220 return return_false_with_msg ("types are not same for ODR");
224 /* Return true if types are compatible from perspective of ICF. */
226 func_checker::compatible_types_p (tree t1
, tree t2
)
228 if (TREE_CODE (t1
) != TREE_CODE (t2
))
229 return return_false_with_msg ("different tree types");
231 if (TYPE_RESTRICT (t1
) != TYPE_RESTRICT (t2
))
232 return return_false_with_msg ("restrict flags are different");
234 if (!types_compatible_p (t1
, t2
))
235 return return_false_with_msg ("types are not compatible");
240 /* Add hash of ARG to HSTATE. FLAGS have same meaning
241 as for operand_equal_p. Works only if operand acces type is OP_NORMAL. */
244 func_checker::hash_operand (const_tree arg
, inchash::hash
&hstate
,
247 if (arg
== NULL_TREE
)
249 hstate
.merge_hash (0);
253 switch (TREE_CODE (arg
))
257 unsigned int index
= 0;
258 if (DECL_CONTEXT (arg
))
259 for (tree p
= DECL_ARGUMENTS (DECL_CONTEXT (arg
));
260 p
&& index
< 32; p
= DECL_CHAIN (p
), index
++)
263 hstate
.add_int (PARM_DECL
);
264 hstate
.add_int (index
);
272 hstate
.add_int (TREE_CODE (arg
));
275 hstate
.add_int (SSA_NAME
);
276 if (SSA_NAME_IS_DEFAULT_DEF (arg
))
277 hash_operand (SSA_NAME_VAR (arg
), hstate
, flags
);
280 inchash::add_expr (DECL_FIELD_OFFSET (arg
), hstate
, flags
);
281 inchash::add_expr (DECL_FIELD_BIT_OFFSET (arg
), hstate
, flags
);
287 /* In gimple all clobbers can be considered equal: while comparaing two
288 gimple clobbers we match the left hand memory accesses. */
289 if (TREE_CLOBBER_P (arg
))
291 hstate
.add_int (0xc10bbe5);
294 gcc_assert (!DECL_P (arg
));
295 gcc_assert (!TYPE_P (arg
));
297 return operand_compare::hash_operand (arg
, hstate
, flags
);
300 /* Add hash of ARG accesses according to ACCESS to HSTATE.
301 FLAGS have same meaning as for operand_equal_p. */
304 func_checker::hash_operand (const_tree arg
, inchash::hash
&hstate
,
305 unsigned int flags
, operand_access_type access
)
307 if (access
== OP_MEMORY
)
310 ao_ref_init (&ref
, const_cast <tree
> (arg
));
311 return hash_ao_ref (&ref
, lto_streaming_expected_p (), m_tbaa
, hstate
);
314 return hash_operand (arg
, hstate
, flags
);
318 func_checker::operand_equal_p (const_tree t1
, const_tree t2
,
322 if (verify_hash_value (t1
, t2
, flags
, &r
))
330 if (TREE_CODE (t1
) != TREE_CODE (t2
))
331 return return_false ();
333 switch (TREE_CODE (t1
))
336 /* All function decls are in the symbol table and known to match
337 before we start comparing bodies. */
340 return return_with_debug (compare_variable_decl (t1
, t2
));
343 int *bb1
= m_label_bb_map
.get (t1
);
344 int *bb2
= m_label_bb_map
.get (t2
);
345 /* Labels can point to another function (non-local GOTOs). */
346 return return_with_debug (bb1
!= NULL
&& bb2
!= NULL
&& *bb1
== *bb2
);
352 return compare_decl (t1
, t2
);
354 return compare_ssa_name (t1
, t2
);
358 /* In gimple all clobbers can be considered equal. We match the left hand
360 if (TREE_CLOBBER_P (t1
) || TREE_CLOBBER_P (t2
))
361 return TREE_CLOBBER_P (t1
) == TREE_CLOBBER_P (t2
);
363 return operand_compare::operand_equal_p (t1
, t2
, flags
);
366 /* Return true if either T1 and T2 cannot be totally scalarized or if doing
367 so would result in copying the same memory. Otherwise return false. */
370 func_checker::safe_for_total_scalarization_p (tree t1
, tree t2
)
372 tree type1
= TREE_TYPE (t1
);
373 tree type2
= TREE_TYPE (t2
);
375 if (!AGGREGATE_TYPE_P (type1
)
376 || !AGGREGATE_TYPE_P (type2
)
377 || !tree_fits_uhwi_p (TYPE_SIZE (type1
))
378 || !tree_fits_uhwi_p (TYPE_SIZE (type2
)))
381 if (!m_total_scalarization_limit_known_p
)
383 push_cfun (DECL_STRUCT_FUNCTION (m_target_func_decl
));
384 m_total_scalarization_limit
= sra_get_max_scalarization_size ();
386 m_total_scalarization_limit_known_p
= true;
389 unsigned HOST_WIDE_INT sz
= tree_to_uhwi (TYPE_SIZE (type1
));
390 gcc_assert (sz
== tree_to_uhwi (TYPE_SIZE (type2
)));
391 if (sz
> m_total_scalarization_limit
)
393 return sra_total_scalarization_would_copy_same_data_p (type1
, type2
);
396 /* Function responsible for comparison of various operands T1 and T2
397 which are accessed as ACCESS.
398 If these components, from functions FUNC1 and FUNC2, are equal, true
402 func_checker::compare_operand (tree t1
, tree t2
, operand_access_type access
)
408 if (access
== OP_MEMORY
)
411 ao_ref_init (&ref1
, const_cast <tree
> (t1
));
412 ao_ref_init (&ref2
, const_cast <tree
> (t2
));
413 int flags
= compare_ao_refs (&ref1
, &ref2
,
414 lto_streaming_expected_p (), m_tbaa
);
418 if (!safe_for_total_scalarization_p (t1
, t2
))
419 return return_false_with_msg
420 ("total scalarization may not be equivalent");
423 if (flags
& SEMANTICS
)
424 return return_false_with_msg
425 ("compare_ao_refs failed (semantic difference)");
426 if (flags
& BASE_ALIAS_SET
)
427 return return_false_with_msg
428 ("compare_ao_refs failed (base alias set difference)");
429 if (flags
& REF_ALIAS_SET
)
430 return return_false_with_msg
431 ("compare_ao_refs failed (ref alias set difference)");
432 if (flags
& ACCESS_PATH
)
433 return return_false_with_msg
434 ("compare_ao_refs failed (access path difference)");
435 if (flags
& DEPENDENCE_CLIQUE
)
436 return return_false_with_msg
437 ("compare_ao_refs failed (dependence clique difference)");
442 if (operand_equal_p (t1
, t2
, OEP_MATCH_SIDE_EFFECTS
))
444 return return_false_with_msg
445 ("operand_equal_p failed");
450 func_checker::compare_asm_inputs_outputs (tree t1
, tree t2
,
451 operand_access_type_map
*map
)
453 gcc_assert (TREE_CODE (t1
) == TREE_LIST
);
454 gcc_assert (TREE_CODE (t2
) == TREE_LIST
);
456 for (; t1
; t1
= TREE_CHAIN (t1
))
461 if (!compare_operand (TREE_VALUE (t1
), TREE_VALUE (t2
),
462 get_operand_access_type (map
, t1
)))
463 return return_false ();
465 tree p1
= TREE_PURPOSE (t1
);
466 tree p2
= TREE_PURPOSE (t2
);
468 gcc_assert (TREE_CODE (p1
) == TREE_LIST
);
469 gcc_assert (TREE_CODE (p2
) == TREE_LIST
);
471 if (strcmp (TREE_STRING_POINTER (TREE_VALUE (p1
)),
472 TREE_STRING_POINTER (TREE_VALUE (p2
))) != 0)
473 return return_false ();
475 t2
= TREE_CHAIN (t2
);
479 return return_false ();
484 /* Verifies that trees T1 and T2 do correspond. */
487 func_checker::compare_variable_decl (const_tree t1
, const_tree t2
)
494 if (DECL_ALIGN (t1
) != DECL_ALIGN (t2
))
495 return return_false_with_msg ("alignments are different");
497 if (DECL_HARD_REGISTER (t1
) != DECL_HARD_REGISTER (t2
))
498 return return_false_with_msg ("DECL_HARD_REGISTER are different");
500 if (DECL_HARD_REGISTER (t1
)
501 && DECL_ASSEMBLER_NAME_RAW (t1
) != DECL_ASSEMBLER_NAME_RAW (t2
))
502 return return_false_with_msg ("HARD REGISTERS are different");
504 /* Symbol table variables are known to match before we start comparing
506 if (decl_in_symtab_p (t1
))
507 return decl_in_symtab_p (t2
);
508 ret
= compare_decl (t1
, t2
);
510 return return_with_debug (ret
);
513 /* Compare loop information for basic blocks BB1 and BB2. */
516 func_checker::compare_loops (basic_block bb1
, basic_block bb2
)
518 if ((bb1
->loop_father
== NULL
) != (bb2
->loop_father
== NULL
))
519 return return_false ();
521 class loop
*l1
= bb1
->loop_father
;
522 class loop
*l2
= bb2
->loop_father
;
526 if ((bb1
== l1
->header
) != (bb2
== l2
->header
))
527 return return_false_with_msg ("header");
528 if ((bb1
== l1
->latch
) != (bb2
== l2
->latch
))
529 return return_false_with_msg ("latch");
530 if (l1
->simdlen
!= l2
->simdlen
)
531 return return_false_with_msg ("simdlen");
532 if (l1
->safelen
!= l2
->safelen
)
533 return return_false_with_msg ("safelen");
534 if (l1
->can_be_parallel
!= l2
->can_be_parallel
)
535 return return_false_with_msg ("can_be_parallel");
536 if (l1
->dont_vectorize
!= l2
->dont_vectorize
)
537 return return_false_with_msg ("dont_vectorize");
538 if (l1
->force_vectorize
!= l2
->force_vectorize
)
539 return return_false_with_msg ("force_vectorize");
540 if (l1
->finite_p
!= l2
->finite_p
)
541 return return_false_with_msg ("finite_p");
542 if (l1
->unroll
!= l2
->unroll
)
543 return return_false_with_msg ("unroll");
544 if (!compare_variable_decl (l1
->simduid
, l2
->simduid
))
545 return return_false_with_msg ("simduid");
550 /* Function visits all gimple labels and creates corresponding
551 mapping between basic blocks and labels. */
554 func_checker::parse_labels (sem_bb
*bb
)
556 for (gimple_stmt_iterator gsi
= gsi_start_bb (bb
->bb
); !gsi_end_p (gsi
);
559 gimple
*stmt
= gsi_stmt (gsi
);
561 if (glabel
*label_stmt
= dyn_cast
<glabel
*> (stmt
))
563 const_tree t
= gimple_label_label (label_stmt
);
564 gcc_assert (TREE_CODE (t
) == LABEL_DECL
);
566 m_label_bb_map
.put (t
, bb
->bb
->index
);
571 /* Basic block equivalence comparison function that returns true if
572 basic blocks BB1 and BB2 (from functions FUNC1 and FUNC2) correspond.
574 In general, a collection of equivalence dictionaries is built for types
575 like SSA names, declarations (VAR_DECL, PARM_DECL, ..). This infrastructure
576 is utilized by every statement-by-statement comparison function. */
579 func_checker::compare_bb (sem_bb
*bb1
, sem_bb
*bb2
)
581 gimple_stmt_iterator gsi1
, gsi2
;
584 gsi1
= gsi_start_nondebug_bb (bb1
->bb
);
585 gsi2
= gsi_start_nondebug_bb (bb2
->bb
);
587 while (!gsi_end_p (gsi1
))
589 if (gsi_end_p (gsi2
))
590 return return_false ();
592 s1
= gsi_stmt (gsi1
);
593 s2
= gsi_stmt (gsi2
);
595 int eh1
= lookup_stmt_eh_lp_fn
596 (DECL_STRUCT_FUNCTION (m_source_func_decl
), s1
);
597 int eh2
= lookup_stmt_eh_lp_fn
598 (DECL_STRUCT_FUNCTION (m_target_func_decl
), s2
);
601 return return_false_with_msg ("EH regions are different");
603 if (gimple_code (s1
) != gimple_code (s2
))
604 return return_false_with_msg ("gimple codes are different");
606 switch (gimple_code (s1
))
609 if (!compare_gimple_call (as_a
<gcall
*> (s1
),
610 as_a
<gcall
*> (s2
)))
611 return return_different_stmts (s1
, s2
, "GIMPLE_CALL");
614 if (!compare_gimple_assign (s1
, s2
))
615 return return_different_stmts (s1
, s2
, "GIMPLE_ASSIGN");
618 if (!compare_gimple_cond (s1
, s2
))
619 return return_different_stmts (s1
, s2
, "GIMPLE_COND");
622 if (!compare_gimple_switch (as_a
<gswitch
*> (s1
),
623 as_a
<gswitch
*> (s2
)))
624 return return_different_stmts (s1
, s2
, "GIMPLE_SWITCH");
628 case GIMPLE_EH_DISPATCH
:
629 if (gimple_eh_dispatch_region (as_a
<geh_dispatch
*> (s1
))
630 != gimple_eh_dispatch_region (as_a
<geh_dispatch
*> (s2
)))
631 return return_different_stmts (s1
, s2
, "GIMPLE_EH_DISPATCH");
634 if (!compare_gimple_resx (as_a
<gresx
*> (s1
),
635 as_a
<gresx
*> (s2
)))
636 return return_different_stmts (s1
, s2
, "GIMPLE_RESX");
639 if (!compare_gimple_label (as_a
<glabel
*> (s1
),
640 as_a
<glabel
*> (s2
)))
641 return return_different_stmts (s1
, s2
, "GIMPLE_LABEL");
644 if (!compare_gimple_return (as_a
<greturn
*> (s1
),
645 as_a
<greturn
*> (s2
)))
646 return return_different_stmts (s1
, s2
, "GIMPLE_RETURN");
649 if (!compare_gimple_goto (s1
, s2
))
650 return return_different_stmts (s1
, s2
, "GIMPLE_GOTO");
653 if (!compare_gimple_asm (as_a
<gasm
*> (s1
),
655 return return_different_stmts (s1
, s2
, "GIMPLE_ASM");
661 return return_false_with_msg ("Unknown GIMPLE code reached");
664 gsi_next_nondebug (&gsi1
);
665 gsi_next_nondebug (&gsi2
);
668 if (!gsi_end_p (gsi2
))
669 return return_false ();
671 if (!compare_loops (bb1
->bb
, bb2
->bb
))
672 return return_false ();
677 /* Verifies for given GIMPLEs S1 and S2 that
678 call statements are semantically equivalent. */
681 func_checker::compare_gimple_call (gcall
*s1
, gcall
*s2
)
686 if (gimple_call_num_args (s1
) != gimple_call_num_args (s2
))
689 operand_access_type_map
map (5);
690 classify_operands (s1
, &map
);
692 t1
= gimple_call_fn (s1
);
693 t2
= gimple_call_fn (s2
);
694 if (!compare_operand (t1
, t2
, get_operand_access_type (&map
, t1
)))
695 return return_false ();
698 if (gimple_call_internal_p (s1
) != gimple_call_internal_p (s2
)
699 || gimple_call_ctrl_altering_p (s1
) != gimple_call_ctrl_altering_p (s2
)
700 || gimple_call_tail_p (s1
) != gimple_call_tail_p (s2
)
701 || gimple_call_return_slot_opt_p (s1
) != gimple_call_return_slot_opt_p (s2
)
702 || gimple_call_from_thunk_p (s1
) != gimple_call_from_thunk_p (s2
)
703 || gimple_call_from_new_or_delete (s1
) != gimple_call_from_new_or_delete (s2
)
704 || gimple_call_va_arg_pack_p (s1
) != gimple_call_va_arg_pack_p (s2
)
705 || gimple_call_alloca_for_var_p (s1
) != gimple_call_alloca_for_var_p (s2
))
708 if (gimple_call_internal_p (s1
)
709 && gimple_call_internal_fn (s1
) != gimple_call_internal_fn (s2
))
712 tree fntype1
= gimple_call_fntype (s1
);
713 tree fntype2
= gimple_call_fntype (s2
);
715 /* For direct calls we verify that types are compatible so if we matched
716 callees, callers must match, too. For indirect calls however verify
718 if (!gimple_call_fndecl (s1
))
720 if ((fntype1
&& !fntype2
)
721 || (!fntype1
&& fntype2
)
722 || (fntype1
&& !types_compatible_p (fntype1
, fntype2
)))
723 return return_false_with_msg ("call function types are not compatible");
726 if (fntype1
&& fntype2
&& comp_type_attributes (fntype1
, fntype2
) != 1)
727 return return_false_with_msg ("different fntype attributes");
729 tree chain1
= gimple_call_chain (s1
);
730 tree chain2
= gimple_call_chain (s2
);
731 if ((chain1
&& !chain2
)
732 || (!chain1
&& chain2
)
733 || !compare_operand (chain1
, chain2
,
734 get_operand_access_type (&map
, chain1
)))
735 return return_false_with_msg ("static call chains are different");
737 /* Checking of argument. */
738 for (i
= 0; i
< gimple_call_num_args (s1
); ++i
)
740 t1
= gimple_call_arg (s1
, i
);
741 t2
= gimple_call_arg (s2
, i
);
743 if (!compare_operand (t1
, t2
, get_operand_access_type (&map
, t1
)))
744 return return_false_with_msg ("GIMPLE call operands are different");
747 /* Return value checking. */
748 t1
= gimple_get_lhs (s1
);
749 t2
= gimple_get_lhs (s2
);
751 /* For internal calls, lhs types need to be verified, as neither fntype nor
752 callee comparisons can catch that. */
753 if (gimple_call_internal_p (s1
)
756 && !compatible_types_p (TREE_TYPE (t1
), TREE_TYPE (t2
)))
757 return return_false_with_msg ("GIMPLE internal call LHS type mismatch");
759 if (!gimple_call_internal_p (s1
))
761 cgraph_edge
*e1
= cgraph_node::get (m_source_func_decl
)->get_edge (s1
);
762 cgraph_edge
*e2
= cgraph_node::get (m_target_func_decl
)->get_edge (s2
);
763 class ipa_edge_args
*args1
= ipa_edge_args_sum
->get (e1
);
764 class ipa_edge_args
*args2
= ipa_edge_args_sum
->get (e2
);
765 if ((args1
!= nullptr) != (args2
!= nullptr))
766 return return_false_with_msg ("ipa_edge_args mismatch");
769 int n1
= ipa_get_cs_argument_count (args1
);
770 int n2
= ipa_get_cs_argument_count (args2
);
772 return return_false_with_msg ("ipa_edge_args nargs mismatch");
773 for (int i
= 0; i
< n1
; i
++)
775 struct ipa_jump_func
*jf1
= ipa_get_ith_jump_func (args1
, i
);
776 struct ipa_jump_func
*jf2
= ipa_get_ith_jump_func (args2
, i
);
777 if (((jf1
!= nullptr) != (jf2
!= nullptr))
778 || (jf1
&& !ipa_jump_functions_equivalent_p (jf1
, jf2
)))
779 return return_false_with_msg ("jump function mismatch");
784 return compare_operand (t1
, t2
, get_operand_access_type (&map
, t1
));
788 /* Verifies for given GIMPLEs S1 and S2 that
789 assignment statements are semantically equivalent. */
792 func_checker::compare_gimple_assign (gimple
*s1
, gimple
*s2
)
795 tree_code code1
, code2
;
798 code1
= gimple_assign_rhs_code (s1
);
799 code2
= gimple_assign_rhs_code (s2
);
804 operand_access_type_map
map (5);
805 classify_operands (s1
, &map
);
807 for (i
= 0; i
< gimple_num_ops (s1
); i
++)
809 arg1
= gimple_op (s1
, i
);
810 arg2
= gimple_op (s2
, i
);
812 /* Compare types for LHS. */
813 if (i
== 0 && !gimple_store_p (s1
))
815 if (!compatible_types_p (TREE_TYPE (arg1
), TREE_TYPE (arg2
)))
816 return return_false_with_msg ("GIMPLE LHS type mismatch");
819 if (!compare_operand (arg1
, arg2
, get_operand_access_type (&map
, arg1
)))
820 return return_false_with_msg ("GIMPLE assignment operands "
828 /* Verifies for given GIMPLEs S1 and S2 that
829 condition statements are semantically equivalent. */
832 func_checker::compare_gimple_cond (gimple
*s1
, gimple
*s2
)
835 tree_code code1
, code2
;
837 code1
= gimple_cond_code (s1
);
838 code2
= gimple_cond_code (s2
);
843 t1
= gimple_cond_lhs (s1
);
844 t2
= gimple_cond_lhs (s2
);
846 if (!compare_operand (t1
, t2
, OP_NORMAL
))
849 t1
= gimple_cond_rhs (s1
);
850 t2
= gimple_cond_rhs (s2
);
852 return compare_operand (t1
, t2
, OP_NORMAL
);
855 /* Verifies for given GIMPLE_LABEL stmts S1 and S2 that
856 label statements are semantically equivalent. */
859 func_checker::compare_gimple_label (const glabel
*g1
, const glabel
*g2
)
864 tree t1
= gimple_label_label (g1
);
865 tree t2
= gimple_label_label (g2
);
867 if (FORCED_LABEL (t1
) || FORCED_LABEL (t2
))
868 return return_false_with_msg ("FORCED_LABEL");
870 /* As the pass build BB to label mapping, no further check is needed. */
874 /* Verifies for given GIMPLE_SWITCH stmts S1 and S2 that
875 switch statements are semantically equivalent. */
878 func_checker::compare_gimple_switch (const gswitch
*g1
, const gswitch
*g2
)
880 unsigned lsize1
, lsize2
, i
;
882 lsize1
= gimple_switch_num_labels (g1
);
883 lsize2
= gimple_switch_num_labels (g2
);
885 if (lsize1
!= lsize2
)
888 tree t1
= gimple_switch_index (g1
);
889 tree t2
= gimple_switch_index (g2
);
891 if (!compare_operand (t1
, t2
, OP_NORMAL
))
894 for (i
= 0; i
< lsize1
; i
++)
896 tree label1
= gimple_switch_label (g1
, i
);
897 tree label2
= gimple_switch_label (g2
, i
);
899 /* Label LOW and HIGH comparison. */
900 tree low1
= CASE_LOW (label1
);
901 tree low2
= CASE_LOW (label2
);
903 if (!tree_int_cst_equal (low1
, low2
))
904 return return_false_with_msg ("case low values are different");
906 tree high1
= CASE_HIGH (label1
);
907 tree high2
= CASE_HIGH (label2
);
909 if (!tree_int_cst_equal (high1
, high2
))
910 return return_false_with_msg ("case high values are different");
912 if (TREE_CODE (label1
) == CASE_LABEL_EXPR
913 && TREE_CODE (label2
) == CASE_LABEL_EXPR
)
915 label1
= CASE_LABEL (label1
);
916 label2
= CASE_LABEL (label2
);
918 if (!compare_operand (label1
, label2
, OP_NORMAL
))
919 return return_false_with_msg ("switch label_exprs are different");
921 else if (!tree_int_cst_equal (label1
, label2
))
922 return return_false_with_msg ("switch labels are different");
928 /* Verifies for given GIMPLE_RETURN stmts S1 and S2 that
929 return statements are semantically equivalent. */
932 func_checker::compare_gimple_return (const greturn
*g1
, const greturn
*g2
)
936 t1
= gimple_return_retval (g1
);
937 t2
= gimple_return_retval (g2
);
939 /* Void return type. */
940 if (t1
== NULL
&& t2
== NULL
)
944 operand_access_type_map
map (3);
945 return compare_operand (t1
, t2
, get_operand_access_type (&map
, t1
));
949 /* Verifies for given GIMPLEs S1 and S2 that
950 goto statements are semantically equivalent. */
953 func_checker::compare_gimple_goto (gimple
*g1
, gimple
*g2
)
957 dest1
= gimple_goto_dest (g1
);
958 dest2
= gimple_goto_dest (g2
);
960 if (TREE_CODE (dest1
) != TREE_CODE (dest2
) || TREE_CODE (dest1
) != SSA_NAME
)
963 return compare_operand (dest1
, dest2
, OP_NORMAL
);
966 /* Verifies for given GIMPLE_RESX stmts S1 and S2 that
967 resx statements are semantically equivalent. */
970 func_checker::compare_gimple_resx (const gresx
*g1
, const gresx
*g2
)
972 return gimple_resx_region (g1
) == gimple_resx_region (g2
);
975 /* Verifies for given GIMPLEs S1 and S2 that ASM statements are equivalent.
976 For the beginning, the pass only supports equality for
977 '__asm__ __volatile__ ("", "", "", "memory")'. */
980 func_checker::compare_gimple_asm (const gasm
*g1
, const gasm
*g2
)
982 if (gimple_asm_volatile_p (g1
) != gimple_asm_volatile_p (g2
))
985 if (gimple_asm_input_p (g1
) != gimple_asm_input_p (g2
))
988 if (gimple_asm_inline_p (g1
) != gimple_asm_inline_p (g2
))
991 if (gimple_asm_ninputs (g1
) != gimple_asm_ninputs (g2
))
994 if (gimple_asm_noutputs (g1
) != gimple_asm_noutputs (g2
))
997 /* We do not suppport goto ASM statement comparison. */
998 if (gimple_asm_nlabels (g1
) || gimple_asm_nlabels (g2
))
1001 if (gimple_asm_nclobbers (g1
) != gimple_asm_nclobbers (g2
))
1004 if (strcmp (gimple_asm_string (g1
), gimple_asm_string (g2
)) != 0)
1005 return return_false_with_msg ("ASM strings are different");
1007 operand_access_type_map
map (5);
1008 classify_operands (g1
, &map
);
1010 for (unsigned i
= 0; i
< gimple_asm_ninputs (g1
); i
++)
1012 tree input1
= gimple_asm_input_op (g1
, i
);
1013 tree input2
= gimple_asm_input_op (g2
, i
);
1015 if (!compare_asm_inputs_outputs (input1
, input2
, &map
))
1016 return return_false_with_msg ("ASM input is different");
1019 for (unsigned i
= 0; i
< gimple_asm_noutputs (g1
); i
++)
1021 tree output1
= gimple_asm_output_op (g1
, i
);
1022 tree output2
= gimple_asm_output_op (g2
, i
);
1024 if (!compare_asm_inputs_outputs (output1
, output2
, &map
))
1025 return return_false_with_msg ("ASM output is different");
1028 for (unsigned i
= 0; i
< gimple_asm_nclobbers (g1
); i
++)
1030 tree clobber1
= gimple_asm_clobber_op (g1
, i
);
1031 tree clobber2
= gimple_asm_clobber_op (g2
, i
);
1033 if (!operand_equal_p (TREE_VALUE (clobber1
), TREE_VALUE (clobber2
),
1035 return return_false_with_msg ("ASM clobber is different");
1041 /* Helper for func_checker::classify_operands. Record that T is a load. */
1044 visit_load_store (gimple
*, tree
, tree t
, void *data
)
1046 func_checker::operand_access_type_map
*map
=
1047 (func_checker::operand_access_type_map
*) data
;
1052 /* Compute hash map determining access types of operands. */
1055 func_checker::classify_operands (const gimple
*stmt
,
1056 operand_access_type_map
*map
)
1058 walk_stmt_load_store_ops (const_cast <gimple
*> (stmt
),
1059 (void *)map
, visit_load_store
, visit_load_store
);
1062 /* Return access type of a given operand. */
1064 func_checker::operand_access_type
1065 func_checker::get_operand_access_type (operand_access_type_map
*map
, tree t
)
1067 if (map
->contains (t
))
1072 } // ipa_icf_gimple namespace