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"
29 #include "fold-const.h"
30 #include "print-tree.h"
33 #include "insn-config.h"
41 #include "tree-pass.h"
44 #include "ipa-utils.h"
45 #include "internal-fn.h"
46 #include "gimple-fold.h"
47 #include "alloc-pool.h"
48 #include "symbol-summary.h"
50 #include "ipa-inline.h"
51 #include "diagnostic.h"
55 #include "gimple-pretty-print.h"
56 #include "stor-layout.h"
58 #include "data-streamer.h"
59 #include "streamer-hooks.h"
60 #include "tree-ssa-operands.h"
61 #include "tree-into-ssa.h"
63 /* Return true when TYPE contains an polymorphic type and thus is interesting
64 for devirtualization machinery. */
66 static bool contains_type_p (tree
, HOST_WIDE_INT
, tree
,
67 bool consider_placement_new
= true,
68 bool consider_bases
= true);
71 contains_polymorphic_type_p (const_tree type
)
73 type
= TYPE_MAIN_VARIANT (type
);
75 if (RECORD_OR_UNION_TYPE_P (type
))
78 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
80 for (tree fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
81 if (TREE_CODE (fld
) == FIELD_DECL
82 && !DECL_ARTIFICIAL (fld
)
83 && contains_polymorphic_type_p (TREE_TYPE (fld
)))
87 if (TREE_CODE (type
) == ARRAY_TYPE
)
88 return contains_polymorphic_type_p (TREE_TYPE (type
));
92 /* Return true if it seems valid to use placement new to build EXPECTED_TYPE
93 at possition CUR_OFFSET within TYPE.
95 POD can be changed to an instance of a polymorphic type by
96 placement new. Here we play safe and assume that any
97 non-polymorphic type is POD. */
99 possible_placement_new (tree type
, tree expected_type
,
100 HOST_WIDE_INT cur_offset
)
104 return ((TREE_CODE (type
) != RECORD_TYPE
105 || !TYPE_BINFO (type
)
106 || cur_offset
>= POINTER_SIZE
107 || !polymorphic_type_binfo_p (TYPE_BINFO (type
)))
108 && (!TYPE_SIZE (type
)
109 || !tree_fits_shwi_p (TYPE_SIZE (type
))
111 + (expected_type
? tree_to_uhwi (TYPE_SIZE (expected_type
))
113 <= tree_to_uhwi (TYPE_SIZE (type
)))));
116 /* THIS->OUTER_TYPE is a type of memory object where object of OTR_TYPE
117 is contained at THIS->OFFSET. Walk the memory representation of
118 THIS->OUTER_TYPE and find the outermost class type that match
119 OTR_TYPE or contain OTR_TYPE as a base. Update THIS
122 If OTR_TYPE is NULL, just find outermost polymorphic type with
123 virtual table present at possition OFFSET.
125 For example when THIS represents type
131 and we look for type at offset sizeof(int), we end up with B and offset 0.
132 If the same is produced by multiple inheritance, we end up with A and offset
135 If we can not find corresponding class, give up by setting
136 THIS->OUTER_TYPE to OTR_TYPE and THIS->OFFSET to NULL.
137 Return true when lookup was sucesful.
139 When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made
140 valid only via alocation of new polymorphic type inside by means
143 When CONSIDER_BASES is false, only look for actual fields, not base types
147 ipa_polymorphic_call_context::restrict_to_inner_class (tree otr_type
,
148 bool consider_placement_new
,
151 tree type
= outer_type
;
152 HOST_WIDE_INT cur_offset
= offset
;
153 bool speculative
= false;
154 bool size_unknown
= false;
155 unsigned HOST_WIDE_INT otr_type_size
= POINTER_SIZE
;
157 /* Update OUTER_TYPE to match EXPECTED_TYPE if it is not set. */
160 clear_outer_type (otr_type
);
164 /* See if OFFSET points inside OUTER_TYPE. If it does not, we know
165 that the context is either invalid, or the instance type must be
166 derived from OUTER_TYPE.
168 Because the instance type may contain field whose type is of OUTER_TYPE,
169 we can not derive any effective information about it.
171 TODO: In the case we know all derrived types, we can definitely do better
173 else if (TYPE_SIZE (outer_type
)
174 && tree_fits_shwi_p (TYPE_SIZE (outer_type
))
175 && tree_to_shwi (TYPE_SIZE (outer_type
)) >= 0
176 && tree_to_shwi (TYPE_SIZE (outer_type
)) <= offset
)
178 clear_outer_type (otr_type
);
182 /* If derived type is not allowed, we know that the context is invalid.
183 For dynamic types, we really do not have information about
184 size of the memory location. It is possible that completely
185 different type is stored after outer_type. */
186 if (!maybe_derived_type
&& !dynamic
)
188 clear_speculation ();
194 if (otr_type
&& TYPE_SIZE (otr_type
)
195 && tree_fits_shwi_p (TYPE_SIZE (otr_type
)))
196 otr_type_size
= tree_to_uhwi (TYPE_SIZE (otr_type
));
198 if (!type
|| offset
< 0)
199 goto no_useful_type_info
;
201 /* Find the sub-object the constant actually refers to and mark whether it is
202 an artificial one (as opposed to a user-defined one).
204 This loop is performed twice; first time for outer_type and second time
205 for speculative_outer_type. The second run has SPECULATIVE set. */
208 unsigned HOST_WIDE_INT pos
, size
;
211 /* If we do not know size of TYPE, we need to be more conservative
212 about accepting cases where we can not find EXPECTED_TYPE.
213 Generally the types that do matter here are of constant size.
214 Size_unknown case should be very rare. */
216 && tree_fits_shwi_p (TYPE_SIZE (type
))
217 && tree_to_shwi (TYPE_SIZE (type
)) >= 0)
218 size_unknown
= false;
222 /* On a match, just return what we found. */
224 && types_odr_comparable (type
, otr_type
)
225 && types_same_for_odr (type
, otr_type
))
227 && TREE_CODE (type
) == RECORD_TYPE
229 && polymorphic_type_binfo_p (TYPE_BINFO (type
))))
233 /* If we did not match the offset, just give up on speculation. */
235 /* Also check if speculation did not end up being same as
237 || (types_must_be_same_for_odr (speculative_outer_type
,
239 && (maybe_derived_type
240 == speculative_maybe_derived_type
)))
241 clear_speculation ();
246 /* If type is known to be final, do not worry about derived
247 types. Testing it here may help us to avoid speculation. */
248 if (otr_type
&& TREE_CODE (outer_type
) == RECORD_TYPE
249 && (!in_lto_p
|| odr_type_p (outer_type
))
250 && type_with_linkage_p (outer_type
)
251 && type_known_to_have_no_derivations_p (outer_type
))
252 maybe_derived_type
= false;
254 /* Type can not contain itself on an non-zero offset. In that case
255 just give up. Still accept the case where size is now known.
256 Either the second copy may appear past the end of type or within
257 the non-POD buffer located inside the variably sized type
260 goto no_useful_type_info
;
261 /* If we determined type precisely or we have no clue on
262 speuclation, we are done. */
263 if (!maybe_derived_type
|| !speculative_outer_type
264 || !speculation_consistent_p (speculative_outer_type
,
266 speculative_maybe_derived_type
,
269 clear_speculation ();
272 /* Otherwise look into speculation now. */
276 type
= speculative_outer_type
;
277 cur_offset
= speculative_offset
;
283 /* Walk fields and find corresponding on at OFFSET. */
284 if (TREE_CODE (type
) == RECORD_TYPE
)
286 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
288 if (TREE_CODE (fld
) != FIELD_DECL
)
291 pos
= int_bit_position (fld
);
292 if (pos
> (unsigned HOST_WIDE_INT
)cur_offset
)
295 /* Do not consider vptr itself. Not even for placement new. */
296 if (!pos
&& DECL_ARTIFICIAL (fld
)
297 && POINTER_TYPE_P (TREE_TYPE (fld
))
299 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
302 if (!DECL_SIZE (fld
) || !tree_fits_uhwi_p (DECL_SIZE (fld
)))
303 goto no_useful_type_info
;
304 size
= tree_to_uhwi (DECL_SIZE (fld
));
306 /* We can always skip types smaller than pointer size:
307 those can not contain a virtual table pointer.
309 Disqualifying fields that are too small to fit OTR_TYPE
310 saves work needed to walk them for no benefit.
311 Because of the way the bases are packed into a class, the
312 field's size may be smaller than type size, so it needs
313 to be done with a care. */
315 if (pos
<= (unsigned HOST_WIDE_INT
)cur_offset
316 && (pos
+ size
) >= (unsigned HOST_WIDE_INT
)cur_offset
319 || !TYPE_SIZE (TREE_TYPE (fld
))
320 || !tree_fits_shwi_p (TYPE_SIZE (TREE_TYPE (fld
)))
321 || (pos
+ tree_to_uhwi (TYPE_SIZE (TREE_TYPE (fld
))))
322 >= cur_offset
+ otr_type_size
))
327 goto no_useful_type_info
;
329 type
= TYPE_MAIN_VARIANT (TREE_TYPE (fld
));
331 /* DECL_ARTIFICIAL represents a basetype. */
332 if (!DECL_ARTIFICIAL (fld
))
338 /* As soon as we se an field containing the type,
339 we know we are not looking for derivations. */
340 maybe_derived_type
= false;
344 speculative_outer_type
= type
;
345 speculative_offset
= cur_offset
;
346 speculative_maybe_derived_type
= false;
349 else if (!consider_bases
)
350 goto no_useful_type_info
;
352 else if (TREE_CODE (type
) == ARRAY_TYPE
)
354 tree subtype
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
356 /* Give up if we don't know array field size.
357 Also give up on non-polymorphic types as they are used
358 as buffers for placement new. */
359 if (!TYPE_SIZE (subtype
)
360 || !tree_fits_shwi_p (TYPE_SIZE (subtype
))
361 || tree_to_shwi (TYPE_SIZE (subtype
)) <= 0
362 || !contains_polymorphic_type_p (subtype
))
363 goto no_useful_type_info
;
365 HOST_WIDE_INT new_offset
= cur_offset
% tree_to_shwi (TYPE_SIZE (subtype
));
367 /* We may see buffer for placement new. In this case the expected type
368 can be bigger than the subtype. */
369 if (TYPE_SIZE (subtype
)
370 && (cur_offset
+ otr_type_size
371 > tree_to_uhwi (TYPE_SIZE (subtype
))))
372 goto no_useful_type_info
;
374 cur_offset
= new_offset
;
375 type
= TYPE_MAIN_VARIANT (subtype
);
380 maybe_derived_type
= false;
384 speculative_outer_type
= type
;
385 speculative_offset
= cur_offset
;
386 speculative_maybe_derived_type
= false;
389 /* Give up on anything else. */
393 if (maybe_derived_type
&& !speculative
394 && TREE_CODE (outer_type
) == RECORD_TYPE
395 && TREE_CODE (otr_type
) == RECORD_TYPE
396 && TYPE_BINFO (otr_type
)
398 && get_binfo_at_offset (TYPE_BINFO (otr_type
), 0, outer_type
))
400 clear_outer_type (otr_type
);
401 if (!speculative_outer_type
402 || !speculation_consistent_p (speculative_outer_type
,
404 speculative_maybe_derived_type
,
406 clear_speculation ();
407 if (speculative_outer_type
)
410 type
= speculative_outer_type
;
411 cur_offset
= speculative_offset
;
416 /* We found no way to embedd EXPECTED_TYPE in TYPE.
417 We still permit two special cases - placement new and
418 the case of variadic types containing themselves. */
420 && consider_placement_new
421 && (size_unknown
|| !type
|| maybe_derived_type
422 || possible_placement_new (type
, otr_type
, cur_offset
)))
424 /* In these weird cases we want to accept the context.
425 In non-speculative run we have no useful outer_type info
426 (TODO: we may eventually want to record upper bound on the
427 type size that can be used to prune the walk),
428 but we still want to consider speculation that may
432 clear_outer_type (otr_type
);
433 if (!speculative_outer_type
434 || !speculation_consistent_p (speculative_outer_type
,
436 speculative_maybe_derived_type
,
438 clear_speculation ();
439 if (speculative_outer_type
)
442 type
= speculative_outer_type
;
443 cur_offset
= speculative_offset
;
449 clear_speculation ();
454 clear_speculation ();
457 clear_outer_type (otr_type
);
465 /* Return true if OUTER_TYPE contains OTR_TYPE at OFFSET.
466 CONSIDER_PLACEMENT_NEW makes function to accept cases where OTR_TYPE can
467 be built within OUTER_TYPE by means of placement new. CONSIDER_BASES makes
468 function to accept cases where OTR_TYPE appears as base of OUTER_TYPE or as
469 base of one of fields of OUTER_TYPE. */
472 contains_type_p (tree outer_type
, HOST_WIDE_INT offset
,
474 bool consider_placement_new
,
477 ipa_polymorphic_call_context context
;
479 /* Check that type is within range. */
482 if (TYPE_SIZE (outer_type
) && TYPE_SIZE (otr_type
)
483 && TREE_CODE (outer_type
) == INTEGER_CST
484 && TREE_CODE (otr_type
) == INTEGER_CST
485 && wi::ltu_p (wi::to_offset (outer_type
), (wi::to_offset (otr_type
) + offset
)))
488 context
.offset
= offset
;
489 context
.outer_type
= TYPE_MAIN_VARIANT (outer_type
);
490 context
.maybe_derived_type
= false;
491 return context
.restrict_to_inner_class (otr_type
, consider_placement_new
, consider_bases
);
495 /* Return a FUNCTION_DECL if BLOCK represents a constructor or destructor.
496 If CHECK_CLONES is true, also check for clones of ctor/dtors. */
499 inlined_polymorphic_ctor_dtor_block_p (tree block
, bool check_clones
)
501 tree fn
= BLOCK_ABSTRACT_ORIGIN (block
);
502 if (fn
== NULL
|| TREE_CODE (fn
) != FUNCTION_DECL
)
505 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
506 || (!DECL_CXX_CONSTRUCTOR_P (fn
) && !DECL_CXX_DESTRUCTOR_P (fn
)))
511 /* Watch for clones where we constant propagated the first
512 argument (pointer to the instance). */
513 fn
= DECL_ABSTRACT_ORIGIN (fn
);
515 || TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
516 || (!DECL_CXX_CONSTRUCTOR_P (fn
) && !DECL_CXX_DESTRUCTOR_P (fn
)))
520 if (flags_from_decl_or_type (fn
) & (ECF_PURE
| ECF_CONST
))
527 /* We know that the instance is stored in variable or parameter
528 (not dynamically allocated) and we want to disprove the fact
529 that it may be in construction at invocation of CALL.
531 BASE represents memory location where instance is stored.
532 If BASE is NULL, it is assumed to be global memory.
533 OUTER_TYPE is known type of the instance or NULL if not
536 For the variable to be in construction we actually need to
537 be in constructor of corresponding global variable or
538 the inline stack of CALL must contain the constructor.
539 Check this condition. This check works safely only before
540 IPA passes, because inline stacks may become out of date
544 decl_maybe_in_construction_p (tree base
, tree outer_type
,
545 gimple
*call
, tree function
)
548 outer_type
= TYPE_MAIN_VARIANT (outer_type
);
549 gcc_assert (!base
|| DECL_P (base
));
551 /* After inlining the code unification optimizations may invalidate
552 inline stacks. Also we need to give up on global variables after
553 IPA, because addresses of these may have been propagated to their
555 if (DECL_STRUCT_FUNCTION (function
)->after_inlining
)
558 /* Pure functions can not do any changes on the dynamic type;
559 that require writting to memory. */
560 if ((!base
|| !auto_var_in_fn_p (base
, function
))
561 && flags_from_decl_or_type (function
) & (ECF_PURE
| ECF_CONST
))
564 bool check_clones
= !base
|| is_global_var (base
);
565 for (tree block
= gimple_block (call
); block
&& TREE_CODE (block
) == BLOCK
;
566 block
= BLOCK_SUPERCONTEXT (block
))
567 if (tree fn
= inlined_polymorphic_ctor_dtor_block_p (block
, check_clones
))
569 tree type
= TYPE_METHOD_BASETYPE (TREE_TYPE (fn
));
571 if (!outer_type
|| !types_odr_comparable (type
, outer_type
))
573 if (TREE_CODE (type
) == RECORD_TYPE
575 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
578 else if (types_same_for_odr (type
, outer_type
))
582 if (!base
|| (TREE_CODE (base
) == VAR_DECL
&& is_global_var (base
)))
584 if (TREE_CODE (TREE_TYPE (function
)) != METHOD_TYPE
585 || (!DECL_CXX_CONSTRUCTOR_P (function
)
586 && !DECL_CXX_DESTRUCTOR_P (function
)))
588 if (!DECL_ABSTRACT_ORIGIN (function
))
590 /* Watch for clones where we constant propagated the first
591 argument (pointer to the instance). */
592 function
= DECL_ABSTRACT_ORIGIN (function
);
594 || TREE_CODE (TREE_TYPE (function
)) != METHOD_TYPE
595 || (!DECL_CXX_CONSTRUCTOR_P (function
)
596 && !DECL_CXX_DESTRUCTOR_P (function
)))
599 tree type
= TYPE_METHOD_BASETYPE (TREE_TYPE (function
));
600 if (!outer_type
|| !types_odr_comparable (type
, outer_type
))
602 if (TREE_CODE (type
) == RECORD_TYPE
604 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
607 else if (types_same_for_odr (type
, outer_type
))
613 /* Dump human readable context to F. If NEWLINE is true, it will be terminated
617 ipa_polymorphic_call_context::dump (FILE *f
, bool newline
) const
621 fprintf (f
, "Call is known to be undefined");
625 fprintf (f
, "nothing known");
626 if (outer_type
|| offset
)
628 fprintf (f
, "Outer type%s:", dynamic
? " (dynamic)":"");
629 print_generic_expr (f
, outer_type
, TDF_SLIM
);
630 if (maybe_derived_type
)
631 fprintf (f
, " (or a derived type)");
632 if (maybe_in_construction
)
633 fprintf (f
, " (maybe in construction)");
634 fprintf (f
, " offset " HOST_WIDE_INT_PRINT_DEC
,
637 if (speculative_outer_type
)
639 if (outer_type
|| offset
)
641 fprintf (f
, "Speculative outer type:");
642 print_generic_expr (f
, speculative_outer_type
, TDF_SLIM
);
643 if (speculative_maybe_derived_type
)
644 fprintf (f
, " (or a derived type)");
645 fprintf (f
, " at offset " HOST_WIDE_INT_PRINT_DEC
,
653 /* Print context to stderr. */
656 ipa_polymorphic_call_context::debug () const
661 /* Stream out the context to OB. */
664 ipa_polymorphic_call_context::stream_out (struct output_block
*ob
) const
666 struct bitpack_d bp
= bitpack_create (ob
->main_stream
);
668 bp_pack_value (&bp
, invalid
, 1);
669 bp_pack_value (&bp
, maybe_in_construction
, 1);
670 bp_pack_value (&bp
, maybe_derived_type
, 1);
671 bp_pack_value (&bp
, speculative_maybe_derived_type
, 1);
672 bp_pack_value (&bp
, dynamic
, 1);
673 bp_pack_value (&bp
, outer_type
!= NULL
, 1);
674 bp_pack_value (&bp
, offset
!= 0, 1);
675 bp_pack_value (&bp
, speculative_outer_type
!= NULL
, 1);
676 streamer_write_bitpack (&bp
);
678 if (outer_type
!= NULL
)
679 stream_write_tree (ob
, outer_type
, true);
681 streamer_write_hwi (ob
, offset
);
682 if (speculative_outer_type
!= NULL
)
684 stream_write_tree (ob
, speculative_outer_type
, true);
685 streamer_write_hwi (ob
, speculative_offset
);
688 gcc_assert (!speculative_offset
);
691 /* Stream in the context from IB and DATA_IN. */
694 ipa_polymorphic_call_context::stream_in (struct lto_input_block
*ib
,
695 struct data_in
*data_in
)
697 struct bitpack_d bp
= streamer_read_bitpack (ib
);
699 invalid
= bp_unpack_value (&bp
, 1);
700 maybe_in_construction
= bp_unpack_value (&bp
, 1);
701 maybe_derived_type
= bp_unpack_value (&bp
, 1);
702 speculative_maybe_derived_type
= bp_unpack_value (&bp
, 1);
703 dynamic
= bp_unpack_value (&bp
, 1);
704 bool outer_type_p
= bp_unpack_value (&bp
, 1);
705 bool offset_p
= bp_unpack_value (&bp
, 1);
706 bool speculative_outer_type_p
= bp_unpack_value (&bp
, 1);
709 outer_type
= stream_read_tree (ib
, data_in
);
713 offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
716 if (speculative_outer_type_p
)
718 speculative_outer_type
= stream_read_tree (ib
, data_in
);
719 speculative_offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
723 speculative_outer_type
= NULL
;
724 speculative_offset
= 0;
728 /* Proudce polymorphic call context for call method of instance
729 that is located within BASE (that is assumed to be a decl) at offset OFF. */
732 ipa_polymorphic_call_context::set_by_decl (tree base
, HOST_WIDE_INT off
)
734 gcc_assert (DECL_P (base
));
735 clear_speculation ();
737 if (!contains_polymorphic_type_p (TREE_TYPE (base
)))
743 outer_type
= TYPE_MAIN_VARIANT (TREE_TYPE (base
));
745 /* Make very conservative assumption that all objects
746 may be in construction.
748 It is up to caller to revisit this via
749 get_dynamic_type or decl_maybe_in_construction_p. */
750 maybe_in_construction
= true;
751 maybe_derived_type
= false;
755 /* CST is an invariant (address of decl), try to get meaningful
756 polymorphic call context for polymorphic call of method
757 if instance of OTR_TYPE that is located at offset OFF of this invariant.
758 Return FALSE if nothing meaningful can be found. */
761 ipa_polymorphic_call_context::set_by_invariant (tree cst
,
765 HOST_WIDE_INT offset2
, size
, max_size
;
770 clear_outer_type (otr_type
);
772 if (TREE_CODE (cst
) != ADDR_EXPR
)
775 cst
= TREE_OPERAND (cst
, 0);
776 base
= get_ref_base_and_extent (cst
, &offset2
, &size
, &max_size
);
777 if (!DECL_P (base
) || max_size
== -1 || max_size
!= size
)
780 /* Only type inconsistent programs can have otr_type that is
781 not part of outer type. */
782 if (otr_type
&& !contains_type_p (TREE_TYPE (base
), off
, otr_type
))
785 set_by_decl (base
, off
);
789 /* See if OP is SSA name initialized as a copy or by single assignment.
790 If so, walk the SSA graph up. Because simple PHI conditional is considered
791 copy, GLOBAL_VISITED may be used to avoid infinite loop walking the SSA
795 walk_ssa_copies (tree op
, hash_set
<tree
> **global_visited
= NULL
)
797 hash_set
<tree
> *visited
= NULL
;
799 while (TREE_CODE (op
) == SSA_NAME
800 && !SSA_NAME_IS_DEFAULT_DEF (op
)
801 /* We might be called via fold_stmt during cfgcleanup where
802 SSA form need not be up-to-date. */
803 && !name_registered_for_update_p (op
)
804 && (gimple_assign_single_p (SSA_NAME_DEF_STMT (op
))
805 || gimple_code (SSA_NAME_DEF_STMT (op
)) == GIMPLE_PHI
))
809 if (!*global_visited
)
810 *global_visited
= new hash_set
<tree
>;
811 if ((*global_visited
)->add (op
))
817 visited
= new hash_set
<tree
>;
818 if (visited
->add (op
))
826 This pattern is implicitly produced for casts to non-primary
827 bases. When doing context analysis, we do not really care
828 about the case pointer is NULL, becuase the call will be
830 if (gimple_code (SSA_NAME_DEF_STMT (op
)) == GIMPLE_PHI
)
832 gimple
*phi
= SSA_NAME_DEF_STMT (op
);
834 if (gimple_phi_num_args (phi
) > 2)
836 if (gimple_phi_num_args (phi
) == 1)
837 op
= gimple_phi_arg_def (phi
, 0);
838 else if (integer_zerop (gimple_phi_arg_def (phi
, 0)))
839 op
= gimple_phi_arg_def (phi
, 1);
840 else if (integer_zerop (gimple_phi_arg_def (phi
, 1)))
841 op
= gimple_phi_arg_def (phi
, 0);
847 if (gimple_assign_load_p (SSA_NAME_DEF_STMT (op
)))
849 op
= gimple_assign_rhs1 (SSA_NAME_DEF_STMT (op
));
859 /* Create polymorphic call context from IP invariant CST.
860 This is typically &global_var.
861 OTR_TYPE specify type of polymorphic call or NULL if unknown, OFF
862 is offset of call. */
864 ipa_polymorphic_call_context::ipa_polymorphic_call_context (tree cst
,
868 clear_speculation ();
869 set_by_invariant (cst
, otr_type
, off
);
872 /* Build context for pointer REF contained in FNDECL at statement STMT.
873 if INSTANCE is non-NULL, return pointer to the object described by
874 the context or DECL where context is contained in. */
876 ipa_polymorphic_call_context::ipa_polymorphic_call_context (tree fndecl
,
881 tree otr_type
= NULL
;
883 hash_set
<tree
> *visited
= NULL
;
885 if (TREE_CODE (ref
) == OBJ_TYPE_REF
)
887 otr_type
= obj_type_ref_class (ref
);
888 base_pointer
= OBJ_TYPE_REF_OBJECT (ref
);
893 /* Set up basic info in case we find nothing interesting in the analysis. */
894 clear_speculation ();
895 clear_outer_type (otr_type
);
898 /* Walk SSA for outer object. */
901 base_pointer
= walk_ssa_copies (base_pointer
, &visited
);
902 if (TREE_CODE (base_pointer
) == ADDR_EXPR
)
904 HOST_WIDE_INT size
, max_size
;
905 HOST_WIDE_INT offset2
;
906 tree base
= get_ref_base_and_extent (TREE_OPERAND (base_pointer
, 0),
907 &offset2
, &size
, &max_size
);
909 if (max_size
!= -1 && max_size
== size
)
910 combine_speculation_with (TYPE_MAIN_VARIANT (TREE_TYPE (base
)),
913 NULL
/* Do not change outer type. */);
915 /* If this is a varying address, punt. */
916 if ((TREE_CODE (base
) == MEM_REF
|| DECL_P (base
))
920 /* We found dereference of a pointer. Type of the pointer
921 and MEM_REF is meaningless, but we can look futher. */
922 if (TREE_CODE (base
) == MEM_REF
)
924 base_pointer
= TREE_OPERAND (base
, 0);
926 += offset2
+ mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
929 /* We found base object. In this case the outer_type
931 else if (DECL_P (base
))
935 /* Only type inconsistent programs can have otr_type that is
936 not part of outer type. */
938 && !contains_type_p (TREE_TYPE (base
),
939 offset
+ offset2
, otr_type
))
943 *instance
= base_pointer
;
946 set_by_decl (base
, offset
+ offset2
);
947 if (outer_type
&& maybe_in_construction
&& stmt
)
948 maybe_in_construction
949 = decl_maybe_in_construction_p (base
,
963 else if (TREE_CODE (base_pointer
) == POINTER_PLUS_EXPR
964 && tree_fits_uhwi_p (TREE_OPERAND (base_pointer
, 1)))
966 offset
+= tree_to_shwi (TREE_OPERAND (base_pointer
, 1))
968 base_pointer
= TREE_OPERAND (base_pointer
, 0);
977 /* Try to determine type of the outer object. */
978 if (TREE_CODE (base_pointer
) == SSA_NAME
979 && SSA_NAME_IS_DEFAULT_DEF (base_pointer
)
980 && TREE_CODE (SSA_NAME_VAR (base_pointer
)) == PARM_DECL
)
982 /* See if parameter is THIS pointer of a method. */
983 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
984 && SSA_NAME_VAR (base_pointer
) == DECL_ARGUMENTS (fndecl
))
987 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (base_pointer
)));
988 gcc_assert (TREE_CODE (outer_type
) == RECORD_TYPE
989 || TREE_CODE (outer_type
) == UNION_TYPE
);
991 /* Dynamic casting has possibly upcasted the type
992 in the hiearchy. In this case outer type is less
993 informative than inner type and we should forget
996 && !contains_type_p (outer_type
, offset
,
998 || !contains_polymorphic_type_p (outer_type
))
1002 *instance
= base_pointer
;
1008 /* If the function is constructor or destructor, then
1009 the type is possibly in construction, but we know
1010 it is not derived type. */
1011 if (DECL_CXX_CONSTRUCTOR_P (fndecl
)
1012 || DECL_CXX_DESTRUCTOR_P (fndecl
))
1014 maybe_in_construction
= true;
1015 maybe_derived_type
= false;
1019 maybe_derived_type
= true;
1020 maybe_in_construction
= false;
1023 *instance
= base_pointer
;
1026 /* Non-PODs passed by value are really passed by invisible
1027 reference. In this case we also know the type of the
1029 if (DECL_BY_REFERENCE (SSA_NAME_VAR (base_pointer
)))
1032 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (base_pointer
)));
1033 /* Only type inconsistent programs can have otr_type that is
1034 not part of outer type. */
1035 if (otr_type
&& !contains_type_p (outer_type
, offset
,
1040 *instance
= base_pointer
;
1043 /* Non-polymorphic types have no interest for us. */
1044 else if (!otr_type
&& !contains_polymorphic_type_p (outer_type
))
1048 *instance
= base_pointer
;
1051 maybe_derived_type
= false;
1052 maybe_in_construction
= false;
1054 *instance
= base_pointer
;
1059 tree base_type
= TREE_TYPE (base_pointer
);
1061 if (TREE_CODE (base_pointer
) == SSA_NAME
1062 && SSA_NAME_IS_DEFAULT_DEF (base_pointer
)
1063 && !(TREE_CODE (SSA_NAME_VAR (base_pointer
)) == PARM_DECL
1064 || TREE_CODE (SSA_NAME_VAR (base_pointer
)) == RESULT_DECL
))
1068 *instance
= base_pointer
;
1071 if (TREE_CODE (base_pointer
) == SSA_NAME
1072 && SSA_NAME_DEF_STMT (base_pointer
)
1073 && gimple_assign_single_p (SSA_NAME_DEF_STMT (base_pointer
)))
1074 base_type
= TREE_TYPE (gimple_assign_rhs1
1075 (SSA_NAME_DEF_STMT (base_pointer
)));
1077 if (base_type
&& POINTER_TYPE_P (base_type
))
1078 combine_speculation_with (TYPE_MAIN_VARIANT (TREE_TYPE (base_type
)),
1080 true, NULL
/* Do not change type here */);
1081 /* TODO: There are multiple ways to derive a type. For instance
1082 if BASE_POINTER is passed to an constructor call prior our refernece.
1083 We do not make this type of flow sensitive analysis yet. */
1085 *instance
= base_pointer
;
1089 /* Structure to be passed in between detect_type_change and
1090 check_stmt_for_type_change. */
1092 struct type_change_info
1094 /* Offset into the object where there is the virtual method pointer we are
1096 HOST_WIDE_INT offset
;
1097 /* The declaration or SSA_NAME pointer of the base that we are checking for
1100 /* The reference to virtual table pointer used. */
1103 /* If we actually can tell the type that the object has changed to, it is
1104 stored in this field. Otherwise it remains NULL_TREE. */
1105 tree known_current_type
;
1106 HOST_WIDE_INT known_current_offset
;
1108 /* Set to true if dynamic type change has been detected. */
1109 bool type_maybe_changed
;
1110 /* Set to true if multiple types have been encountered. known_current_type
1111 must be disregarded in that case. */
1112 bool multiple_types_encountered
;
1113 /* Set to true if we possibly missed some dynamic type changes and we should
1114 consider the set to be speculative. */
1116 bool seen_unanalyzed_store
;
1119 /* Return true if STMT is not call and can modify a virtual method table pointer.
1120 We take advantage of fact that vtable stores must appear within constructor
1121 and destructor functions. */
1124 noncall_stmt_may_be_vtbl_ptr_store (gimple
*stmt
)
1126 if (is_gimple_assign (stmt
))
1128 tree lhs
= gimple_assign_lhs (stmt
);
1130 if (gimple_clobber_p (stmt
))
1132 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs
)))
1134 if (flag_strict_aliasing
1135 && !POINTER_TYPE_P (TREE_TYPE (lhs
)))
1138 if (TREE_CODE (lhs
) == COMPONENT_REF
1139 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
1141 /* In the future we might want to use get_base_ref_and_offset to find
1142 if there is a field corresponding to the offset and if so, proceed
1143 almost like if it was a component ref. */
1147 /* Code unification may mess with inline stacks. */
1148 if (cfun
->after_inlining
)
1151 /* Walk the inline stack and watch out for ctors/dtors.
1152 TODO: Maybe we can require the store to appear in toplevel
1153 block of CTOR/DTOR. */
1154 for (tree block
= gimple_block (stmt
); block
&& TREE_CODE (block
) == BLOCK
;
1155 block
= BLOCK_SUPERCONTEXT (block
))
1156 if (BLOCK_ABSTRACT_ORIGIN (block
)
1157 && TREE_CODE (BLOCK_ABSTRACT_ORIGIN (block
)) == FUNCTION_DECL
)
1158 return inlined_polymorphic_ctor_dtor_block_p (block
, false);
1159 return (TREE_CODE (TREE_TYPE (current_function_decl
)) == METHOD_TYPE
1160 && (DECL_CXX_CONSTRUCTOR_P (current_function_decl
)
1161 || DECL_CXX_DESTRUCTOR_P (current_function_decl
)));
1164 /* If STMT can be proved to be an assignment to the virtual method table
1165 pointer of ANALYZED_OBJ and the type associated with the new table
1166 identified, return the type. Otherwise return NULL_TREE if type changes
1167 in unknown way or ERROR_MARK_NODE if type is unchanged. */
1170 extr_type_from_vtbl_ptr_store (gimple
*stmt
, struct type_change_info
*tci
,
1171 HOST_WIDE_INT
*type_offset
)
1173 HOST_WIDE_INT offset
, size
, max_size
;
1174 tree lhs
, rhs
, base
;
1176 if (!gimple_assign_single_p (stmt
))
1179 lhs
= gimple_assign_lhs (stmt
);
1180 rhs
= gimple_assign_rhs1 (stmt
);
1181 if (TREE_CODE (lhs
) != COMPONENT_REF
1182 || !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
1185 fprintf (dump_file
, " LHS is not virtual table.\n");
1189 if (tci
->vtbl_ptr_ref
&& operand_equal_p (lhs
, tci
->vtbl_ptr_ref
, 0))
1193 base
= get_ref_base_and_extent (lhs
, &offset
, &size
, &max_size
);
1194 if (DECL_P (tci
->instance
))
1196 if (base
!= tci
->instance
)
1200 fprintf (dump_file
, " base:");
1201 print_generic_expr (dump_file
, base
, TDF_SLIM
);
1202 fprintf (dump_file
, " does not match instance:");
1203 print_generic_expr (dump_file
, tci
->instance
, TDF_SLIM
);
1204 fprintf (dump_file
, "\n");
1209 else if (TREE_CODE (base
) == MEM_REF
)
1211 if (!operand_equal_p (tci
->instance
, TREE_OPERAND (base
, 0), 0))
1215 fprintf (dump_file
, " base mem ref:");
1216 print_generic_expr (dump_file
, base
, TDF_SLIM
);
1217 fprintf (dump_file
, " does not match instance:");
1218 print_generic_expr (dump_file
, tci
->instance
, TDF_SLIM
);
1219 fprintf (dump_file
, "\n");
1223 if (!integer_zerop (TREE_OPERAND (base
, 1)))
1225 if (!tree_fits_shwi_p (TREE_OPERAND (base
, 1)))
1229 fprintf (dump_file
, " base mem ref:");
1230 print_generic_expr (dump_file
, base
, TDF_SLIM
);
1231 fprintf (dump_file
, " has non-representable offset:");
1232 print_generic_expr (dump_file
, tci
->instance
, TDF_SLIM
);
1233 fprintf (dump_file
, "\n");
1238 offset
+= tree_to_shwi (TREE_OPERAND (base
, 1)) * BITS_PER_UNIT
;
1241 else if (!operand_equal_p (tci
->instance
, base
, 0)
1246 fprintf (dump_file
, " base:");
1247 print_generic_expr (dump_file
, base
, TDF_SLIM
);
1248 fprintf (dump_file
, " does not match instance:");
1249 print_generic_expr (dump_file
, tci
->instance
, TDF_SLIM
);
1250 fprintf (dump_file
, " with offset %i\n", (int)tci
->offset
);
1252 return tci
->offset
> POINTER_SIZE
? error_mark_node
: NULL_TREE
;
1254 if (offset
!= tci
->offset
1255 || size
!= POINTER_SIZE
1256 || max_size
!= POINTER_SIZE
)
1259 fprintf (dump_file
, " wrong offset %i!=%i or size %i\n",
1260 (int)offset
, (int)tci
->offset
, (int)size
);
1261 return offset
+ POINTER_SIZE
<= tci
->offset
1263 && tci
->offset
+ POINTER_SIZE
> offset
+ max_size
)
1264 ? error_mark_node
: NULL
;
1269 unsigned HOST_WIDE_INT offset2
;
1271 if (!vtable_pointer_value_to_vtable (rhs
, &vtable
, &offset2
))
1274 fprintf (dump_file
, " Failed to lookup binfo\n");
1278 tree binfo
= subbinfo_with_vtable_at_offset (TYPE_BINFO (DECL_CONTEXT (vtable
)),
1283 fprintf (dump_file
, " Construction vtable used\n");
1284 /* FIXME: We should suport construction contexts. */
1288 *type_offset
= tree_to_shwi (BINFO_OFFSET (binfo
)) * BITS_PER_UNIT
;
1289 return DECL_CONTEXT (vtable
);
1292 /* Record dynamic type change of TCI to TYPE. */
1295 record_known_type (struct type_change_info
*tci
, tree type
, HOST_WIDE_INT offset
)
1301 fprintf (dump_file
, " Recording type: ");
1302 print_generic_expr (dump_file
, type
, TDF_SLIM
);
1303 fprintf (dump_file
, " at offset %i\n", (int)offset
);
1306 fprintf (dump_file
, " Recording unknown type\n");
1309 /* If we found a constructor of type that is not polymorphic or
1310 that may contain the type in question as a field (not as base),
1311 restrict to the inner class first to make type matching bellow
1315 || (TREE_CODE (type
) != RECORD_TYPE
1316 || !TYPE_BINFO (type
)
1317 || !polymorphic_type_binfo_p (TYPE_BINFO (type
)))))
1319 ipa_polymorphic_call_context context
;
1321 context
.offset
= offset
;
1322 context
.outer_type
= type
;
1323 context
.maybe_in_construction
= false;
1324 context
.maybe_derived_type
= false;
1325 context
.dynamic
= true;
1326 /* If we failed to find the inner type, we know that the call
1327 would be undefined for type produced here. */
1328 if (!context
.restrict_to_inner_class (tci
->otr_type
))
1331 fprintf (dump_file
, " Ignoring; does not contain otr_type\n");
1334 /* Watch for case we reached an POD type and anticipate placement
1336 if (!context
.maybe_derived_type
)
1338 type
= context
.outer_type
;
1339 offset
= context
.offset
;
1342 if (tci
->type_maybe_changed
1343 && (!types_same_for_odr (type
, tci
->known_current_type
)
1344 || offset
!= tci
->known_current_offset
))
1345 tci
->multiple_types_encountered
= true;
1346 tci
->known_current_type
= TYPE_MAIN_VARIANT (type
);
1347 tci
->known_current_offset
= offset
;
1348 tci
->type_maybe_changed
= true;
1351 /* Callback of walk_aliased_vdefs and a helper function for
1352 detect_type_change to check whether a particular statement may modify
1353 the virtual table pointer, and if possible also determine the new type of
1354 the (sub-)object. It stores its result into DATA, which points to a
1355 type_change_info structure. */
1358 check_stmt_for_type_change (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef
, void *data
)
1360 gimple
*stmt
= SSA_NAME_DEF_STMT (vdef
);
1361 struct type_change_info
*tci
= (struct type_change_info
*) data
;
1364 /* If we already gave up, just terminate the rest of walk. */
1365 if (tci
->multiple_types_encountered
)
1368 if (is_gimple_call (stmt
))
1370 if (gimple_call_flags (stmt
) & (ECF_CONST
| ECF_PURE
))
1373 /* Check for a constructor call. */
1374 if ((fn
= gimple_call_fndecl (stmt
)) != NULL_TREE
1375 && DECL_CXX_CONSTRUCTOR_P (fn
)
1376 && TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
1377 && gimple_call_num_args (stmt
))
1379 tree op
= walk_ssa_copies (gimple_call_arg (stmt
, 0));
1380 tree type
= TYPE_METHOD_BASETYPE (TREE_TYPE (fn
));
1381 HOST_WIDE_INT offset
= 0, size
, max_size
;
1385 fprintf (dump_file
, " Checking constructor call: ");
1386 print_gimple_stmt (dump_file
, stmt
, 0, 0);
1389 /* See if THIS parameter seems like instance pointer. */
1390 if (TREE_CODE (op
) == ADDR_EXPR
)
1392 op
= get_ref_base_and_extent (TREE_OPERAND (op
, 0),
1393 &offset
, &size
, &max_size
);
1394 if (size
!= max_size
|| max_size
== -1)
1396 tci
->speculative
= true;
1399 if (op
&& TREE_CODE (op
) == MEM_REF
)
1401 if (!tree_fits_shwi_p (TREE_OPERAND (op
, 1)))
1403 tci
->speculative
= true;
1406 offset
+= tree_to_shwi (TREE_OPERAND (op
, 1))
1408 op
= TREE_OPERAND (op
, 0);
1410 else if (DECL_P (op
))
1414 tci
->speculative
= true;
1417 op
= walk_ssa_copies (op
);
1419 if (operand_equal_p (op
, tci
->instance
, 0)
1421 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
1422 && tree_fits_shwi_p (TYPE_SIZE (type
))
1423 && tree_to_shwi (TYPE_SIZE (type
)) + offset
> tci
->offset
1424 /* Some inlined constructors may look as follows:
1425 _3 = operator new (16);
1426 MEM[(struct &)_3] ={v} {CLOBBER};
1427 MEM[(struct CompositeClass *)_3]._vptr.CompositeClass
1428 = &MEM[(void *)&_ZTV14CompositeClass + 16B];
1429 _7 = &MEM[(struct CompositeClass *)_3].object;
1430 EmptyClass::EmptyClass (_7);
1432 When determining dynamic type of _3 and because we stop at first
1433 dynamic type found, we would stop on EmptyClass::EmptyClass (_7).
1434 In this case the emptyclass is not even polymorphic and we miss
1435 it is contained in an outer type that is polymorphic. */
1437 && (tci
->offset
== offset
|| contains_polymorphic_type_p (type
)))
1439 record_known_type (tci
, type
, tci
->offset
- offset
);
1443 /* Calls may possibly change dynamic type by placement new. Assume
1444 it will not happen, but make result speculative only. */
1447 fprintf (dump_file
, " Function call may change dynamic type:");
1448 print_gimple_stmt (dump_file
, stmt
, 0, 0);
1450 tci
->speculative
= true;
1453 /* Check for inlined virtual table store. */
1454 else if (noncall_stmt_may_be_vtbl_ptr_store (stmt
))
1457 HOST_WIDE_INT offset
= 0;
1460 fprintf (dump_file
, " Checking vtbl store: ");
1461 print_gimple_stmt (dump_file
, stmt
, 0, 0);
1464 type
= extr_type_from_vtbl_ptr_store (stmt
, tci
, &offset
);
1465 if (type
== error_mark_node
)
1467 gcc_assert (!type
|| TYPE_MAIN_VARIANT (type
) == type
);
1471 fprintf (dump_file
, " Unanalyzed store may change type.\n");
1472 tci
->seen_unanalyzed_store
= true;
1473 tci
->speculative
= true;
1476 record_known_type (tci
, type
, offset
);
1483 /* THIS is polymorphic call context obtained from get_polymorphic_context.
1484 OTR_OBJECT is pointer to the instance returned by OBJ_TYPE_REF_OBJECT.
1485 INSTANCE is pointer to the outer instance as returned by
1486 get_polymorphic_context. To avoid creation of temporary expressions,
1487 INSTANCE may also be an declaration of get_polymorphic_context found the
1488 value to be in static storage.
1490 If the type of instance is not fully determined
1491 (either OUTER_TYPE is unknown or MAYBE_IN_CONSTRUCTION/INCLUDE_DERIVED_TYPES
1492 is set), try to walk memory writes and find the actual construction of the
1495 Return true if memory is unchanged from function entry.
1497 We do not include this analysis in the context analysis itself, because
1498 it needs memory SSA to be fully built and the walk may be expensive.
1499 So it is not suitable for use withing fold_stmt and similar uses. */
1502 ipa_polymorphic_call_context::get_dynamic_type (tree instance
,
1507 struct type_change_info tci
;
1509 bool function_entry_reached
= false;
1510 tree instance_ref
= NULL
;
1511 gimple
*stmt
= call
;
1512 /* Remember OFFSET before it is modified by restrict_to_inner_class.
1513 This is because we do not update INSTANCE when walking inwards. */
1514 HOST_WIDE_INT instance_offset
= offset
;
1517 otr_type
= TYPE_MAIN_VARIANT (otr_type
);
1519 /* Walk into inner type. This may clear maybe_derived_type and save us
1520 from useless work. It also makes later comparsions with static type
1522 if (outer_type
&& otr_type
)
1524 if (!restrict_to_inner_class (otr_type
))
1528 if (!maybe_in_construction
&& !maybe_derived_type
)
1531 /* We need to obtain refernce to virtual table pointer. It is better
1532 to look it up in the code rather than build our own. This require bit
1533 of pattern matching, but we end up verifying that what we found is
1536 What we pattern match is:
1538 tmp = instance->_vptr.A; // vtbl ptr load
1539 tmp2 = tmp[otr_token]; // vtable lookup
1540 OBJ_TYPE_REF(tmp2;instance->0) (instance);
1542 We want to start alias oracle walk from vtbl pointer load,
1543 but we may not be able to identify it, for example, when PRE moved the
1546 if (gimple_code (call
) == GIMPLE_CALL
)
1548 tree ref
= gimple_call_fn (call
);
1549 HOST_WIDE_INT offset2
, size
, max_size
;
1551 if (TREE_CODE (ref
) == OBJ_TYPE_REF
)
1553 ref
= OBJ_TYPE_REF_EXPR (ref
);
1554 ref
= walk_ssa_copies (ref
);
1556 /* If call target is already known, no need to do the expensive
1558 if (is_gimple_min_invariant (ref
))
1561 /* Check if definition looks like vtable lookup. */
1562 if (TREE_CODE (ref
) == SSA_NAME
1563 && !SSA_NAME_IS_DEFAULT_DEF (ref
)
1564 && gimple_assign_load_p (SSA_NAME_DEF_STMT (ref
))
1565 && TREE_CODE (gimple_assign_rhs1
1566 (SSA_NAME_DEF_STMT (ref
))) == MEM_REF
)
1568 ref
= get_base_address
1569 (TREE_OPERAND (gimple_assign_rhs1
1570 (SSA_NAME_DEF_STMT (ref
)), 0));
1571 ref
= walk_ssa_copies (ref
);
1572 /* Find base address of the lookup and see if it looks like
1574 if (TREE_CODE (ref
) == SSA_NAME
1575 && !SSA_NAME_IS_DEFAULT_DEF (ref
)
1576 && gimple_assign_load_p (SSA_NAME_DEF_STMT (ref
)))
1578 tree ref_exp
= gimple_assign_rhs1 (SSA_NAME_DEF_STMT (ref
));
1579 tree base_ref
= get_ref_base_and_extent
1580 (ref_exp
, &offset2
, &size
, &max_size
);
1582 /* Finally verify that what we found looks like read from
1583 OTR_OBJECT or from INSTANCE with offset OFFSET. */
1585 && ((TREE_CODE (base_ref
) == MEM_REF
1586 && ((offset2
== instance_offset
1587 && TREE_OPERAND (base_ref
, 0) == instance
)
1589 && TREE_OPERAND (base_ref
, 0)
1591 || (DECL_P (instance
) && base_ref
== instance
1592 && offset2
== instance_offset
)))
1594 stmt
= SSA_NAME_DEF_STMT (ref
);
1595 instance_ref
= ref_exp
;
1602 /* If we failed to look up the refernece in code, build our own. */
1605 /* If the statement in question does not use memory, we can't tell
1607 if (!gimple_vuse (stmt
))
1609 ao_ref_init_from_ptr_and_size (&ao
, otr_object
, NULL
);
1612 /* Otherwise use the real reference. */
1613 ao_ref_init (&ao
, instance_ref
);
1615 /* We look for vtbl pointer read. */
1616 ao
.size
= POINTER_SIZE
;
1617 ao
.max_size
= ao
.size
;
1618 /* We are looking for stores to vptr pointer within the instance of
1620 TODO: The vptr pointer type is globally known, we probably should
1621 keep it and do that even when otr_type is unknown. */
1625 = get_alias_set (outer_type
? outer_type
: otr_type
);
1627 = get_alias_set (TREE_TYPE (BINFO_VTABLE (TYPE_BINFO (otr_type
))));
1632 fprintf (dump_file
, "Determining dynamic type for call: ");
1633 print_gimple_stmt (dump_file
, call
, 0, 0);
1634 fprintf (dump_file
, " Starting walk at: ");
1635 print_gimple_stmt (dump_file
, stmt
, 0, 0);
1636 fprintf (dump_file
, " instance pointer: ");
1637 print_generic_expr (dump_file
, otr_object
, TDF_SLIM
);
1638 fprintf (dump_file
, " Outer instance pointer: ");
1639 print_generic_expr (dump_file
, instance
, TDF_SLIM
);
1640 fprintf (dump_file
, " offset: %i (bits)", (int)offset
);
1641 fprintf (dump_file
, " vtbl reference: ");
1642 print_generic_expr (dump_file
, instance_ref
, TDF_SLIM
);
1643 fprintf (dump_file
, "\n");
1646 tci
.offset
= offset
;
1647 tci
.instance
= instance
;
1648 tci
.vtbl_ptr_ref
= instance_ref
;
1649 gcc_assert (TREE_CODE (instance
) != MEM_REF
);
1650 tci
.known_current_type
= NULL_TREE
;
1651 tci
.known_current_offset
= 0;
1652 tci
.otr_type
= otr_type
;
1653 tci
.type_maybe_changed
= false;
1654 tci
.multiple_types_encountered
= false;
1655 tci
.speculative
= false;
1656 tci
.seen_unanalyzed_store
= false;
1658 walk_aliased_vdefs (&ao
, gimple_vuse (stmt
), check_stmt_for_type_change
,
1659 &tci
, NULL
, &function_entry_reached
);
1661 /* If we did not find any type changing statements, we may still drop
1662 maybe_in_construction flag if the context already have outer type.
1664 Here we make special assumptions about both constructors and
1665 destructors which are all the functions that are allowed to alter the
1666 VMT pointers. It assumes that destructors begin with assignment into
1667 all VMT pointers and that constructors essentially look in the
1670 1) The very first thing they do is that they call constructors of
1671 ancestor sub-objects that have them.
1673 2) Then VMT pointers of this and all its ancestors is set to new
1674 values corresponding to the type corresponding to the constructor.
1676 3) Only afterwards, other stuff such as constructor of member
1677 sub-objects and the code written by the user is run. Only this may
1678 include calling virtual functions, directly or indirectly.
1680 4) placement new can not be used to change type of non-POD statically
1681 allocated variables.
1683 There is no way to call a constructor of an ancestor sub-object in any
1686 This means that we do not have to care whether constructors get the
1687 correct type information because they will always change it (in fact,
1688 if we define the type to be given by the VMT pointer, it is undefined).
1690 The most important fact to derive from the above is that if, for some
1691 statement in the section 3, we try to detect whether the dynamic type
1692 has changed, we can safely ignore all calls as we examine the function
1693 body backwards until we reach statements in section 2 because these
1694 calls cannot be ancestor constructors or destructors (if the input is
1695 not bogus) and so do not change the dynamic type (this holds true only
1696 for automatically allocated objects but at the moment we devirtualize
1697 only these). We then must detect that statements in section 2 change
1698 the dynamic type and can try to derive the new type. That is enough
1699 and we can stop, we will never see the calls into constructors of
1700 sub-objects in this code.
1702 Therefore if the static outer type was found (outer_type)
1703 we can safely ignore tci.speculative that is set on calls and give up
1704 only if there was dyanmic type store that may affect given variable
1705 (seen_unanalyzed_store) */
1707 if (!tci
.type_maybe_changed
1710 && !tci
.seen_unanalyzed_store
1711 && !tci
.multiple_types_encountered
1712 && offset
== tci
.offset
1713 && types_same_for_odr (tci
.known_current_type
,
1716 if (!outer_type
|| tci
.seen_unanalyzed_store
)
1718 if (maybe_in_construction
)
1719 maybe_in_construction
= false;
1721 fprintf (dump_file
, " No dynamic type change found.\n");
1725 if (tci
.known_current_type
1726 && !function_entry_reached
1727 && !tci
.multiple_types_encountered
)
1729 if (!tci
.speculative
)
1731 outer_type
= TYPE_MAIN_VARIANT (tci
.known_current_type
);
1732 offset
= tci
.known_current_offset
;
1734 maybe_in_construction
= false;
1735 maybe_derived_type
= false;
1737 fprintf (dump_file
, " Determined dynamic type.\n");
1739 else if (!speculative_outer_type
1740 || speculative_maybe_derived_type
)
1742 speculative_outer_type
= TYPE_MAIN_VARIANT (tci
.known_current_type
);
1743 speculative_offset
= tci
.known_current_offset
;
1744 speculative_maybe_derived_type
= false;
1746 fprintf (dump_file
, " Determined speculative dynamic type.\n");
1751 fprintf (dump_file
, " Found multiple types%s%s\n",
1752 function_entry_reached
? " (function entry reached)" : "",
1753 function_entry_reached
? " (multiple types encountered)" : "");
1759 /* See if speculation given by SPEC_OUTER_TYPE, SPEC_OFFSET and SPEC_MAYBE_DERIVED_TYPE
1760 seems consistent (and useful) with what we already have in the non-speculative context. */
1763 ipa_polymorphic_call_context::speculation_consistent_p (tree spec_outer_type
,
1764 HOST_WIDE_INT spec_offset
,
1765 bool spec_maybe_derived_type
,
1766 tree otr_type
) const
1768 if (!flag_devirtualize_speculatively
)
1771 /* Non-polymorphic types are useless for deriving likely polymorphic
1773 if (!spec_outer_type
|| !contains_polymorphic_type_p (spec_outer_type
))
1776 /* If we know nothing, speculation is always good. */
1780 /* Speculation is only useful to avoid derived types.
1781 This is not 100% true for placement new, where the outer context may
1782 turn out to be useless, but ignore these for now. */
1783 if (!maybe_derived_type
)
1786 /* If types agrees, speculation is consistent, but it makes sense only
1787 when it says something new. */
1788 if (types_must_be_same_for_odr (spec_outer_type
, outer_type
))
1789 return maybe_derived_type
&& !spec_maybe_derived_type
;
1791 /* If speculation does not contain the type in question, ignore it. */
1793 && !contains_type_p (spec_outer_type
, spec_offset
, otr_type
, false, true))
1796 /* If outer type already contains speculation as a filed,
1797 it is useless. We already know from OUTER_TYPE
1798 SPEC_TYPE and that it is not in the construction. */
1799 if (contains_type_p (outer_type
, offset
- spec_offset
,
1800 spec_outer_type
, false, false))
1803 /* If speculative outer type is not more specified than outer
1805 We can only decide this safely if we can compare types with OUTER_TYPE.
1807 if ((!in_lto_p
|| odr_type_p (outer_type
))
1808 && !contains_type_p (spec_outer_type
,
1809 spec_offset
- offset
,
1815 /* Improve THIS with speculation described by NEW_OUTER_TYPE, NEW_OFFSET,
1816 NEW_MAYBE_DERIVED_TYPE
1817 If OTR_TYPE is set, assume the context is used with OTR_TYPE. */
1820 ipa_polymorphic_call_context::combine_speculation_with
1821 (tree new_outer_type
, HOST_WIDE_INT new_offset
, bool new_maybe_derived_type
,
1824 if (!new_outer_type
)
1827 /* restrict_to_inner_class may eliminate wrong speculation making our job
1830 restrict_to_inner_class (otr_type
);
1832 if (!speculation_consistent_p (new_outer_type
, new_offset
,
1833 new_maybe_derived_type
, otr_type
))
1836 /* New speculation is a win in case we have no speculation or new
1837 speculation does not consider derivations. */
1838 if (!speculative_outer_type
1839 || (speculative_maybe_derived_type
1840 && !new_maybe_derived_type
))
1842 speculative_outer_type
= new_outer_type
;
1843 speculative_offset
= new_offset
;
1844 speculative_maybe_derived_type
= new_maybe_derived_type
;
1847 else if (types_must_be_same_for_odr (speculative_outer_type
,
1850 if (speculative_offset
!= new_offset
)
1852 /* OK we have two contexts that seems valid but they disagree,
1855 This is not a lattice operation, so we may want to drop it later. */
1856 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1858 "Speculative outer types match, "
1859 "offset mismatch -> invalid speculation\n");
1860 clear_speculation ();
1865 if (speculative_maybe_derived_type
&& !new_maybe_derived_type
)
1867 speculative_maybe_derived_type
= false;
1874 /* Choose type that contains the other. This one either contains the outer
1875 as a field (thus giving exactly one target) or is deeper in the type
1877 else if (speculative_outer_type
1878 && speculative_maybe_derived_type
1879 && (new_offset
> speculative_offset
1880 || (new_offset
== speculative_offset
1881 && contains_type_p (new_outer_type
,
1882 0, speculative_outer_type
, false))))
1884 tree old_outer_type
= speculative_outer_type
;
1885 HOST_WIDE_INT old_offset
= speculative_offset
;
1886 bool old_maybe_derived_type
= speculative_maybe_derived_type
;
1888 speculative_outer_type
= new_outer_type
;
1889 speculative_offset
= new_offset
;
1890 speculative_maybe_derived_type
= new_maybe_derived_type
;
1893 restrict_to_inner_class (otr_type
);
1895 /* If the speculation turned out to make no sense, revert to sensible
1897 if (!speculative_outer_type
)
1899 speculative_outer_type
= old_outer_type
;
1900 speculative_offset
= old_offset
;
1901 speculative_maybe_derived_type
= old_maybe_derived_type
;
1904 return (old_offset
!= speculative_offset
1905 || old_maybe_derived_type
!= speculative_maybe_derived_type
1906 || types_must_be_same_for_odr (speculative_outer_type
,
1912 /* Make speculation less specific so
1913 NEW_OUTER_TYPE, NEW_OFFSET, NEW_MAYBE_DERIVED_TYPE is also included.
1914 If OTR_TYPE is set, assume the context is used with OTR_TYPE. */
1917 ipa_polymorphic_call_context::meet_speculation_with
1918 (tree new_outer_type
, HOST_WIDE_INT new_offset
, bool new_maybe_derived_type
,
1921 if (!new_outer_type
&& speculative_outer_type
)
1923 clear_speculation ();
1927 /* restrict_to_inner_class may eliminate wrong speculation making our job
1930 restrict_to_inner_class (otr_type
);
1932 if (!speculative_outer_type
1933 || !speculation_consistent_p (speculative_outer_type
,
1935 speculative_maybe_derived_type
,
1939 if (!speculation_consistent_p (new_outer_type
, new_offset
,
1940 new_maybe_derived_type
, otr_type
))
1942 clear_speculation ();
1946 else if (types_must_be_same_for_odr (speculative_outer_type
,
1949 if (speculative_offset
!= new_offset
)
1951 clear_speculation ();
1956 if (!speculative_maybe_derived_type
&& new_maybe_derived_type
)
1958 speculative_maybe_derived_type
= true;
1965 /* See if one type contains the other as a field (not base). */
1966 else if (contains_type_p (new_outer_type
, new_offset
- speculative_offset
,
1967 speculative_outer_type
, false, false))
1969 else if (contains_type_p (speculative_outer_type
,
1970 speculative_offset
- new_offset
,
1971 new_outer_type
, false, false))
1973 speculative_outer_type
= new_outer_type
;
1974 speculative_offset
= new_offset
;
1975 speculative_maybe_derived_type
= new_maybe_derived_type
;
1978 /* See if OUTER_TYPE is base of CTX.OUTER_TYPE. */
1979 else if (contains_type_p (new_outer_type
,
1980 new_offset
- speculative_offset
,
1981 speculative_outer_type
, false, true))
1983 if (!speculative_maybe_derived_type
)
1985 speculative_maybe_derived_type
= true;
1990 /* See if CTX.OUTER_TYPE is base of OUTER_TYPE. */
1991 else if (contains_type_p (speculative_outer_type
,
1992 speculative_offset
- new_offset
, new_outer_type
, false, true))
1994 speculative_outer_type
= new_outer_type
;
1995 speculative_offset
= new_offset
;
1996 speculative_maybe_derived_type
= true;
2001 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2002 fprintf (dump_file
, "Giving up on speculative meet\n");
2003 clear_speculation ();
2008 /* Assume that both THIS and a given context is valid and strenghten THIS
2009 if possible. Return true if any strenghtening was made.
2010 If actual type the context is being used in is known, OTR_TYPE should be
2011 set accordingly. This improves quality of combined result. */
2014 ipa_polymorphic_call_context::combine_with (ipa_polymorphic_call_context ctx
,
2017 bool updated
= false;
2019 if (ctx
.useless_p () || invalid
)
2022 /* Restricting context to inner type makes merging easier, however do not
2023 do that unless we know how the context is used (OTR_TYPE is non-NULL) */
2024 if (otr_type
&& !invalid
&& !ctx
.invalid
)
2026 restrict_to_inner_class (otr_type
);
2027 ctx
.restrict_to_inner_class (otr_type
);
2032 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2034 fprintf (dump_file
, "Polymorphic call context combine:");
2036 fprintf (dump_file
, "With context: ");
2037 ctx
.dump (dump_file
);
2040 fprintf (dump_file
, "To be used with type: ");
2041 print_generic_expr (dump_file
, otr_type
, TDF_SLIM
);
2042 fprintf (dump_file
, "\n");
2046 /* If call is known to be invalid, we are done. */
2049 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2050 fprintf (dump_file
, "-> Invalid context\n");
2054 if (!ctx
.outer_type
)
2056 else if (!outer_type
)
2058 outer_type
= ctx
.outer_type
;
2059 offset
= ctx
.offset
;
2060 dynamic
= ctx
.dynamic
;
2061 maybe_in_construction
= ctx
.maybe_in_construction
;
2062 maybe_derived_type
= ctx
.maybe_derived_type
;
2065 /* If types are known to be same, merging is quite easy. */
2066 else if (types_must_be_same_for_odr (outer_type
, ctx
.outer_type
))
2068 if (offset
!= ctx
.offset
2069 && TYPE_SIZE (outer_type
)
2070 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
)
2072 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2073 fprintf (dump_file
, "Outer types match, offset mismatch -> invalid\n");
2074 clear_speculation ();
2075 clear_outer_type ();
2079 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2080 fprintf (dump_file
, "Outer types match, merging flags\n");
2081 if (maybe_in_construction
&& !ctx
.maybe_in_construction
)
2084 maybe_in_construction
= false;
2086 if (maybe_derived_type
&& !ctx
.maybe_derived_type
)
2089 maybe_derived_type
= false;
2091 if (dynamic
&& !ctx
.dynamic
)
2097 /* If we know the type precisely, there is not much to improve. */
2098 else if (!maybe_derived_type
&& !maybe_in_construction
2099 && !ctx
.maybe_derived_type
&& !ctx
.maybe_in_construction
)
2101 /* It may be easy to check if second context permits the first
2102 and set INVALID otherwise. This is not easy to do in general;
2103 contains_type_p may return false negatives for non-comparable
2106 If OTR_TYPE is known, we however can expect that
2107 restrict_to_inner_class should have discovered the same base
2109 if (otr_type
&& !ctx
.maybe_in_construction
&& !ctx
.maybe_derived_type
)
2111 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2112 fprintf (dump_file
, "Contextes disagree -> invalid\n");
2116 /* See if one type contains the other as a field (not base).
2117 In this case we want to choose the wider type, because it contains
2118 more information. */
2119 else if (contains_type_p (ctx
.outer_type
, ctx
.offset
- offset
,
2120 outer_type
, false, false))
2122 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2123 fprintf (dump_file
, "Second type contain the first as a field\n");
2125 if (maybe_derived_type
)
2127 outer_type
= ctx
.outer_type
;
2128 maybe_derived_type
= ctx
.maybe_derived_type
;
2129 offset
= ctx
.offset
;
2130 dynamic
= ctx
.dynamic
;
2134 /* If we do not know how the context is being used, we can
2135 not clear MAYBE_IN_CONSTRUCTION because it may be offseted
2136 to other component of OUTER_TYPE later and we know nothing
2138 if (otr_type
&& maybe_in_construction
2139 && !ctx
.maybe_in_construction
)
2141 maybe_in_construction
= false;
2145 else if (contains_type_p (outer_type
, offset
- ctx
.offset
,
2146 ctx
.outer_type
, false, false))
2148 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2149 fprintf (dump_file
, "First type contain the second as a field\n");
2151 if (otr_type
&& maybe_in_construction
2152 && !ctx
.maybe_in_construction
)
2154 maybe_in_construction
= false;
2158 /* See if OUTER_TYPE is base of CTX.OUTER_TYPE. */
2159 else if (contains_type_p (ctx
.outer_type
,
2160 ctx
.offset
- offset
, outer_type
, false, true))
2162 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2163 fprintf (dump_file
, "First type is base of second\n");
2164 if (!maybe_derived_type
)
2166 if (!ctx
.maybe_in_construction
2167 && types_odr_comparable (outer_type
, ctx
.outer_type
))
2169 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2170 fprintf (dump_file
, "Second context does not permit base -> invalid\n");
2174 /* Pick variant deeper in the hiearchy. */
2177 outer_type
= ctx
.outer_type
;
2178 maybe_in_construction
= ctx
.maybe_in_construction
;
2179 maybe_derived_type
= ctx
.maybe_derived_type
;
2180 offset
= ctx
.offset
;
2181 dynamic
= ctx
.dynamic
;
2185 /* See if CTX.OUTER_TYPE is base of OUTER_TYPE. */
2186 else if (contains_type_p (outer_type
,
2187 offset
- ctx
.offset
, ctx
.outer_type
, false, true))
2189 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2190 fprintf (dump_file
, "Second type is base of first\n");
2191 if (!ctx
.maybe_derived_type
)
2193 if (!maybe_in_construction
2194 && types_odr_comparable (outer_type
, ctx
.outer_type
))
2196 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2197 fprintf (dump_file
, "First context does not permit base -> invalid\n");
2200 /* Pick the base type. */
2201 else if (maybe_in_construction
)
2203 outer_type
= ctx
.outer_type
;
2204 maybe_in_construction
= ctx
.maybe_in_construction
;
2205 maybe_derived_type
= ctx
.maybe_derived_type
;
2206 offset
= ctx
.offset
;
2207 dynamic
= ctx
.dynamic
;
2212 /* TODO handle merging using hiearchy. */
2213 else if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2214 fprintf (dump_file
, "Giving up on merge\n");
2216 updated
|= combine_speculation_with (ctx
.speculative_outer_type
,
2217 ctx
.speculative_offset
,
2218 ctx
.speculative_maybe_derived_type
,
2221 if (updated
&& dump_file
&& (dump_flags
& TDF_DETAILS
))
2223 fprintf (dump_file
, "Updated as: ");
2225 fprintf (dump_file
, "\n");
2231 clear_speculation ();
2232 clear_outer_type ();
2236 /* Take non-speculative info, merge it with speculative and clear speculation.
2237 Used when we no longer manage to keep track of actual outer type, but we
2238 think it is still there.
2240 If OTR_TYPE is set, the transformation can be done more effectively assuming
2241 that context is going to be used only that way. */
2244 ipa_polymorphic_call_context::make_speculative (tree otr_type
)
2246 tree spec_outer_type
= outer_type
;
2247 HOST_WIDE_INT spec_offset
= offset
;
2248 bool spec_maybe_derived_type
= maybe_derived_type
;
2253 clear_outer_type ();
2254 clear_speculation ();
2259 clear_outer_type ();
2260 combine_speculation_with (spec_outer_type
, spec_offset
,
2261 spec_maybe_derived_type
,
2265 /* Use when we can not track dynamic type change. This speculatively assume
2266 type change is not happening. */
2269 ipa_polymorphic_call_context::possible_dynamic_type_change (bool in_poly_cdtor
,
2273 make_speculative (otr_type
);
2274 else if (in_poly_cdtor
)
2275 maybe_in_construction
= true;
2278 /* Return TRUE if this context conveys the same information as OTHER. */
2281 ipa_polymorphic_call_context::equal_to
2282 (const ipa_polymorphic_call_context
&x
) const
2285 return x
.useless_p ();
2288 if (x
.useless_p () || x
.invalid
)
2294 || !types_odr_comparable (outer_type
, x
.outer_type
)
2295 || !types_same_for_odr (outer_type
, x
.outer_type
)
2296 || offset
!= x
.offset
2297 || maybe_in_construction
!= x
.maybe_in_construction
2298 || maybe_derived_type
!= x
.maybe_derived_type
2299 || dynamic
!= x
.dynamic
)
2302 else if (x
.outer_type
)
2306 if (speculative_outer_type
2307 && speculation_consistent_p (speculative_outer_type
, speculative_offset
,
2308 speculative_maybe_derived_type
, NULL_TREE
))
2310 if (!x
.speculative_outer_type
)
2313 if (!types_odr_comparable (speculative_outer_type
,
2314 x
.speculative_outer_type
)
2315 || !types_same_for_odr (speculative_outer_type
,
2316 x
.speculative_outer_type
)
2317 || speculative_offset
!= x
.speculative_offset
2318 || speculative_maybe_derived_type
!= x
.speculative_maybe_derived_type
)
2321 else if (x
.speculative_outer_type
2322 && x
.speculation_consistent_p (x
.speculative_outer_type
,
2323 x
.speculative_offset
,
2324 x
.speculative_maybe_derived_type
,
2331 /* Modify context to be strictly less restrictive than CTX. */
2334 ipa_polymorphic_call_context::meet_with (ipa_polymorphic_call_context ctx
,
2337 bool updated
= false;
2339 if (useless_p () || ctx
.invalid
)
2342 /* Restricting context to inner type makes merging easier, however do not
2343 do that unless we know how the context is used (OTR_TYPE is non-NULL) */
2344 if (otr_type
&& !useless_p () && !ctx
.useless_p ())
2346 restrict_to_inner_class (otr_type
);
2347 ctx
.restrict_to_inner_class (otr_type
);
2355 if (ctx
.useless_p () || invalid
)
2361 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2363 fprintf (dump_file
, "Polymorphic call context meet:");
2365 fprintf (dump_file
, "With context: ");
2366 ctx
.dump (dump_file
);
2369 fprintf (dump_file
, "To be used with type: ");
2370 print_generic_expr (dump_file
, otr_type
, TDF_SLIM
);
2371 fprintf (dump_file
, "\n");
2375 if (!dynamic
&& ctx
.dynamic
)
2381 /* If call is known to be invalid, we are done. */
2384 else if (!ctx
.outer_type
)
2386 clear_outer_type ();
2389 /* If types are known to be same, merging is quite easy. */
2390 else if (types_must_be_same_for_odr (outer_type
, ctx
.outer_type
))
2392 if (offset
!= ctx
.offset
2393 && TYPE_SIZE (outer_type
)
2394 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
)
2396 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2397 fprintf (dump_file
, "Outer types match, offset mismatch -> clearing\n");
2398 clear_outer_type ();
2401 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2402 fprintf (dump_file
, "Outer types match, merging flags\n");
2403 if (!maybe_in_construction
&& ctx
.maybe_in_construction
)
2406 maybe_in_construction
= true;
2408 if (!maybe_derived_type
&& ctx
.maybe_derived_type
)
2411 maybe_derived_type
= true;
2413 if (!dynamic
&& ctx
.dynamic
)
2419 /* See if one type contains the other as a field (not base). */
2420 else if (contains_type_p (ctx
.outer_type
, ctx
.offset
- offset
,
2421 outer_type
, false, false))
2423 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2424 fprintf (dump_file
, "Second type contain the first as a field\n");
2426 /* The second type is more specified, so we keep the first.
2427 We need to set DYNAMIC flag to avoid declaring context INVALID
2428 of OFFSET ends up being out of range. */
2432 && (!TYPE_SIZE (ctx
.outer_type
)
2433 || !TYPE_SIZE (outer_type
)
2434 || !operand_equal_p (TYPE_SIZE (ctx
.outer_type
),
2435 TYPE_SIZE (outer_type
), 0)))))
2441 else if (contains_type_p (outer_type
, offset
- ctx
.offset
,
2442 ctx
.outer_type
, false, false))
2444 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2445 fprintf (dump_file
, "First type contain the second as a field\n");
2450 && (!TYPE_SIZE (ctx
.outer_type
)
2451 || !TYPE_SIZE (outer_type
)
2452 || !operand_equal_p (TYPE_SIZE (ctx
.outer_type
),
2453 TYPE_SIZE (outer_type
), 0)))))
2455 outer_type
= ctx
.outer_type
;
2456 offset
= ctx
.offset
;
2457 dynamic
= ctx
.dynamic
;
2458 maybe_in_construction
= ctx
.maybe_in_construction
;
2459 maybe_derived_type
= ctx
.maybe_derived_type
;
2462 /* See if OUTER_TYPE is base of CTX.OUTER_TYPE. */
2463 else if (contains_type_p (ctx
.outer_type
,
2464 ctx
.offset
- offset
, outer_type
, false, true))
2466 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2467 fprintf (dump_file
, "First type is base of second\n");
2468 if (!maybe_derived_type
)
2470 maybe_derived_type
= true;
2473 if (!maybe_in_construction
&& ctx
.maybe_in_construction
)
2475 maybe_in_construction
= true;
2478 if (!dynamic
&& ctx
.dynamic
)
2484 /* See if CTX.OUTER_TYPE is base of OUTER_TYPE. */
2485 else if (contains_type_p (outer_type
,
2486 offset
- ctx
.offset
, ctx
.outer_type
, false, true))
2488 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2489 fprintf (dump_file
, "Second type is base of first\n");
2490 outer_type
= ctx
.outer_type
;
2491 offset
= ctx
.offset
;
2493 if (!maybe_derived_type
)
2494 maybe_derived_type
= true;
2495 if (!maybe_in_construction
&& ctx
.maybe_in_construction
)
2496 maybe_in_construction
= true;
2497 if (!dynamic
&& ctx
.dynamic
)
2500 /* TODO handle merging using hiearchy. */
2503 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2504 fprintf (dump_file
, "Giving up on meet\n");
2505 clear_outer_type ();
2509 updated
|= meet_speculation_with (ctx
.speculative_outer_type
,
2510 ctx
.speculative_offset
,
2511 ctx
.speculative_maybe_derived_type
,
2514 if (updated
&& dump_file
&& (dump_flags
& TDF_DETAILS
))
2516 fprintf (dump_file
, "Updated as: ");
2518 fprintf (dump_file
, "\n");