1 /* Analysis of polymorphic call context.
2 Copyright (C) 2013-2014 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"
26 #include "print-tree.h"
29 #include "tree-pass.h"
32 #include "hash-table.h"
34 #include "tree-pretty-print.h"
36 #include "basic-block.h"
39 #include "plugin-api.h"
43 #include "hard-reg-set.h"
48 #include "ipa-utils.h"
49 #include "tree-ssa-alias.h"
50 #include "internal-fn.h"
51 #include "gimple-fold.h"
52 #include "gimple-expr.h"
54 #include "alloc-pool.h"
56 #include "ipa-inline.h"
57 #include "diagnostic.h"
61 #include "gimple-pretty-print.h"
62 #include "stor-layout.h"
64 #include "data-streamer.h"
65 #include "lto-streamer.h"
66 #include "streamer-hooks.h"
68 /* Return true when TYPE contains an polymorphic type and thus is interesting
69 for devirtualization machinery. */
71 static bool contains_type_p (tree
, HOST_WIDE_INT
, tree
,
72 bool consider_placement_new
= true,
73 bool consider_bases
= true);
76 contains_polymorphic_type_p (const_tree type
)
78 type
= TYPE_MAIN_VARIANT (type
);
80 if (RECORD_OR_UNION_TYPE_P (type
))
83 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
85 for (tree fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
86 if (TREE_CODE (fld
) == FIELD_DECL
87 && !DECL_ARTIFICIAL (fld
)
88 && contains_polymorphic_type_p (TREE_TYPE (fld
)))
92 if (TREE_CODE (type
) == ARRAY_TYPE
)
93 return contains_polymorphic_type_p (TREE_TYPE (type
));
97 /* Return true if it seems valid to use placement new to build EXPECTED_TYPE
98 at possition CUR_OFFSET within TYPE.
100 POD can be changed to an instance of a polymorphic type by
101 placement new. Here we play safe and assume that any
102 non-polymorphic type is POD. */
104 possible_placement_new (tree type
, tree expected_type
,
105 HOST_WIDE_INT cur_offset
)
107 return ((TREE_CODE (type
) != RECORD_TYPE
108 || !TYPE_BINFO (type
)
109 || cur_offset
>= POINTER_SIZE
110 || !polymorphic_type_binfo_p (TYPE_BINFO (type
)))
111 && (!TYPE_SIZE (type
)
112 || !tree_fits_shwi_p (TYPE_SIZE (type
))
114 + (expected_type
? tree_to_uhwi (TYPE_SIZE (expected_type
))
115 : GET_MODE_BITSIZE (Pmode
))
116 <= tree_to_uhwi (TYPE_SIZE (type
)))));
119 /* THIS->OUTER_TYPE is a type of memory object where object of OTR_TYPE
120 is contained at THIS->OFFSET. Walk the memory representation of
121 THIS->OUTER_TYPE and find the outermost class type that match
122 OTR_TYPE or contain OTR_TYPE as a base. Update THIS
125 If OTR_TYPE is NULL, just find outermost polymorphic type with
126 virtual table present at possition OFFSET.
128 For example when THIS represents type
134 and we look for type at offset sizeof(int), we end up with B and offset 0.
135 If the same is produced by multiple inheritance, we end up with A and offset
138 If we can not find corresponding class, give up by setting
139 THIS->OUTER_TYPE to OTR_TYPE and THIS->OFFSET to NULL.
140 Return true when lookup was sucesful.
142 When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made
143 valid only via alocation of new polymorphic type inside by means
146 When CONSIDER_BASES is false, only look for actual fields, not base types
150 ipa_polymorphic_call_context::restrict_to_inner_class (tree otr_type
,
151 bool consider_placement_new
,
154 tree type
= outer_type
;
155 HOST_WIDE_INT cur_offset
= offset
;
156 bool speculative
= false;
157 bool size_unknown
= false;
158 unsigned HOST_WIDE_INT otr_type_size
= GET_MODE_BITSIZE (Pmode
);
160 /* Update OUTER_TYPE to match EXPECTED_TYPE if it is not set. */
163 clear_outer_type (otr_type
);
167 /* See if OFFSET points inside OUTER_TYPE. If it does not, we know
168 that the context is either invalid, or the instance type must be
169 derived from OUTER_TYPE.
171 Because the instance type may contain field whose type is of OUTER_TYPE,
172 we can not derive any effective information about it.
174 TODO: In the case we know all derrived types, we can definitely do better
176 else if (TYPE_SIZE (outer_type
)
177 && tree_fits_shwi_p (TYPE_SIZE (outer_type
))
178 && tree_to_shwi (TYPE_SIZE (outer_type
)) >= 0
179 && tree_to_shwi (TYPE_SIZE (outer_type
)) <= offset
)
181 clear_outer_type (otr_type
);
185 /* If derived type is not allowed, we know that the context is invalid.
186 For dynamic types, we really do not have information about
187 size of the memory location. It is possible that completely
188 different type is stored after outer_type. */
189 if (!maybe_derived_type
&& !dynamic
)
191 clear_speculation ();
197 if (otr_type
&& TYPE_SIZE (otr_type
)
198 && tree_fits_shwi_p (TYPE_SIZE (otr_type
)))
199 otr_type_size
= tree_to_uhwi (TYPE_SIZE (otr_type
));
201 if (!type
|| offset
< 0)
202 goto no_useful_type_info
;
204 /* Find the sub-object the constant actually refers to and mark whether it is
205 an artificial one (as opposed to a user-defined one).
207 This loop is performed twice; first time for outer_type and second time
208 for speculative_outer_type. The second run has SPECULATIVE set. */
211 unsigned HOST_WIDE_INT pos
, size
;
214 /* If we do not know size of TYPE, we need to be more conservative
215 about accepting cases where we can not find EXPECTED_TYPE.
216 Generally the types that do matter here are of constant size.
217 Size_unknown case should be very rare. */
219 && tree_fits_shwi_p (TYPE_SIZE (type
))
220 && tree_to_shwi (TYPE_SIZE (type
)) >= 0)
221 size_unknown
= false;
225 /* On a match, just return what we found. */
227 && types_odr_comparable (type
, otr_type
)
228 && types_same_for_odr (type
, otr_type
))
230 && TREE_CODE (type
) == RECORD_TYPE
232 && polymorphic_type_binfo_p (TYPE_BINFO (type
))))
236 /* If we did not match the offset, just give up on speculation. */
238 /* Also check if speculation did not end up being same as
240 || (types_must_be_same_for_odr (speculative_outer_type
,
242 && (maybe_derived_type
243 == speculative_maybe_derived_type
)))
244 clear_speculation ();
249 /* If type is known to be final, do not worry about derived
250 types. Testing it here may help us to avoid speculation. */
251 if (otr_type
&& TREE_CODE (outer_type
) == RECORD_TYPE
252 && (!in_lto_p
|| odr_type_p (outer_type
))
253 && type_known_to_have_no_deriavations_p (outer_type
))
254 maybe_derived_type
= false;
256 /* Type can not contain itself on an non-zero offset. In that case
257 just give up. Still accept the case where size is now known.
258 Either the second copy may appear past the end of type or within
259 the non-POD buffer located inside the variably sized type
262 goto no_useful_type_info
;
263 /* If we determined type precisely or we have no clue on
264 speuclation, we are done. */
265 if (!maybe_derived_type
|| !speculative_outer_type
266 || !speculation_consistent_p (speculative_outer_type
,
268 speculative_maybe_derived_type
,
271 clear_speculation ();
274 /* Otherwise look into speculation now. */
278 type
= speculative_outer_type
;
279 cur_offset
= speculative_offset
;
285 /* Walk fields and find corresponding on at OFFSET. */
286 if (TREE_CODE (type
) == RECORD_TYPE
)
288 for (fld
= TYPE_FIELDS (type
); fld
; fld
= DECL_CHAIN (fld
))
290 if (TREE_CODE (fld
) != FIELD_DECL
)
293 pos
= int_bit_position (fld
);
294 if (pos
> (unsigned HOST_WIDE_INT
)cur_offset
)
297 /* Do not consider vptr itself. Not even for placement new. */
298 if (!pos
&& DECL_ARTIFICIAL (fld
)
299 && POINTER_TYPE_P (TREE_TYPE (fld
))
301 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
304 if (!DECL_SIZE (fld
) || !tree_fits_uhwi_p (DECL_SIZE (fld
)))
305 goto no_useful_type_info
;
306 size
= tree_to_uhwi (DECL_SIZE (fld
));
308 /* We can always skip types smaller than pointer size:
309 those can not contain a virtual table pointer.
311 Disqualifying fields that are too small to fit OTR_TYPE
312 saves work needed to walk them for no benefit.
313 Because of the way the bases are packed into a class, the
314 field's size may be smaller than type size, so it needs
315 to be done with a care. */
317 if (pos
<= (unsigned HOST_WIDE_INT
)cur_offset
318 && (pos
+ size
) >= (unsigned HOST_WIDE_INT
)cur_offset
319 + GET_MODE_BITSIZE (Pmode
)
321 || !TYPE_SIZE (TREE_TYPE (fld
))
322 || !tree_fits_shwi_p (TYPE_SIZE (TREE_TYPE (fld
)))
323 || (pos
+ tree_to_uhwi (TYPE_SIZE (TREE_TYPE (fld
))))
324 >= cur_offset
+ otr_type_size
))
329 goto no_useful_type_info
;
331 type
= TYPE_MAIN_VARIANT (TREE_TYPE (fld
));
333 /* DECL_ARTIFICIAL represents a basetype. */
334 if (!DECL_ARTIFICIAL (fld
))
340 /* As soon as we se an field containing the type,
341 we know we are not looking for derivations. */
342 maybe_derived_type
= false;
346 speculative_outer_type
= type
;
347 speculative_offset
= cur_offset
;
348 speculative_maybe_derived_type
= false;
351 else if (!consider_bases
)
352 goto no_useful_type_info
;
354 else if (TREE_CODE (type
) == ARRAY_TYPE
)
356 tree subtype
= TYPE_MAIN_VARIANT (TREE_TYPE (type
));
358 /* Give up if we don't know array field size.
359 Also give up on non-polymorphic types as they are used
360 as buffers for placement new. */
361 if (!TYPE_SIZE (subtype
)
362 || !tree_fits_shwi_p (TYPE_SIZE (subtype
))
363 || tree_to_shwi (TYPE_SIZE (subtype
)) <= 0
364 || !contains_polymorphic_type_p (subtype
))
365 goto no_useful_type_info
;
367 HOST_WIDE_INT new_offset
= cur_offset
% tree_to_shwi (TYPE_SIZE (subtype
));
369 /* We may see buffer for placement new. In this case the expected type
370 can be bigger than the subtype. */
371 if (TYPE_SIZE (subtype
)
372 && (cur_offset
+ otr_type_size
373 > tree_to_uhwi (TYPE_SIZE (subtype
))))
374 goto no_useful_type_info
;
376 cur_offset
= new_offset
;
382 maybe_derived_type
= false;
386 speculative_outer_type
= type
;
387 speculative_offset
= cur_offset
;
388 speculative_maybe_derived_type
= false;
391 /* Give up on anything else. */
395 if (maybe_derived_type
&& !speculative
396 && TREE_CODE (outer_type
) == RECORD_TYPE
397 && TREE_CODE (otr_type
) == RECORD_TYPE
398 && TYPE_BINFO (otr_type
)
400 && get_binfo_at_offset (TYPE_BINFO (otr_type
), 0, outer_type
))
402 clear_outer_type (otr_type
);
403 if (!speculative_outer_type
404 || !speculation_consistent_p (speculative_outer_type
,
406 speculative_maybe_derived_type
,
408 clear_speculation ();
409 if (speculative_outer_type
)
412 type
= speculative_outer_type
;
413 cur_offset
= speculative_offset
;
418 /* We found no way to embedd EXPECTED_TYPE in TYPE.
419 We still permit two special cases - placement new and
420 the case of variadic types containing themselves. */
422 && consider_placement_new
423 && (size_unknown
|| !type
|| maybe_derived_type
424 || possible_placement_new (type
, otr_type
, cur_offset
)))
426 /* In these weird cases we want to accept the context.
427 In non-speculative run we have no useful outer_type info
428 (TODO: we may eventually want to record upper bound on the
429 type size that can be used to prune the walk),
430 but we still want to consider speculation that may
434 clear_outer_type (otr_type
);
435 if (!speculative_outer_type
436 || !speculation_consistent_p (speculative_outer_type
,
438 speculative_maybe_derived_type
,
440 clear_speculation ();
441 if (speculative_outer_type
)
444 type
= speculative_outer_type
;
445 cur_offset
= speculative_offset
;
451 clear_speculation ();
456 clear_speculation ();
459 clear_outer_type (otr_type
);
467 /* Return true if OUTER_TYPE contains OTR_TYPE at OFFSET.
468 CONSIDER_PLACEMENT_NEW makes function to accept cases where OTR_TYPE can
469 be built within OUTER_TYPE by means of placement new. CONSIDER_BASES makes
470 function to accept cases where OTR_TYPE appears as base of OUTER_TYPE or as
471 base of one of fields of OUTER_TYPE. */
474 contains_type_p (tree outer_type
, HOST_WIDE_INT offset
,
476 bool consider_placement_new
,
479 ipa_polymorphic_call_context context
;
481 /* Check that type is within range. */
484 if (TYPE_SIZE (outer_type
) && TYPE_SIZE (otr_type
)
485 && TREE_CODE (outer_type
) == INTEGER_CST
486 && TREE_CODE (otr_type
) == INTEGER_CST
487 && wi::ltu_p (wi::to_offset (outer_type
), (wi::to_offset (otr_type
) + offset
)))
490 context
.offset
= offset
;
491 context
.outer_type
= TYPE_MAIN_VARIANT (outer_type
);
492 context
.maybe_derived_type
= false;
493 return context
.restrict_to_inner_class (otr_type
, consider_placement_new
, consider_bases
);
497 /* We know that the instance is stored in variable or parameter
498 (not dynamically allocated) and we want to disprove the fact
499 that it may be in construction at invocation of CALL.
501 BASE represents memory location where instance is stored.
502 If BASE is NULL, it is assumed to be global memory.
503 OUTER_TYPE is known type of the instance or NULL if not
506 For the variable to be in construction we actually need to
507 be in constructor of corresponding global variable or
508 the inline stack of CALL must contain the constructor.
509 Check this condition. This check works safely only before
510 IPA passes, because inline stacks may become out of date
514 decl_maybe_in_construction_p (tree base
, tree outer_type
,
515 gimple call
, tree function
)
518 outer_type
= TYPE_MAIN_VARIANT (outer_type
);
519 gcc_assert (!base
|| DECL_P (base
));
521 /* After inlining the code unification optimizations may invalidate
522 inline stacks. Also we need to give up on global variables after
523 IPA, because addresses of these may have been propagated to their
525 if (DECL_STRUCT_FUNCTION (function
)->after_inlining
)
528 /* Pure functions can not do any changes on the dynamic type;
529 that require writting to memory. */
530 if ((!base
|| !auto_var_in_fn_p (base
, function
))
531 && flags_from_decl_or_type (function
) & (ECF_PURE
| ECF_CONST
))
534 for (tree block
= gimple_block (call
); block
&& TREE_CODE (block
) == BLOCK
;
535 block
= BLOCK_SUPERCONTEXT (block
))
536 if (BLOCK_ABSTRACT_ORIGIN (block
)
537 && TREE_CODE (BLOCK_ABSTRACT_ORIGIN (block
)) == FUNCTION_DECL
)
539 tree fn
= BLOCK_ABSTRACT_ORIGIN (block
);
541 if (TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
542 || (!DECL_CXX_CONSTRUCTOR_P (fn
)
543 && !DECL_CXX_DESTRUCTOR_P (fn
)))
545 /* Watch for clones where we constant propagated the first
546 argument (pointer to the instance). */
547 fn
= DECL_ABSTRACT_ORIGIN (fn
);
549 || (base
&& !is_global_var (base
))
550 || TREE_CODE (TREE_TYPE (fn
)) != METHOD_TYPE
551 || (!DECL_CXX_CONSTRUCTOR_P (fn
)
552 && !DECL_CXX_DESTRUCTOR_P (fn
)))
555 if (flags_from_decl_or_type (fn
) & (ECF_PURE
| ECF_CONST
))
558 tree type
= TYPE_MAIN_VARIANT (method_class_type (TREE_TYPE (fn
)));
560 if (!outer_type
|| !types_odr_comparable (type
, outer_type
))
562 if (TREE_CODE (type
) == RECORD_TYPE
564 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
567 else if (types_same_for_odr (type
, outer_type
))
571 if (!base
|| (TREE_CODE (base
) == VAR_DECL
&& is_global_var (base
)))
573 if (TREE_CODE (TREE_TYPE (function
)) != METHOD_TYPE
574 || (!DECL_CXX_CONSTRUCTOR_P (function
)
575 && !DECL_CXX_DESTRUCTOR_P (function
)))
577 if (!DECL_ABSTRACT_ORIGIN (function
))
579 /* Watch for clones where we constant propagated the first
580 argument (pointer to the instance). */
581 function
= DECL_ABSTRACT_ORIGIN (function
);
583 || TREE_CODE (TREE_TYPE (function
)) != METHOD_TYPE
584 || (!DECL_CXX_CONSTRUCTOR_P (function
)
585 && !DECL_CXX_DESTRUCTOR_P (function
)))
588 tree type
= TYPE_MAIN_VARIANT (method_class_type (TREE_TYPE (function
)));
589 if (!outer_type
|| !types_odr_comparable (type
, outer_type
))
591 if (TREE_CODE (type
) == RECORD_TYPE
593 && polymorphic_type_binfo_p (TYPE_BINFO (type
)))
596 else if (types_same_for_odr (type
, outer_type
))
602 /* Dump human readable context to F. If NEWLINE is true, it will be terminated
606 ipa_polymorphic_call_context::dump (FILE *f
, bool newline
) const
610 fprintf (f
, "Call is known to be undefined");
614 fprintf (f
, "nothing known");
615 if (outer_type
|| offset
)
617 fprintf (f
, "Outer type%s:", dynamic
? " (dynamic)":"");
618 print_generic_expr (f
, outer_type
, TDF_SLIM
);
619 if (maybe_derived_type
)
620 fprintf (f
, " (or a derived type)");
621 if (maybe_in_construction
)
622 fprintf (f
, " (maybe in construction)");
623 fprintf (f
, " offset "HOST_WIDE_INT_PRINT_DEC
,
626 if (speculative_outer_type
)
628 if (outer_type
|| offset
)
630 fprintf (f
, "Speculative outer type:");
631 print_generic_expr (f
, speculative_outer_type
, TDF_SLIM
);
632 if (speculative_maybe_derived_type
)
633 fprintf (f
, " (or a derived type)");
634 fprintf (f
, " at offset "HOST_WIDE_INT_PRINT_DEC
,
642 /* Print context to stderr. */
645 ipa_polymorphic_call_context::debug () const
650 /* Stream out the context to OB. */
653 ipa_polymorphic_call_context::stream_out (struct output_block
*ob
) const
655 struct bitpack_d bp
= bitpack_create (ob
->main_stream
);
657 bp_pack_value (&bp
, invalid
, 1);
658 bp_pack_value (&bp
, maybe_in_construction
, 1);
659 bp_pack_value (&bp
, maybe_derived_type
, 1);
660 bp_pack_value (&bp
, speculative_maybe_derived_type
, 1);
661 bp_pack_value (&bp
, dynamic
, 1);
662 bp_pack_value (&bp
, outer_type
!= NULL
, 1);
663 bp_pack_value (&bp
, offset
!= 0, 1);
664 bp_pack_value (&bp
, speculative_outer_type
!= NULL
, 1);
665 streamer_write_bitpack (&bp
);
667 if (outer_type
!= NULL
)
668 stream_write_tree (ob
, outer_type
, true);
670 streamer_write_hwi (ob
, offset
);
671 if (speculative_outer_type
!= NULL
)
673 stream_write_tree (ob
, speculative_outer_type
, true);
674 streamer_write_hwi (ob
, speculative_offset
);
677 gcc_assert (!speculative_offset
);
680 /* Stream in the context from IB and DATA_IN. */
683 ipa_polymorphic_call_context::stream_in (struct lto_input_block
*ib
,
684 struct data_in
*data_in
)
686 struct bitpack_d bp
= streamer_read_bitpack (ib
);
688 invalid
= bp_unpack_value (&bp
, 1);
689 maybe_in_construction
= bp_unpack_value (&bp
, 1);
690 maybe_derived_type
= bp_unpack_value (&bp
, 1);
691 speculative_maybe_derived_type
= bp_unpack_value (&bp
, 1);
692 dynamic
= bp_unpack_value (&bp
, 1);
693 bool outer_type_p
= bp_unpack_value (&bp
, 1);
694 bool offset_p
= bp_unpack_value (&bp
, 1);
695 bool speculative_outer_type_p
= bp_unpack_value (&bp
, 1);
698 outer_type
= stream_read_tree (ib
, data_in
);
702 offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
705 if (speculative_outer_type_p
)
707 speculative_outer_type
= stream_read_tree (ib
, data_in
);
708 speculative_offset
= (HOST_WIDE_INT
) streamer_read_hwi (ib
);
712 speculative_outer_type
= NULL
;
713 speculative_offset
= 0;
717 /* Proudce polymorphic call context for call method of instance
718 that is located within BASE (that is assumed to be a decl) at offset OFF. */
721 ipa_polymorphic_call_context::set_by_decl (tree base
, HOST_WIDE_INT off
)
723 gcc_assert (DECL_P (base
));
724 clear_speculation ();
726 if (!contains_polymorphic_type_p (TREE_TYPE (base
)))
732 outer_type
= TYPE_MAIN_VARIANT (TREE_TYPE (base
));
734 /* Make very conservative assumption that all objects
735 may be in construction.
737 It is up to caller to revisit this via
738 get_dynamic_type or decl_maybe_in_construction_p. */
739 maybe_in_construction
= true;
740 maybe_derived_type
= false;
744 /* CST is an invariant (address of decl), try to get meaningful
745 polymorphic call context for polymorphic call of method
746 if instance of OTR_TYPE that is located at offset OFF of this invariant.
747 Return FALSE if nothing meaningful can be found. */
750 ipa_polymorphic_call_context::set_by_invariant (tree cst
,
754 HOST_WIDE_INT offset2
, size
, max_size
;
759 clear_outer_type (otr_type
);
761 if (TREE_CODE (cst
) != ADDR_EXPR
)
764 cst
= TREE_OPERAND (cst
, 0);
765 base
= get_ref_base_and_extent (cst
, &offset2
, &size
, &max_size
);
766 if (!DECL_P (base
) || max_size
== -1 || max_size
!= size
)
769 /* Only type inconsistent programs can have otr_type that is
770 not part of outer type. */
771 if (otr_type
&& !contains_type_p (TREE_TYPE (base
), off
, otr_type
))
774 set_by_decl (base
, off
);
778 /* See if OP is SSA name initialized as a copy or by single assignment.
779 If so, walk the SSA graph up. Because simple PHI conditional is considered
780 copy, GLOBAL_VISITED may be used to avoid infinite loop walking the SSA
784 walk_ssa_copies (tree op
, hash_set
<tree
> **global_visited
= NULL
)
786 hash_set
<tree
> *visited
= NULL
;
788 while (TREE_CODE (op
) == SSA_NAME
789 && !SSA_NAME_IS_DEFAULT_DEF (op
)
790 && SSA_NAME_DEF_STMT (op
)
791 && (gimple_assign_single_p (SSA_NAME_DEF_STMT (op
))
792 || gimple_code (SSA_NAME_DEF_STMT (op
)) == GIMPLE_PHI
))
796 if (!*global_visited
)
797 *global_visited
= new hash_set
<tree
>;
798 if ((*global_visited
)->add (op
))
804 visited
= new hash_set
<tree
>;
805 if (visited
->add (op
))
813 This pattern is implicitly produced for casts to non-primary
814 bases. When doing context analysis, we do not really care
815 about the case pointer is NULL, becuase the call will be
817 if (gimple_code (SSA_NAME_DEF_STMT (op
)) == GIMPLE_PHI
)
819 gimple phi
= SSA_NAME_DEF_STMT (op
);
821 if (gimple_phi_num_args (phi
) > 2)
823 if (gimple_phi_num_args (phi
) == 1)
824 op
= gimple_phi_arg_def (phi
, 0);
825 else if (integer_zerop (gimple_phi_arg_def (phi
, 0)))
826 op
= gimple_phi_arg_def (phi
, 1);
827 else if (integer_zerop (gimple_phi_arg_def (phi
, 1)))
828 op
= gimple_phi_arg_def (phi
, 0);
834 if (gimple_assign_load_p (SSA_NAME_DEF_STMT (op
)))
836 op
= gimple_assign_rhs1 (SSA_NAME_DEF_STMT (op
));
846 /* Create polymorphic call context from IP invariant CST.
847 This is typically &global_var.
848 OTR_TYPE specify type of polymorphic call or NULL if unknown, OFF
849 is offset of call. */
851 ipa_polymorphic_call_context::ipa_polymorphic_call_context (tree cst
,
855 clear_speculation ();
856 set_by_invariant (cst
, otr_type
, off
);
859 /* Build context for pointer REF contained in FNDECL at statement STMT.
860 if INSTANCE is non-NULL, return pointer to the object described by
861 the context or DECL where context is contained in. */
863 ipa_polymorphic_call_context::ipa_polymorphic_call_context (tree fndecl
,
868 tree otr_type
= NULL
;
870 hash_set
<tree
> *visited
= NULL
;
872 if (TREE_CODE (ref
) == OBJ_TYPE_REF
)
874 otr_type
= obj_type_ref_class (ref
);
875 base_pointer
= OBJ_TYPE_REF_OBJECT (ref
);
880 /* Set up basic info in case we find nothing interesting in the analysis. */
881 clear_speculation ();
882 clear_outer_type (otr_type
);
885 /* Walk SSA for outer object. */
888 base_pointer
= walk_ssa_copies (base_pointer
, &visited
);
889 if (TREE_CODE (base_pointer
) == ADDR_EXPR
)
891 HOST_WIDE_INT size
, max_size
;
892 HOST_WIDE_INT offset2
;
893 tree base
= get_ref_base_and_extent (TREE_OPERAND (base_pointer
, 0),
894 &offset2
, &size
, &max_size
);
896 if (max_size
!= -1 && max_size
== size
)
897 combine_speculation_with (TYPE_MAIN_VARIANT (TREE_TYPE (base
)),
900 NULL
/* Do not change outer type. */);
902 /* If this is a varying address, punt. */
903 if ((TREE_CODE (base
) == MEM_REF
|| DECL_P (base
))
907 /* We found dereference of a pointer. Type of the pointer
908 and MEM_REF is meaningless, but we can look futher. */
909 if (TREE_CODE (base
) == MEM_REF
)
911 base_pointer
= TREE_OPERAND (base
, 0);
913 += offset2
+ mem_ref_offset (base
).to_short_addr () * BITS_PER_UNIT
;
916 /* We found base object. In this case the outer_type
918 else if (DECL_P (base
))
922 /* Only type inconsistent programs can have otr_type that is
923 not part of outer type. */
925 && !contains_type_p (TREE_TYPE (base
),
926 offset
+ offset2
, otr_type
))
930 *instance
= base_pointer
;
933 set_by_decl (base
, offset
+ offset2
);
934 if (outer_type
&& maybe_in_construction
&& stmt
)
935 maybe_in_construction
936 = decl_maybe_in_construction_p (base
,
950 else if (TREE_CODE (base_pointer
) == POINTER_PLUS_EXPR
951 && tree_fits_uhwi_p (TREE_OPERAND (base_pointer
, 1)))
953 offset
+= tree_to_shwi (TREE_OPERAND (base_pointer
, 1))
955 base_pointer
= TREE_OPERAND (base_pointer
, 0);
964 /* Try to determine type of the outer object. */
965 if (TREE_CODE (base_pointer
) == SSA_NAME
966 && SSA_NAME_IS_DEFAULT_DEF (base_pointer
)
967 && TREE_CODE (SSA_NAME_VAR (base_pointer
)) == PARM_DECL
)
969 /* See if parameter is THIS pointer of a method. */
970 if (TREE_CODE (TREE_TYPE (fndecl
)) == METHOD_TYPE
971 && SSA_NAME_VAR (base_pointer
) == DECL_ARGUMENTS (fndecl
))
974 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (base_pointer
)));
975 gcc_assert (TREE_CODE (outer_type
) == RECORD_TYPE
976 || TREE_CODE (outer_type
) == UNION_TYPE
);
978 /* Dynamic casting has possibly upcasted the type
979 in the hiearchy. In this case outer type is less
980 informative than inner type and we should forget
983 && !contains_type_p (outer_type
, offset
,
985 || !contains_polymorphic_type_p (outer_type
))
989 *instance
= base_pointer
;
995 /* If the function is constructor or destructor, then
996 the type is possibly in construction, but we know
997 it is not derived type. */
998 if (DECL_CXX_CONSTRUCTOR_P (fndecl
)
999 || DECL_CXX_DESTRUCTOR_P (fndecl
))
1001 maybe_in_construction
= true;
1002 maybe_derived_type
= false;
1006 maybe_derived_type
= true;
1007 maybe_in_construction
= false;
1010 *instance
= base_pointer
;
1013 /* Non-PODs passed by value are really passed by invisible
1014 reference. In this case we also know the type of the
1016 if (DECL_BY_REFERENCE (SSA_NAME_VAR (base_pointer
)))
1019 = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (base_pointer
)));
1020 /* Only type inconsistent programs can have otr_type that is
1021 not part of outer type. */
1022 if (otr_type
&& !contains_type_p (outer_type
, offset
,
1027 *instance
= base_pointer
;
1030 /* Non-polymorphic types have no interest for us. */
1031 else if (!otr_type
&& !contains_polymorphic_type_p (outer_type
))
1035 *instance
= base_pointer
;
1038 maybe_derived_type
= false;
1039 maybe_in_construction
= false;
1041 *instance
= base_pointer
;
1046 tree base_type
= TREE_TYPE (base_pointer
);
1048 if (TREE_CODE (base_pointer
) == SSA_NAME
1049 && SSA_NAME_IS_DEFAULT_DEF (base_pointer
)
1050 && TREE_CODE (SSA_NAME_VAR (base_pointer
)) != PARM_DECL
)
1054 *instance
= base_pointer
;
1057 if (TREE_CODE (base_pointer
) == SSA_NAME
1058 && SSA_NAME_DEF_STMT (base_pointer
)
1059 && gimple_assign_single_p (SSA_NAME_DEF_STMT (base_pointer
)))
1060 base_type
= TREE_TYPE (gimple_assign_rhs1
1061 (SSA_NAME_DEF_STMT (base_pointer
)));
1063 if (POINTER_TYPE_P (base_type
))
1064 combine_speculation_with (TYPE_MAIN_VARIANT (TREE_TYPE (base_type
)),
1066 true, NULL
/* Do not change type here */);
1067 /* TODO: There are multiple ways to derive a type. For instance
1068 if BASE_POINTER is passed to an constructor call prior our refernece.
1069 We do not make this type of flow sensitive analysis yet. */
1071 *instance
= base_pointer
;
1075 /* Structure to be passed in between detect_type_change and
1076 check_stmt_for_type_change. */
1078 struct type_change_info
1080 /* Offset into the object where there is the virtual method pointer we are
1082 HOST_WIDE_INT offset
;
1083 /* The declaration or SSA_NAME pointer of the base that we are checking for
1086 /* The reference to virtual table pointer used. */
1089 /* If we actually can tell the type that the object has changed to, it is
1090 stored in this field. Otherwise it remains NULL_TREE. */
1091 tree known_current_type
;
1092 HOST_WIDE_INT known_current_offset
;
1094 /* Set to true if dynamic type change has been detected. */
1095 bool type_maybe_changed
;
1096 /* Set to true if multiple types have been encountered. known_current_type
1097 must be disregarded in that case. */
1098 bool multiple_types_encountered
;
1099 /* Set to true if we possibly missed some dynamic type changes and we should
1100 consider the set to be speculative. */
1102 bool seen_unanalyzed_store
;
1105 /* Return true if STMT is not call and can modify a virtual method table pointer.
1106 We take advantage of fact that vtable stores must appear within constructor
1107 and destructor functions. */
1110 noncall_stmt_may_be_vtbl_ptr_store (gimple stmt
)
1112 if (is_gimple_assign (stmt
))
1114 tree lhs
= gimple_assign_lhs (stmt
);
1116 if (gimple_clobber_p (stmt
))
1118 if (!AGGREGATE_TYPE_P (TREE_TYPE (lhs
)))
1120 if (flag_strict_aliasing
1121 && !POINTER_TYPE_P (TREE_TYPE (lhs
)))
1124 if (TREE_CODE (lhs
) == COMPONENT_REF
1125 && !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
1127 /* In the future we might want to use get_base_ref_and_offset to find
1128 if there is a field corresponding to the offset and if so, proceed
1129 almost like if it was a component ref. */
1133 /* Code unification may mess with inline stacks. */
1134 if (cfun
->after_inlining
)
1137 /* Walk the inline stack and watch out for ctors/dtors.
1138 TODO: Maybe we can require the store to appear in toplevel
1139 block of CTOR/DTOR. */
1140 for (tree block
= gimple_block (stmt
); block
&& TREE_CODE (block
) == BLOCK
;
1141 block
= BLOCK_SUPERCONTEXT (block
))
1142 if (BLOCK_ABSTRACT_ORIGIN (block
)
1143 && TREE_CODE (BLOCK_ABSTRACT_ORIGIN (block
)) == FUNCTION_DECL
)
1145 tree fn
= BLOCK_ABSTRACT_ORIGIN (block
);
1147 if (flags_from_decl_or_type (fn
) & (ECF_PURE
| ECF_CONST
))
1149 return (TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
1150 && (DECL_CXX_CONSTRUCTOR_P (fn
)
1151 || DECL_CXX_DESTRUCTOR_P (fn
)));
1153 return (TREE_CODE (TREE_TYPE (current_function_decl
)) == METHOD_TYPE
1154 && (DECL_CXX_CONSTRUCTOR_P (current_function_decl
)
1155 || DECL_CXX_DESTRUCTOR_P (current_function_decl
)));
1158 /* If STMT can be proved to be an assignment to the virtual method table
1159 pointer of ANALYZED_OBJ and the type associated with the new table
1160 identified, return the type. Otherwise return NULL_TREE if type changes
1161 in unknown way or ERROR_MARK_NODE if type is unchanged. */
1164 extr_type_from_vtbl_ptr_store (gimple stmt
, struct type_change_info
*tci
,
1165 HOST_WIDE_INT
*type_offset
)
1167 HOST_WIDE_INT offset
, size
, max_size
;
1168 tree lhs
, rhs
, base
;
1170 if (!gimple_assign_single_p (stmt
))
1173 lhs
= gimple_assign_lhs (stmt
);
1174 rhs
= gimple_assign_rhs1 (stmt
);
1175 if (TREE_CODE (lhs
) != COMPONENT_REF
1176 || !DECL_VIRTUAL_P (TREE_OPERAND (lhs
, 1)))
1179 fprintf (dump_file
, " LHS is not virtual table.\n");
1183 if (tci
->vtbl_ptr_ref
&& operand_equal_p (lhs
, tci
->vtbl_ptr_ref
, 0))
1187 base
= get_ref_base_and_extent (lhs
, &offset
, &size
, &max_size
);
1188 if (DECL_P (tci
->instance
))
1190 if (base
!= tci
->instance
)
1194 fprintf (dump_file
, " base:");
1195 print_generic_expr (dump_file
, base
, TDF_SLIM
);
1196 fprintf (dump_file
, " does not match instance:");
1197 print_generic_expr (dump_file
, tci
->instance
, TDF_SLIM
);
1198 fprintf (dump_file
, "\n");
1203 else if (TREE_CODE (base
) == MEM_REF
)
1205 if (!operand_equal_p (tci
->instance
, TREE_OPERAND (base
, 0), 0))
1209 fprintf (dump_file
, " base mem ref:");
1210 print_generic_expr (dump_file
, base
, TDF_SLIM
);
1211 fprintf (dump_file
, " does not match instance:");
1212 print_generic_expr (dump_file
, tci
->instance
, TDF_SLIM
);
1213 fprintf (dump_file
, "\n");
1217 if (!integer_zerop (TREE_OPERAND (base
, 1)))
1219 if (!tree_fits_shwi_p (TREE_OPERAND (base
, 1)))
1223 fprintf (dump_file
, " base mem ref:");
1224 print_generic_expr (dump_file
, base
, TDF_SLIM
);
1225 fprintf (dump_file
, " has non-representable offset:");
1226 print_generic_expr (dump_file
, tci
->instance
, TDF_SLIM
);
1227 fprintf (dump_file
, "\n");
1232 offset
+= tree_to_shwi (TREE_OPERAND (base
, 1)) * BITS_PER_UNIT
;
1235 else if (!operand_equal_p (tci
->instance
, base
, 0)
1240 fprintf (dump_file
, " base:");
1241 print_generic_expr (dump_file
, base
, TDF_SLIM
);
1242 fprintf (dump_file
, " does not match instance:");
1243 print_generic_expr (dump_file
, tci
->instance
, TDF_SLIM
);
1244 fprintf (dump_file
, " with offset %i\n", (int)tci
->offset
);
1246 return tci
->offset
> GET_MODE_BITSIZE (Pmode
) ? error_mark_node
: NULL_TREE
;
1248 if (offset
!= tci
->offset
1249 || size
!= POINTER_SIZE
1250 || max_size
!= POINTER_SIZE
)
1253 fprintf (dump_file
, " wrong offset %i!=%i or size %i\n",
1254 (int)offset
, (int)tci
->offset
, (int)size
);
1255 return offset
+ GET_MODE_BITSIZE (Pmode
) <= tci
->offset
1257 && tci
->offset
+ GET_MODE_BITSIZE (Pmode
) > offset
+ max_size
)
1258 ? error_mark_node
: NULL
;
1263 unsigned HOST_WIDE_INT offset2
;
1265 if (!vtable_pointer_value_to_vtable (rhs
, &vtable
, &offset2
))
1268 fprintf (dump_file
, " Failed to lookup binfo\n");
1272 tree binfo
= subbinfo_with_vtable_at_offset (TYPE_BINFO (DECL_CONTEXT (vtable
)),
1277 fprintf (dump_file
, " Construction vtable used\n");
1278 /* FIXME: We should suport construction contexts. */
1282 *type_offset
= tree_to_shwi (BINFO_OFFSET (binfo
)) * BITS_PER_UNIT
;
1283 return DECL_CONTEXT (vtable
);
1286 /* Record dynamic type change of TCI to TYPE. */
1289 record_known_type (struct type_change_info
*tci
, tree type
, HOST_WIDE_INT offset
)
1295 fprintf (dump_file
, " Recording type: ");
1296 print_generic_expr (dump_file
, type
, TDF_SLIM
);
1297 fprintf (dump_file
, " at offset %i\n", (int)offset
);
1300 fprintf (dump_file
, " Recording unknown type\n");
1303 /* If we found a constructor of type that is not polymorphic or
1304 that may contain the type in question as a field (not as base),
1305 restrict to the inner class first to make type matching bellow
1309 || (TREE_CODE (type
) != RECORD_TYPE
1310 || !polymorphic_type_binfo_p (TYPE_BINFO (type
)))))
1312 ipa_polymorphic_call_context context
;
1314 context
.offset
= offset
;
1315 context
.outer_type
= type
;
1316 context
.maybe_in_construction
= false;
1317 context
.maybe_derived_type
= false;
1318 context
.dynamic
= true;
1319 /* If we failed to find the inner type, we know that the call
1320 would be undefined for type produced here. */
1321 if (!context
.restrict_to_inner_class (tci
->otr_type
))
1324 fprintf (dump_file
, " Ignoring; does not contain otr_type\n");
1327 /* Watch for case we reached an POD type and anticipate placement
1329 if (!context
.maybe_derived_type
)
1331 type
= context
.outer_type
;
1332 offset
= context
.offset
;
1335 if (tci
->type_maybe_changed
1336 && (!types_same_for_odr (type
, tci
->known_current_type
)
1337 || offset
!= tci
->known_current_offset
))
1338 tci
->multiple_types_encountered
= true;
1339 tci
->known_current_type
= TYPE_MAIN_VARIANT (type
);
1340 tci
->known_current_offset
= offset
;
1341 tci
->type_maybe_changed
= true;
1344 /* Callback of walk_aliased_vdefs and a helper function for
1345 detect_type_change to check whether a particular statement may modify
1346 the virtual table pointer, and if possible also determine the new type of
1347 the (sub-)object. It stores its result into DATA, which points to a
1348 type_change_info structure. */
1351 check_stmt_for_type_change (ao_ref
*ao ATTRIBUTE_UNUSED
, tree vdef
, void *data
)
1353 gimple stmt
= SSA_NAME_DEF_STMT (vdef
);
1354 struct type_change_info
*tci
= (struct type_change_info
*) data
;
1357 /* If we already gave up, just terminate the rest of walk. */
1358 if (tci
->multiple_types_encountered
)
1361 if (is_gimple_call (stmt
))
1363 if (gimple_call_flags (stmt
) & (ECF_CONST
| ECF_PURE
))
1366 /* Check for a constructor call. */
1367 if ((fn
= gimple_call_fndecl (stmt
)) != NULL_TREE
1368 && DECL_CXX_CONSTRUCTOR_P (fn
)
1369 && TREE_CODE (TREE_TYPE (fn
)) == METHOD_TYPE
1370 && gimple_call_num_args (stmt
))
1372 tree op
= walk_ssa_copies (gimple_call_arg (stmt
, 0));
1373 tree type
= method_class_type (TREE_TYPE (fn
));
1374 HOST_WIDE_INT offset
= 0, size
, max_size
;
1378 fprintf (dump_file
, " Checking constructor call: ");
1379 print_gimple_stmt (dump_file
, stmt
, 0, 0);
1382 /* See if THIS parameter seems like instance pointer. */
1383 if (TREE_CODE (op
) == ADDR_EXPR
)
1385 op
= get_ref_base_and_extent (TREE_OPERAND (op
, 0),
1386 &offset
, &size
, &max_size
);
1387 if (size
!= max_size
|| max_size
== -1)
1389 tci
->speculative
= true;
1392 if (op
&& TREE_CODE (op
) == MEM_REF
)
1394 if (!tree_fits_shwi_p (TREE_OPERAND (op
, 1)))
1396 tci
->speculative
= true;
1399 offset
+= tree_to_shwi (TREE_OPERAND (op
, 1))
1401 op
= TREE_OPERAND (op
, 0);
1403 else if (DECL_P (op
))
1407 tci
->speculative
= true;
1410 op
= walk_ssa_copies (op
);
1412 if (operand_equal_p (op
, tci
->instance
, 0)
1414 && TREE_CODE (TYPE_SIZE (type
)) == INTEGER_CST
1415 && tree_fits_shwi_p (TYPE_SIZE (type
))
1416 && tree_to_shwi (TYPE_SIZE (type
)) + offset
> tci
->offset
)
1418 record_known_type (tci
, type
, tci
->offset
- offset
);
1422 /* Calls may possibly change dynamic type by placement new. Assume
1423 it will not happen, but make result speculative only. */
1426 fprintf (dump_file
, " Function call may change dynamic type:");
1427 print_gimple_stmt (dump_file
, stmt
, 0, 0);
1429 tci
->speculative
= true;
1432 /* Check for inlined virtual table store. */
1433 else if (noncall_stmt_may_be_vtbl_ptr_store (stmt
))
1436 HOST_WIDE_INT offset
= 0;
1439 fprintf (dump_file
, " Checking vtbl store: ");
1440 print_gimple_stmt (dump_file
, stmt
, 0, 0);
1443 type
= extr_type_from_vtbl_ptr_store (stmt
, tci
, &offset
);
1444 if (type
== error_mark_node
)
1446 gcc_assert (!type
|| TYPE_MAIN_VARIANT (type
) == type
);
1450 fprintf (dump_file
, " Unanalyzed store may change type.\n");
1451 tci
->seen_unanalyzed_store
= true;
1452 tci
->speculative
= true;
1455 record_known_type (tci
, type
, offset
);
1462 /* THIS is polymorphic call context obtained from get_polymorphic_context.
1463 OTR_OBJECT is pointer to the instance returned by OBJ_TYPE_REF_OBJECT.
1464 INSTANCE is pointer to the outer instance as returned by
1465 get_polymorphic_context. To avoid creation of temporary expressions,
1466 INSTANCE may also be an declaration of get_polymorphic_context found the
1467 value to be in static storage.
1469 If the type of instance is not fully determined
1470 (either OUTER_TYPE is unknown or MAYBE_IN_CONSTRUCTION/INCLUDE_DERIVED_TYPES
1471 is set), try to walk memory writes and find the actual construction of the
1474 Return true if memory is unchanged from function entry.
1476 We do not include this analysis in the context analysis itself, because
1477 it needs memory SSA to be fully built and the walk may be expensive.
1478 So it is not suitable for use withing fold_stmt and similar uses. */
1481 ipa_polymorphic_call_context::get_dynamic_type (tree instance
,
1486 struct type_change_info tci
;
1488 bool function_entry_reached
= false;
1489 tree instance_ref
= NULL
;
1491 /* Remember OFFSET before it is modified by restrict_to_inner_class.
1492 This is because we do not update INSTANCE when walking inwards. */
1493 HOST_WIDE_INT instance_offset
= offset
;
1496 otr_type
= TYPE_MAIN_VARIANT (otr_type
);
1498 /* Walk into inner type. This may clear maybe_derived_type and save us
1499 from useless work. It also makes later comparsions with static type
1501 if (outer_type
&& otr_type
)
1503 if (!restrict_to_inner_class (otr_type
))
1507 if (!maybe_in_construction
&& !maybe_derived_type
)
1510 /* We need to obtain refernce to virtual table pointer. It is better
1511 to look it up in the code rather than build our own. This require bit
1512 of pattern matching, but we end up verifying that what we found is
1515 What we pattern match is:
1517 tmp = instance->_vptr.A; // vtbl ptr load
1518 tmp2 = tmp[otr_token]; // vtable lookup
1519 OBJ_TYPE_REF(tmp2;instance->0) (instance);
1521 We want to start alias oracle walk from vtbl pointer load,
1522 but we may not be able to identify it, for example, when PRE moved the
1525 if (gimple_code (call
) == GIMPLE_CALL
)
1527 tree ref
= gimple_call_fn (call
);
1528 HOST_WIDE_INT offset2
, size
, max_size
;
1530 if (TREE_CODE (ref
) == OBJ_TYPE_REF
)
1532 ref
= OBJ_TYPE_REF_EXPR (ref
);
1533 ref
= walk_ssa_copies (ref
);
1535 /* Check if definition looks like vtable lookup. */
1536 if (TREE_CODE (ref
) == SSA_NAME
1537 && !SSA_NAME_IS_DEFAULT_DEF (ref
)
1538 && gimple_assign_load_p (SSA_NAME_DEF_STMT (ref
))
1539 && TREE_CODE (gimple_assign_rhs1
1540 (SSA_NAME_DEF_STMT (ref
))) == MEM_REF
)
1542 ref
= get_base_address
1543 (TREE_OPERAND (gimple_assign_rhs1
1544 (SSA_NAME_DEF_STMT (ref
)), 0));
1545 ref
= walk_ssa_copies (ref
);
1546 /* Find base address of the lookup and see if it looks like
1548 if (TREE_CODE (ref
) == SSA_NAME
1549 && !SSA_NAME_IS_DEFAULT_DEF (ref
)
1550 && gimple_assign_load_p (SSA_NAME_DEF_STMT (ref
)))
1552 tree ref_exp
= gimple_assign_rhs1 (SSA_NAME_DEF_STMT (ref
));
1553 tree base_ref
= get_ref_base_and_extent
1554 (ref_exp
, &offset2
, &size
, &max_size
);
1556 /* Finally verify that what we found looks like read from OTR_OBJECT
1557 or from INSTANCE with offset OFFSET. */
1559 && ((TREE_CODE (base_ref
) == MEM_REF
1560 && ((offset2
== instance_offset
1561 && TREE_OPERAND (base_ref
, 0) == instance
)
1562 || (!offset2
&& TREE_OPERAND (base_ref
, 0) == otr_object
)))
1563 || (DECL_P (instance
) && base_ref
== instance
1564 && offset2
== instance_offset
)))
1566 stmt
= SSA_NAME_DEF_STMT (ref
);
1567 instance_ref
= ref_exp
;
1574 /* If we failed to look up the refernece in code, build our own. */
1577 /* If the statement in question does not use memory, we can't tell
1579 if (!gimple_vuse (stmt
))
1581 ao_ref_init_from_ptr_and_size (&ao
, otr_object
, NULL
);
1584 /* Otherwise use the real reference. */
1585 ao_ref_init (&ao
, instance_ref
);
1587 /* We look for vtbl pointer read. */
1588 ao
.size
= POINTER_SIZE
;
1589 ao
.max_size
= ao
.size
;
1592 = get_deref_alias_set (TREE_TYPE (BINFO_VTABLE (TYPE_BINFO (otr_type
))));
1596 fprintf (dump_file
, "Determining dynamic type for call: ");
1597 print_gimple_stmt (dump_file
, call
, 0, 0);
1598 fprintf (dump_file
, " Starting walk at: ");
1599 print_gimple_stmt (dump_file
, stmt
, 0, 0);
1600 fprintf (dump_file
, " instance pointer: ");
1601 print_generic_expr (dump_file
, otr_object
, TDF_SLIM
);
1602 fprintf (dump_file
, " Outer instance pointer: ");
1603 print_generic_expr (dump_file
, instance
, TDF_SLIM
);
1604 fprintf (dump_file
, " offset: %i (bits)", (int)offset
);
1605 fprintf (dump_file
, " vtbl reference: ");
1606 print_generic_expr (dump_file
, instance_ref
, TDF_SLIM
);
1607 fprintf (dump_file
, "\n");
1610 tci
.offset
= offset
;
1611 tci
.instance
= instance
;
1612 tci
.vtbl_ptr_ref
= instance_ref
;
1613 gcc_assert (TREE_CODE (instance
) != MEM_REF
);
1614 tci
.known_current_type
= NULL_TREE
;
1615 tci
.known_current_offset
= 0;
1616 tci
.otr_type
= otr_type
;
1617 tci
.type_maybe_changed
= false;
1618 tci
.multiple_types_encountered
= false;
1619 tci
.speculative
= false;
1620 tci
.seen_unanalyzed_store
= false;
1622 walk_aliased_vdefs (&ao
, gimple_vuse (stmt
), check_stmt_for_type_change
,
1623 &tci
, NULL
, &function_entry_reached
);
1625 /* If we did not find any type changing statements, we may still drop
1626 maybe_in_construction flag if the context already have outer type.
1628 Here we make special assumptions about both constructors and
1629 destructors which are all the functions that are allowed to alter the
1630 VMT pointers. It assumes that destructors begin with assignment into
1631 all VMT pointers and that constructors essentially look in the
1634 1) The very first thing they do is that they call constructors of
1635 ancestor sub-objects that have them.
1637 2) Then VMT pointers of this and all its ancestors is set to new
1638 values corresponding to the type corresponding to the constructor.
1640 3) Only afterwards, other stuff such as constructor of member
1641 sub-objects and the code written by the user is run. Only this may
1642 include calling virtual functions, directly or indirectly.
1644 4) placement new can not be used to change type of non-POD statically
1645 allocated variables.
1647 There is no way to call a constructor of an ancestor sub-object in any
1650 This means that we do not have to care whether constructors get the
1651 correct type information because they will always change it (in fact,
1652 if we define the type to be given by the VMT pointer, it is undefined).
1654 The most important fact to derive from the above is that if, for some
1655 statement in the section 3, we try to detect whether the dynamic type
1656 has changed, we can safely ignore all calls as we examine the function
1657 body backwards until we reach statements in section 2 because these
1658 calls cannot be ancestor constructors or destructors (if the input is
1659 not bogus) and so do not change the dynamic type (this holds true only
1660 for automatically allocated objects but at the moment we devirtualize
1661 only these). We then must detect that statements in section 2 change
1662 the dynamic type and can try to derive the new type. That is enough
1663 and we can stop, we will never see the calls into constructors of
1664 sub-objects in this code.
1666 Therefore if the static outer type was found (outer_type)
1667 we can safely ignore tci.speculative that is set on calls and give up
1668 only if there was dyanmic type store that may affect given variable
1669 (seen_unanalyzed_store) */
1671 if (!tci
.type_maybe_changed
1674 && !tci
.seen_unanalyzed_store
1675 && !tci
.multiple_types_encountered
1676 && offset
== tci
.offset
1677 && types_same_for_odr (tci
.known_current_type
,
1680 if (!outer_type
|| tci
.seen_unanalyzed_store
)
1682 if (maybe_in_construction
)
1683 maybe_in_construction
= false;
1685 fprintf (dump_file
, " No dynamic type change found.\n");
1689 if (tci
.known_current_type
1690 && !function_entry_reached
1691 && !tci
.multiple_types_encountered
)
1693 if (!tci
.speculative
)
1695 outer_type
= TYPE_MAIN_VARIANT (tci
.known_current_type
);
1696 offset
= tci
.known_current_offset
;
1698 maybe_in_construction
= false;
1699 maybe_derived_type
= false;
1701 fprintf (dump_file
, " Determined dynamic type.\n");
1703 else if (!speculative_outer_type
1704 || speculative_maybe_derived_type
)
1706 speculative_outer_type
= TYPE_MAIN_VARIANT (tci
.known_current_type
);
1707 speculative_offset
= tci
.known_current_offset
;
1708 speculative_maybe_derived_type
= false;
1710 fprintf (dump_file
, " Determined speculative dynamic type.\n");
1715 fprintf (dump_file
, " Found multiple types%s%s\n",
1716 function_entry_reached
? " (function entry reached)" : "",
1717 function_entry_reached
? " (multiple types encountered)" : "");
1723 /* See if speculation given by SPEC_OUTER_TYPE, SPEC_OFFSET and SPEC_MAYBE_DERIVED_TYPE
1724 seems consistent (and useful) with what we already have in the non-speculative context. */
1727 ipa_polymorphic_call_context::speculation_consistent_p (tree spec_outer_type
,
1728 HOST_WIDE_INT spec_offset
,
1729 bool spec_maybe_derived_type
,
1730 tree otr_type
) const
1732 if (!flag_devirtualize_speculatively
)
1735 /* Non-polymorphic types are useless for deriving likely polymorphic
1737 if (!spec_outer_type
|| !contains_polymorphic_type_p (spec_outer_type
))
1740 /* If we know nothing, speculation is always good. */
1744 /* Speculation is only useful to avoid derived types.
1745 This is not 100% true for placement new, where the outer context may
1746 turn out to be useless, but ignore these for now. */
1747 if (!maybe_derived_type
)
1750 /* If types agrees, speculation is consistent, but it makes sense only
1751 when it says something new. */
1752 if (types_must_be_same_for_odr (spec_outer_type
, outer_type
))
1753 return maybe_derived_type
&& !spec_maybe_derived_type
;
1755 /* If speculation does not contain the type in question, ignore it. */
1757 && !contains_type_p (spec_outer_type
, spec_offset
, otr_type
, false, true))
1760 /* If outer type already contains speculation as a filed,
1761 it is useless. We already know from OUTER_TYPE
1762 SPEC_TYPE and that it is not in the construction. */
1763 if (contains_type_p (outer_type
, offset
- spec_offset
,
1764 spec_outer_type
, false, false))
1767 /* If speculative outer type is not more specified than outer
1769 We can only decide this safely if we can compare types with OUTER_TYPE.
1771 if ((!in_lto_p
|| odr_type_p (outer_type
))
1772 && !contains_type_p (spec_outer_type
,
1773 spec_offset
- offset
,
1779 /* Improve THIS with speculation described by NEW_OUTER_TYPE, NEW_OFFSET,
1780 NEW_MAYBE_DERIVED_TYPE
1781 If OTR_TYPE is set, assume the context is used with OTR_TYPE. */
1784 ipa_polymorphic_call_context::combine_speculation_with
1785 (tree new_outer_type
, HOST_WIDE_INT new_offset
, bool new_maybe_derived_type
,
1788 if (!new_outer_type
)
1791 /* restrict_to_inner_class may eliminate wrong speculation making our job
1794 restrict_to_inner_class (otr_type
);
1796 if (!speculation_consistent_p (new_outer_type
, new_offset
,
1797 new_maybe_derived_type
, otr_type
))
1800 /* New speculation is a win in case we have no speculation or new
1801 speculation does not consider derivations. */
1802 if (!speculative_outer_type
1803 || (speculative_maybe_derived_type
1804 && !new_maybe_derived_type
))
1806 speculative_outer_type
= new_outer_type
;
1807 speculative_offset
= new_offset
;
1808 speculative_maybe_derived_type
= new_maybe_derived_type
;
1811 else if (types_must_be_same_for_odr (speculative_outer_type
,
1814 if (speculative_offset
!= new_offset
)
1816 /* OK we have two contexts that seems valid but they disagree,
1819 This is not a lattice operation, so we may want to drop it later. */
1820 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1822 "Speculative outer types match, "
1823 "offset mismatch -> invalid speculation\n");
1824 clear_speculation ();
1829 if (speculative_maybe_derived_type
&& !new_maybe_derived_type
)
1831 speculative_maybe_derived_type
= false;
1838 /* Choose type that contains the other. This one either contains the outer
1839 as a field (thus giving exactly one target) or is deeper in the type
1841 else if (speculative_outer_type
1842 && speculative_maybe_derived_type
1843 && (new_offset
> speculative_offset
1844 || (new_offset
== speculative_offset
1845 && contains_type_p (new_outer_type
,
1846 0, speculative_outer_type
, false))))
1848 tree old_outer_type
= speculative_outer_type
;
1849 HOST_WIDE_INT old_offset
= speculative_offset
;
1850 bool old_maybe_derived_type
= speculative_maybe_derived_type
;
1852 speculative_outer_type
= new_outer_type
;
1853 speculative_offset
= new_offset
;
1854 speculative_maybe_derived_type
= new_maybe_derived_type
;
1857 restrict_to_inner_class (otr_type
);
1859 /* If the speculation turned out to make no sense, revert to sensible
1861 if (!speculative_outer_type
)
1863 speculative_outer_type
= old_outer_type
;
1864 speculative_offset
= old_offset
;
1865 speculative_maybe_derived_type
= old_maybe_derived_type
;
1868 return (old_offset
!= speculative_offset
1869 || old_maybe_derived_type
!= speculative_maybe_derived_type
1870 || types_must_be_same_for_odr (speculative_outer_type
,
1876 /* Make speculation less specific so
1877 NEW_OUTER_TYPE, NEW_OFFSET, NEW_MAYBE_DERIVED_TYPE is also included.
1878 If OTR_TYPE is set, assume the context is used with OTR_TYPE. */
1881 ipa_polymorphic_call_context::meet_speculation_with
1882 (tree new_outer_type
, HOST_WIDE_INT new_offset
, bool new_maybe_derived_type
,
1885 if (!new_outer_type
&& speculative_outer_type
)
1887 clear_speculation ();
1891 /* restrict_to_inner_class may eliminate wrong speculation making our job
1894 restrict_to_inner_class (otr_type
);
1896 if (!speculative_outer_type
1897 || !speculation_consistent_p (speculative_outer_type
,
1899 speculative_maybe_derived_type
,
1903 if (!speculation_consistent_p (new_outer_type
, new_offset
,
1904 new_maybe_derived_type
, otr_type
))
1906 clear_speculation ();
1910 else if (types_must_be_same_for_odr (speculative_outer_type
,
1913 if (speculative_offset
!= new_offset
)
1915 clear_speculation ();
1920 if (!speculative_maybe_derived_type
&& new_maybe_derived_type
)
1922 speculative_maybe_derived_type
= true;
1929 /* See if one type contains the other as a field (not base). */
1930 else if (contains_type_p (new_outer_type
, new_offset
- speculative_offset
,
1931 speculative_outer_type
, false, false))
1933 else if (contains_type_p (speculative_outer_type
,
1934 speculative_offset
- new_offset
,
1935 new_outer_type
, false, false))
1937 speculative_outer_type
= new_outer_type
;
1938 speculative_offset
= new_offset
;
1939 speculative_maybe_derived_type
= new_maybe_derived_type
;
1942 /* See if OUTER_TYPE is base of CTX.OUTER_TYPE. */
1943 else if (contains_type_p (new_outer_type
,
1944 new_offset
- speculative_offset
,
1945 speculative_outer_type
, false, true))
1947 if (!speculative_maybe_derived_type
)
1949 speculative_maybe_derived_type
= true;
1954 /* See if CTX.OUTER_TYPE is base of OUTER_TYPE. */
1955 else if (contains_type_p (speculative_outer_type
,
1956 speculative_offset
- new_offset
, new_outer_type
, false, true))
1958 speculative_outer_type
= new_outer_type
;
1959 speculative_offset
= new_offset
;
1960 speculative_maybe_derived_type
= true;
1965 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1966 fprintf (dump_file
, "Giving up on speculative meet\n");
1967 clear_speculation ();
1972 /* Assume that both THIS and a given context is valid and strenghten THIS
1973 if possible. Return true if any strenghtening was made.
1974 If actual type the context is being used in is known, OTR_TYPE should be
1975 set accordingly. This improves quality of combined result. */
1978 ipa_polymorphic_call_context::combine_with (ipa_polymorphic_call_context ctx
,
1981 bool updated
= false;
1983 if (ctx
.useless_p () || invalid
)
1986 /* Restricting context to inner type makes merging easier, however do not
1987 do that unless we know how the context is used (OTR_TYPE is non-NULL) */
1988 if (otr_type
&& !invalid
&& !ctx
.invalid
)
1990 restrict_to_inner_class (otr_type
);
1991 ctx
.restrict_to_inner_class (otr_type
);
1996 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
1998 fprintf (dump_file
, "Polymorphic call context combine:");
2000 fprintf (dump_file
, "With context: ");
2001 ctx
.dump (dump_file
);
2004 fprintf (dump_file
, "To be used with type: ");
2005 print_generic_expr (dump_file
, otr_type
, TDF_SLIM
);
2006 fprintf (dump_file
, "\n");
2010 /* If call is known to be invalid, we are done. */
2013 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2014 fprintf (dump_file
, "-> Invalid context\n");
2018 if (!ctx
.outer_type
)
2020 else if (!outer_type
)
2022 outer_type
= ctx
.outer_type
;
2023 offset
= ctx
.offset
;
2024 dynamic
= ctx
.dynamic
;
2025 maybe_in_construction
= ctx
.maybe_in_construction
;
2026 maybe_derived_type
= ctx
.maybe_derived_type
;
2029 /* If types are known to be same, merging is quite easy. */
2030 else if (types_must_be_same_for_odr (outer_type
, ctx
.outer_type
))
2032 if (offset
!= ctx
.offset
2033 && TYPE_SIZE (outer_type
)
2034 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
)
2036 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2037 fprintf (dump_file
, "Outer types match, offset mismatch -> invalid\n");
2038 clear_speculation ();
2039 clear_outer_type ();
2043 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2044 fprintf (dump_file
, "Outer types match, merging flags\n");
2045 if (maybe_in_construction
&& !ctx
.maybe_in_construction
)
2048 maybe_in_construction
= false;
2050 if (maybe_derived_type
&& !ctx
.maybe_derived_type
)
2053 maybe_derived_type
= false;
2055 if (dynamic
&& !ctx
.dynamic
)
2061 /* If we know the type precisely, there is not much to improve. */
2062 else if (!maybe_derived_type
&& !maybe_in_construction
2063 && !ctx
.maybe_derived_type
&& !ctx
.maybe_in_construction
)
2065 /* It may be easy to check if second context permits the first
2066 and set INVALID otherwise. This is not easy to do in general;
2067 contains_type_p may return false negatives for non-comparable
2070 If OTR_TYPE is known, we however can expect that
2071 restrict_to_inner_class should have discovered the same base
2073 if (otr_type
&& !ctx
.maybe_in_construction
&& !ctx
.maybe_derived_type
)
2075 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2076 fprintf (dump_file
, "Contextes disagree -> invalid\n");
2080 /* See if one type contains the other as a field (not base).
2081 In this case we want to choose the wider type, because it contains
2082 more information. */
2083 else if (contains_type_p (ctx
.outer_type
, ctx
.offset
- offset
,
2084 outer_type
, false, false))
2086 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2087 fprintf (dump_file
, "Second type contain the first as a field\n");
2089 if (maybe_derived_type
)
2091 outer_type
= ctx
.outer_type
;
2092 maybe_derived_type
= ctx
.maybe_derived_type
;
2093 offset
= ctx
.offset
;
2094 dynamic
= ctx
.dynamic
;
2098 /* If we do not know how the context is being used, we can
2099 not clear MAYBE_IN_CONSTRUCTION because it may be offseted
2100 to other component of OUTER_TYPE later and we know nothing
2102 if (otr_type
&& maybe_in_construction
2103 && !ctx
.maybe_in_construction
)
2105 maybe_in_construction
= false;
2109 else if (contains_type_p (outer_type
, offset
- ctx
.offset
,
2110 ctx
.outer_type
, false, false))
2112 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2113 fprintf (dump_file
, "First type contain the second as a field\n");
2115 if (otr_type
&& maybe_in_construction
2116 && !ctx
.maybe_in_construction
)
2118 maybe_in_construction
= false;
2122 /* See if OUTER_TYPE is base of CTX.OUTER_TYPE. */
2123 else if (contains_type_p (ctx
.outer_type
,
2124 ctx
.offset
- offset
, outer_type
, false, true))
2126 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2127 fprintf (dump_file
, "First type is base of second\n");
2128 if (!maybe_derived_type
)
2130 if (!ctx
.maybe_in_construction
2131 && types_odr_comparable (outer_type
, ctx
.outer_type
))
2133 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2134 fprintf (dump_file
, "Second context does not permit base -> invalid\n");
2138 /* Pick variant deeper in the hiearchy. */
2141 outer_type
= ctx
.outer_type
;
2142 maybe_in_construction
= ctx
.maybe_in_construction
;
2143 maybe_derived_type
= ctx
.maybe_derived_type
;
2144 offset
= ctx
.offset
;
2145 dynamic
= ctx
.dynamic
;
2149 /* See if CTX.OUTER_TYPE is base of OUTER_TYPE. */
2150 else if (contains_type_p (outer_type
,
2151 offset
- ctx
.offset
, ctx
.outer_type
, false, true))
2153 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2154 fprintf (dump_file
, "Second type is base of first\n");
2155 if (!ctx
.maybe_derived_type
)
2157 if (!maybe_in_construction
2158 && types_odr_comparable (outer_type
, ctx
.outer_type
))
2160 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2161 fprintf (dump_file
, "First context does not permit base -> invalid\n");
2164 /* Pick the base type. */
2165 else if (maybe_in_construction
)
2167 outer_type
= ctx
.outer_type
;
2168 maybe_in_construction
= ctx
.maybe_in_construction
;
2169 maybe_derived_type
= ctx
.maybe_derived_type
;
2170 offset
= ctx
.offset
;
2171 dynamic
= ctx
.dynamic
;
2176 /* TODO handle merging using hiearchy. */
2177 else if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2178 fprintf (dump_file
, "Giving up on merge\n");
2180 updated
|= combine_speculation_with (ctx
.speculative_outer_type
,
2181 ctx
.speculative_offset
,
2182 ctx
.speculative_maybe_derived_type
,
2185 if (updated
&& dump_file
&& (dump_flags
& TDF_DETAILS
))
2187 fprintf (dump_file
, "Updated as: ");
2189 fprintf (dump_file
, "\n");
2195 clear_speculation ();
2196 clear_outer_type ();
2200 /* Take non-speculative info, merge it with speculative and clear speculation.
2201 Used when we no longer manage to keep track of actual outer type, but we
2202 think it is still there.
2204 If OTR_TYPE is set, the transformation can be done more effectively assuming
2205 that context is going to be used only that way. */
2208 ipa_polymorphic_call_context::make_speculative (tree otr_type
)
2210 tree spec_outer_type
= outer_type
;
2211 HOST_WIDE_INT spec_offset
= offset
;
2212 bool spec_maybe_derived_type
= maybe_derived_type
;
2217 clear_outer_type ();
2218 clear_speculation ();
2223 clear_outer_type ();
2224 combine_speculation_with (spec_outer_type
, spec_offset
,
2225 spec_maybe_derived_type
,
2229 /* Use when we can not track dynamic type change. This speculatively assume
2230 type change is not happening. */
2233 ipa_polymorphic_call_context::possible_dynamic_type_change (bool in_poly_cdtor
,
2237 make_speculative (otr_type
);
2238 else if (in_poly_cdtor
)
2239 maybe_in_construction
= true;
2242 /* Return TRUE if this context conveys the same information as OTHER. */
2245 ipa_polymorphic_call_context::equal_to
2246 (const ipa_polymorphic_call_context
&x
) const
2249 return x
.useless_p ();
2252 if (x
.useless_p () || x
.invalid
)
2258 || !types_odr_comparable (outer_type
, x
.outer_type
)
2259 || !types_same_for_odr (outer_type
, x
.outer_type
)
2260 || offset
!= x
.offset
2261 || maybe_in_construction
!= x
.maybe_in_construction
2262 || maybe_derived_type
!= x
.maybe_derived_type
2263 || dynamic
!= x
.dynamic
)
2266 else if (x
.outer_type
)
2270 if (speculative_outer_type
2271 && speculation_consistent_p (speculative_outer_type
, speculative_offset
,
2272 speculative_maybe_derived_type
, NULL_TREE
))
2274 if (!x
.speculative_outer_type
)
2277 if (!types_odr_comparable (speculative_outer_type
,
2278 x
.speculative_outer_type
)
2279 || !types_same_for_odr (speculative_outer_type
,
2280 x
.speculative_outer_type
)
2281 || speculative_offset
!= x
.speculative_offset
2282 || speculative_maybe_derived_type
!= x
.speculative_maybe_derived_type
)
2285 else if (x
.speculative_outer_type
2286 && x
.speculation_consistent_p (x
.speculative_outer_type
,
2287 x
.speculative_offset
,
2288 x
.speculative_maybe_derived_type
,
2295 /* Modify context to be strictly less restrictive than CTX. */
2298 ipa_polymorphic_call_context::meet_with (ipa_polymorphic_call_context ctx
,
2301 bool updated
= false;
2303 if (useless_p () || ctx
.invalid
)
2306 /* Restricting context to inner type makes merging easier, however do not
2307 do that unless we know how the context is used (OTR_TYPE is non-NULL) */
2308 if (otr_type
&& !useless_p () && !ctx
.useless_p ())
2310 restrict_to_inner_class (otr_type
);
2311 ctx
.restrict_to_inner_class (otr_type
);
2319 if (ctx
.useless_p () || invalid
)
2325 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2327 fprintf (dump_file
, "Polymorphic call context meet:");
2329 fprintf (dump_file
, "With context: ");
2330 ctx
.dump (dump_file
);
2333 fprintf (dump_file
, "To be used with type: ");
2334 print_generic_expr (dump_file
, otr_type
, TDF_SLIM
);
2335 fprintf (dump_file
, "\n");
2339 if (!dynamic
&& ctx
.dynamic
)
2345 /* If call is known to be invalid, we are done. */
2348 else if (!ctx
.outer_type
)
2350 clear_outer_type ();
2353 /* If types are known to be same, merging is quite easy. */
2354 else if (types_must_be_same_for_odr (outer_type
, ctx
.outer_type
))
2356 if (offset
!= ctx
.offset
2357 && TYPE_SIZE (outer_type
)
2358 && TREE_CODE (TYPE_SIZE (outer_type
)) == INTEGER_CST
)
2360 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2361 fprintf (dump_file
, "Outer types match, offset mismatch -> clearing\n");
2362 clear_outer_type ();
2365 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2366 fprintf (dump_file
, "Outer types match, merging flags\n");
2367 if (!maybe_in_construction
&& ctx
.maybe_in_construction
)
2370 maybe_in_construction
= true;
2372 if (!maybe_derived_type
&& ctx
.maybe_derived_type
)
2375 maybe_derived_type
= true;
2377 if (!dynamic
&& ctx
.dynamic
)
2383 /* See if one type contains the other as a field (not base). */
2384 else if (contains_type_p (ctx
.outer_type
, ctx
.offset
- offset
,
2385 outer_type
, false, false))
2387 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2388 fprintf (dump_file
, "Second type contain the first as a field\n");
2390 /* The second type is more specified, so we keep the first.
2391 We need to set DYNAMIC flag to avoid declaring context INVALID
2392 of OFFSET ends up being out of range. */
2396 && (!TYPE_SIZE (ctx
.outer_type
)
2397 || !TYPE_SIZE (outer_type
)
2398 || !operand_equal_p (TYPE_SIZE (ctx
.outer_type
),
2399 TYPE_SIZE (outer_type
), 0)))))
2405 else if (contains_type_p (outer_type
, offset
- ctx
.offset
,
2406 ctx
.outer_type
, false, false))
2408 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2409 fprintf (dump_file
, "First type contain the second as a field\n");
2414 && (!TYPE_SIZE (ctx
.outer_type
)
2415 || !TYPE_SIZE (outer_type
)
2416 || !operand_equal_p (TYPE_SIZE (ctx
.outer_type
),
2417 TYPE_SIZE (outer_type
), 0)))))
2419 outer_type
= ctx
.outer_type
;
2420 offset
= ctx
.offset
;
2421 dynamic
= ctx
.dynamic
;
2422 maybe_in_construction
= ctx
.maybe_in_construction
;
2423 maybe_derived_type
= ctx
.maybe_derived_type
;
2426 /* See if OUTER_TYPE is base of CTX.OUTER_TYPE. */
2427 else if (contains_type_p (ctx
.outer_type
,
2428 ctx
.offset
- offset
, outer_type
, false, true))
2430 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2431 fprintf (dump_file
, "First type is base of second\n");
2432 if (!maybe_derived_type
)
2434 maybe_derived_type
= true;
2437 if (!maybe_in_construction
&& ctx
.maybe_in_construction
)
2439 maybe_in_construction
= true;
2442 if (!dynamic
&& ctx
.dynamic
)
2448 /* See if CTX.OUTER_TYPE is base of OUTER_TYPE. */
2449 else if (contains_type_p (outer_type
,
2450 offset
- ctx
.offset
, ctx
.outer_type
, false, true))
2452 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2453 fprintf (dump_file
, "Second type is base of first\n");
2454 outer_type
= ctx
.outer_type
;
2455 offset
= ctx
.offset
;
2457 if (!maybe_derived_type
)
2458 maybe_derived_type
= true;
2459 if (!maybe_in_construction
&& ctx
.maybe_in_construction
)
2460 maybe_in_construction
= true;
2461 if (!dynamic
&& ctx
.dynamic
)
2464 /* TODO handle merging using hiearchy. */
2467 if (dump_file
&& (dump_flags
& TDF_DETAILS
))
2468 fprintf (dump_file
, "Giving up on meet\n");
2469 clear_outer_type ();
2473 updated
|= meet_speculation_with (ctx
.speculative_outer_type
,
2474 ctx
.speculative_offset
,
2475 ctx
.speculative_maybe_derived_type
,
2478 if (updated
&& dump_file
&& (dump_flags
& TDF_DETAILS
))
2480 fprintf (dump_file
, "Updated as: ");
2482 fprintf (dump_file
, "\n");