1 /* Basic IPA utilities for type inheritance graph construction and
3 Copyright (C) 2013-2014 Free Software Foundation, Inc.
4 Contributed by Jan Hubicka
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/>. */
23 ODR = One Definition Rule
24 In short, the ODR states that:
25 1 In any translation unit, a template, type, function, or object can
26 have no more than one definition. Some of these can have any number
27 of declarations. A definition provides an instance.
28 2 In the entire program, an object or non-inline function cannot have
29 more than one definition; if an object or function is used, it must
30 have exactly one definition. You can declare an object or function
31 that is never used, in which case you don't have to provide
32 a definition. In no event can there be more than one definition.
33 3 Some things, like types, templates, and extern inline functions, can
34 be defined in more than one translation unit. For a given entity,
35 each definition must be the same. Non-extern objects and functions
36 in different translation units are different entities, even if their
37 names and types are the same.
40 This is the Gimple representation of type information of a polymorphic call.
41 It contains two parameters:
42 otr_type is a type of class whose method is called.
43 otr_token is the index into virtual table where address is taken.
46 This is the type inheritance information attached to each tree
47 RECORD_TYPE by the C++ frotend. It provides information about base
48 types and virtual tables.
50 BINFO is linked to the RECORD_TYPE by TYPE_BINFO.
51 BINFO also links to its type by BINFO_TYPE and to the virtual table by
54 Base types of a given type are enumerated by BINFO_BASE_BINFO
55 vector. Members of this vectors are not BINFOs associated
56 with a base type. Rather they are new copies of BINFOs
57 (base BINFOs). Their virtual tables may differ from
58 virtual table of the base type. Also BINFO_OFFSET specifies
59 offset of the base within the type.
61 In the case of single inheritance, the virtual table is shared
62 and BINFO_VTABLE of base BINFO is NULL. In the case of multiple
63 inheritance the individual virtual tables are pointer to by
64 BINFO_VTABLE of base binfos (that differs of BINFO_VTABLE of
65 binfo associated to the base type).
67 BINFO lookup for a given base type and offset can be done by
68 get_binfo_at_offset. It returns proper BINFO whose virtual table
69 can be used for lookup of virtual methods associated with the
73 This is an index of virtual method in virtual table associated
74 to the type defining it. Token can be looked up from OBJ_TYPE_REF
75 or from DECL_VINDEX of a given virtual table.
77 polymorphic (indirect) call
78 This is callgraph represention of virtual method call. Every
79 polymorphic call contains otr_type and otr_token taken from
80 original OBJ_TYPE_REF at callgraph construction time.
84 build_type_inheritance_graph triggers a construction of the type inheritance
87 We reconstruct it based on types of methods we see in the unit.
88 This means that the graph is not complete. Types with no methods are not
89 inserted into the graph. Also types without virtual methods are not
90 represented at all, though it may be easy to add this.
92 The inheritance graph is represented as follows:
94 Vertices are structures odr_type. Every odr_type may correspond
95 to one or more tree type nodes that are equivalent by ODR rule.
96 (the multiple type nodes appear only with linktime optimization)
98 Edges are represented by odr_type->base and odr_type->derived_types.
99 At the moment we do not track offsets of types for multiple inheritance.
102 possible_polymorphic_call_targets returns, given an parameters found in
103 indirect polymorphic edge all possible polymorphic call targets of the call.
105 pass_ipa_devirt performs simple speculative devirtualization.
110 #include "coretypes.h"
113 #include "print-tree.h"
117 #include "tree-pass.h"
118 #include "pointer-set.h"
120 #include "hash-table.h"
121 #include "tree-pretty-print.h"
122 #include "ipa-utils.h"
123 #include "tree-ssa-alias.h"
124 #include "internal-fn.h"
125 #include "gimple-fold.h"
126 #include "gimple-expr.h"
128 #include "ipa-inline.h"
129 #include "diagnostic.h"
130 #include "tree-dfa.h"
131 #include "demangle.h"
134 static bool odr_violation_reported
= false;
136 /* Dummy polymorphic call context. */
138 const ipa_polymorphic_call_context ipa_dummy_polymorphic_call_context
139 = {0, NULL
, false, true};
141 /* Pointer set of all call targets appearing in the cache. */
142 static pointer_set_t
*cached_polymorphic_call_targets
;
144 /* The node of type inheritance graph. For each type unique in
145 One Defintion Rule (ODR) sense, we produce one node linking all
146 main variants of types equivalent to it, bases and derived types. */
148 struct GTY(()) odr_type_d
152 /* All bases; built only for main variants of types */
153 vec
<odr_type
> GTY((skip
)) bases
;
154 /* All derrived types with virtual methods seen in unit;
155 built only for main variants oftypes */
156 vec
<odr_type
> GTY((skip
)) derived_types
;
158 /* All equivalent types, if more than one. */
159 vec
<tree
, va_gc
> *types
;
160 /* Set of all equivalent types, if NON-NULL. */
161 pointer_set_t
* GTY((skip
)) types_set
;
163 /* Unique ID indexing the type in odr_types array. */
165 /* Is it in anonymous namespace? */
166 bool anonymous_namespace
;
167 /* Do we know about all derivations of given type? */
168 bool all_derivations_known
;
169 /* Did we report ODR violation here? */
174 /* Return true if BINFO corresponds to a type with virtual methods.
176 Every type has several BINFOs. One is the BINFO associated by the type
177 while other represents bases of derived types. The BINFOs representing
178 bases do not have BINFO_VTABLE pointer set when this is the single
179 inheritance (because vtables are shared). Look up the BINFO of type
180 and check presence of its vtable. */
183 polymorphic_type_binfo_p (tree binfo
)
185 /* See if BINFO's type has an virtual table associtated with it. */
186 return BINFO_VTABLE (TYPE_BINFO (BINFO_TYPE (binfo
)));
189 /* Return TRUE if all derived types of T are known and thus
190 we may consider the walk of derived type complete.
192 This is typically true only for final anonymous namespace types and types
193 defined within functions (that may be COMDAT and thus shared across units,
194 but with the same set of derived types). */
197 type_all_derivations_known_p (tree t
)
199 if (TYPE_FINAL_P (t
))
203 if (type_in_anonymous_namespace_p (t
))
205 return (decl_function_context (TYPE_NAME (t
)) != NULL
);
208 /* Return TURE if type's constructors are all visible. */
211 type_all_ctors_visible_p (tree t
)
214 && cgraph_state
>= CGRAPH_STATE_CONSTRUCTION
215 /* We can not always use type_all_derivations_known_p.
216 For function local types we must assume case where
217 the function is COMDAT and shared in between units.
219 TODO: These cases are quite easy to get, but we need
220 to keep track of C++ privatizing via -Wno-weak
221 as well as the IPA privatizing. */
222 && type_in_anonymous_namespace_p (t
);
225 /* Return TRUE if type may have instance. */
228 type_possibly_instantiated_p (tree t
)
233 /* TODO: Add abstract types here. */
234 if (!type_all_ctors_visible_p (t
))
237 vtable
= BINFO_VTABLE (TYPE_BINFO (t
));
238 if (TREE_CODE (vtable
) == POINTER_PLUS_EXPR
)
239 vtable
= TREE_OPERAND (TREE_OPERAND (vtable
, 0), 0);
240 vnode
= varpool_get_node (vtable
);
241 return vnode
&& vnode
->definition
;
244 /* One Definition Rule hashtable helpers. */
248 typedef odr_type_d value_type
;
249 typedef union tree_node compare_type
;
250 static inline hashval_t
hash (const value_type
*);
251 static inline bool equal (const value_type
*, const compare_type
*);
252 static inline void remove (value_type
*);
255 /* Return type that was declared with T's name so that T is an
256 qualified variant of it. */
259 main_odr_variant (const_tree t
)
261 if (TYPE_NAME (t
) && TREE_CODE (TYPE_NAME (t
)) == TYPE_DECL
)
262 return TREE_TYPE (TYPE_NAME (t
));
263 /* Unnamed types and non-C++ produced types can be compared by variants. */
265 return TYPE_MAIN_VARIANT (t
);
268 /* Produce hash based on type name. */
271 hash_type_name (tree t
)
273 gcc_checking_assert (main_odr_variant (t
) == t
);
275 /* If not in LTO, all main variants are unique, so we can do
278 return htab_hash_pointer (t
);
280 /* Anonymous types are unique. */
281 if (type_in_anonymous_namespace_p (t
))
282 return htab_hash_pointer (t
);
284 /* For polymorphic types, we can simply hash the virtual table. */
285 if (TREE_CODE (t
) == RECORD_TYPE
286 && TYPE_BINFO (t
) && BINFO_VTABLE (TYPE_BINFO (t
)))
288 tree v
= BINFO_VTABLE (TYPE_BINFO (t
));
291 if (TREE_CODE (v
) == POINTER_PLUS_EXPR
)
293 hash
= TREE_INT_CST_LOW (TREE_OPERAND (v
, 1));
294 v
= TREE_OPERAND (TREE_OPERAND (v
, 0), 0);
297 v
= DECL_ASSEMBLER_NAME (v
);
298 hash
= iterative_hash_hashval_t (hash
, htab_hash_pointer (v
));
302 /* Rest is not implemented yet. */
306 /* Return the computed hashcode for ODR_TYPE. */
309 odr_hasher::hash (const value_type
*odr_type
)
311 return hash_type_name (odr_type
->type
);
314 /* For languages with One Definition Rule, work out if
315 types are the same based on their name.
317 This is non-trivial for LTO where minnor differences in
318 the type representation may have prevented type merging
319 to merge two copies of otherwise equivalent type.
321 Until we start streaming mangled type names, this function works
322 only for polymorphic types. */
325 types_same_for_odr (const_tree type1
, const_tree type2
)
327 gcc_checking_assert (TYPE_P (type1
) && TYPE_P (type2
));
329 type1
= main_odr_variant (type1
);
330 type2
= main_odr_variant (type2
);
338 /* Check for anonymous namespaces. Those have !TREE_PUBLIC
339 on the corresponding TYPE_STUB_DECL. */
340 if (type_in_anonymous_namespace_p (type1
)
341 || type_in_anonymous_namespace_p (type2
))
344 /* At the moment we have no way to establish ODR equivlaence at LTO
345 other than comparing virtual table pointrs of polymorphic types.
346 Eventually we should start saving mangled names in TYPE_NAME.
347 Then this condition will become non-trivial. */
349 if (TREE_CODE (type1
) == RECORD_TYPE
350 && TYPE_BINFO (type1
) && TYPE_BINFO (type2
)
351 && BINFO_VTABLE (TYPE_BINFO (type1
))
352 && BINFO_VTABLE (TYPE_BINFO (type2
)))
354 tree v1
= BINFO_VTABLE (TYPE_BINFO (type1
));
355 tree v2
= BINFO_VTABLE (TYPE_BINFO (type2
));
356 gcc_assert (TREE_CODE (v1
) == POINTER_PLUS_EXPR
357 && TREE_CODE (v2
) == POINTER_PLUS_EXPR
);
358 return (operand_equal_p (TREE_OPERAND (v1
, 1),
359 TREE_OPERAND (v2
, 1), 0)
360 && DECL_ASSEMBLER_NAME
361 (TREE_OPERAND (TREE_OPERAND (v1
, 0), 0))
362 == DECL_ASSEMBLER_NAME
363 (TREE_OPERAND (TREE_OPERAND (v2
, 0), 0)));
369 /* Compare types T1 and T2 and return true if they are
373 odr_hasher::equal (const value_type
*t1
, const compare_type
*ct2
)
375 tree t2
= const_cast <tree
> (ct2
);
377 gcc_checking_assert (main_odr_variant (t2
) == t2
);
382 return types_same_for_odr (t1
->type
, t2
);
385 /* Free ODR type V. */
388 odr_hasher::remove (value_type
*v
)
391 v
->derived_types
.release ();
393 pointer_set_destroy (v
->types_set
);
397 /* ODR type hash used to lookup ODR type based on tree type node. */
399 typedef hash_table
<odr_hasher
> odr_hash_type
;
400 static odr_hash_type
*odr_hash
;
402 /* ODR types are also stored into ODR_TYPE vector to allow consistent
403 walking. Bases appear before derived types. Vector is garbage collected
404 so we won't end up visiting empty types. */
406 static GTY(()) vec
<odr_type
, va_gc
> *odr_types_ptr
;
407 #define odr_types (*odr_types_ptr)
409 /* Set TYPE_BINFO of TYPE and its variants to BINFO. */
411 set_type_binfo (tree type
, tree binfo
)
413 for (; type
; type
= TYPE_NEXT_VARIANT (type
))
414 if (COMPLETE_TYPE_P (type
))
415 TYPE_BINFO (type
) = binfo
;
417 gcc_assert (!TYPE_BINFO (type
));
420 /* TYPE is equivalent to VAL by ODR, but its tree representation differs
421 from VAL->type. This may happen in LTO where tree merging did not merge
422 all variants of the same type. It may or may not mean the ODR violation.
423 Add it to the list of duplicates and warn on some violations. */
426 add_type_duplicate (odr_type val
, tree type
)
428 bool build_bases
= false;
430 val
->types_set
= pointer_set_create ();
432 /* Always prefer complete type to be the leader. */
433 if (!COMPLETE_TYPE_P (val
->type
)
434 && COMPLETE_TYPE_P (type
))
443 /* See if this duplicate is new. */
444 if (!pointer_set_insert (val
->types_set
, type
))
447 bool base_mismatch
= false;
451 gcc_assert (in_lto_p
);
452 vec_safe_push (val
->types
, type
);
454 /* First we compare memory layout. */
455 if (!types_compatible_p (val
->type
, type
))
458 odr_violation_reported
= true;
459 if (BINFO_VTABLE (TYPE_BINFO (val
->type
))
460 && warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (type
)), 0,
461 "type %qD violates one definition rule ",
464 inform (DECL_SOURCE_LOCATION (TYPE_NAME (val
->type
)),
465 "a type with the same name but different layout is "
466 "defined in another translation unit");
469 val
->odr_violated
= true;
470 if (cgraph_dump_file
)
472 fprintf (cgraph_dump_file
, "ODR violation or merging or ODR type bug?\n");
474 print_node (cgraph_dump_file
, "", val
->type
, 0);
475 putc ('\n',cgraph_dump_file
);
476 print_node (cgraph_dump_file
, "", type
, 0);
477 putc ('\n',cgraph_dump_file
);
481 /* Next sanity check that bases are the same. If not, we will end
482 up producing wrong answers. */
483 if (COMPLETE_TYPE_P (type
) && COMPLETE_TYPE_P (val
->type
)
484 && TREE_CODE (val
->type
) == RECORD_TYPE
485 && TREE_CODE (type
) == RECORD_TYPE
486 && TYPE_BINFO (val
->type
) && TYPE_BINFO (type
))
488 for (j
= 0, i
= 0; i
< BINFO_N_BASE_BINFOS (TYPE_BINFO (type
)); i
++)
489 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO (TYPE_BINFO (type
), i
)))
491 odr_type base
= get_odr_type
493 (BINFO_BASE_BINFO (TYPE_BINFO (type
),
496 if (val
->bases
.length () <= j
|| val
->bases
[j
] != base
)
497 base_mismatch
= true;
503 odr_violation_reported
= true;
506 && warning_at (DECL_SOURCE_LOCATION (TYPE_NAME (type
)), 0,
507 "type %qD violates one definition rule ",
509 inform (DECL_SOURCE_LOCATION (TYPE_NAME (val
->type
)),
510 "a type with the same name but different bases is "
511 "defined in another translation unit");
512 val
->odr_violated
= true;
513 if (cgraph_dump_file
)
515 fprintf (cgraph_dump_file
, "ODR bse violation or merging bug?\n");
517 print_node (cgraph_dump_file
, "", val
->type
, 0);
518 putc ('\n',cgraph_dump_file
);
519 print_node (cgraph_dump_file
, "", type
, 0);
520 putc ('\n',cgraph_dump_file
);
525 /* Regularize things a little. During LTO same types may come with
526 different BINFOs. Either because their virtual table was
527 not merged by tree merging and only later at decl merging or
528 because one type comes with external vtable, while other
529 with internal. We want to merge equivalent binfos to conserve
530 memory and streaming overhead.
532 The external vtables are more harmful: they contain references
533 to external declarations of methods that may be defined in the
534 merged LTO unit. For this reason we absolutely need to remove
535 them and replace by internal variants. Not doing so will lead
536 to incomplete answers from possible_polymorphic_call_targets. */
537 if (!flag_ltrans
&& merge
538 && TREE_CODE (val
->type
) == RECORD_TYPE
539 && TREE_CODE (type
) == RECORD_TYPE
540 && TYPE_BINFO (val
->type
) && TYPE_BINFO (type
)
541 && TYPE_MAIN_VARIANT (type
) == type
542 && TYPE_MAIN_VARIANT (val
->type
) == val
->type
543 && BINFO_VTABLE (TYPE_BINFO (val
->type
))
544 && BINFO_VTABLE (TYPE_BINFO (type
)))
546 tree master_binfo
= TYPE_BINFO (val
->type
);
547 tree v1
= BINFO_VTABLE (master_binfo
);
548 tree v2
= BINFO_VTABLE (TYPE_BINFO (type
));
550 if (TREE_CODE (v1
) == POINTER_PLUS_EXPR
)
552 gcc_assert (TREE_CODE (v2
) == POINTER_PLUS_EXPR
553 && operand_equal_p (TREE_OPERAND (v1
, 1),
554 TREE_OPERAND (v2
, 1), 0));
555 v1
= TREE_OPERAND (TREE_OPERAND (v1
, 0), 0);
556 v2
= TREE_OPERAND (TREE_OPERAND (v2
, 0), 0);
558 gcc_assert (DECL_ASSEMBLER_NAME (v1
)
559 == DECL_ASSEMBLER_NAME (v2
));
561 if (DECL_EXTERNAL (v1
) && !DECL_EXTERNAL (v2
))
565 set_type_binfo (val
->type
, TYPE_BINFO (type
));
566 for (i
= 0; i
< val
->types
->length (); i
++)
568 if (TYPE_BINFO ((*val
->types
)[i
])
570 set_type_binfo ((*val
->types
)[i
], TYPE_BINFO (type
));
572 BINFO_TYPE (TYPE_BINFO (type
)) = val
->type
;
575 set_type_binfo (type
, master_binfo
);
581 /* Get ODR type hash entry for TYPE. If INSERT is true, create
582 possibly new entry. */
585 get_odr_type (tree type
, bool insert
)
590 bool build_bases
= false;
591 bool insert_to_odr_array
= false;
594 type
= main_odr_variant (type
);
596 hash
= hash_type_name (type
);
598 = odr_hash
->find_slot_with_hash (type
, hash
, insert
? INSERT
: NO_INSERT
);
602 /* See if we already have entry for type. */
607 /* With LTO we need to support multiple tree representation of
608 the same ODR type. */
609 if (val
->type
!= type
)
610 build_bases
= add_type_duplicate (val
, type
);
615 val
= ggc_cleared_alloc
<odr_type_d
> ();
618 val
->derived_types
= vNULL
;
619 val
->anonymous_namespace
= type_in_anonymous_namespace_p (type
);
620 build_bases
= COMPLETE_TYPE_P (val
->type
);
621 insert_to_odr_array
= true;
624 if (build_bases
&& TREE_CODE (type
) == RECORD_TYPE
&& TYPE_BINFO (type
)
625 && type
== TYPE_MAIN_VARIANT (type
))
627 tree binfo
= TYPE_BINFO (type
);
630 gcc_assert (BINFO_TYPE (TYPE_BINFO (val
->type
)) = type
);
632 val
->all_derivations_known
= type_all_derivations_known_p (type
);
634 for (i
= 0; i
< BINFO_N_BASE_BINFOS (binfo
); i
++)
635 /* For now record only polymorphic types. other are
636 pointless for devirtualization and we can not precisely
637 determine ODR equivalency of these during LTO. */
638 if (polymorphic_type_binfo_p (BINFO_BASE_BINFO (binfo
, i
)))
640 odr_type base
= get_odr_type (BINFO_TYPE (BINFO_BASE_BINFO (binfo
,
643 gcc_assert (TYPE_MAIN_VARIANT (base
->type
) == base
->type
);
644 base
->derived_types
.safe_push (val
);
645 val
->bases
.safe_push (base
);
646 if (base
->id
> base_id
)
650 /* Ensure that type always appears after bases. */
651 if (insert_to_odr_array
)
654 val
->id
= odr_types
.length ();
655 vec_safe_push (odr_types_ptr
, val
);
657 else if (base_id
> val
->id
)
659 odr_types
[val
->id
] = 0;
660 /* Be sure we did not recorded any derived types; these may need
662 gcc_assert (val
->derived_types
.length() == 0);
664 val
->id
= odr_types
.length ();
665 vec_safe_push (odr_types_ptr
, val
);
670 /* Dump ODR type T and all its derrived type. INDENT specify indentation for
671 recusive printing. */
674 dump_odr_type (FILE *f
, odr_type t
, int indent
=0)
677 fprintf (f
, "%*s type %i: ", indent
* 2, "", t
->id
);
678 print_generic_expr (f
, t
->type
, TDF_SLIM
);
679 fprintf (f
, "%s", t
->anonymous_namespace
? " (anonymous namespace)":"");
680 fprintf (f
, "%s\n", t
->all_derivations_known
? " (derivations known)":"");
681 if (TYPE_NAME (t
->type
))
683 fprintf (f
, "%*s defined at: %s:%i\n", indent
* 2, "",
684 DECL_SOURCE_FILE (TYPE_NAME (t
->type
)),
685 DECL_SOURCE_LINE (TYPE_NAME (t
->type
)));
687 if (t
->bases
.length ())
689 fprintf (f
, "%*s base odr type ids: ", indent
* 2, "");
690 for (i
= 0; i
< t
->bases
.length (); i
++)
691 fprintf (f
, " %i", t
->bases
[i
]->id
);
694 if (t
->derived_types
.length ())
696 fprintf (f
, "%*s derived types:\n", indent
* 2, "");
697 for (i
= 0; i
< t
->derived_types
.length (); i
++)
698 dump_odr_type (f
, t
->derived_types
[i
], indent
+ 1);
703 /* Dump the type inheritance graph. */
706 dump_type_inheritance_graph (FILE *f
)
711 fprintf (f
, "\n\nType inheritance graph:\n");
712 for (i
= 0; i
< odr_types
.length (); i
++)
714 if (odr_types
[i
] && odr_types
[i
]->bases
.length () == 0)
715 dump_odr_type (f
, odr_types
[i
]);
717 for (i
= 0; i
< odr_types
.length (); i
++)
719 if (odr_types
[i
] && odr_types
[i
]->types
&& odr_types
[i
]->types
->length ())
722 fprintf (f
, "Duplicate tree types for odr type %i\n", i
);
723 print_node (f
, "", odr_types
[i
]->type
, 0);
724 for (j
= 0; j
< odr_types
[i
]->types
->length (); j
++)
727 fprintf (f
, "duplicate #%i\n", j
);
728 print_node (f
, "", (*odr_types
[i
]->types
)[j
], 0);
729 t
= (*odr_types
[i
]->types
)[j
];
730 while (TYPE_P (t
) && TYPE_CONTEXT (t
))
732 t
= TYPE_CONTEXT (t
);
733 print_node (f
, "", t
, 0);
741 /* Given method type T, return type of class it belongs to.
742 Lookup this pointer and get its type. */
745 method_class_type (const_tree t
)
747 tree first_parm_type
= TREE_VALUE (TYPE_ARG_TYPES (t
));
748 gcc_assert (TREE_CODE (t
) == METHOD_TYPE
);
750 return TREE_TYPE (first_parm_type
);
753 /* Initialize IPA devirt and build inheritance tree graph. */
756 build_type_inheritance_graph (void)
758 struct symtab_node
*n
;
759 FILE *inheritance_dump_file
;
764 timevar_push (TV_IPA_INHERITANCE
);
765 inheritance_dump_file
= dump_begin (TDI_inheritance
, &flags
);
766 odr_hash
= new odr_hash_type (23);
768 /* We reconstruct the graph starting of types of all methods seen in the
771 if (is_a
<cgraph_node
*> (n
)
772 && DECL_VIRTUAL_P (n
->decl
)
773 && symtab_real_symbol_p (n
))
774 get_odr_type (TYPE_MAIN_VARIANT (method_class_type (TREE_TYPE (n
->decl
))),
777 /* Look also for virtual tables of types that do not define any methods.
779 We need it in a case where class B has virtual base of class A
780 re-defining its virtual method and there is class C with no virtual
781 methods with B as virtual base.
783 Here we output B's virtual method in two variant - for non-virtual
784 and virtual inheritance. B's virtual table has non-virtual version,
785 while C's has virtual.
787 For this reason we need to know about C in order to include both
788 variants of B. More correctly, record_target_from_binfo should
789 add both variants of the method when walking B, but we have no
790 link in between them.
792 We rely on fact that either the method is exported and thus we
793 assume it is called externally or C is in anonymous namespace and
794 thus we will see the vtable. */
796 else if (is_a
<varpool_node
*> (n
)
797 && DECL_VIRTUAL_P (n
->decl
)
798 && TREE_CODE (DECL_CONTEXT (n
->decl
)) == RECORD_TYPE
799 && TYPE_BINFO (DECL_CONTEXT (n
->decl
))
800 && polymorphic_type_binfo_p (TYPE_BINFO (DECL_CONTEXT (n
->decl
))))
801 get_odr_type (TYPE_MAIN_VARIANT (DECL_CONTEXT (n
->decl
)), true);
802 if (inheritance_dump_file
)
804 dump_type_inheritance_graph (inheritance_dump_file
);
805 dump_end (TDI_inheritance
, inheritance_dump_file
);
807 timevar_pop (TV_IPA_INHERITANCE
);
810 /* Return true if N has reference from live virtual table
811 (and thus can be a destination of polymorphic call).
812 Be conservatively correct when callgraph is not built or
813 if the method may be referred externally. */
816 referenced_from_vtable_p (struct cgraph_node
*node
)
822 if (node
->externally_visible
823 || node
->used_from_other_partition
)
826 /* Keep this test constant time.
827 It is unlikely this can happen except for the case where speculative
828 devirtualization introduced many speculative edges to this node.
829 In this case the target is very likely alive anyway. */
830 if (node
->ref_list
.referring
.length () > 100)
833 /* We need references built. */
834 if (cgraph_state
<= CGRAPH_STATE_CONSTRUCTION
)
837 for (i
= 0; node
->iterate_referring (i
, ref
); i
++)
839 if ((ref
->use
== IPA_REF_ALIAS
840 && referenced_from_vtable_p (cgraph (ref
->referring
)))
841 || (ref
->use
== IPA_REF_ADDR
842 && TREE_CODE (ref
->referring
->decl
) == VAR_DECL
843 && DECL_VIRTUAL_P (ref
->referring
->decl
)))
851 /* If TARGET has associated node, record it in the NODES array.
852 CAN_REFER specify if program can refer to the target directly.
853 if TARGET is unknown (NULL) or it can not be inserted (for example because
854 its body was already removed and there is no way to refer to it), clear
858 maybe_record_node (vec
<cgraph_node
*> &nodes
,
859 tree target
, pointer_set_t
*inserted
,
863 struct cgraph_node
*target_node
;
865 /* cxa_pure_virtual and __builtin_unreachable do not need to be added into
866 list of targets; the runtime effect of calling them is undefined.
867 Only "real" virtual methods should be accounted. */
868 if (target
&& TREE_CODE (TREE_TYPE (target
)) != METHOD_TYPE
)
873 /* The only case when method of anonymous namespace becomes unreferable
874 is when we completely optimized it out. */
877 || !type_in_anonymous_namespace_p (DECL_CONTEXT (target
)))
885 target_node
= cgraph_get_node (target
);
887 /* Method can only be called by polymorphic call if any
888 of vtables refering to it are alive.
890 While this holds for non-anonymous functions, too, there are
891 cases where we want to keep them in the list; for example
892 inline functions with -fno-weak are static, but we still
893 may devirtualize them when instance comes from other unit.
894 The same holds for LTO.
896 Currently we ignore these functions in speculative devirtualization.
897 ??? Maybe it would make sense to be more aggressive for LTO even
900 && type_in_anonymous_namespace_p (DECL_CONTEXT (target
))
902 || !referenced_from_vtable_p (target_node
)))
904 /* See if TARGET is useful function we can deal with. */
905 else if (target_node
!= NULL
906 && (TREE_PUBLIC (target
)
907 || DECL_EXTERNAL (target
)
908 || target_node
->definition
)
909 && symtab_real_symbol_p (target_node
))
911 gcc_assert (!target_node
->global
.inlined_to
);
912 gcc_assert (symtab_real_symbol_p (target_node
));
913 if (!pointer_set_insert (inserted
, target
))
915 pointer_set_insert (cached_polymorphic_call_targets
,
917 nodes
.safe_push (target_node
);
921 && (!type_in_anonymous_namespace_p
922 (DECL_CONTEXT (target
))
927 /* See if BINFO's type match OUTER_TYPE. If so, lookup
928 BINFO of subtype of OTR_TYPE at OFFSET and in that BINFO find
929 method in vtable and insert method to NODES array
930 or BASES_TO_CONSIDER if this array is non-NULL.
931 Otherwise recurse to base BINFOs.
932 This match what get_binfo_at_offset does, but with offset
935 TYPE_BINFOS is a stack of BINFOS of types with defined
936 virtual table seen on way from class type to BINFO.
938 MATCHED_VTABLES tracks virtual tables we already did lookup
939 for virtual function in. INSERTED tracks nodes we already
942 ANONYMOUS is true if BINFO is part of anonymous namespace.
944 Clear COMPLETEP when we hit unreferable target.
948 record_target_from_binfo (vec
<cgraph_node
*> &nodes
,
949 vec
<tree
> *bases_to_consider
,
952 vec
<tree
> &type_binfos
,
953 HOST_WIDE_INT otr_token
,
955 HOST_WIDE_INT offset
,
956 pointer_set_t
*inserted
,
957 pointer_set_t
*matched_vtables
,
961 tree type
= BINFO_TYPE (binfo
);
966 if (BINFO_VTABLE (binfo
))
967 type_binfos
.safe_push (binfo
);
968 if (types_same_for_odr (type
, outer_type
))
971 tree type_binfo
= NULL
;
973 /* Lookup BINFO with virtual table. For normal types it is always last
975 for (i
= type_binfos
.length () - 1; i
>= 0; i
--)
976 if (BINFO_OFFSET (type_binfos
[i
]) == BINFO_OFFSET (binfo
))
978 type_binfo
= type_binfos
[i
];
981 if (BINFO_VTABLE (binfo
))
983 /* If this is duplicated BINFO for base shared by virtual inheritance,
984 we may not have its associated vtable. This is not a problem, since
985 we will walk it on the other path. */
988 tree inner_binfo
= get_binfo_at_offset (type_binfo
,
992 gcc_assert (odr_violation_reported
);
995 /* For types in anonymous namespace first check if the respective vtable
996 is alive. If not, we know the type can't be called. */
997 if (!flag_ltrans
&& anonymous
)
999 tree vtable
= BINFO_VTABLE (inner_binfo
);
1000 varpool_node
*vnode
;
1002 if (TREE_CODE (vtable
) == POINTER_PLUS_EXPR
)
1003 vtable
= TREE_OPERAND (TREE_OPERAND (vtable
, 0), 0);
1004 vnode
= varpool_get_node (vtable
);
1005 if (!vnode
|| !vnode
->definition
)
1008 gcc_assert (inner_binfo
);
1009 if (bases_to_consider
1010 ? !pointer_set_contains (matched_vtables
, BINFO_VTABLE (inner_binfo
))
1011 : !pointer_set_insert (matched_vtables
, BINFO_VTABLE (inner_binfo
)))
1014 tree target
= gimple_get_virt_method_for_binfo (otr_token
,
1017 if (!bases_to_consider
)
1018 maybe_record_node (nodes
, target
, inserted
, can_refer
, completep
);
1019 /* Destructors are never called via construction vtables. */
1020 else if (!target
|| !DECL_CXX_DESTRUCTOR_P (target
))
1021 bases_to_consider
->safe_push (target
);
1027 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
1028 /* Walking bases that have no virtual method is pointless excercise. */
1029 if (polymorphic_type_binfo_p (base_binfo
))
1030 record_target_from_binfo (nodes
, bases_to_consider
, base_binfo
, otr_type
,
1032 otr_token
, outer_type
, offset
, inserted
,
1033 matched_vtables
, anonymous
, completep
);
1034 if (BINFO_VTABLE (binfo
))
1038 /* Lookup virtual methods matching OTR_TYPE (with OFFSET and OTR_TOKEN)
1039 of TYPE, insert them to NODES, recurse into derived nodes.
1040 INSERTED is used to avoid duplicate insertions of methods into NODES.
1041 MATCHED_VTABLES are used to avoid duplicate walking vtables.
1042 Clear COMPLETEP if unreferable target is found.
1044 If CONSIDER_CONSTURCTION is true, record to BASES_TO_CONSDIER
1045 all cases where BASE_SKIPPED is true (because the base is abstract
1049 possible_polymorphic_call_targets_1 (vec
<cgraph_node
*> &nodes
,
1050 pointer_set_t
*inserted
,
1051 pointer_set_t
*matched_vtables
,
1054 HOST_WIDE_INT otr_token
,
1056 HOST_WIDE_INT offset
,
1058 vec
<tree
> &bases_to_consider
,
1059 bool consider_construction
)
1061 tree binfo
= TYPE_BINFO (type
->type
);
1063 vec
<tree
> type_binfos
= vNULL
;
1064 bool possibly_instantiated
= type_possibly_instantiated_p (type
->type
);
1066 /* We may need to consider types w/o instances because of possible derived
1067 types using their methods either directly or via construction vtables.
1068 We are safe to skip them when all derivations are known, since we will
1070 This is done by recording them to BASES_TO_CONSIDER array. */
1071 if (possibly_instantiated
|| consider_construction
)
1073 record_target_from_binfo (nodes
,
1074 (!possibly_instantiated
1075 && type_all_derivations_known_p (type
->type
))
1076 ? &bases_to_consider
: NULL
,
1077 binfo
, otr_type
, type_binfos
, otr_token
,
1079 inserted
, matched_vtables
,
1080 type
->anonymous_namespace
, completep
);
1082 type_binfos
.release ();
1083 for (i
= 0; i
< type
->derived_types
.length (); i
++)
1084 possible_polymorphic_call_targets_1 (nodes
, inserted
,
1087 type
->derived_types
[i
],
1088 otr_token
, outer_type
, offset
, completep
,
1089 bases_to_consider
, consider_construction
);
1092 /* Cache of queries for polymorphic call targets.
1094 Enumerating all call targets may get expensive when there are many
1095 polymorphic calls in the program, so we memoize all the previous
1096 queries and avoid duplicated work. */
1098 struct polymorphic_call_target_d
1100 HOST_WIDE_INT otr_token
;
1101 ipa_polymorphic_call_context context
;
1103 vec
<cgraph_node
*> targets
;
1104 int nonconstruction_targets
;
1108 /* Polymorphic call target cache helpers. */
1110 struct polymorphic_call_target_hasher
1112 typedef polymorphic_call_target_d value_type
;
1113 typedef polymorphic_call_target_d compare_type
;
1114 static inline hashval_t
hash (const value_type
*);
1115 static inline bool equal (const value_type
*, const compare_type
*);
1116 static inline void remove (value_type
*);
1119 /* Return the computed hashcode for ODR_QUERY. */
1122 polymorphic_call_target_hasher::hash (const value_type
*odr_query
)
1126 hash
= iterative_hash_host_wide_int
1127 (odr_query
->otr_token
,
1128 odr_query
->type
->id
);
1129 hash
= iterative_hash_hashval_t (TYPE_UID (odr_query
->context
.outer_type
),
1131 hash
= iterative_hash_host_wide_int (odr_query
->context
.offset
, hash
);
1132 return iterative_hash_hashval_t
1133 (((int)odr_query
->context
.maybe_in_construction
<< 1)
1134 | (int)odr_query
->context
.maybe_derived_type
, hash
);
1137 /* Compare cache entries T1 and T2. */
1140 polymorphic_call_target_hasher::equal (const value_type
*t1
,
1141 const compare_type
*t2
)
1143 return (t1
->type
== t2
->type
&& t1
->otr_token
== t2
->otr_token
1144 && t1
->context
.offset
== t2
->context
.offset
1145 && t1
->context
.outer_type
== t2
->context
.outer_type
1146 && t1
->context
.maybe_in_construction
1147 == t2
->context
.maybe_in_construction
1148 && t1
->context
.maybe_derived_type
== t2
->context
.maybe_derived_type
);
1151 /* Remove entry in polymorphic call target cache hash. */
1154 polymorphic_call_target_hasher::remove (value_type
*v
)
1156 v
->targets
.release ();
1160 /* Polymorphic call target query cache. */
1162 typedef hash_table
<polymorphic_call_target_hasher
>
1163 polymorphic_call_target_hash_type
;
1164 static polymorphic_call_target_hash_type
*polymorphic_call_target_hash
;
1166 /* Destroy polymorphic call target query cache. */
1169 free_polymorphic_call_targets_hash ()
1171 if (cached_polymorphic_call_targets
)
1173 delete polymorphic_call_target_hash
;
1174 polymorphic_call_target_hash
= NULL
;
1175 pointer_set_destroy (cached_polymorphic_call_targets
);
1176 cached_polymorphic_call_targets
= NULL
;
1180 /* When virtual function is removed, we may need to flush the cache. */
1183 devirt_node_removal_hook (struct cgraph_node
*n
, void *d ATTRIBUTE_UNUSED
)
1185 if (cached_polymorphic_call_targets
1186 && pointer_set_contains (cached_polymorphic_call_targets
, n
))
1187 free_polymorphic_call_targets_hash ();
1190 /* Return true when TYPE contains an polymorphic type and thus is interesting
1191 for devirtualization machinery. */
1194 contains_polymorphic_type_p (const_tree type
)
1196 type
= TYPE_MAIN_VARIANT (type
);
1198 if (RECORD_OR_UNION_TYPE_P (type
))
1200 if (TYPE_BINFO (type
)
1201 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
1203 for (tree fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
1204 if (TREE_CODE (fld
) == FIELD_DECL
1205 && !DECL_ARTIFICIAL (fld
)
1206 && contains_polymorphic_type_p (TREE_TYPE (fld
)))
1210 if (TREE_CODE (type
) == ARRAY_TYPE
)
1211 return contains_polymorphic_type_p (TREE_TYPE (type
));
1215 /* CONTEXT->OUTER_TYPE is a type of memory object where object of EXPECTED_TYPE
1216 is contained at CONTEXT->OFFSET. Walk the memory representation of
1217 CONTEXT->OUTER_TYPE and find the outermost class type that match
1218 EXPECTED_TYPE or contain EXPECTED_TYPE as a base. Update CONTEXT
1221 For example when CONTEXT represents type
1227 and we look for type at offset sizeof(int), we end up with B and offset 0.
1228 If the same is produced by multiple inheritance, we end up with A and offset
1231 If we can not find corresponding class, give up by setting
1232 CONTEXT->OUTER_TYPE to EXPECTED_TYPE and CONTEXT->OFFSET to NULL.
1233 Return true when lookup was sucesful. */
1236 get_class_context (ipa_polymorphic_call_context
*context
,
1239 tree type
= context
->outer_type
;
1240 HOST_WIDE_INT offset
= context
->offset
;
1242 /* Find the sub-object the constant actually refers to and mark whether it is
1243 an artificial one (as opposed to a user-defined one). */
1246 HOST_WIDE_INT pos
, size
;
1249 /* On a match, just return what we found. */
1250 if (TREE_CODE (type
) == TREE_CODE (expected_type
)
1251 && types_same_for_odr (type
, expected_type
))
1253 /* Type can not contain itself on an non-zero offset. In that case
1257 gcc_assert (offset
== 0);
1261 /* Walk fields and find corresponding on at OFFSET. */
1262 if (TREE_CODE (type
) == RECORD_TYPE
)
1264 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
1266 if (TREE_CODE (fld
) != FIELD_DECL
)
1269 pos
= int_bit_position (fld
);
1270 size
= tree_to_uhwi (DECL_SIZE (fld
));
1271 if (pos
<= offset
&& (pos
+ size
) > offset
)
1278 type
= TYPE_MAIN_VARIANT (TREE_TYPE (fld
));
1280 /* DECL_ARTIFICIAL represents a basetype. */
1281 if (!DECL_ARTIFICIAL (fld
))
1283 context
->outer_type
= type
;
1284 context
->offset
= offset
;
1285 /* As soon as we se an field containing the type,
1286 we know we are not looking for derivations. */
1287 context
->maybe_derived_type
= false;
1290 else if (TREE_CODE (type
) == ARRAY_TYPE
)
1292 tree subtype
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
1294 /* Give up if we don't know array size. */
1295 if (!tree_fits_shwi_p (TYPE_SIZE (subtype
))
1296 || !tree_to_shwi (TYPE_SIZE (subtype
)) <= 0)
1298 offset
= offset
% tree_to_shwi (TYPE_SIZE (subtype
));
1300 context
->outer_type
= type
;
1301 context
->offset
= offset
;
1302 context
->maybe_derived_type
= false;
1304 /* Give up on anything else. */
1309 /* If we failed to find subtype we look for, give up and fall back to the
1310 most generic query. */
1312 context
->outer_type
= expected_type
;
1313 context
->offset
= 0;
1314 context
->maybe_derived_type
= true;
1315 context
->maybe_in_construction
= true;
1316 /* POD can be changed to an instance of a polymorphic type by
1317 placement new. Here we play safe and assume that any
1318 non-polymorphic type is POD. */
1319 if ((TREE_CODE (type
) != RECORD_TYPE
1320 || !TYPE_BINFO (type
)
1321 || !polymorphic_type_binfo_p (TYPE_BINFO (type
)))
1322 && (TREE_CODE (TYPE_SIZE (type
)) != INTEGER_CST
1323 || (offset
+ tree_to_uhwi (TYPE_SIZE (expected_type
)) <=
1324 tree_to_uhwi (TYPE_SIZE (type
)))))
1329 /* Return true if OUTER_TYPE contains OTR_TYPE at OFFSET. */
1332 contains_type_p (tree outer_type
, HOST_WIDE_INT offset
,
1335 ipa_polymorphic_call_context context
= {offset
,
1336 TYPE_MAIN_VARIANT (outer_type
),
1338 return get_class_context (&context
, otr_type
);
1341 /* Lookup base of BINFO that has virtual table VTABLE with OFFSET. */
1344 subbinfo_with_vtable_at_offset (tree binfo
, unsigned HOST_WIDE_INT offset
,
1347 tree v
= BINFO_VTABLE (binfo
);
1350 unsigned HOST_WIDE_INT this_offset
;
1354 if (!vtable_pointer_value_to_vtable (v
, &v
, &this_offset
))
1357 if (offset
== this_offset
1358 && DECL_ASSEMBLER_NAME (v
) == DECL_ASSEMBLER_NAME (vtable
))
1362 for (i
= 0; BINFO_BASE_ITERATE (binfo
, i
, base_binfo
); i
++)
1363 if (polymorphic_type_binfo_p (base_binfo
))
1365 base_binfo
= subbinfo_with_vtable_at_offset (base_binfo
, offset
, vtable
);
1372 /* T is known constant value of virtual table pointer.
1373 Store virtual table to V and its offset to OFFSET.
1374 Return false if T does not look like virtual table reference. */
1377 vtable_pointer_value_to_vtable (const_tree t
, tree
*v
,
1378 unsigned HOST_WIDE_INT
*offset
)
1380 /* We expect &MEM[(void *)&virtual_table + 16B].
1381 We obtain object's BINFO from the context of the virtual table.
1382 This one contains pointer to virtual table represented via
1383 POINTER_PLUS_EXPR. Verify that this pointer match to what
1384 we propagated through.
1386 In the case of virtual inheritance, the virtual tables may
1387 be nested, i.e. the offset may be different from 16 and we may
1388 need to dive into the type representation. */
1389 if (TREE_CODE (t
) == ADDR_EXPR
1390 && TREE_CODE (TREE_OPERAND (t
, 0)) == MEM_REF
1391 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t
, 0), 0)) == ADDR_EXPR
1392 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (t
, 0), 1)) == INTEGER_CST
1393 && (TREE_CODE (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 0), 0), 0))
1395 && DECL_VIRTUAL_P (TREE_OPERAND (TREE_OPERAND
1396 (TREE_OPERAND (t
, 0), 0), 0)))
1398 *v
= TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t
, 0), 0), 0);
1399 *offset
= tree_to_uhwi (TREE_OPERAND (TREE_OPERAND (t
, 0), 1));
1403 /* Alternative representation, used by C++ frontend is POINTER_PLUS_EXPR.
1404 We need to handle it when T comes from static variable initializer or
1406 if (TREE_CODE (t
) == POINTER_PLUS_EXPR
)
1408 *offset
= tree_to_uhwi (TREE_OPERAND (t
, 1));
1409 t
= TREE_OPERAND (t
, 0);
1414 if (TREE_CODE (t
) != ADDR_EXPR
)
1416 *v
= TREE_OPERAND (t
, 0);
1420 /* T is known constant value of virtual table pointer. Return BINFO of the
1424 vtable_pointer_value_to_binfo (const_tree t
)
1427 unsigned HOST_WIDE_INT offset
;
1429 if (!vtable_pointer_value_to_vtable (t
, &vtable
, &offset
))
1432 /* FIXME: for stores of construction vtables we return NULL,
1433 because we do not have BINFO for those. Eventually we should fix
1434 our representation to allow this case to be handled, too.
1435 In the case we see store of BINFO we however may assume
1436 that standard folding will be ale to cope with it. */
1437 return subbinfo_with_vtable_at_offset (TYPE_BINFO (DECL_CONTEXT (vtable
)),
1441 /* We know that the instance is stored in variable or parameter
1442 (not dynamically allocated) and we want to disprove the fact
1443 that it may be in construction at invocation of CALL.
1445 For the variable to be in construction we actually need to
1446 be in constructor of corresponding global variable or
1447 the inline stack of CALL must contain the constructor.
1448 Check this condition. This check works safely only before
1449 IPA passes, because inline stacks may become out of date
1453 decl_maybe_in_construction_p (tree base
, tree outer_type
,
1454 gimple call
, tree function
)
1456 outer_type
= TYPE_MAIN_VARIANT (outer_type
);
1457 gcc_assert (DECL_P (base
));
1459 /* After inlining the code unification optimizations may invalidate
1460 inline stacks. Also we need to give up on global variables after
1461 IPA, because addresses of these may have been propagated to their
1463 if (DECL_STRUCT_FUNCTION (function
)->after_inlining
)
1466 /* Pure functions can not do any changes on the dynamic type;
1467 that require writting to memory. */
1468 if (!auto_var_in_fn_p (base
, function
)
1469 && flags_from_decl_or_type (function
) & (ECF_PURE
| ECF_CONST
))
1472 for (tree block
= gimple_block (call
); block
&& TREE_CODE (block
) == BLOCK
;
1473 block
= BLOCK_SUPERCONTEXT (block
))
1474 if (BLOCK_ABSTRACT_ORIGIN (block
)
1475 && TREE_CODE (BLOCK_ABSTRACT_ORIGIN (block
)) == FUNCTION_DECL
)
1477 tree fn
= BLOCK_ABSTRACT_ORIGIN (block
);
1479 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
1480 || (!DECL_CXX_CONSTRUCTOR_P (fn
)
1481 || !DECL_CXX_DESTRUCTOR_P (fn
)))
1483 /* Watch for clones where we constant propagated the first
1484 argument (pointer to the instance). */
1485 fn
= DECL_ABSTRACT_ORIGIN (fn
);
1487 || !is_global_var (base
)
1488 || TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
1489 || (!DECL_CXX_CONSTRUCTOR_P (fn
)
1490 || !DECL_CXX_DESTRUCTOR_P (fn
)))
1493 if (flags_from_decl_or_type (fn
) & (ECF_PURE
| ECF_CONST
))
1496 /* FIXME: this can go away once we have ODR types equivalency on
1498 if (in_lto_p
&& !polymorphic_type_binfo_p (TYPE_BINFO (outer_type
)))
1500 tree type
= TYPE_MAIN_VARIANT (method_class_type (TREE_TYPE (fn
)));
1501 if (types_same_for_odr (type
, outer_type
))
1505 if (TREE_CODE (base
) == VAR_DECL
1506 && is_global_var (base
))
1508 if (TREE_CODE (TREE_TYPE (function
)) != METHOD_TYPE
1509 || (!DECL_CXX_CONSTRUCTOR_P (function
)
1510 || !DECL_CXX_DESTRUCTOR_P (function
)))
1512 if (!DECL_ABSTRACT_ORIGIN (function
))
1514 /* Watch for clones where we constant propagated the first
1515 argument (pointer to the instance). */
1516 function
= DECL_ABSTRACT_ORIGIN (function
);
1518 || TREE_CODE (TREE_TYPE (function
)) != METHOD_TYPE
1519 || (!DECL_CXX_CONSTRUCTOR_P (function
)
1520 || !DECL_CXX_DESTRUCTOR_P (function
)))
1523 /* FIXME: this can go away once we have ODR types equivalency on
1525 if (in_lto_p
&& !polymorphic_type_binfo_p (TYPE_BINFO (outer_type
)))
1527 tree type
= TYPE_MAIN_VARIANT (method_class_type (TREE_TYPE (function
)));
1528 if (types_same_for_odr (type
, outer_type
))
1534 /* Proudce polymorphic call context for call method of instance
1535 that is located within BASE (that is assumed to be a decl) at OFFSET. */
1538 get_polymorphic_call_info_for_decl (ipa_polymorphic_call_context
*context
,
1539 tree base
, HOST_WIDE_INT offset
)
1541 gcc_assert (DECL_P (base
));
1543 context
->outer_type
= TYPE_MAIN_VARIANT (TREE_TYPE (base
));
1544 context
->offset
= offset
;
1545 /* Make very conservative assumption that all objects
1546 may be in construction.
1547 TODO: ipa-prop already contains code to tell better.
1549 context
->maybe_in_construction
= true;
1550 context
->maybe_derived_type
= false;
1553 /* CST is an invariant (address of decl), try to get meaningful
1554 polymorphic call context for polymorphic call of method
1555 if instance of OTR_TYPE that is located at OFFSET of this invariant.
1556 Return FALSE if nothing meaningful can be found. */
1559 get_polymorphic_call_info_from_invariant (ipa_polymorphic_call_context
*context
,
1562 HOST_WIDE_INT offset
)
1564 HOST_WIDE_INT offset2
, size
, max_size
;
1567 if (TREE_CODE (cst
) != ADDR_EXPR
)
1570 cst
= TREE_OPERAND (cst
, 0);
1571 base
= get_ref_base_and_extent (cst
, &offset2
, &size
, &max_size
);
1572 if (!DECL_P (base
) || max_size
== -1 || max_size
!= size
)
1575 /* Only type inconsistent programs can have otr_type that is
1576 not part of outer type. */
1577 if (!contains_type_p (TREE_TYPE (base
), offset
, otr_type
))
1580 get_polymorphic_call_info_for_decl (context
, base
, offset
);
1584 /* Given REF call in FNDECL, determine class of the polymorphic
1585 call (OTR_TYPE), its token (OTR_TOKEN) and CONTEXT.
1586 CALL is optional argument giving the actual statement (usually call) where
1587 the context is used.
1588 Return pointer to object described by the context */
1591 get_polymorphic_call_info (tree fndecl
,
1594 HOST_WIDE_INT
*otr_token
,
1595 ipa_polymorphic_call_context
*context
,
1599 *otr_type
= obj_type_ref_class (ref
);
1600 *otr_token
= tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref
));
1602 /* Set up basic info in case we find nothing interesting in the analysis. */
1603 context
->outer_type
= TYPE_MAIN_VARIANT (*otr_type
);
1604 context
->offset
= 0;
1605 base_pointer
= OBJ_TYPE_REF_OBJECT (ref
);
1606 context
->maybe_derived_type
= true;
1607 context
->maybe_in_construction
= true;
1609 /* Walk SSA for outer object. */
1612 if (TREE_CODE (base_pointer
) == SSA_NAME
1613 && !SSA_NAME_IS_DEFAULT_DEF (base_pointer
)
1614 && SSA_NAME_DEF_STMT (base_pointer
)
1615 && gimple_assign_single_p (SSA_NAME_DEF_STMT (base_pointer
)))
1617 base_pointer
= gimple_assign_rhs1 (SSA_NAME_DEF_STMT (base_pointer
));
1618 STRIP_NOPS (base_pointer
);
1620 else if (TREE_CODE (base_pointer
) == ADDR_EXPR
)
1622 HOST_WIDE_INT size
, max_size
;
1623 HOST_WIDE_INT offset2
;
1624 tree base
= get_ref_base_and_extent (TREE_OPERAND (base_pointer
, 0),
1625 &offset2
, &size
, &max_size
);
1627 /* If this is a varying address, punt. */
1628 if ((TREE_CODE (base
) == MEM_REF
|| DECL_P (base
))
1630 && max_size
== size
)
1632 /* We found dereference of a pointer. Type of the pointer
1633 and MEM_REF is meaningless, but we can look futher. */
1634 if (TREE_CODE (base
) == MEM_REF
)
1636 base_pointer
= TREE_OPERAND (base
, 0);
1638 += offset2
+ mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
1639 context
->outer_type
= NULL
;
1641 /* We found base object. In this case the outer_type
1643 else if (DECL_P (base
))
1645 gcc_assert (!POINTER_TYPE_P (TREE_TYPE (base
)));
1647 /* Only type inconsistent programs can have otr_type that is
1648 not part of outer type. */
1649 if (!contains_type_p (TREE_TYPE (base
),
1650 context
->offset
+ offset2
, *otr_type
))
1652 /* Use OTR_TOKEN = INT_MAX as a marker of probably type inconsistent
1653 code sequences; we arrange the calls to be builtin_unreachable
1655 *otr_token
= INT_MAX
;
1656 return base_pointer
;
1658 get_polymorphic_call_info_for_decl (context
, base
,
1659 context
->offset
+ offset2
);
1660 if (context
->maybe_in_construction
&& call
)
1661 context
->maybe_in_construction
1662 = decl_maybe_in_construction_p (base
,
1663 context
->outer_type
,
1665 current_function_decl
);
1674 else if (TREE_CODE (base_pointer
) == POINTER_PLUS_EXPR
1675 && tree_fits_uhwi_p (TREE_OPERAND (base_pointer
, 1)))
1677 context
->offset
+= tree_to_shwi (TREE_OPERAND (base_pointer
, 1))
1679 base_pointer
= TREE_OPERAND (base_pointer
, 0);
1686 /* Try to determine type of the outer object. */
1687 if (TREE_CODE (base_pointer
) == SSA_NAME
1688 && SSA_NAME_IS_DEFAULT_DEF (base_pointer
)
1689 && TREE_CODE (SSA_NAME_VAR (base_pointer
)) == PARM_DECL
)
1691 /* See if parameter is THIS pointer of a method. */
1692 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
1693 && SSA_NAME_VAR (base_pointer
) == DECL_ARGUMENTS (fndecl
))
1696 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (base_pointer
)));
1697 gcc_assert (TREE_CODE (context
->outer_type
) == RECORD_TYPE
);
1699 /* Dynamic casting has possibly upcasted the type
1700 in the hiearchy. In this case outer type is less
1701 informative than inner type and we should forget
1703 if (!contains_type_p (context
->outer_type
, context
->offset
,
1706 context
->outer_type
= NULL
;
1707 return base_pointer
;
1710 /* If the function is constructor or destructor, then
1711 the type is possibly in construction, but we know
1712 it is not derived type. */
1713 if (DECL_CXX_CONSTRUCTOR_P (fndecl
)
1714 || DECL_CXX_DESTRUCTOR_P (fndecl
))
1716 context
->maybe_in_construction
= true;
1717 context
->maybe_derived_type
= false;
1721 context
->maybe_derived_type
= true;
1722 context
->maybe_in_construction
= false;
1724 return base_pointer
;
1726 /* Non-PODs passed by value are really passed by invisible
1727 reference. In this case we also know the type of the
1729 if (DECL_BY_REFERENCE (SSA_NAME_VAR (base_pointer
)))
1732 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (base_pointer
)));
1733 gcc_assert (!POINTER_TYPE_P (context
->outer_type
));
1734 /* Only type inconsistent programs can have otr_type that is
1735 not part of outer type. */
1736 if (!contains_type_p (context
->outer_type
, context
->offset
,
1739 /* Use OTR_TOKEN = INT_MAX as a marker of probably type inconsistent
1740 code sequences; we arrange the calls to be builtin_unreachable
1742 *otr_token
= INT_MAX
;
1743 return base_pointer
;
1745 context
->maybe_derived_type
= false;
1746 context
->maybe_in_construction
= false;
1747 return base_pointer
;
1750 /* TODO: There are multiple ways to derive a type. For instance
1751 if BASE_POINTER is passed to an constructor call prior our refernece.
1752 We do not make this type of flow sensitive analysis yet. */
1753 return base_pointer
;
1756 /* Walk bases of OUTER_TYPE that contain OTR_TYPE at OFFSET.
1757 Lookup their respecitve virtual methods for OTR_TOKEN and OTR_TYPE
1758 and insert them to NODES.
1760 MATCHED_VTABLES and INSERTED is used to avoid duplicated work. */
1763 record_targets_from_bases (tree otr_type
,
1764 HOST_WIDE_INT otr_token
,
1766 HOST_WIDE_INT offset
,
1767 vec
<cgraph_node
*> &nodes
,
1768 pointer_set_t
*inserted
,
1769 pointer_set_t
*matched_vtables
,
1774 HOST_WIDE_INT pos
, size
;
1778 if (types_same_for_odr (outer_type
, otr_type
))
1781 for (fld
= TYPE_FIELDS (outer_type
); fld
; fld
= DECL_CHAIN (fld
))
1783 if (TREE_CODE (fld
) != FIELD_DECL
)
1786 pos
= int_bit_position (fld
);
1787 size
= tree_to_shwi (DECL_SIZE (fld
));
1788 if (pos
<= offset
&& (pos
+ size
) > offset
1789 /* Do not get confused by zero sized bases. */
1790 && polymorphic_type_binfo_p (TYPE_BINFO (TREE_TYPE (fld
))))
1793 /* Within a class type we should always find correcponding fields. */
1794 gcc_assert (fld
&& TREE_CODE (TREE_TYPE (fld
)) == RECORD_TYPE
);
1796 /* Nonbasetypes should have been stripped by outer_class_type. */
1797 gcc_assert (DECL_ARTIFICIAL (fld
));
1799 outer_type
= TREE_TYPE (fld
);
1802 base_binfo
= get_binfo_at_offset (TYPE_BINFO (outer_type
),
1806 gcc_assert (odr_violation_reported
);
1809 gcc_assert (base_binfo
);
1810 if (!pointer_set_insert (matched_vtables
, BINFO_VTABLE (base_binfo
)))
1813 tree target
= gimple_get_virt_method_for_binfo (otr_token
,
1816 if (!target
|| ! DECL_CXX_DESTRUCTOR_P (target
))
1817 maybe_record_node (nodes
, target
, inserted
, can_refer
, completep
);
1818 pointer_set_insert (matched_vtables
, BINFO_VTABLE (base_binfo
));
1823 /* When virtual table is removed, we may need to flush the cache. */
1826 devirt_variable_node_removal_hook (varpool_node
*n
,
1827 void *d ATTRIBUTE_UNUSED
)
1829 if (cached_polymorphic_call_targets
1830 && DECL_VIRTUAL_P (n
->decl
)
1831 && type_in_anonymous_namespace_p (DECL_CONTEXT (n
->decl
)))
1832 free_polymorphic_call_targets_hash ();
1835 /* Return vector containing possible targets of polymorphic call of type
1836 OTR_TYPE caling method OTR_TOKEN within type of OTR_OUTER_TYPE and OFFSET.
1837 If INCLUDE_BASES is true, walk also base types of OUTER_TYPES containig
1838 OTR_TYPE and include their virtual method. This is useful for types
1839 possibly in construction or destruction where the virtual table may
1840 temporarily change to one of base types. INCLUDE_DERIVER_TYPES make
1841 us to walk the inheritance graph for all derivations.
1843 OTR_TOKEN == INT_MAX is used to mark calls that are provably
1844 undefined and should be redirected to unreachable.
1846 If COMPLETEP is non-NULL, store true if the list is complete.
1847 CACHE_TOKEN (if non-NULL) will get stored to an unique ID of entry
1848 in the target cache. If user needs to visit every target list
1849 just once, it can memoize them.
1851 NONCONSTRUCTION_TARGETS specify number of targets with asumption that
1852 the type is not in the construction. Those targets appear first in the
1855 Returned vector is placed into cache. It is NOT caller's responsibility
1856 to free it. The vector can be freed on cgraph_remove_node call if
1857 the particular node is a virtual function present in the cache. */
1860 possible_polymorphic_call_targets (tree otr_type
,
1861 HOST_WIDE_INT otr_token
,
1862 ipa_polymorphic_call_context context
,
1865 int *nonconstruction_targetsp
)
1867 static struct cgraph_node_hook_list
*node_removal_hook_holder
;
1868 pointer_set_t
*inserted
;
1869 pointer_set_t
*matched_vtables
;
1870 vec
<cgraph_node
*> nodes
= vNULL
;
1871 vec
<tree
> bases_to_consider
= vNULL
;
1872 odr_type type
, outer_type
;
1873 polymorphic_call_target_d key
;
1874 polymorphic_call_target_d
**slot
;
1879 bool skipped
= false;
1881 otr_type
= TYPE_MAIN_VARIANT (otr_type
);
1883 /* If ODR is not initialized, return empty incomplete list. */
1889 *cache_token
= NULL
;
1890 if (nonconstruction_targetsp
)
1891 *nonconstruction_targetsp
= 0;
1895 /* If we hit type inconsistency, just return empty list of targets. */
1896 if (otr_token
== INT_MAX
)
1901 *cache_token
= NULL
;
1902 if (nonconstruction_targetsp
)
1903 *nonconstruction_targetsp
= 0;
1907 type
= get_odr_type (otr_type
, true);
1909 /* Recording type variants would wast results cache. */
1910 gcc_assert (!context
.outer_type
1911 || TYPE_MAIN_VARIANT (context
.outer_type
) == context
.outer_type
);
1913 /* Lookup the outer class type we want to walk. */
1914 if (context
.outer_type
1915 && !get_class_context (&context
, otr_type
))
1920 *cache_token
= NULL
;
1921 if (nonconstruction_targetsp
)
1922 *nonconstruction_targetsp
= 0;
1926 /* Check that get_class_context kept the main variant. */
1927 gcc_assert (!context
.outer_type
1928 || TYPE_MAIN_VARIANT (context
.outer_type
) == context
.outer_type
);
1930 /* We canonicalize our query, so we do not need extra hashtable entries. */
1932 /* Without outer type, we have no use for offset. Just do the
1933 basic search from innter type */
1934 if (!context
.outer_type
)
1936 context
.outer_type
= otr_type
;
1939 /* We need to update our hiearchy if the type does not exist. */
1940 outer_type
= get_odr_type (context
.outer_type
, true);
1941 /* If the type is complete, there are no derivations. */
1942 if (TYPE_FINAL_P (outer_type
->type
))
1943 context
.maybe_derived_type
= false;
1945 /* Initialize query cache. */
1946 if (!cached_polymorphic_call_targets
)
1948 cached_polymorphic_call_targets
= pointer_set_create ();
1949 polymorphic_call_target_hash
1950 = new polymorphic_call_target_hash_type (23);
1951 if (!node_removal_hook_holder
)
1953 node_removal_hook_holder
=
1954 cgraph_add_node_removal_hook (&devirt_node_removal_hook
, NULL
);
1955 varpool_add_node_removal_hook (&devirt_variable_node_removal_hook
,
1960 /* Lookup cached answer. */
1962 key
.otr_token
= otr_token
;
1963 key
.context
= context
;
1964 slot
= polymorphic_call_target_hash
->find_slot (&key
, INSERT
);
1966 *cache_token
= (void *)*slot
;
1970 *completep
= (*slot
)->complete
;
1971 if (nonconstruction_targetsp
)
1972 *nonconstruction_targetsp
= (*slot
)->nonconstruction_targets
;
1973 return (*slot
)->targets
;
1978 /* Do actual search. */
1979 timevar_push (TV_IPA_VIRTUAL_CALL
);
1980 *slot
= XCNEW (polymorphic_call_target_d
);
1982 *cache_token
= (void *)*slot
;
1983 (*slot
)->type
= type
;
1984 (*slot
)->otr_token
= otr_token
;
1985 (*slot
)->context
= context
;
1987 inserted
= pointer_set_create ();
1988 matched_vtables
= pointer_set_create ();
1990 /* First see virtual method of type itself. */
1991 binfo
= get_binfo_at_offset (TYPE_BINFO (outer_type
->type
),
1992 context
.offset
, otr_type
);
1994 target
= gimple_get_virt_method_for_binfo (otr_token
, binfo
,
1998 gcc_assert (odr_violation_reported
);
2002 /* Destructors are never called through construction virtual tables,
2003 because the type is always known. */
2004 if (target
&& DECL_CXX_DESTRUCTOR_P (target
))
2005 context
.maybe_in_construction
= false;
2009 /* In the case we get complete method, we don't need
2010 to walk derivations. */
2011 if (DECL_FINAL_P (target
))
2012 context
.maybe_derived_type
= false;
2015 /* If OUTER_TYPE is abstract, we know we are not seeing its instance. */
2016 if (type_possibly_instantiated_p (outer_type
->type
))
2017 maybe_record_node (nodes
, target
, inserted
, can_refer
, &complete
);
2021 gcc_assert (in_lto_p
|| context
.maybe_derived_type
);
2025 pointer_set_insert (matched_vtables
, BINFO_VTABLE (binfo
));
2027 /* Next walk recursively all derived types. */
2028 if (context
.maybe_derived_type
)
2030 /* For anonymous namespace types we can attempt to build full type.
2031 All derivations must be in this unit (unless we see partial unit). */
2032 if (!type
->all_derivations_known
)
2034 for (i
= 0; i
< outer_type
->derived_types
.length(); i
++)
2035 possible_polymorphic_call_targets_1 (nodes
, inserted
,
2038 outer_type
->derived_types
[i
],
2039 otr_token
, outer_type
->type
,
2040 context
.offset
, &complete
,
2042 context
.maybe_in_construction
);
2045 /* Finally walk bases, if asked to. */
2046 (*slot
)->nonconstruction_targets
= nodes
.length();
2048 /* Destructors are never called through construction virtual tables,
2049 because the type is always known. One of entries may be cxa_pure_virtual
2050 so look to at least two of them. */
2051 if (context
.maybe_in_construction
)
2052 for (i
=0 ; i
< MIN (nodes
.length (), 2); i
++)
2053 if (DECL_CXX_DESTRUCTOR_P (nodes
[i
]->decl
))
2054 context
.maybe_in_construction
= false;
2055 if (context
.maybe_in_construction
)
2057 if (type
!= outer_type
2059 || (context
.maybe_derived_type
2060 && !type_all_derivations_known_p (outer_type
->type
))))
2061 record_targets_from_bases (otr_type
, otr_token
, outer_type
->type
,
2062 context
.offset
, nodes
, inserted
,
2063 matched_vtables
, &complete
);
2065 maybe_record_node (nodes
, target
, inserted
, can_refer
, &complete
);
2066 for (i
= 0; i
< bases_to_consider
.length(); i
++)
2067 maybe_record_node (nodes
, bases_to_consider
[i
], inserted
, can_refer
, &complete
);
2069 bases_to_consider
.release();
2071 (*slot
)->targets
= nodes
;
2072 (*slot
)->complete
= complete
;
2074 *completep
= complete
;
2075 if (nonconstruction_targetsp
)
2076 *nonconstruction_targetsp
= (*slot
)->nonconstruction_targets
;
2078 pointer_set_destroy (inserted
);
2079 pointer_set_destroy (matched_vtables
);
2080 timevar_pop (TV_IPA_VIRTUAL_CALL
);
2084 /* Dump all possible targets of a polymorphic call. */
2087 dump_possible_polymorphic_call_targets (FILE *f
,
2089 HOST_WIDE_INT otr_token
,
2090 const ipa_polymorphic_call_context
&ctx
)
2092 vec
<cgraph_node
*> targets
;
2094 odr_type type
= get_odr_type (TYPE_MAIN_VARIANT (otr_type
), false);
2096 int nonconstruction
;
2100 targets
= possible_polymorphic_call_targets (otr_type
, otr_token
,
2102 &final
, NULL
, &nonconstruction
);
2103 fprintf (f
, " Targets of polymorphic call of type %i:", type
->id
);
2104 print_generic_expr (f
, type
->type
, TDF_SLIM
);
2105 fprintf (f
, " token %i\n", (int)otr_token
);
2106 if (ctx
.outer_type
|| ctx
.offset
)
2108 fprintf (f
, " Contained in type:");
2109 print_generic_expr (f
, ctx
.outer_type
, TDF_SLIM
);
2110 fprintf (f
, " at offset "HOST_WIDE_INT_PRINT_DEC
"\n",
2114 fprintf (f
, " %s%s%s\n ",
2115 final
? "This is a complete list." :
2116 "This is partial list; extra targets may be defined in other units.",
2117 ctx
.maybe_in_construction
? " (base types included)" : "",
2118 ctx
.maybe_derived_type
? " (derived types included)" : "");
2119 for (i
= 0; i
< targets
.length (); i
++)
2122 if (i
== (unsigned)nonconstruction
)
2123 fprintf (f
, "\n If the type is in construction,"
2124 " then additional tarets are:\n"
2127 name
= cplus_demangle_v3 (targets
[i
]->asm_name (), 0);
2128 fprintf (f
, " %s/%i", name
? name
: targets
[i
]->name (), targets
[i
]->order
);
2131 if (!targets
[i
]->definition
)
2132 fprintf (f
, " (no definition%s)",
2133 DECL_DECLARED_INLINE_P (targets
[i
]->decl
)
2136 fprintf (f
, "\n\n");
2140 /* Return true if N can be possibly target of a polymorphic call of
2141 OTR_TYPE/OTR_TOKEN. */
2144 possible_polymorphic_call_target_p (tree otr_type
,
2145 HOST_WIDE_INT otr_token
,
2146 const ipa_polymorphic_call_context
&ctx
,
2147 struct cgraph_node
*n
)
2149 vec
<cgraph_node
*> targets
;
2151 enum built_in_function fcode
;
2154 if (TREE_CODE (TREE_TYPE (n
->decl
)) == FUNCTION_TYPE
2155 && ((fcode
= DECL_FUNCTION_CODE (n
->decl
))
2156 == BUILT_IN_UNREACHABLE
2157 || fcode
== BUILT_IN_TRAP
))
2162 targets
= possible_polymorphic_call_targets (otr_type
, otr_token
, ctx
, &final
);
2163 for (i
= 0; i
< targets
.length (); i
++)
2164 if (symtab_semantically_equivalent_p (n
, targets
[i
]))
2167 /* At a moment we allow middle end to dig out new external declarations
2168 as a targets of polymorphic calls. */
2169 if (!final
&& !n
->definition
)
2175 /* After callgraph construction new external nodes may appear.
2176 Add them into the graph. */
2179 update_type_inheritance_graph (void)
2181 struct cgraph_node
*n
;
2185 free_polymorphic_call_targets_hash ();
2186 timevar_push (TV_IPA_INHERITANCE
);
2187 /* We reconstruct the graph starting from types of all methods seen in the
2189 FOR_EACH_FUNCTION (n
)
2190 if (DECL_VIRTUAL_P (n
->decl
)
2192 && symtab_real_symbol_p (n
))
2193 get_odr_type (method_class_type (TYPE_MAIN_VARIANT (TREE_TYPE (n
->decl
))),
2195 timevar_pop (TV_IPA_INHERITANCE
);
2199 /* Return true if N looks like likely target of a polymorphic call.
2200 Rule out cxa_pure_virtual, noreturns, function declared cold and
2201 other obvious cases. */
2204 likely_target_p (struct cgraph_node
*n
)
2207 /* cxa_pure_virtual and similar things are not likely. */
2208 if (TREE_CODE (TREE_TYPE (n
->decl
)) != METHOD_TYPE
)
2210 flags
= flags_from_decl_or_type (n
->decl
);
2211 if (flags
& ECF_NORETURN
)
2213 if (lookup_attribute ("cold",
2214 DECL_ATTRIBUTES (n
->decl
)))
2216 if (n
->frequency
< NODE_FREQUENCY_NORMAL
)
2218 /* If there are no virtual tables refering the target alive,
2219 the only way the target can be called is an instance comming from other
2220 compilation unit; speculative devirtualization is build around an
2221 assumption that won't happen. */
2222 if (!referenced_from_vtable_p (n
))
2227 /* The ipa-devirt pass.
2228 When polymorphic call has only one likely target in the unit,
2229 turn it into speculative call. */
2234 struct cgraph_node
*n
;
2235 struct pointer_set_t
*bad_call_targets
= pointer_set_create ();
2236 struct cgraph_edge
*e
;
2238 int npolymorphic
= 0, nspeculated
= 0, nconverted
= 0, ncold
= 0;
2239 int nmultiple
= 0, noverwritable
= 0, ndevirtualized
= 0, nnotdefined
= 0;
2240 int nwrong
= 0, nok
= 0, nexternal
= 0, nartificial
= 0;
2242 FOR_EACH_DEFINED_FUNCTION (n
)
2244 bool update
= false;
2245 if (dump_file
&& n
->indirect_calls
)
2246 fprintf (dump_file
, "\n\nProcesing function %s/%i\n",
2247 n
->name (), n
->order
);
2248 for (e
= n
->indirect_calls
; e
; e
= e
->next_callee
)
2249 if (e
->indirect_info
->polymorphic
)
2251 struct cgraph_node
*likely_target
= NULL
;
2254 int nonconstruction_targets
;
2255 vec
<cgraph_node
*>targets
2256 = possible_polymorphic_call_targets
2257 (e
, &final
, &cache_token
, &nonconstruction_targets
);
2261 dump_possible_polymorphic_call_targets
2266 if (!cgraph_maybe_hot_edge_p (e
))
2269 fprintf (dump_file
, "Call is cold\n\n");
2276 fprintf (dump_file
, "Call is aready speculated\n\n");
2279 /* When dumping see if we agree with speculation. */
2283 if (pointer_set_contains (bad_call_targets
,
2287 fprintf (dump_file
, "Target list is known to be useless\n\n");
2291 for (i
= 0; i
< targets
.length (); i
++)
2292 if (likely_target_p (targets
[i
]))
2296 if (i
< (unsigned) nonconstruction_targets
)
2298 likely_target
= NULL
;
2300 fprintf (dump_file
, "More than one likely target\n\n");
2305 likely_target
= targets
[i
];
2309 pointer_set_insert (bad_call_targets
, cache_token
);
2312 /* This is reached only when dumping; check if we agree or disagree
2313 with the speculation. */
2316 struct cgraph_edge
*e2
;
2317 struct ipa_ref
*ref
;
2318 cgraph_speculative_call_info (e
, e2
, e
, ref
);
2319 if (cgraph_function_or_thunk_node (e2
->callee
, NULL
)
2320 == cgraph_function_or_thunk_node (likely_target
, NULL
))
2322 fprintf (dump_file
, "We agree with speculation\n\n");
2327 fprintf (dump_file
, "We disagree with speculation\n\n");
2332 if (!likely_target
->definition
)
2335 fprintf (dump_file
, "Target is not an definition\n\n");
2339 /* Do not introduce new references to external symbols. While we
2340 can handle these just well, it is common for programs to
2341 incorrectly with headers defining methods they are linked
2343 if (DECL_EXTERNAL (likely_target
->decl
))
2346 fprintf (dump_file
, "Target is external\n\n");
2350 /* Don't use an implicitly-declared destructor (c++/58678). */
2351 struct cgraph_node
*non_thunk_target
2352 = cgraph_function_node (likely_target
);
2353 if (DECL_ARTIFICIAL (non_thunk_target
->decl
)
2354 && DECL_COMDAT (non_thunk_target
->decl
))
2357 fprintf (dump_file
, "Target is artificial\n\n");
2361 if (cgraph_function_body_availability (likely_target
)
2362 <= AVAIL_OVERWRITABLE
2363 && symtab_can_be_discarded (likely_target
))
2366 fprintf (dump_file
, "Target is overwritable\n\n");
2370 else if (dbg_cnt (devirt
))
2372 if (dump_enabled_p ())
2374 location_t locus
= gimple_location_safe (e
->call_stmt
);
2375 dump_printf_loc (MSG_OPTIMIZED_LOCATIONS
, locus
,
2376 "speculatively devirtualizing call in %s/%i to %s/%i\n",
2377 n
->name (), n
->order
,
2378 likely_target
->name (),
2379 likely_target
->order
);
2381 if (!symtab_can_be_discarded (likely_target
))
2384 alias
= cgraph (symtab_nonoverwritable_alias
2387 likely_target
= alias
;
2391 cgraph_turn_edge_to_speculative
2392 (e
, likely_target
, e
->count
* 8 / 10, e
->frequency
* 8 / 10);
2396 inline_update_overall_summary (n
);
2398 pointer_set_destroy (bad_call_targets
);
2402 "%i polymorphic calls, %i devirtualized,"
2403 " %i speculatively devirtualized, %i cold\n"
2404 "%i have multiple targets, %i overwritable,"
2405 " %i already speculated (%i agree, %i disagree),"
2406 " %i external, %i not defined, %i artificial\n",
2407 npolymorphic
, ndevirtualized
, nconverted
, ncold
,
2408 nmultiple
, noverwritable
, nspeculated
, nok
, nwrong
,
2409 nexternal
, nnotdefined
, nartificial
);
2410 return ndevirtualized
? TODO_remove_functions
: 0;
2415 const pass_data pass_data_ipa_devirt
=
2417 IPA_PASS
, /* type */
2418 "devirt", /* name */
2419 OPTGROUP_NONE
, /* optinfo_flags */
2420 TV_IPA_DEVIRT
, /* tv_id */
2421 0, /* properties_required */
2422 0, /* properties_provided */
2423 0, /* properties_destroyed */
2424 0, /* todo_flags_start */
2425 ( TODO_dump_symtab
), /* todo_flags_finish */
2428 class pass_ipa_devirt
: public ipa_opt_pass_d
2431 pass_ipa_devirt (gcc::context
*ctxt
)
2432 : ipa_opt_pass_d (pass_data_ipa_devirt
, ctxt
,
2433 NULL
, /* generate_summary */
2434 NULL
, /* write_summary */
2435 NULL
, /* read_summary */
2436 NULL
, /* write_optimization_summary */
2437 NULL
, /* read_optimization_summary */
2438 NULL
, /* stmt_fixup */
2439 0, /* function_transform_todo_flags_start */
2440 NULL
, /* function_transform */
2441 NULL
) /* variable_transform */
2444 /* opt_pass methods: */
2445 virtual bool gate (function
*)
2447 return (flag_devirtualize
2448 && flag_devirtualize_speculatively
2452 virtual unsigned int execute (function
*) { return ipa_devirt (); }
2454 }; // class pass_ipa_devirt
2459 make_pass_ipa_devirt (gcc::context
*ctxt
)
2461 return new pass_ipa_devirt (ctxt
);
2464 #include "gt-ipa-devirt.h"