1 /* Analysis of polymorphic call context.
2 Copyright (C) 2013-2015 Free Software Foundation, Inc.
3 Contributed by Jan Hubicka
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 3, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3. If not see
19 <http://www.gnu.org/licenses/>. */
23 #include "coretypes.h"
28 #include "double-int.h"
35 #include "fold-const.h"
36 #include "print-tree.h"
39 #include "hard-reg-set.h"
43 #include "statistics.h"
45 #include "fixed-value.h"
46 #include "insn-config.h"
54 #include "tree-pass.h"
56 #include "tree-pretty-print.h"
58 #include "basic-block.h"
61 #include "plugin-api.h"
64 #include "ipa-utils.h"
65 #include "tree-ssa-alias.h"
66 #include "internal-fn.h"
67 #include "gimple-fold.h"
68 #include "gimple-expr.h"
70 #include "alloc-pool.h"
71 #include "symbol-summary.h"
73 #include "ipa-inline.h"
74 #include "diagnostic.h"
78 #include "gimple-pretty-print.h"
79 #include "stor-layout.h"
81 #include "data-streamer.h"
82 #include "lto-streamer.h"
83 #include "streamer-hooks.h"
84 #include "tree-ssa-operands.h"
85 #include "tree-into-ssa.h"
87 /* Return true when TYPE contains an polymorphic type and thus is interesting
88 for devirtualization machinery. */
90 static bool contains_type_p (tree
, HOST_WIDE_INT
, tree
,
91 bool consider_placement_new
= true,
92 bool consider_bases
= true);
95 contains_polymorphic_type_p (const_tree type
)
97 type
= TYPE_MAIN_VARIANT (type
);
99 if (RECORD_OR_UNION_TYPE_P (type
))
101 if (TYPE_BINFO (type
)
102 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
104 for (tree fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
105 if (TREE_CODE (fld
) == FIELD_DECL
106 && !DECL_ARTIFICIAL (fld
)
107 && contains_polymorphic_type_p (TREE_TYPE (fld
)))
111 if (TREE_CODE (type
) == ARRAY_TYPE
)
112 return contains_polymorphic_type_p (TREE_TYPE (type
));
116 /* Return true if it seems valid to use placement new to build EXPECTED_TYPE
117 at possition CUR_OFFSET within TYPE.
119 POD can be changed to an instance of a polymorphic type by
120 placement new. Here we play safe and assume that any
121 non-polymorphic type is POD. */
123 possible_placement_new (tree type
, tree expected_type
,
124 HOST_WIDE_INT cur_offset
)
128 return ((TREE_CODE (type
) != RECORD_TYPE
129 || !TYPE_BINFO (type
)
130 || cur_offset
>= POINTER_SIZE
131 || !polymorphic_type_binfo_p (TYPE_BINFO (type
)))
132 && (!TYPE_SIZE (type
)
133 || !tree_fits_shwi_p (TYPE_SIZE (type
))
135 + (expected_type
? tree_to_uhwi (TYPE_SIZE (expected_type
))
137 <= tree_to_uhwi (TYPE_SIZE (type
)))));
140 /* THIS->OUTER_TYPE is a type of memory object where object of OTR_TYPE
141 is contained at THIS->OFFSET. Walk the memory representation of
142 THIS->OUTER_TYPE and find the outermost class type that match
143 OTR_TYPE or contain OTR_TYPE as a base. Update THIS
146 If OTR_TYPE is NULL, just find outermost polymorphic type with
147 virtual table present at possition OFFSET.
149 For example when THIS represents type
155 and we look for type at offset sizeof(int), we end up with B and offset 0.
156 If the same is produced by multiple inheritance, we end up with A and offset
159 If we can not find corresponding class, give up by setting
160 THIS->OUTER_TYPE to OTR_TYPE and THIS->OFFSET to NULL.
161 Return true when lookup was sucesful.
163 When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made
164 valid only via alocation of new polymorphic type inside by means
167 When CONSIDER_BASES is false, only look for actual fields, not base types
171 ipa_polymorphic_call_context::restrict_to_inner_class (tree otr_type
,
172 bool consider_placement_new
,
175 tree type
= outer_type
;
176 HOST_WIDE_INT cur_offset
= offset
;
177 bool speculative
= false;
178 bool size_unknown
= false;
179 unsigned HOST_WIDE_INT otr_type_size
= POINTER_SIZE
;
181 /* Update OUTER_TYPE to match EXPECTED_TYPE if it is not set. */
184 clear_outer_type (otr_type
);
188 /* See if OFFSET points inside OUTER_TYPE. If it does not, we know
189 that the context is either invalid, or the instance type must be
190 derived from OUTER_TYPE.
192 Because the instance type may contain field whose type is of OUTER_TYPE,
193 we can not derive any effective information about it.
195 TODO: In the case we know all derrived types, we can definitely do better
197 else if (TYPE_SIZE (outer_type
)
198 && tree_fits_shwi_p (TYPE_SIZE (outer_type
))
199 && tree_to_shwi (TYPE_SIZE (outer_type
)) >= 0
200 && tree_to_shwi (TYPE_SIZE (outer_type
)) <= offset
)
202 bool der
= maybe_derived_type
; /* clear_outer_type will reset it. */
204 clear_outer_type (otr_type
);
208 /* If derived type is not allowed, we know that the context is invalid.
209 For dynamic types, we really do not have information about
210 size of the memory location. It is possible that completely
211 different type is stored after outer_type. */
214 clear_speculation ();
220 if (otr_type
&& TYPE_SIZE (otr_type
)
221 && tree_fits_shwi_p (TYPE_SIZE (otr_type
)))
222 otr_type_size
= tree_to_uhwi (TYPE_SIZE (otr_type
));
224 if (!type
|| offset
< 0)
225 goto no_useful_type_info
;
227 /* Find the sub-object the constant actually refers to and mark whether it is
228 an artificial one (as opposed to a user-defined one).
230 This loop is performed twice; first time for outer_type and second time
231 for speculative_outer_type. The second run has SPECULATIVE set. */
234 unsigned HOST_WIDE_INT pos
, size
;
237 /* If we do not know size of TYPE, we need to be more conservative
238 about accepting cases where we can not find EXPECTED_TYPE.
239 Generally the types that do matter here are of constant size.
240 Size_unknown case should be very rare. */
242 && tree_fits_shwi_p (TYPE_SIZE (type
))
243 && tree_to_shwi (TYPE_SIZE (type
)) >= 0)
244 size_unknown
= false;
248 /* On a match, just return what we found. */
250 && types_odr_comparable (type
, otr_type
)
251 && types_same_for_odr (type
, otr_type
))
253 && TREE_CODE (type
) == RECORD_TYPE
255 && polymorphic_type_binfo_p (TYPE_BINFO (type
))))
259 /* If we did not match the offset, just give up on speculation. */
261 /* Also check if speculation did not end up being same as
263 || (types_must_be_same_for_odr (speculative_outer_type
,
265 && (maybe_derived_type
266 == speculative_maybe_derived_type
)))
267 clear_speculation ();
272 /* If type is known to be final, do not worry about derived
273 types. Testing it here may help us to avoid speculation. */
274 if (otr_type
&& TREE_CODE (outer_type
) == RECORD_TYPE
275 && (!in_lto_p
|| odr_type_p (outer_type
))
276 && type_known_to_have_no_deriavations_p (outer_type
))
277 maybe_derived_type
= false;
279 /* Type can not contain itself on an non-zero offset. In that case
280 just give up. Still accept the case where size is now known.
281 Either the second copy may appear past the end of type or within
282 the non-POD buffer located inside the variably sized type
285 goto no_useful_type_info
;
286 /* If we determined type precisely or we have no clue on
287 speuclation, we are done. */
288 if (!maybe_derived_type
|| !speculative_outer_type
289 || !speculation_consistent_p (speculative_outer_type
,
291 speculative_maybe_derived_type
,
294 clear_speculation ();
297 /* Otherwise look into speculation now. */
301 type
= speculative_outer_type
;
302 cur_offset
= speculative_offset
;
308 /* Walk fields and find corresponding on at OFFSET. */
309 if (TREE_CODE (type
) == RECORD_TYPE
)
311 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
313 if (TREE_CODE (fld
) != FIELD_DECL
)
316 pos
= int_bit_position (fld
);
317 if (pos
> (unsigned HOST_WIDE_INT
)cur_offset
)
320 /* Do not consider vptr itself. Not even for placement new. */
321 if (!pos
&& DECL_ARTIFICIAL (fld
)
322 && POINTER_TYPE_P (TREE_TYPE (fld
))
324 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
327 if (!DECL_SIZE (fld
) || !tree_fits_uhwi_p (DECL_SIZE (fld
)))
328 goto no_useful_type_info
;
329 size
= tree_to_uhwi (DECL_SIZE (fld
));
331 /* We can always skip types smaller than pointer size:
332 those can not contain a virtual table pointer.
334 Disqualifying fields that are too small to fit OTR_TYPE
335 saves work needed to walk them for no benefit.
336 Because of the way the bases are packed into a class, the
337 field's size may be smaller than type size, so it needs
338 to be done with a care. */
340 if (pos
<= (unsigned HOST_WIDE_INT
)cur_offset
341 && (pos
+ size
) >= (unsigned HOST_WIDE_INT
)cur_offset
344 || !TYPE_SIZE (TREE_TYPE (fld
))
345 || !tree_fits_shwi_p (TYPE_SIZE (TREE_TYPE (fld
)))
346 || (pos
+ tree_to_uhwi (TYPE_SIZE (TREE_TYPE (fld
))))
347 >= cur_offset
+ otr_type_size
))
352 goto no_useful_type_info
;
354 type
= TYPE_MAIN_VARIANT (TREE_TYPE (fld
));
356 /* DECL_ARTIFICIAL represents a basetype. */
357 if (!DECL_ARTIFICIAL (fld
))
363 /* As soon as we se an field containing the type,
364 we know we are not looking for derivations. */
365 maybe_derived_type
= false;
369 speculative_outer_type
= type
;
370 speculative_offset
= cur_offset
;
371 speculative_maybe_derived_type
= false;
374 else if (!consider_bases
)
375 goto no_useful_type_info
;
377 else if (TREE_CODE (type
) == ARRAY_TYPE
)
379 tree subtype
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
381 /* Give up if we don't know array field size.
382 Also give up on non-polymorphic types as they are used
383 as buffers for placement new. */
384 if (!TYPE_SIZE (subtype
)
385 || !tree_fits_shwi_p (TYPE_SIZE (subtype
))
386 || tree_to_shwi (TYPE_SIZE (subtype
)) <= 0
387 || !contains_polymorphic_type_p (subtype
))
388 goto no_useful_type_info
;
390 HOST_WIDE_INT new_offset
= cur_offset
% tree_to_shwi (TYPE_SIZE (subtype
));
392 /* We may see buffer for placement new. In this case the expected type
393 can be bigger than the subtype. */
394 if (TYPE_SIZE (subtype
)
395 && (cur_offset
+ otr_type_size
396 > tree_to_uhwi (TYPE_SIZE (subtype
))))
397 goto no_useful_type_info
;
399 cur_offset
= new_offset
;
405 maybe_derived_type
= false;
409 speculative_outer_type
= type
;
410 speculative_offset
= cur_offset
;
411 speculative_maybe_derived_type
= false;
414 /* Give up on anything else. */
418 if (maybe_derived_type
&& !speculative
419 && TREE_CODE (outer_type
) == RECORD_TYPE
420 && TREE_CODE (otr_type
) == RECORD_TYPE
421 && TYPE_BINFO (otr_type
)
423 && get_binfo_at_offset (TYPE_BINFO (otr_type
), 0, outer_type
))
425 clear_outer_type (otr_type
);
426 if (!speculative_outer_type
427 || !speculation_consistent_p (speculative_outer_type
,
429 speculative_maybe_derived_type
,
431 clear_speculation ();
432 if (speculative_outer_type
)
435 type
= speculative_outer_type
;
436 cur_offset
= speculative_offset
;
441 /* We found no way to embedd EXPECTED_TYPE in TYPE.
442 We still permit two special cases - placement new and
443 the case of variadic types containing themselves. */
445 && consider_placement_new
446 && (size_unknown
|| !type
|| maybe_derived_type
447 || possible_placement_new (type
, otr_type
, cur_offset
)))
449 /* In these weird cases we want to accept the context.
450 In non-speculative run we have no useful outer_type info
451 (TODO: we may eventually want to record upper bound on the
452 type size that can be used to prune the walk),
453 but we still want to consider speculation that may
457 clear_outer_type (otr_type
);
458 if (!speculative_outer_type
459 || !speculation_consistent_p (speculative_outer_type
,
461 speculative_maybe_derived_type
,
463 clear_speculation ();
464 if (speculative_outer_type
)
467 type
= speculative_outer_type
;
468 cur_offset
= speculative_offset
;
475 clear_speculation ();
481 clear_speculation ();
484 clear_outer_type (otr_type
);
492 /* Return true if OUTER_TYPE contains OTR_TYPE at OFFSET.
493 CONSIDER_PLACEMENT_NEW makes function to accept cases where OTR_TYPE can
494 be built within OUTER_TYPE by means of placement new. CONSIDER_BASES makes
495 function to accept cases where OTR_TYPE appears as base of OUTER_TYPE or as
496 base of one of fields of OUTER_TYPE. */
499 contains_type_p (tree outer_type
, HOST_WIDE_INT offset
,
501 bool consider_placement_new
,
504 ipa_polymorphic_call_context context
;
506 /* Check that type is within range. */
509 if (TYPE_SIZE (outer_type
) && TYPE_SIZE (otr_type
)
510 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
511 && TREE_CODE (TYPE_SIZE (otr_type
)) == INTEGER_CST
512 && wi::ltu_p (wi::to_offset (TYPE_SIZE (outer_type
)),
513 (wi::to_offset (TYPE_SIZE (otr_type
)) + offset
)))
516 context
.offset
= offset
;
517 context
.outer_type
= TYPE_MAIN_VARIANT (outer_type
);
518 context
.maybe_derived_type
= false;
519 context
.dynamic
= false;
520 return context
.restrict_to_inner_class (otr_type
, consider_placement_new
,
525 /* Return a FUNCTION_DECL if BLOCK represents a constructor or destructor.
526 If CHECK_CLONES is true, also check for clones of ctor/dtors. */
529 inlined_polymorphic_ctor_dtor_block_p (tree block
, bool check_clones
)
531 tree fn
= block_ultimate_origin (block
);
532 if (fn
== NULL
|| TREE_CODE (fn
) != FUNCTION_DECL
)
535 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
536 || (!DECL_CXX_CONSTRUCTOR_P (fn
) && !DECL_CXX_DESTRUCTOR_P (fn
)))
541 /* Watch for clones where we constant propagated the first
542 argument (pointer to the instance). */
543 fn
= DECL_ABSTRACT_ORIGIN (fn
);
545 || TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
546 || (!DECL_CXX_CONSTRUCTOR_P (fn
) && !DECL_CXX_DESTRUCTOR_P (fn
)))
550 if (flags_from_decl_or_type (fn
) & (ECF_PURE
| ECF_CONST
))
557 /* We know that the instance is stored in variable or parameter
558 (not dynamically allocated) and we want to disprove the fact
559 that it may be in construction at invocation of CALL.
561 BASE represents memory location where instance is stored.
562 If BASE is NULL, it is assumed to be global memory.
563 OUTER_TYPE is known type of the instance or NULL if not
566 For the variable to be in construction we actually need to
567 be in constructor of corresponding global variable or
568 the inline stack of CALL must contain the constructor.
569 Check this condition. This check works safely only before
570 IPA passes, because inline stacks may become out of date
574 decl_maybe_in_construction_p (tree base
, tree outer_type
,
575 gimple call
, tree function
)
578 outer_type
= TYPE_MAIN_VARIANT (outer_type
);
579 gcc_assert (!base
|| DECL_P (base
));
581 /* After inlining the code unification optimizations may invalidate
582 inline stacks. Also we need to give up on global variables after
583 IPA, because addresses of these may have been propagated to their
585 if (DECL_STRUCT_FUNCTION (function
)->after_inlining
)
588 /* Pure functions can not do any changes on the dynamic type;
589 that require writting to memory. */
590 if ((!base
|| !auto_var_in_fn_p (base
, function
))
591 && flags_from_decl_or_type (function
) & (ECF_PURE
| ECF_CONST
))
594 bool check_clones
= !base
|| is_global_var (base
);
595 for (tree block
= gimple_block (call
); block
&& TREE_CODE (block
) == BLOCK
;
596 block
= BLOCK_SUPERCONTEXT (block
))
597 if (tree fn
= inlined_polymorphic_ctor_dtor_block_p (block
, check_clones
))
599 tree type
= TYPE_MAIN_VARIANT (method_class_type (TREE_TYPE (fn
)));
601 if (!outer_type
|| !types_odr_comparable (type
, outer_type
))
603 if (TREE_CODE (type
) == RECORD_TYPE
605 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
608 else if (types_same_for_odr (type
, outer_type
))
612 if (!base
|| (TREE_CODE (base
) == VAR_DECL
&& is_global_var (base
)))
614 if (TREE_CODE (TREE_TYPE (function
)) != METHOD_TYPE
615 || (!DECL_CXX_CONSTRUCTOR_P (function
)
616 && !DECL_CXX_DESTRUCTOR_P (function
)))
618 if (!DECL_ABSTRACT_ORIGIN (function
))
620 /* Watch for clones where we constant propagated the first
621 argument (pointer to the instance). */
622 function
= DECL_ABSTRACT_ORIGIN (function
);
624 || TREE_CODE (TREE_TYPE (function
)) != METHOD_TYPE
625 || (!DECL_CXX_CONSTRUCTOR_P (function
)
626 && !DECL_CXX_DESTRUCTOR_P (function
)))
629 tree type
= TYPE_MAIN_VARIANT (method_class_type (TREE_TYPE (function
)));
630 if (!outer_type
|| !types_odr_comparable (type
, outer_type
))
632 if (TREE_CODE (type
) == RECORD_TYPE
634 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
637 else if (types_same_for_odr (type
, outer_type
))
643 /* Dump human readable context to F. If NEWLINE is true, it will be terminated
647 ipa_polymorphic_call_context::dump (FILE *f
, bool newline
) const
651 fprintf (f
, "Call is known to be undefined");
655 fprintf (f
, "nothing known");
656 if (outer_type
|| offset
)
658 fprintf (f
, "Outer type%s:", dynamic
? " (dynamic)":"");
659 print_generic_expr (f
, outer_type
, TDF_SLIM
);
660 if (maybe_derived_type
)
661 fprintf (f
, " (or a derived type)");
662 if (maybe_in_construction
)
663 fprintf (f
, " (maybe in construction)");
664 fprintf (f
, " offset " HOST_WIDE_INT_PRINT_DEC
,
667 if (speculative_outer_type
)
669 if (outer_type
|| offset
)
671 fprintf (f
, "Speculative outer type:");
672 print_generic_expr (f
, speculative_outer_type
, TDF_SLIM
);
673 if (speculative_maybe_derived_type
)
674 fprintf (f
, " (or a derived type)");
675 fprintf (f
, " at offset " HOST_WIDE_INT_PRINT_DEC
,
683 /* Print context to stderr. */
686 ipa_polymorphic_call_context::debug () const
691 /* Stream out the context to OB. */
694 ipa_polymorphic_call_context::stream_out (struct output_block
*ob
) const
696 struct bitpack_d bp
= bitpack_create (ob
->main_stream
);
698 bp_pack_value (&bp
, invalid
, 1);
699 bp_pack_value (&bp
, maybe_in_construction
, 1);
700 bp_pack_value (&bp
, maybe_derived_type
, 1);
701 bp_pack_value (&bp
, speculative_maybe_derived_type
, 1);
702 bp_pack_value (&bp
, dynamic
, 1);
703 bp_pack_value (&bp
, outer_type
!= NULL
, 1);
704 bp_pack_value (&bp
, offset
!= 0, 1);
705 bp_pack_value (&bp
, speculative_outer_type
!= NULL
, 1);
706 streamer_write_bitpack (&bp
);
708 if (outer_type
!= NULL
)
709 stream_write_tree (ob
, outer_type
, true);
711 streamer_write_hwi (ob
, offset
);
712 if (speculative_outer_type
!= NULL
)
714 stream_write_tree (ob
, speculative_outer_type
, true);
715 streamer_write_hwi (ob
, speculative_offset
);
718 gcc_assert (!speculative_offset
);
721 /* Stream in the context from IB and DATA_IN. */
724 ipa_polymorphic_call_context::stream_in (struct lto_input_block
*ib
,
725 struct data_in
*data_in
)
727 struct bitpack_d bp
= streamer_read_bitpack (ib
);
729 invalid
= bp_unpack_value (&bp
, 1);
730 maybe_in_construction
= bp_unpack_value (&bp
, 1);
731 maybe_derived_type
= bp_unpack_value (&bp
, 1);
732 speculative_maybe_derived_type
= bp_unpack_value (&bp
, 1);
733 dynamic
= bp_unpack_value (&bp
, 1);
734 bool outer_type_p
= bp_unpack_value (&bp
, 1);
735 bool offset_p
= bp_unpack_value (&bp
, 1);
736 bool speculative_outer_type_p
= bp_unpack_value (&bp
, 1);
739 outer_type
= stream_read_tree (ib
, data_in
);
743 offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
746 if (speculative_outer_type_p
)
748 speculative_outer_type
= stream_read_tree (ib
, data_in
);
749 speculative_offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
753 speculative_outer_type
= NULL
;
754 speculative_offset
= 0;
758 /* Proudce polymorphic call context for call method of instance
759 that is located within BASE (that is assumed to be a decl) at offset OFF. */
762 ipa_polymorphic_call_context::set_by_decl (tree base
, HOST_WIDE_INT off
)
764 gcc_assert (DECL_P (base
));
765 clear_speculation ();
767 if (!contains_polymorphic_type_p (TREE_TYPE (base
)))
773 outer_type
= TYPE_MAIN_VARIANT (TREE_TYPE (base
));
775 /* Make very conservative assumption that all objects
776 may be in construction.
778 It is up to caller to revisit this via
779 get_dynamic_type or decl_maybe_in_construction_p. */
780 maybe_in_construction
= true;
781 maybe_derived_type
= false;
785 /* CST is an invariant (address of decl), try to get meaningful
786 polymorphic call context for polymorphic call of method
787 if instance of OTR_TYPE that is located at offset OFF of this invariant.
788 Return FALSE if nothing meaningful can be found. */
791 ipa_polymorphic_call_context::set_by_invariant (tree cst
,
795 HOST_WIDE_INT offset2
, size
, max_size
;
800 clear_outer_type (otr_type
);
802 if (TREE_CODE (cst
) != ADDR_EXPR
)
805 cst
= TREE_OPERAND (cst
, 0);
806 base
= get_ref_base_and_extent (cst
, &offset2
, &size
, &max_size
);
807 if (!DECL_P (base
) || max_size
== -1 || max_size
!= size
)
810 /* Only type inconsistent programs can have otr_type that is
811 not part of outer type. */
812 if (otr_type
&& !contains_type_p (TREE_TYPE (base
), off
, otr_type
))
815 set_by_decl (base
, off
);
819 /* See if OP is SSA name initialized as a copy or by single assignment.
820 If so, walk the SSA graph up. Because simple PHI conditional is considered
821 copy, GLOBAL_VISITED may be used to avoid infinite loop walking the SSA
825 walk_ssa_copies (tree op
, hash_set
<tree
> **global_visited
= NULL
)
827 hash_set
<tree
> *visited
= NULL
;
829 while (TREE_CODE (op
) == SSA_NAME
830 && !SSA_NAME_IS_DEFAULT_DEF (op
)
831 /* We might be called via fold_stmt during cfgcleanup where
832 SSA form need not be up-to-date. */
833 && !name_registered_for_update_p (op
)
834 && (gimple_assign_single_p (SSA_NAME_DEF_STMT (op
))
835 || gimple_code (SSA_NAME_DEF_STMT (op
)) == GIMPLE_PHI
))
839 if (!*global_visited
)
840 *global_visited
= new hash_set
<tree
>;
841 if ((*global_visited
)->add (op
))
847 visited
= new hash_set
<tree
>;
848 if (visited
->add (op
))
856 This pattern is implicitly produced for casts to non-primary
857 bases. When doing context analysis, we do not really care
858 about the case pointer is NULL, becuase the call will be
860 if (gimple_code (SSA_NAME_DEF_STMT (op
)) == GIMPLE_PHI
)
862 gimple phi
= SSA_NAME_DEF_STMT (op
);
864 if (gimple_phi_num_args (phi
) > 2)
866 if (gimple_phi_num_args (phi
) == 1)
867 op
= gimple_phi_arg_def (phi
, 0);
868 else if (integer_zerop (gimple_phi_arg_def (phi
, 0)))
869 op
= gimple_phi_arg_def (phi
, 1);
870 else if (integer_zerop (gimple_phi_arg_def (phi
, 1)))
871 op
= gimple_phi_arg_def (phi
, 0);
877 if (gimple_assign_load_p (SSA_NAME_DEF_STMT (op
)))
879 op
= gimple_assign_rhs1 (SSA_NAME_DEF_STMT (op
));
889 /* Create polymorphic call context from IP invariant CST.
890 This is typically &global_var.
891 OTR_TYPE specify type of polymorphic call or NULL if unknown, OFF
892 is offset of call. */
894 ipa_polymorphic_call_context::ipa_polymorphic_call_context (tree cst
,
898 clear_speculation ();
899 set_by_invariant (cst
, otr_type
, off
);
902 /* Build context for pointer REF contained in FNDECL at statement STMT.
903 if INSTANCE is non-NULL, return pointer to the object described by
904 the context or DECL where context is contained in. */
906 ipa_polymorphic_call_context::ipa_polymorphic_call_context (tree fndecl
,
911 tree otr_type
= NULL
;
913 hash_set
<tree
> *visited
= NULL
;
915 if (TREE_CODE (ref
) == OBJ_TYPE_REF
)
917 otr_type
= obj_type_ref_class (ref
);
918 base_pointer
= OBJ_TYPE_REF_OBJECT (ref
);
923 /* Set up basic info in case we find nothing interesting in the analysis. */
924 clear_speculation ();
925 clear_outer_type (otr_type
);
928 /* Walk SSA for outer object. */
931 base_pointer
= walk_ssa_copies (base_pointer
, &visited
);
932 if (TREE_CODE (base_pointer
) == ADDR_EXPR
)
934 HOST_WIDE_INT size
, max_size
;
935 HOST_WIDE_INT offset2
;
936 tree base
= get_ref_base_and_extent (TREE_OPERAND (base_pointer
, 0),
937 &offset2
, &size
, &max_size
);
939 if (max_size
!= -1 && max_size
== size
)
940 combine_speculation_with (TYPE_MAIN_VARIANT (TREE_TYPE (base
)),
943 NULL
/* Do not change outer type. */);
945 /* If this is a varying address, punt. */
946 if ((TREE_CODE (base
) == MEM_REF
|| DECL_P (base
))
950 /* We found dereference of a pointer. Type of the pointer
951 and MEM_REF is meaningless, but we can look futher. */
952 if (TREE_CODE (base
) == MEM_REF
)
954 base_pointer
= TREE_OPERAND (base
, 0);
956 += offset2
+ mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
959 /* We found base object. In this case the outer_type
961 else if (DECL_P (base
))
965 /* Only type inconsistent programs can have otr_type that is
966 not part of outer type. */
968 && !contains_type_p (TREE_TYPE (base
),
969 offset
+ offset2
, otr_type
))
973 *instance
= base_pointer
;
976 set_by_decl (base
, offset
+ offset2
);
977 if (outer_type
&& maybe_in_construction
&& stmt
)
978 maybe_in_construction
979 = decl_maybe_in_construction_p (base
,
993 else if (TREE_CODE (base_pointer
) == POINTER_PLUS_EXPR
994 && tree_fits_uhwi_p (TREE_OPERAND (base_pointer
, 1)))
996 offset
+= tree_to_shwi (TREE_OPERAND (base_pointer
, 1))
998 base_pointer
= TREE_OPERAND (base_pointer
, 0);
1007 /* Try to determine type of the outer object. */
1008 if (TREE_CODE (base_pointer
) == SSA_NAME
1009 && SSA_NAME_IS_DEFAULT_DEF (base_pointer
)
1010 && TREE_CODE (SSA_NAME_VAR (base_pointer
)) == PARM_DECL
)
1012 /* See if parameter is THIS pointer of a method. */
1013 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
1014 && SSA_NAME_VAR (base_pointer
) == DECL_ARGUMENTS (fndecl
))
1017 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (base_pointer
)));
1018 gcc_assert (TREE_CODE (outer_type
) == RECORD_TYPE
1019 || TREE_CODE (outer_type
) == UNION_TYPE
);
1021 /* Dynamic casting has possibly upcasted the type
1022 in the hiearchy. In this case outer type is less
1023 informative than inner type and we should forget
1026 && !contains_type_p (outer_type
, offset
,
1028 || !contains_polymorphic_type_p (outer_type
))
1032 *instance
= base_pointer
;
1038 /* If the function is constructor or destructor, then
1039 the type is possibly in construction, but we know
1040 it is not derived type. */
1041 if (DECL_CXX_CONSTRUCTOR_P (fndecl
)
1042 || DECL_CXX_DESTRUCTOR_P (fndecl
))
1044 maybe_in_construction
= true;
1045 maybe_derived_type
= false;
1049 maybe_derived_type
= true;
1050 maybe_in_construction
= false;
1053 *instance
= base_pointer
;
1056 /* Non-PODs passed by value are really passed by invisible
1057 reference. In this case we also know the type of the
1059 if (DECL_BY_REFERENCE (SSA_NAME_VAR (base_pointer
)))
1062 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (base_pointer
)));
1063 /* Only type inconsistent programs can have otr_type that is
1064 not part of outer type. */
1065 if (otr_type
&& !contains_type_p (outer_type
, offset
,
1070 *instance
= base_pointer
;
1073 /* Non-polymorphic types have no interest for us. */
1074 else if (!otr_type
&& !contains_polymorphic_type_p (outer_type
))
1078 *instance
= base_pointer
;
1081 maybe_derived_type
= false;
1082 maybe_in_construction
= false;
1084 *instance
= base_pointer
;
1089 tree base_type
= TREE_TYPE (base_pointer
);
1091 if (TREE_CODE (base_pointer
) == SSA_NAME
1092 && SSA_NAME_IS_DEFAULT_DEF (base_pointer
)
1093 && !(TREE_CODE (SSA_NAME_VAR (base_pointer
)) == PARM_DECL
1094 || TREE_CODE (SSA_NAME_VAR (base_pointer
)) == RESULT_DECL
))
1098 *instance
= base_pointer
;
1101 if (TREE_CODE (base_pointer
) == SSA_NAME
1102 && SSA_NAME_DEF_STMT (base_pointer
)
1103 && gimple_assign_single_p (SSA_NAME_DEF_STMT (base_pointer
)))
1104 base_type
= TREE_TYPE (gimple_assign_rhs1
1105 (SSA_NAME_DEF_STMT (base_pointer
)));
1107 if (base_type
&& POINTER_TYPE_P (base_type
))
1108 combine_speculation_with (TYPE_MAIN_VARIANT (TREE_TYPE (base_type
)),
1110 true, NULL
/* Do not change type here */);
1111 /* TODO: There are multiple ways to derive a type. For instance
1112 if BASE_POINTER is passed to an constructor call prior our refernece.
1113 We do not make this type of flow sensitive analysis yet. */
1115 *instance
= base_pointer
;
1119 /* Structure to be passed in between detect_type_change and
1120 check_stmt_for_type_change. */
1122 struct type_change_info
1124 /* Offset into the object where there is the virtual method pointer we are
1126 HOST_WIDE_INT offset
;
1127 /* The declaration or SSA_NAME pointer of the base that we are checking for
1130 /* The reference to virtual table pointer used. */
1133 /* If we actually can tell the type that the object has changed to, it is
1134 stored in this field. Otherwise it remains NULL_TREE. */
1135 tree known_current_type
;
1136 HOST_WIDE_INT known_current_offset
;
1138 /* Set to true if dynamic type change has been detected. */
1139 bool type_maybe_changed
;
1140 /* Set to true if multiple types have been encountered. known_current_type
1141 must be disregarded in that case. */
1142 bool multiple_types_encountered
;
1143 /* Set to true if we possibly missed some dynamic type changes and we should
1144 consider the set to be speculative. */
1146 bool seen_unanalyzed_store
;
1149 /* Return true if STMT is not call and can modify a virtual method table pointer.
1150 We take advantage of fact that vtable stores must appear within constructor
1151 and destructor functions. */
1154 noncall_stmt_may_be_vtbl_ptr_store (gimple stmt
)
1156 if (is_gimple_assign (stmt
))
1158 tree lhs
= gimple_assign_lhs (stmt
);
1160 if (gimple_clobber_p (stmt
))
1162 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs
)))
1164 if (flag_strict_aliasing
1165 && !POINTER_TYPE_P (TREE_TYPE (lhs
)))
1168 if (TREE_CODE (lhs
) == COMPONENT_REF
1169 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
1171 /* In the future we might want to use get_base_ref_and_offset to find
1172 if there is a field corresponding to the offset and if so, proceed
1173 almost like if it was a component ref. */
1177 /* Code unification may mess with inline stacks. */
1178 if (cfun
->after_inlining
)
1181 /* Walk the inline stack and watch out for ctors/dtors.
1182 TODO: Maybe we can require the store to appear in toplevel
1183 block of CTOR/DTOR. */
1184 for (tree block
= gimple_block (stmt
); block
&& TREE_CODE (block
) == BLOCK
;
1185 block
= BLOCK_SUPERCONTEXT (block
))
1186 if (BLOCK_ABSTRACT_ORIGIN (block
)
1187 && TREE_CODE (block_ultimate_origin (block
)) == FUNCTION_DECL
)
1188 return inlined_polymorphic_ctor_dtor_block_p (block
, false);
1189 return (TREE_CODE (TREE_TYPE (current_function_decl
)) == METHOD_TYPE
1190 && (DECL_CXX_CONSTRUCTOR_P (current_function_decl
)
1191 || DECL_CXX_DESTRUCTOR_P (current_function_decl
)));
1194 /* If STMT can be proved to be an assignment to the virtual method table
1195 pointer of ANALYZED_OBJ and the type associated with the new table
1196 identified, return the type. Otherwise return NULL_TREE if type changes
1197 in unknown way or ERROR_MARK_NODE if type is unchanged. */
1200 extr_type_from_vtbl_ptr_store (gimple stmt
, struct type_change_info
*tci
,
1201 HOST_WIDE_INT
*type_offset
)
1203 HOST_WIDE_INT offset
, size
, max_size
;
1204 tree lhs
, rhs
, base
;
1206 if (!gimple_assign_single_p (stmt
))
1209 lhs
= gimple_assign_lhs (stmt
);
1210 rhs
= gimple_assign_rhs1 (stmt
);
1211 if (TREE_CODE (lhs
) != COMPONENT_REF
1212 || !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
1215 fprintf (dump_file
, " LHS is not virtual table.\n");
1219 if (tci
->vtbl_ptr_ref
&& operand_equal_p (lhs
, tci
->vtbl_ptr_ref
, 0))
1223 base
= get_ref_base_and_extent (lhs
, &offset
, &size
, &max_size
);
1224 if (DECL_P (tci
->instance
))
1226 if (base
!= tci
->instance
)
1230 fprintf (dump_file
, " base:");
1231 print_generic_expr (dump_file
, base
, TDF_SLIM
);
1232 fprintf (dump_file
, " does not match instance:");
1233 print_generic_expr (dump_file
, tci
->instance
, TDF_SLIM
);
1234 fprintf (dump_file
, "\n");
1239 else if (TREE_CODE (base
) == MEM_REF
)
1241 if (!operand_equal_p (tci
->instance
, TREE_OPERAND (base
, 0), 0))
1245 fprintf (dump_file
, " base mem ref:");
1246 print_generic_expr (dump_file
, base
, TDF_SLIM
);
1247 fprintf (dump_file
, " does not match instance:");
1248 print_generic_expr (dump_file
, tci
->instance
, TDF_SLIM
);
1249 fprintf (dump_file
, "\n");
1253 if (!integer_zerop (TREE_OPERAND (base
, 1)))
1255 if (!tree_fits_shwi_p (TREE_OPERAND (base
, 1)))
1259 fprintf (dump_file
, " base mem ref:");
1260 print_generic_expr (dump_file
, base
, TDF_SLIM
);
1261 fprintf (dump_file
, " has non-representable offset:");
1262 print_generic_expr (dump_file
, tci
->instance
, TDF_SLIM
);
1263 fprintf (dump_file
, "\n");
1268 offset
+= tree_to_shwi (TREE_OPERAND (base
, 1)) * BITS_PER_UNIT
;
1271 else if (!operand_equal_p (tci
->instance
, base
, 0)
1276 fprintf (dump_file
, " base:");
1277 print_generic_expr (dump_file
, base
, TDF_SLIM
);
1278 fprintf (dump_file
, " does not match instance:");
1279 print_generic_expr (dump_file
, tci
->instance
, TDF_SLIM
);
1280 fprintf (dump_file
, " with offset %i\n", (int)tci
->offset
);
1282 return tci
->offset
> POINTER_SIZE
? error_mark_node
: NULL_TREE
;
1284 if (offset
!= tci
->offset
1285 || size
!= POINTER_SIZE
1286 || max_size
!= POINTER_SIZE
)
1289 fprintf (dump_file
, " wrong offset %i!=%i or size %i\n",
1290 (int)offset
, (int)tci
->offset
, (int)size
);
1291 return offset
+ POINTER_SIZE
<= tci
->offset
1293 && tci
->offset
+ POINTER_SIZE
> offset
+ max_size
)
1294 ? error_mark_node
: NULL
;
1299 unsigned HOST_WIDE_INT offset2
;
1301 if (!vtable_pointer_value_to_vtable (rhs
, &vtable
, &offset2
))
1304 fprintf (dump_file
, " Failed to lookup binfo\n");
1308 tree binfo
= subbinfo_with_vtable_at_offset (TYPE_BINFO (DECL_CONTEXT (vtable
)),
1313 fprintf (dump_file
, " Construction vtable used\n");
1314 /* FIXME: We should suport construction contexts. */
1318 *type_offset
= tree_to_shwi (BINFO_OFFSET (binfo
)) * BITS_PER_UNIT
;
1319 return DECL_CONTEXT (vtable
);
1322 /* Record dynamic type change of TCI to TYPE. */
1325 record_known_type (struct type_change_info
*tci
, tree type
, HOST_WIDE_INT offset
)
1331 fprintf (dump_file
, " Recording type: ");
1332 print_generic_expr (dump_file
, type
, TDF_SLIM
);
1333 fprintf (dump_file
, " at offset %i\n", (int)offset
);
1336 fprintf (dump_file
, " Recording unknown type\n");
1339 /* If we found a constructor of type that is not polymorphic or
1340 that may contain the type in question as a field (not as base),
1341 restrict to the inner class first to make type matching bellow
1345 || (TREE_CODE (type
) != RECORD_TYPE
1346 || !TYPE_BINFO (type
)
1347 || !polymorphic_type_binfo_p (TYPE_BINFO (type
)))))
1349 ipa_polymorphic_call_context context
;
1351 context
.offset
= offset
;
1352 context
.outer_type
= type
;
1353 context
.maybe_in_construction
= false;
1354 context
.maybe_derived_type
= false;
1355 context
.dynamic
= true;
1356 /* If we failed to find the inner type, we know that the call
1357 would be undefined for type produced here. */
1358 if (!context
.restrict_to_inner_class (tci
->otr_type
))
1361 fprintf (dump_file
, " Ignoring; does not contain otr_type\n");
1364 /* Watch for case we reached an POD type and anticipate placement
1366 if (!context
.maybe_derived_type
)
1368 type
= context
.outer_type
;
1369 offset
= context
.offset
;
1372 if (tci
->type_maybe_changed
1373 && (!types_same_for_odr (type
, tci
->known_current_type
)
1374 || offset
!= tci
->known_current_offset
))
1375 tci
->multiple_types_encountered
= true;
1376 tci
->known_current_type
= TYPE_MAIN_VARIANT (type
);
1377 tci
->known_current_offset
= offset
;
1378 tci
->type_maybe_changed
= true;
1381 /* Callback of walk_aliased_vdefs and a helper function for
1382 detect_type_change to check whether a particular statement may modify
1383 the virtual table pointer, and if possible also determine the new type of
1384 the (sub-)object. It stores its result into DATA, which points to a
1385 type_change_info structure. */
1388 check_stmt_for_type_change (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef
, void *data
)
1390 gimple stmt
= SSA_NAME_DEF_STMT (vdef
);
1391 struct type_change_info
*tci
= (struct type_change_info
*) data
;
1394 /* If we already gave up, just terminate the rest of walk. */
1395 if (tci
->multiple_types_encountered
)
1398 if (is_gimple_call (stmt
))
1400 if (gimple_call_flags (stmt
) & (ECF_CONST
| ECF_PURE
))
1403 /* Check for a constructor call. */
1404 if ((fn
= gimple_call_fndecl (stmt
)) != NULL_TREE
1405 && DECL_CXX_CONSTRUCTOR_P (fn
)
1406 && TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
1407 && gimple_call_num_args (stmt
))
1409 tree op
= walk_ssa_copies (gimple_call_arg (stmt
, 0));
1410 tree type
= method_class_type (TREE_TYPE (fn
));
1411 HOST_WIDE_INT offset
= 0, size
, max_size
;
1415 fprintf (dump_file
, " Checking constructor call: ");
1416 print_gimple_stmt (dump_file
, stmt
, 0, 0);
1419 /* See if THIS parameter seems like instance pointer. */
1420 if (TREE_CODE (op
) == ADDR_EXPR
)
1422 op
= get_ref_base_and_extent (TREE_OPERAND (op
, 0),
1423 &offset
, &size
, &max_size
);
1424 if (size
!= max_size
|| max_size
== -1)
1426 tci
->speculative
= true;
1429 if (op
&& TREE_CODE (op
) == MEM_REF
)
1431 if (!tree_fits_shwi_p (TREE_OPERAND (op
, 1)))
1433 tci
->speculative
= true;
1436 offset
+= tree_to_shwi (TREE_OPERAND (op
, 1))
1438 op
= TREE_OPERAND (op
, 0);
1440 else if (DECL_P (op
))
1444 tci
->speculative
= true;
1447 op
= walk_ssa_copies (op
);
1449 if (operand_equal_p (op
, tci
->instance
, 0)
1451 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
1452 && tree_fits_shwi_p (TYPE_SIZE (type
))
1453 && tree_to_shwi (TYPE_SIZE (type
)) + offset
> tci
->offset
1454 /* Some inlined constructors may look as follows:
1455 _3 = operator new (16);
1456 MEM[(struct &)_3] ={v} {CLOBBER};
1457 MEM[(struct CompositeClass *)_3]._vptr.CompositeClass
1458 = &MEM[(void *)&_ZTV14CompositeClass + 16B];
1459 _7 = &MEM[(struct CompositeClass *)_3].object;
1460 EmptyClass::EmptyClass (_7);
1462 When determining dynamic type of _3 and because we stop at first
1463 dynamic type found, we would stop on EmptyClass::EmptyClass (_7).
1464 In this case the emptyclass is not even polymorphic and we miss
1465 it is contained in an outer type that is polymorphic. */
1467 && (tci
->offset
== offset
|| contains_polymorphic_type_p (type
)))
1469 record_known_type (tci
, type
, tci
->offset
- offset
);
1473 /* Calls may possibly change dynamic type by placement new. Assume
1474 it will not happen, but make result speculative only. */
1477 fprintf (dump_file
, " Function call may change dynamic type:");
1478 print_gimple_stmt (dump_file
, stmt
, 0, 0);
1480 tci
->speculative
= true;
1483 /* Check for inlined virtual table store. */
1484 else if (noncall_stmt_may_be_vtbl_ptr_store (stmt
))
1487 HOST_WIDE_INT offset
= 0;
1490 fprintf (dump_file
, " Checking vtbl store: ");
1491 print_gimple_stmt (dump_file
, stmt
, 0, 0);
1494 type
= extr_type_from_vtbl_ptr_store (stmt
, tci
, &offset
);
1495 if (type
== error_mark_node
)
1497 gcc_assert (!type
|| TYPE_MAIN_VARIANT (type
) == type
);
1501 fprintf (dump_file
, " Unanalyzed store may change type.\n");
1502 tci
->seen_unanalyzed_store
= true;
1503 tci
->speculative
= true;
1506 record_known_type (tci
, type
, offset
);
1513 /* THIS is polymorphic call context obtained from get_polymorphic_context.
1514 OTR_OBJECT is pointer to the instance returned by OBJ_TYPE_REF_OBJECT.
1515 INSTANCE is pointer to the outer instance as returned by
1516 get_polymorphic_context. To avoid creation of temporary expressions,
1517 INSTANCE may also be an declaration of get_polymorphic_context found the
1518 value to be in static storage.
1520 If the type of instance is not fully determined
1521 (either OUTER_TYPE is unknown or MAYBE_IN_CONSTRUCTION/INCLUDE_DERIVED_TYPES
1522 is set), try to walk memory writes and find the actual construction of the
1525 Return true if memory is unchanged from function entry.
1527 We do not include this analysis in the context analysis itself, because
1528 it needs memory SSA to be fully built and the walk may be expensive.
1529 So it is not suitable for use withing fold_stmt and similar uses. */
1532 ipa_polymorphic_call_context::get_dynamic_type (tree instance
,
1537 struct type_change_info tci
;
1539 bool function_entry_reached
= false;
1540 tree instance_ref
= NULL
;
1542 /* Remember OFFSET before it is modified by restrict_to_inner_class.
1543 This is because we do not update INSTANCE when walking inwards. */
1544 HOST_WIDE_INT instance_offset
= offset
;
1545 tree instance_outer_type
= outer_type
;
1548 otr_type
= TYPE_MAIN_VARIANT (otr_type
);
1550 /* Walk into inner type. This may clear maybe_derived_type and save us
1551 from useless work. It also makes later comparsions with static type
1553 if (outer_type
&& otr_type
)
1555 if (!restrict_to_inner_class (otr_type
))
1559 if (!maybe_in_construction
&& !maybe_derived_type
)
1562 /* We need to obtain refernce to virtual table pointer. It is better
1563 to look it up in the code rather than build our own. This require bit
1564 of pattern matching, but we end up verifying that what we found is
1567 What we pattern match is:
1569 tmp = instance->_vptr.A; // vtbl ptr load
1570 tmp2 = tmp[otr_token]; // vtable lookup
1571 OBJ_TYPE_REF(tmp2;instance->0) (instance);
1573 We want to start alias oracle walk from vtbl pointer load,
1574 but we may not be able to identify it, for example, when PRE moved the
1577 if (gimple_code (call
) == GIMPLE_CALL
)
1579 tree ref
= gimple_call_fn (call
);
1580 HOST_WIDE_INT offset2
, size
, max_size
;
1582 if (TREE_CODE (ref
) == OBJ_TYPE_REF
)
1584 ref
= OBJ_TYPE_REF_EXPR (ref
);
1585 ref
= walk_ssa_copies (ref
);
1587 /* Check if definition looks like vtable lookup. */
1588 if (TREE_CODE (ref
) == SSA_NAME
1589 && !SSA_NAME_IS_DEFAULT_DEF (ref
)
1590 && gimple_assign_load_p (SSA_NAME_DEF_STMT (ref
))
1591 && TREE_CODE (gimple_assign_rhs1
1592 (SSA_NAME_DEF_STMT (ref
))) == MEM_REF
)
1594 ref
= get_base_address
1595 (TREE_OPERAND (gimple_assign_rhs1
1596 (SSA_NAME_DEF_STMT (ref
)), 0));
1597 ref
= walk_ssa_copies (ref
);
1598 /* Find base address of the lookup and see if it looks like
1600 if (TREE_CODE (ref
) == SSA_NAME
1601 && !SSA_NAME_IS_DEFAULT_DEF (ref
)
1602 && gimple_assign_load_p (SSA_NAME_DEF_STMT (ref
)))
1604 tree ref_exp
= gimple_assign_rhs1 (SSA_NAME_DEF_STMT (ref
));
1605 tree base_ref
= get_ref_base_and_extent
1606 (ref_exp
, &offset2
, &size
, &max_size
);
1608 /* Finally verify that what we found looks like read from OTR_OBJECT
1609 or from INSTANCE with offset OFFSET. */
1611 && ((TREE_CODE (base_ref
) == MEM_REF
1612 && ((offset2
== instance_offset
1613 && TREE_OPERAND (base_ref
, 0) == instance
)
1614 || (!offset2
&& TREE_OPERAND (base_ref
, 0) == otr_object
)))
1615 || (DECL_P (instance
) && base_ref
== instance
1616 && offset2
== instance_offset
)))
1618 stmt
= SSA_NAME_DEF_STMT (ref
);
1619 instance_ref
= ref_exp
;
1626 /* If we failed to look up the reference in code, build our own. */
1629 /* If the statement in question does not use memory, we can't tell
1631 if (!gimple_vuse (stmt
))
1633 ao_ref_init_from_ptr_and_size (&ao
, otr_object
, NULL
);
1636 /* Otherwise use the real reference. */
1637 ao_ref_init (&ao
, instance_ref
);
1639 /* We look for vtbl pointer read. */
1640 ao
.size
= POINTER_SIZE
;
1641 ao
.max_size
= ao
.size
;
1644 = get_deref_alias_set (TREE_TYPE (BINFO_VTABLE (TYPE_BINFO (otr_type
))));
1648 fprintf (dump_file
, "Determining dynamic type for call: ");
1649 print_gimple_stmt (dump_file
, call
, 0, 0);
1650 fprintf (dump_file
, " Starting walk at: ");
1651 print_gimple_stmt (dump_file
, stmt
, 0, 0);
1652 fprintf (dump_file
, " instance pointer: ");
1653 print_generic_expr (dump_file
, otr_object
, TDF_SLIM
);
1654 fprintf (dump_file
, " Outer instance pointer: ");
1655 print_generic_expr (dump_file
, instance
, TDF_SLIM
);
1656 fprintf (dump_file
, " offset: %i (bits)", (int)instance_offset
);
1657 fprintf (dump_file
, " vtbl reference: ");
1658 print_generic_expr (dump_file
, instance_ref
, TDF_SLIM
);
1659 fprintf (dump_file
, "\n");
1662 tci
.offset
= instance_offset
;
1663 tci
.instance
= instance
;
1664 tci
.vtbl_ptr_ref
= instance_ref
;
1665 gcc_assert (TREE_CODE (instance
) != MEM_REF
);
1666 tci
.known_current_type
= NULL_TREE
;
1667 tci
.known_current_offset
= 0;
1668 tci
.otr_type
= otr_type
;
1669 tci
.type_maybe_changed
= false;
1670 tci
.multiple_types_encountered
= false;
1671 tci
.speculative
= false;
1672 tci
.seen_unanalyzed_store
= false;
1674 walk_aliased_vdefs (&ao
, gimple_vuse (stmt
), check_stmt_for_type_change
,
1675 &tci
, NULL
, &function_entry_reached
);
1677 /* If we did not find any type changing statements, we may still drop
1678 maybe_in_construction flag if the context already have outer type.
1680 Here we make special assumptions about both constructors and
1681 destructors which are all the functions that are allowed to alter the
1682 VMT pointers. It assumes that destructors begin with assignment into
1683 all VMT pointers and that constructors essentially look in the
1686 1) The very first thing they do is that they call constructors of
1687 ancestor sub-objects that have them.
1689 2) Then VMT pointers of this and all its ancestors is set to new
1690 values corresponding to the type corresponding to the constructor.
1692 3) Only afterwards, other stuff such as constructor of member
1693 sub-objects and the code written by the user is run. Only this may
1694 include calling virtual functions, directly or indirectly.
1696 4) placement new can not be used to change type of non-POD statically
1697 allocated variables.
1699 There is no way to call a constructor of an ancestor sub-object in any
1702 This means that we do not have to care whether constructors get the
1703 correct type information because they will always change it (in fact,
1704 if we define the type to be given by the VMT pointer, it is undefined).
1706 The most important fact to derive from the above is that if, for some
1707 statement in the section 3, we try to detect whether the dynamic type
1708 has changed, we can safely ignore all calls as we examine the function
1709 body backwards until we reach statements in section 2 because these
1710 calls cannot be ancestor constructors or destructors (if the input is
1711 not bogus) and so do not change the dynamic type (this holds true only
1712 for automatically allocated objects but at the moment we devirtualize
1713 only these). We then must detect that statements in section 2 change
1714 the dynamic type and can try to derive the new type. That is enough
1715 and we can stop, we will never see the calls into constructors of
1716 sub-objects in this code.
1718 Therefore if the static outer type was found (outer_type)
1719 we can safely ignore tci.speculative that is set on calls and give up
1720 only if there was dyanmic type store that may affect given variable
1721 (seen_unanalyzed_store) */
1723 if (!tci
.type_maybe_changed
1726 && !tci
.seen_unanalyzed_store
1727 && !tci
.multiple_types_encountered
1728 && ((offset
== tci
.offset
1729 && types_same_for_odr (tci
.known_current_type
,
1731 || (instance_offset
== offset
1732 && types_same_for_odr (tci
.known_current_type
,
1733 instance_outer_type
)))))
1735 if (!outer_type
|| tci
.seen_unanalyzed_store
)
1737 if (maybe_in_construction
)
1738 maybe_in_construction
= false;
1740 fprintf (dump_file
, " No dynamic type change found.\n");
1744 if (tci
.known_current_type
1745 && !function_entry_reached
1746 && !tci
.multiple_types_encountered
)
1748 if (!tci
.speculative
)
1750 outer_type
= TYPE_MAIN_VARIANT (tci
.known_current_type
);
1751 offset
= tci
.known_current_offset
;
1753 maybe_in_construction
= false;
1754 maybe_derived_type
= false;
1756 fprintf (dump_file
, " Determined dynamic type.\n");
1758 else if (!speculative_outer_type
1759 || speculative_maybe_derived_type
)
1761 speculative_outer_type
= TYPE_MAIN_VARIANT (tci
.known_current_type
);
1762 speculative_offset
= tci
.known_current_offset
;
1763 speculative_maybe_derived_type
= false;
1765 fprintf (dump_file
, " Determined speculative dynamic type.\n");
1770 fprintf (dump_file
, " Found multiple types%s%s\n",
1771 function_entry_reached
? " (function entry reached)" : "",
1772 function_entry_reached
? " (multiple types encountered)" : "");
1778 /* See if speculation given by SPEC_OUTER_TYPE, SPEC_OFFSET and SPEC_MAYBE_DERIVED_TYPE
1779 seems consistent (and useful) with what we already have in the non-speculative context. */
1782 ipa_polymorphic_call_context::speculation_consistent_p (tree spec_outer_type
,
1783 HOST_WIDE_INT spec_offset
,
1784 bool spec_maybe_derived_type
,
1785 tree otr_type
) const
1787 if (!flag_devirtualize_speculatively
)
1790 /* Non-polymorphic types are useless for deriving likely polymorphic
1792 if (!spec_outer_type
|| !contains_polymorphic_type_p (spec_outer_type
))
1795 /* If we know nothing, speculation is always good. */
1799 /* Speculation is only useful to avoid derived types.
1800 This is not 100% true for placement new, where the outer context may
1801 turn out to be useless, but ignore these for now. */
1802 if (!maybe_derived_type
)
1805 /* If types agrees, speculation is consistent, but it makes sense only
1806 when it says something new. */
1807 if (types_must_be_same_for_odr (spec_outer_type
, outer_type
))
1808 return maybe_derived_type
&& !spec_maybe_derived_type
;
1810 /* If speculation does not contain the type in question, ignore it. */
1812 && !contains_type_p (spec_outer_type
, spec_offset
, otr_type
, false, true))
1815 /* If outer type already contains speculation as a filed,
1816 it is useless. We already know from OUTER_TYPE
1817 SPEC_TYPE and that it is not in the construction. */
1818 if (contains_type_p (outer_type
, offset
- spec_offset
,
1819 spec_outer_type
, false, false))
1822 /* If speculative outer type is not more specified than outer
1824 We can only decide this safely if we can compare types with OUTER_TYPE.
1826 if ((!in_lto_p
|| odr_type_p (outer_type
))
1827 && !contains_type_p (spec_outer_type
,
1828 spec_offset
- offset
,
1834 /* Improve THIS with speculation described by NEW_OUTER_TYPE, NEW_OFFSET,
1835 NEW_MAYBE_DERIVED_TYPE
1836 If OTR_TYPE is set, assume the context is used with OTR_TYPE. */
1839 ipa_polymorphic_call_context::combine_speculation_with
1840 (tree new_outer_type
, HOST_WIDE_INT new_offset
, bool new_maybe_derived_type
,
1843 if (!new_outer_type
)
1846 /* restrict_to_inner_class may eliminate wrong speculation making our job
1849 restrict_to_inner_class (otr_type
);
1851 if (!speculation_consistent_p (new_outer_type
, new_offset
,
1852 new_maybe_derived_type
, otr_type
))
1855 /* New speculation is a win in case we have no speculation or new
1856 speculation does not consider derivations. */
1857 if (!speculative_outer_type
1858 || (speculative_maybe_derived_type
1859 && !new_maybe_derived_type
))
1861 speculative_outer_type
= new_outer_type
;
1862 speculative_offset
= new_offset
;
1863 speculative_maybe_derived_type
= new_maybe_derived_type
;
1866 else if (types_must_be_same_for_odr (speculative_outer_type
,
1869 if (speculative_offset
!= new_offset
)
1871 /* OK we have two contexts that seems valid but they disagree,
1874 This is not a lattice operation, so we may want to drop it later. */
1875 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1877 "Speculative outer types match, "
1878 "offset mismatch -> invalid speculation\n");
1879 clear_speculation ();
1884 if (speculative_maybe_derived_type
&& !new_maybe_derived_type
)
1886 speculative_maybe_derived_type
= false;
1893 /* Choose type that contains the other. This one either contains the outer
1894 as a field (thus giving exactly one target) or is deeper in the type
1896 else if (speculative_outer_type
1897 && speculative_maybe_derived_type
1898 && (new_offset
> speculative_offset
1899 || (new_offset
== speculative_offset
1900 && contains_type_p (new_outer_type
,
1901 0, speculative_outer_type
, false))))
1903 tree old_outer_type
= speculative_outer_type
;
1904 HOST_WIDE_INT old_offset
= speculative_offset
;
1905 bool old_maybe_derived_type
= speculative_maybe_derived_type
;
1907 speculative_outer_type
= new_outer_type
;
1908 speculative_offset
= new_offset
;
1909 speculative_maybe_derived_type
= new_maybe_derived_type
;
1912 restrict_to_inner_class (otr_type
);
1914 /* If the speculation turned out to make no sense, revert to sensible
1916 if (!speculative_outer_type
)
1918 speculative_outer_type
= old_outer_type
;
1919 speculative_offset
= old_offset
;
1920 speculative_maybe_derived_type
= old_maybe_derived_type
;
1923 return (old_offset
!= speculative_offset
1924 || old_maybe_derived_type
!= speculative_maybe_derived_type
1925 || types_must_be_same_for_odr (speculative_outer_type
,
1931 /* Make speculation less specific so
1932 NEW_OUTER_TYPE, NEW_OFFSET, NEW_MAYBE_DERIVED_TYPE is also included.
1933 If OTR_TYPE is set, assume the context is used with OTR_TYPE. */
1936 ipa_polymorphic_call_context::meet_speculation_with
1937 (tree new_outer_type
, HOST_WIDE_INT new_offset
, bool new_maybe_derived_type
,
1940 if (!new_outer_type
&& speculative_outer_type
)
1942 clear_speculation ();
1946 /* restrict_to_inner_class may eliminate wrong speculation making our job
1949 restrict_to_inner_class (otr_type
);
1951 if (!speculative_outer_type
1952 || !speculation_consistent_p (speculative_outer_type
,
1954 speculative_maybe_derived_type
,
1958 if (!speculation_consistent_p (new_outer_type
, new_offset
,
1959 new_maybe_derived_type
, otr_type
))
1961 clear_speculation ();
1965 else if (types_must_be_same_for_odr (speculative_outer_type
,
1968 if (speculative_offset
!= new_offset
)
1970 clear_speculation ();
1975 if (!speculative_maybe_derived_type
&& new_maybe_derived_type
)
1977 speculative_maybe_derived_type
= true;
1984 /* See if one type contains the other as a field (not base). */
1985 else if (contains_type_p (new_outer_type
, new_offset
- speculative_offset
,
1986 speculative_outer_type
, false, false))
1988 else if (contains_type_p (speculative_outer_type
,
1989 speculative_offset
- new_offset
,
1990 new_outer_type
, false, false))
1992 speculative_outer_type
= new_outer_type
;
1993 speculative_offset
= new_offset
;
1994 speculative_maybe_derived_type
= new_maybe_derived_type
;
1997 /* See if OUTER_TYPE is base of CTX.OUTER_TYPE. */
1998 else if (contains_type_p (new_outer_type
,
1999 new_offset
- speculative_offset
,
2000 speculative_outer_type
, false, true))
2002 if (!speculative_maybe_derived_type
)
2004 speculative_maybe_derived_type
= true;
2009 /* See if CTX.OUTER_TYPE is base of OUTER_TYPE. */
2010 else if (contains_type_p (speculative_outer_type
,
2011 speculative_offset
- new_offset
, new_outer_type
, false, true))
2013 speculative_outer_type
= new_outer_type
;
2014 speculative_offset
= new_offset
;
2015 speculative_maybe_derived_type
= true;
2020 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2021 fprintf (dump_file
, "Giving up on speculative meet\n");
2022 clear_speculation ();
2027 /* Assume that both THIS and a given context is valid and strenghten THIS
2028 if possible. Return true if any strenghtening was made.
2029 If actual type the context is being used in is known, OTR_TYPE should be
2030 set accordingly. This improves quality of combined result. */
2033 ipa_polymorphic_call_context::combine_with (ipa_polymorphic_call_context ctx
,
2036 bool updated
= false;
2038 if (ctx
.useless_p () || invalid
)
2041 /* Restricting context to inner type makes merging easier, however do not
2042 do that unless we know how the context is used (OTR_TYPE is non-NULL) */
2043 if (otr_type
&& !invalid
&& !ctx
.invalid
)
2045 restrict_to_inner_class (otr_type
);
2046 ctx
.restrict_to_inner_class (otr_type
);
2051 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2053 fprintf (dump_file
, "Polymorphic call context combine:");
2055 fprintf (dump_file
, "With context: ");
2056 ctx
.dump (dump_file
);
2059 fprintf (dump_file
, "To be used with type: ");
2060 print_generic_expr (dump_file
, otr_type
, TDF_SLIM
);
2061 fprintf (dump_file
, "\n");
2065 /* If call is known to be invalid, we are done. */
2068 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2069 fprintf (dump_file
, "-> Invalid context\n");
2073 if (!ctx
.outer_type
)
2075 else if (!outer_type
)
2077 outer_type
= ctx
.outer_type
;
2078 offset
= ctx
.offset
;
2079 dynamic
= ctx
.dynamic
;
2080 maybe_in_construction
= ctx
.maybe_in_construction
;
2081 maybe_derived_type
= ctx
.maybe_derived_type
;
2084 /* If types are known to be same, merging is quite easy. */
2085 else if (types_must_be_same_for_odr (outer_type
, ctx
.outer_type
))
2087 if (offset
!= ctx
.offset
2088 && TYPE_SIZE (outer_type
)
2089 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
)
2091 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2092 fprintf (dump_file
, "Outer types match, offset mismatch -> invalid\n");
2093 clear_speculation ();
2094 clear_outer_type ();
2098 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2099 fprintf (dump_file
, "Outer types match, merging flags\n");
2100 if (maybe_in_construction
&& !ctx
.maybe_in_construction
)
2103 maybe_in_construction
= false;
2105 if (maybe_derived_type
&& !ctx
.maybe_derived_type
)
2108 maybe_derived_type
= false;
2110 if (dynamic
&& !ctx
.dynamic
)
2116 /* If we know the type precisely, there is not much to improve. */
2117 else if (!maybe_derived_type
&& !maybe_in_construction
2118 && !ctx
.maybe_derived_type
&& !ctx
.maybe_in_construction
)
2120 /* It may be easy to check if second context permits the first
2121 and set INVALID otherwise. This is not easy to do in general;
2122 contains_type_p may return false negatives for non-comparable
2125 If OTR_TYPE is known, we however can expect that
2126 restrict_to_inner_class should have discovered the same base
2128 if (otr_type
&& !ctx
.maybe_in_construction
&& !ctx
.maybe_derived_type
)
2130 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2131 fprintf (dump_file
, "Contextes disagree -> invalid\n");
2135 /* See if one type contains the other as a field (not base).
2136 In this case we want to choose the wider type, because it contains
2137 more information. */
2138 else if (contains_type_p (ctx
.outer_type
, ctx
.offset
- offset
,
2139 outer_type
, false, false))
2141 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2142 fprintf (dump_file
, "Second type contain the first as a field\n");
2144 if (maybe_derived_type
)
2146 outer_type
= ctx
.outer_type
;
2147 maybe_derived_type
= ctx
.maybe_derived_type
;
2148 offset
= ctx
.offset
;
2149 dynamic
= ctx
.dynamic
;
2153 /* If we do not know how the context is being used, we can
2154 not clear MAYBE_IN_CONSTRUCTION because it may be offseted
2155 to other component of OUTER_TYPE later and we know nothing
2157 if (otr_type
&& maybe_in_construction
2158 && !ctx
.maybe_in_construction
)
2160 maybe_in_construction
= false;
2164 else if (contains_type_p (outer_type
, offset
- ctx
.offset
,
2165 ctx
.outer_type
, false, false))
2167 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2168 fprintf (dump_file
, "First type contain the second as a field\n");
2170 if (otr_type
&& maybe_in_construction
2171 && !ctx
.maybe_in_construction
)
2173 maybe_in_construction
= false;
2177 /* See if OUTER_TYPE is base of CTX.OUTER_TYPE. */
2178 else if (contains_type_p (ctx
.outer_type
,
2179 ctx
.offset
- offset
, outer_type
, false, true))
2181 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2182 fprintf (dump_file
, "First type is base of second\n");
2183 if (!maybe_derived_type
)
2185 if (!ctx
.maybe_in_construction
2186 && types_odr_comparable (outer_type
, ctx
.outer_type
))
2188 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2189 fprintf (dump_file
, "Second context does not permit base -> invalid\n");
2193 /* Pick variant deeper in the hiearchy. */
2196 outer_type
= ctx
.outer_type
;
2197 maybe_in_construction
= ctx
.maybe_in_construction
;
2198 maybe_derived_type
= ctx
.maybe_derived_type
;
2199 offset
= ctx
.offset
;
2200 dynamic
= ctx
.dynamic
;
2204 /* See if CTX.OUTER_TYPE is base of OUTER_TYPE. */
2205 else if (contains_type_p (outer_type
,
2206 offset
- ctx
.offset
, ctx
.outer_type
, false, true))
2208 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2209 fprintf (dump_file
, "Second type is base of first\n");
2210 if (!ctx
.maybe_derived_type
)
2212 if (!maybe_in_construction
2213 && types_odr_comparable (outer_type
, ctx
.outer_type
))
2215 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2216 fprintf (dump_file
, "First context does not permit base -> invalid\n");
2219 /* Pick the base type. */
2220 else if (maybe_in_construction
)
2222 outer_type
= ctx
.outer_type
;
2223 maybe_in_construction
= ctx
.maybe_in_construction
;
2224 maybe_derived_type
= ctx
.maybe_derived_type
;
2225 offset
= ctx
.offset
;
2226 dynamic
= ctx
.dynamic
;
2231 /* TODO handle merging using hiearchy. */
2232 else if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2233 fprintf (dump_file
, "Giving up on merge\n");
2235 updated
|= combine_speculation_with (ctx
.speculative_outer_type
,
2236 ctx
.speculative_offset
,
2237 ctx
.speculative_maybe_derived_type
,
2240 if (updated
&& dump_file
&& (dump_flags
& TDF_DETAILS
))
2242 fprintf (dump_file
, "Updated as: ");
2244 fprintf (dump_file
, "\n");
2250 clear_speculation ();
2251 clear_outer_type ();
2255 /* Take non-speculative info, merge it with speculative and clear speculation.
2256 Used when we no longer manage to keep track of actual outer type, but we
2257 think it is still there.
2259 If OTR_TYPE is set, the transformation can be done more effectively assuming
2260 that context is going to be used only that way. */
2263 ipa_polymorphic_call_context::make_speculative (tree otr_type
)
2265 tree spec_outer_type
= outer_type
;
2266 HOST_WIDE_INT spec_offset
= offset
;
2267 bool spec_maybe_derived_type
= maybe_derived_type
;
2272 clear_outer_type ();
2273 clear_speculation ();
2278 clear_outer_type ();
2279 combine_speculation_with (spec_outer_type
, spec_offset
,
2280 spec_maybe_derived_type
,
2284 /* Use when we can not track dynamic type change. This speculatively assume
2285 type change is not happening. */
2288 ipa_polymorphic_call_context::possible_dynamic_type_change (bool in_poly_cdtor
,
2292 make_speculative (otr_type
);
2293 else if (in_poly_cdtor
)
2294 maybe_in_construction
= true;
2297 /* Return TRUE if this context conveys the same information as OTHER. */
2300 ipa_polymorphic_call_context::equal_to
2301 (const ipa_polymorphic_call_context
&x
) const
2304 return x
.useless_p ();
2307 if (x
.useless_p () || x
.invalid
)
2313 || !types_odr_comparable (outer_type
, x
.outer_type
)
2314 || !types_same_for_odr (outer_type
, x
.outer_type
)
2315 || offset
!= x
.offset
2316 || maybe_in_construction
!= x
.maybe_in_construction
2317 || maybe_derived_type
!= x
.maybe_derived_type
2318 || dynamic
!= x
.dynamic
)
2321 else if (x
.outer_type
)
2325 if (speculative_outer_type
2326 && speculation_consistent_p (speculative_outer_type
, speculative_offset
,
2327 speculative_maybe_derived_type
, NULL_TREE
))
2329 if (!x
.speculative_outer_type
)
2332 if (!types_odr_comparable (speculative_outer_type
,
2333 x
.speculative_outer_type
)
2334 || !types_same_for_odr (speculative_outer_type
,
2335 x
.speculative_outer_type
)
2336 || speculative_offset
!= x
.speculative_offset
2337 || speculative_maybe_derived_type
!= x
.speculative_maybe_derived_type
)
2340 else if (x
.speculative_outer_type
2341 && x
.speculation_consistent_p (x
.speculative_outer_type
,
2342 x
.speculative_offset
,
2343 x
.speculative_maybe_derived_type
,
2350 /* Modify context to be strictly less restrictive than CTX. */
2353 ipa_polymorphic_call_context::meet_with (ipa_polymorphic_call_context ctx
,
2356 bool updated
= false;
2358 if (useless_p () || ctx
.invalid
)
2361 /* Restricting context to inner type makes merging easier, however do not
2362 do that unless we know how the context is used (OTR_TYPE is non-NULL) */
2363 if (otr_type
&& !useless_p () && !ctx
.useless_p ())
2365 restrict_to_inner_class (otr_type
);
2366 ctx
.restrict_to_inner_class (otr_type
);
2374 if (ctx
.useless_p () || invalid
)
2380 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2382 fprintf (dump_file
, "Polymorphic call context meet:");
2384 fprintf (dump_file
, "With context: ");
2385 ctx
.dump (dump_file
);
2388 fprintf (dump_file
, "To be used with type: ");
2389 print_generic_expr (dump_file
, otr_type
, TDF_SLIM
);
2390 fprintf (dump_file
, "\n");
2394 if (!dynamic
&& ctx
.dynamic
)
2400 /* If call is known to be invalid, we are done. */
2403 else if (!ctx
.outer_type
)
2405 clear_outer_type ();
2408 /* If types are known to be same, merging is quite easy. */
2409 else if (types_must_be_same_for_odr (outer_type
, ctx
.outer_type
))
2411 if (offset
!= ctx
.offset
2412 && TYPE_SIZE (outer_type
)
2413 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
)
2415 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2416 fprintf (dump_file
, "Outer types match, offset mismatch -> clearing\n");
2417 clear_outer_type ();
2420 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2421 fprintf (dump_file
, "Outer types match, merging flags\n");
2422 if (!maybe_in_construction
&& ctx
.maybe_in_construction
)
2425 maybe_in_construction
= true;
2427 if (!maybe_derived_type
&& ctx
.maybe_derived_type
)
2430 maybe_derived_type
= true;
2432 if (!dynamic
&& ctx
.dynamic
)
2438 /* See if one type contains the other as a field (not base). */
2439 else if (contains_type_p (ctx
.outer_type
, ctx
.offset
- offset
,
2440 outer_type
, false, false))
2442 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2443 fprintf (dump_file
, "Second type contain the first as a field\n");
2445 /* The second type is more specified, so we keep the first.
2446 We need to set DYNAMIC flag to avoid declaring context INVALID
2447 of OFFSET ends up being out of range. */
2451 && (!TYPE_SIZE (ctx
.outer_type
)
2452 || !TYPE_SIZE (outer_type
)
2453 || !operand_equal_p (TYPE_SIZE (ctx
.outer_type
),
2454 TYPE_SIZE (outer_type
), 0)))))
2460 else if (contains_type_p (outer_type
, offset
- ctx
.offset
,
2461 ctx
.outer_type
, false, false))
2463 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2464 fprintf (dump_file
, "First type contain the second as a field\n");
2469 && (!TYPE_SIZE (ctx
.outer_type
)
2470 || !TYPE_SIZE (outer_type
)
2471 || !operand_equal_p (TYPE_SIZE (ctx
.outer_type
),
2472 TYPE_SIZE (outer_type
), 0)))))
2474 outer_type
= ctx
.outer_type
;
2475 offset
= ctx
.offset
;
2476 dynamic
= ctx
.dynamic
;
2477 maybe_in_construction
= ctx
.maybe_in_construction
;
2478 maybe_derived_type
= ctx
.maybe_derived_type
;
2481 /* See if OUTER_TYPE is base of CTX.OUTER_TYPE. */
2482 else if (contains_type_p (ctx
.outer_type
,
2483 ctx
.offset
- offset
, outer_type
, false, true))
2485 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2486 fprintf (dump_file
, "First type is base of second\n");
2487 if (!maybe_derived_type
)
2489 maybe_derived_type
= true;
2492 if (!maybe_in_construction
&& ctx
.maybe_in_construction
)
2494 maybe_in_construction
= true;
2497 if (!dynamic
&& ctx
.dynamic
)
2503 /* See if CTX.OUTER_TYPE is base of OUTER_TYPE. */
2504 else if (contains_type_p (outer_type
,
2505 offset
- ctx
.offset
, ctx
.outer_type
, false, true))
2507 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2508 fprintf (dump_file
, "Second type is base of first\n");
2509 outer_type
= ctx
.outer_type
;
2510 offset
= ctx
.offset
;
2512 if (!maybe_derived_type
)
2513 maybe_derived_type
= true;
2514 if (!maybe_in_construction
&& ctx
.maybe_in_construction
)
2515 maybe_in_construction
= true;
2516 if (!dynamic
&& ctx
.dynamic
)
2519 /* TODO handle merging using hiearchy. */
2522 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2523 fprintf (dump_file
, "Giving up on meet\n");
2524 clear_outer_type ();
2528 updated
|= meet_speculation_with (ctx
.speculative_outer_type
,
2529 ctx
.speculative_offset
,
2530 ctx
.speculative_maybe_derived_type
,
2533 if (updated
&& dump_file
&& (dump_flags
& TDF_DETAILS
))
2535 fprintf (dump_file
, "Updated as: ");
2537 fprintf (dump_file
, "\n");