/* Analysis of polymorphic call context.
- Copyright (C) 2013-2014 Free Software Foundation, Inc.
+ Copyright (C) 2013-2020 Free Software Foundation, Inc.
Contributed by Jan Hubicka
This file is part of GCC.
#include "config.h"
#include "system.h"
#include "coretypes.h"
-#include "tm.h"
+#include "backend.h"
+#include "rtl.h"
#include "tree.h"
-#include "print-tree.h"
-#include "calls.h"
-#include "expr.h"
-#include "tree-pass.h"
-#include "hash-set.h"
-#include "target.h"
-#include "hash-table.h"
-#include "inchash.h"
-#include "tree-pretty-print.h"
-#include "predict.h"
-#include "basic-block.h"
-#include "ipa-utils.h"
-#include "tree-ssa-alias.h"
-#include "internal-fn.h"
-#include "gimple-fold.h"
-#include "gimple-expr.h"
#include "gimple.h"
-#include "ipa-inline.h"
+#include "tree-pass.h"
+#include "tree-ssa-operands.h"
+#include "streamer-hooks.h"
+#include "cgraph.h"
+#include "data-streamer.h"
#include "diagnostic.h"
+#include "alias.h"
+#include "fold-const.h"
+#include "calls.h"
+#include "ipa-utils.h"
#include "tree-dfa.h"
-#include "demangle.h"
-#include "dbgcnt.h"
#include "gimple-pretty-print.h"
-#include "stor-layout.h"
-#include "intl.h"
-#include "data-streamer.h"
-#include "lto-streamer.h"
-#include "streamer-hooks.h"
+#include "tree-into-ssa.h"
/* Return true when TYPE contains an polymorphic type and thus is interesting
for devirtualization machinery. */
}
/* Return true if it seems valid to use placement new to build EXPECTED_TYPE
- at possition CUR_OFFSET within TYPE.
+ at position CUR_OFFSET within TYPE.
POD can be changed to an instance of a polymorphic type by
placement new. Here we play safe and assume that any
possible_placement_new (tree type, tree expected_type,
HOST_WIDE_INT cur_offset)
{
+ if (cur_offset < 0)
+ return true;
return ((TREE_CODE (type) != RECORD_TYPE
|| !TYPE_BINFO (type)
- || cur_offset >= BITS_PER_WORD
+ || cur_offset >= POINTER_SIZE
|| !polymorphic_type_binfo_p (TYPE_BINFO (type)))
&& (!TYPE_SIZE (type)
|| !tree_fits_shwi_p (TYPE_SIZE (type))
|| (cur_offset
+ (expected_type ? tree_to_uhwi (TYPE_SIZE (expected_type))
- : GET_MODE_BITSIZE (Pmode))
+ : POINTER_SIZE)
<= tree_to_uhwi (TYPE_SIZE (type)))));
}
to represent it.
If OTR_TYPE is NULL, just find outermost polymorphic type with
- virtual table present at possition OFFSET.
+ virtual table present at position OFFSET.
For example when THIS represents type
class A
If the same is produced by multiple inheritance, we end up with A and offset
sizeof(int).
- If we can not find corresponding class, give up by setting
+ If we cannot find corresponding class, give up by setting
THIS->OUTER_TYPE to OTR_TYPE and THIS->OFFSET to NULL.
- Return true when lookup was sucesful.
+ Return true when lookup was successful.
When CONSIDER_PLACEMENT_NEW is false, reject contexts that may be made
- valid only via alocation of new polymorphic type inside by means
+ valid only via allocation of new polymorphic type inside by means
of placement new.
When CONSIDER_BASES is false, only look for actual fields, not base types
HOST_WIDE_INT cur_offset = offset;
bool speculative = false;
bool size_unknown = false;
- unsigned HOST_WIDE_INT otr_type_size = GET_MODE_BITSIZE (Pmode);
+ unsigned HOST_WIDE_INT otr_type_size = POINTER_SIZE;
/* Update OUTER_TYPE to match EXPECTED_TYPE if it is not set. */
if (!outer_type)
derived from OUTER_TYPE.
Because the instance type may contain field whose type is of OUTER_TYPE,
- we can not derive any effective information about it.
+ we cannot derive any effective information about it.
- TODO: In the case we know all derrived types, we can definitely do better
+ TODO: In the case we know all derived types, we can definitely do better
here. */
else if (TYPE_SIZE (outer_type)
&& tree_fits_shwi_p (TYPE_SIZE (outer_type))
&& tree_to_shwi (TYPE_SIZE (outer_type)) >= 0
&& tree_to_shwi (TYPE_SIZE (outer_type)) <= offset)
{
+ bool der = maybe_derived_type; /* clear_outer_type will reset it. */
+ bool dyn = dynamic;
clear_outer_type (otr_type);
type = otr_type;
cur_offset = 0;
For dynamic types, we really do not have information about
size of the memory location. It is possible that completely
different type is stored after outer_type. */
- if (!maybe_derived_type && !dynamic)
+ if (!der && !dyn)
{
clear_speculation ();
invalid = true;
tree fld;
/* If we do not know size of TYPE, we need to be more conservative
- about accepting cases where we can not find EXPECTED_TYPE.
+ about accepting cases where we cannot find EXPECTED_TYPE.
Generally the types that do matter here are of constant size.
Size_unknown case should be very rare. */
if (TYPE_SIZE (type)
types. Testing it here may help us to avoid speculation. */
if (otr_type && TREE_CODE (outer_type) == RECORD_TYPE
&& (!in_lto_p || odr_type_p (outer_type))
- && type_known_to_have_no_deriavations_p (outer_type))
+ && type_with_linkage_p (outer_type)
+ && type_known_to_have_no_derivations_p (outer_type))
maybe_derived_type = false;
- /* Type can not contain itself on an non-zero offset. In that case
+ /* Type cannot contain itself on an non-zero offset. In that case
just give up. Still accept the case where size is now known.
Either the second copy may appear past the end of type or within
the non-POD buffer located inside the variably sized type
if (cur_offset != 0)
goto no_useful_type_info;
/* If we determined type precisely or we have no clue on
- speuclation, we are done. */
+ speculation, we are done. */
if (!maybe_derived_type || !speculative_outer_type
|| !speculation_consistent_p (speculative_outer_type,
speculative_offset,
{
for (fld = TYPE_FIELDS (type); fld; fld = DECL_CHAIN (fld))
{
- if (TREE_CODE (fld) != FIELD_DECL)
+ if (TREE_CODE (fld) != FIELD_DECL
+ || TREE_TYPE (fld) == error_mark_node)
continue;
pos = int_bit_position (fld);
size = tree_to_uhwi (DECL_SIZE (fld));
/* We can always skip types smaller than pointer size:
- those can not contain a virtual table pointer.
+ those cannot contain a virtual table pointer.
Disqualifying fields that are too small to fit OTR_TYPE
saves work needed to walk them for no benefit.
if (pos <= (unsigned HOST_WIDE_INT)cur_offset
&& (pos + size) >= (unsigned HOST_WIDE_INT)cur_offset
- + GET_MODE_BITSIZE (Pmode)
+ + POINTER_SIZE
&& (!otr_type
|| !TYPE_SIZE (TREE_TYPE (fld))
|| !tree_fits_shwi_p (TYPE_SIZE (TREE_TYPE (fld)))
{
outer_type = type;
offset = cur_offset;
- /* As soon as we se an field containing the type,
+ /* As soon as we see an field containing the type,
we know we are not looking for derivations. */
maybe_derived_type = false;
}
goto no_useful_type_info;
cur_offset = new_offset;
- type = subtype;
+ type = TYPE_MAIN_VARIANT (subtype);
if (!speculative)
{
outer_type = type;
else
return true;
}
- /* We found no way to embedd EXPECTED_TYPE in TYPE.
+ /* We found no way to embed EXPECTED_TYPE in TYPE.
We still permit two special cases - placement new and
the case of variadic types containing themselves. */
if (!speculative
return true;
}
else
- clear_speculation ();
- return true;
+ {
+ clear_speculation ();
+ return true;
+ }
}
else
{
/* Check that type is within range. */
if (offset < 0)
return false;
- if (TYPE_SIZE (outer_type) && TYPE_SIZE (otr_type)
- && TREE_CODE (outer_type) == INTEGER_CST
- && TREE_CODE (otr_type) == INTEGER_CST
- && wi::ltu_p (wi::to_offset (outer_type), (wi::to_offset (otr_type) + offset)))
- return false;
+
+ /* PR ipa/71207
+ As OUTER_TYPE can be a type which has a diamond virtual inheritance,
+ it's not necessary that INNER_TYPE will fit within OUTER_TYPE with
+ a given offset. It can happen that INNER_TYPE also contains a base object,
+ however it would point to the same instance in the OUTER_TYPE. */
context.offset = offset;
context.outer_type = TYPE_MAIN_VARIANT (outer_type);
context.maybe_derived_type = false;
- return context.restrict_to_inner_class (otr_type, consider_placement_new, consider_bases);
+ context.dynamic = false;
+ return context.restrict_to_inner_class (otr_type, consider_placement_new,
+ consider_bases);
+}
+
+
+/* Return a FUNCTION_DECL if FN represent a constructor or destructor.
+ If CHECK_CLONES is true, also check for clones of ctor/dtors. */
+
+tree
+polymorphic_ctor_dtor_p (tree fn, bool check_clones)
+{
+ if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
+ || (!DECL_CXX_CONSTRUCTOR_P (fn) && !DECL_CXX_DESTRUCTOR_P (fn)))
+ {
+ if (!check_clones)
+ return NULL_TREE;
+
+ /* Watch for clones where we constant propagated the first
+ argument (pointer to the instance). */
+ fn = DECL_ABSTRACT_ORIGIN (fn);
+ if (!fn
+ || TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
+ || (!DECL_CXX_CONSTRUCTOR_P (fn) && !DECL_CXX_DESTRUCTOR_P (fn)))
+ return NULL_TREE;
+ }
+
+ if (flags_from_decl_or_type (fn) & (ECF_PURE | ECF_CONST))
+ return NULL_TREE;
+
+ return fn;
+}
+
+/* Return a FUNCTION_DECL if BLOCK represents a constructor or destructor.
+ If CHECK_CLONES is true, also check for clones of ctor/dtors. */
+
+tree
+inlined_polymorphic_ctor_dtor_block_p (tree block, bool check_clones)
+{
+ tree fn = block_ultimate_origin (block);
+ if (fn == NULL || TREE_CODE (fn) != FUNCTION_DECL)
+ return NULL_TREE;
+
+ return polymorphic_ctor_dtor_p (fn, check_clones);
}
bool
decl_maybe_in_construction_p (tree base, tree outer_type,
- gimple call, tree function)
+ gimple *call, tree function)
{
if (outer_type)
outer_type = TYPE_MAIN_VARIANT (outer_type);
if (DECL_STRUCT_FUNCTION (function)->after_inlining)
return true;
- /* Pure functions can not do any changes on the dynamic type;
- that require writting to memory. */
+ /* Pure functions cannot do any changes on the dynamic type;
+ that require writing to memory. */
if ((!base || !auto_var_in_fn_p (base, function))
&& flags_from_decl_or_type (function) & (ECF_PURE | ECF_CONST))
return false;
+ bool check_clones = !base || is_global_var (base);
for (tree block = gimple_block (call); block && TREE_CODE (block) == BLOCK;
block = BLOCK_SUPERCONTEXT (block))
- if (BLOCK_ABSTRACT_ORIGIN (block)
- && TREE_CODE (BLOCK_ABSTRACT_ORIGIN (block)) == FUNCTION_DECL)
+ if (tree fn = inlined_polymorphic_ctor_dtor_block_p (block, check_clones))
{
- tree fn = BLOCK_ABSTRACT_ORIGIN (block);
-
- if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
- || (!DECL_CXX_CONSTRUCTOR_P (fn)
- && !DECL_CXX_DESTRUCTOR_P (fn)))
- {
- /* Watch for clones where we constant propagated the first
- argument (pointer to the instance). */
- fn = DECL_ABSTRACT_ORIGIN (fn);
- if (!fn
- || (base && !is_global_var (base))
- || TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
- || (!DECL_CXX_CONSTRUCTOR_P (fn)
- && !DECL_CXX_DESTRUCTOR_P (fn)))
- continue;
- }
- if (flags_from_decl_or_type (fn) & (ECF_PURE | ECF_CONST))
- continue;
-
- tree type = TYPE_MAIN_VARIANT (method_class_type (TREE_TYPE (fn)));
+ tree type = TYPE_METHOD_BASETYPE (TREE_TYPE (fn));
if (!outer_type || !types_odr_comparable (type, outer_type))
{
return true;
}
- if (!base || (TREE_CODE (base) == VAR_DECL && is_global_var (base)))
+ if (!base || (VAR_P (base) && is_global_var (base)))
{
if (TREE_CODE (TREE_TYPE (function)) != METHOD_TYPE
|| (!DECL_CXX_CONSTRUCTOR_P (function)
&& !DECL_CXX_DESTRUCTOR_P (function)))
return false;
}
- tree type = TYPE_MAIN_VARIANT (method_class_type (TREE_TYPE (function)));
+ tree type = TYPE_METHOD_BASETYPE (TREE_TYPE (function));
if (!outer_type || !types_odr_comparable (type, outer_type))
{
if (TREE_CODE (type) == RECORD_TYPE
return false;
}
-/* Dump human readable context to F. */
+/* Dump human readable context to F. If NEWLINE is true, it will be terminated
+ by a newline. */
void
-ipa_polymorphic_call_context::dump (FILE *f) const
+ipa_polymorphic_call_context::dump (FILE *f, bool newline) const
{
fprintf (f, " ");
if (invalid)
fprintf (f, " (or a derived type)");
if (maybe_in_construction)
fprintf (f, " (maybe in construction)");
- fprintf (f, " offset "HOST_WIDE_INT_PRINT_DEC,
+ fprintf (f, " offset " HOST_WIDE_INT_PRINT_DEC,
offset);
}
if (speculative_outer_type)
print_generic_expr (f, speculative_outer_type, TDF_SLIM);
if (speculative_maybe_derived_type)
fprintf (f, " (or a derived type)");
- fprintf (f, " at offset "HOST_WIDE_INT_PRINT_DEC,
+ fprintf (f, " at offset " HOST_WIDE_INT_PRINT_DEC,
speculative_offset);
}
}
- fprintf(f, "\n");
+ if (newline)
+ fprintf(f, "\n");
}
/* Print context to stderr. */
/* Stream in the context from IB and DATA_IN. */
void
-ipa_polymorphic_call_context::stream_in (struct lto_input_block *ib,
- struct data_in *data_in)
+ipa_polymorphic_call_context::stream_in (class lto_input_block *ib,
+ class data_in *data_in)
{
struct bitpack_d bp = streamer_read_bitpack (ib);
}
}
-/* Proudce polymorphic call context for call method of instance
+/* Produce polymorphic call context for call method of instance
that is located within BASE (that is assumed to be a decl) at offset OFF. */
void
tree otr_type,
HOST_WIDE_INT off)
{
- HOST_WIDE_INT offset2, size, max_size;
+ poly_int64 offset2, size, max_size;
+ bool reverse;
tree base;
invalid = false;
return false;
cst = TREE_OPERAND (cst, 0);
- base = get_ref_base_and_extent (cst, &offset2, &size, &max_size);
- if (!DECL_P (base) || max_size == -1 || max_size != size)
+ base = get_ref_base_and_extent (cst, &offset2, &size, &max_size, &reverse);
+ if (!DECL_P (base) || !known_size_p (max_size) || maybe_ne (max_size, size))
return false;
/* Only type inconsistent programs can have otr_type that is
STRIP_NOPS (op);
while (TREE_CODE (op) == SSA_NAME
&& !SSA_NAME_IS_DEFAULT_DEF (op)
- && SSA_NAME_DEF_STMT (op)
+ /* We might be called via fold_stmt during cfgcleanup where
+ SSA form need not be up-to-date. */
+ && !name_registered_for_update_p (op)
&& (gimple_assign_single_p (SSA_NAME_DEF_STMT (op))
|| gimple_code (SSA_NAME_DEF_STMT (op)) == GIMPLE_PHI))
{
ptr = ptr.foo;
This pattern is implicitly produced for casts to non-primary
bases. When doing context analysis, we do not really care
- about the case pointer is NULL, becuase the call will be
+ about the case pointer is NULL, because the call will be
undefined anyway. */
if (gimple_code (SSA_NAME_DEF_STMT (op)) == GIMPLE_PHI)
{
- gimple phi = SSA_NAME_DEF_STMT (op);
+ gimple *phi = SSA_NAME_DEF_STMT (op);
if (gimple_phi_num_args (phi) > 2)
goto done;
ipa_polymorphic_call_context::ipa_polymorphic_call_context (tree fndecl,
tree ref,
- gimple stmt,
+ gimple *stmt,
tree *instance)
{
tree otr_type = NULL;
base_pointer = walk_ssa_copies (base_pointer, &visited);
if (TREE_CODE (base_pointer) == ADDR_EXPR)
{
- HOST_WIDE_INT size, max_size;
- HOST_WIDE_INT offset2;
- tree base = get_ref_base_and_extent (TREE_OPERAND (base_pointer, 0),
- &offset2, &size, &max_size);
+ HOST_WIDE_INT offset2, size;
+ bool reverse;
+ tree base
+ = get_ref_base_and_extent_hwi (TREE_OPERAND (base_pointer, 0),
+ &offset2, &size, &reverse);
+ if (!base)
+ break;
- if (max_size != -1 && max_size == size)
- combine_speculation_with (TYPE_MAIN_VARIANT (TREE_TYPE (base)),
- offset + offset2,
- true,
- NULL /* Do not change outer type. */);
+ combine_speculation_with (TYPE_MAIN_VARIANT (TREE_TYPE (base)),
+ offset + offset2,
+ true,
+ NULL /* Do not change outer type. */);
/* If this is a varying address, punt. */
- if ((TREE_CODE (base) == MEM_REF || DECL_P (base))
- && max_size != -1
- && max_size == size)
+ if (TREE_CODE (base) == MEM_REF || DECL_P (base))
{
/* We found dereference of a pointer. Type of the pointer
- and MEM_REF is meaningless, but we can look futher. */
- if (TREE_CODE (base) == MEM_REF)
+ and MEM_REF is meaningless, but we can look further. */
+ offset_int mem_offset;
+ if (TREE_CODE (base) == MEM_REF
+ && mem_ref_offset (base).is_constant (&mem_offset))
{
+ offset_int o = mem_offset * BITS_PER_UNIT;
+ o += offset;
+ o += offset2;
+ if (!wi::fits_shwi_p (o))
+ break;
base_pointer = TREE_OPERAND (base, 0);
- offset
- += offset2 + mem_ref_offset (base).to_short_addr () * BITS_PER_UNIT;
+ offset = o.to_shwi ();
outer_type = NULL;
}
/* We found base object. In this case the outer_type
break;
}
else if (TREE_CODE (base_pointer) == POINTER_PLUS_EXPR
- && tree_fits_uhwi_p (TREE_OPERAND (base_pointer, 1)))
+ && TREE_CODE (TREE_OPERAND (base_pointer, 1)) == INTEGER_CST)
{
- offset += tree_to_shwi (TREE_OPERAND (base_pointer, 1))
- * BITS_PER_UNIT;
+ offset_int o
+ = offset_int::from (wi::to_wide (TREE_OPERAND (base_pointer, 1)),
+ SIGNED);
+ o *= BITS_PER_UNIT;
+ o += offset;
+ if (!wi::fits_shwi_p (o))
+ break;
+ offset = o.to_shwi ();
base_pointer = TREE_OPERAND (base_pointer, 0);
}
else
{
outer_type
= TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (base_pointer)));
+ cgraph_node *node = cgraph_node::get (current_function_decl);
gcc_assert (TREE_CODE (outer_type) == RECORD_TYPE
|| TREE_CODE (outer_type) == UNION_TYPE);
+ /* Handle the case we inlined into a thunk. In this case
+ thunk has THIS pointer of type bar, but it really receives
+ address to its base type foo which sits in bar at
+ 0-thunk.fixed_offset. It starts with code that adds
+ think.fixed_offset to the pointer to compensate for this.
+
+ Because we walked all the way to the beginning of thunk, we now
+ see pointer &bar-thunk.fixed_offset and need to compensate
+ for it. */
+ if (node->thunk.fixed_offset)
+ offset -= node->thunk.fixed_offset * BITS_PER_UNIT;
+
/* Dynamic casting has possibly upcasted the type
- in the hiearchy. In this case outer type is less
+ in the hierarchy. In this case outer type is less
informative than inner type and we should forget
about it. */
if ((otr_type
&& !contains_type_p (outer_type, offset,
otr_type))
- || !contains_polymorphic_type_p (outer_type))
+ || !contains_polymorphic_type_p (outer_type)
+ /* If we compile thunk with virtual offset, the THIS pointer
+ is adjusted by unknown value. We can't thus use outer info
+ at all. */
+ || node->thunk.virtual_offset_p)
{
outer_type = NULL;
if (instance)
maybe_in_construction = false;
}
if (instance)
- *instance = base_pointer;
+ {
+ /* If method is expanded thunk, we need to apply thunk offset
+ to instance pointer. */
+ if (node->thunk.virtual_offset_p
+ || node->thunk.fixed_offset)
+ *instance = NULL;
+ else
+ *instance = base_pointer;
+ }
return;
}
/* Non-PODs passed by value are really passed by invisible
if (TREE_CODE (base_pointer) == SSA_NAME
&& SSA_NAME_IS_DEFAULT_DEF (base_pointer)
- && TREE_CODE (SSA_NAME_VAR (base_pointer)) != PARM_DECL)
+ && !(TREE_CODE (SSA_NAME_VAR (base_pointer)) == PARM_DECL
+ || TREE_CODE (SSA_NAME_VAR (base_pointer)) == RESULT_DECL))
{
invalid = true;
if (instance)
base_type = TREE_TYPE (gimple_assign_rhs1
(SSA_NAME_DEF_STMT (base_pointer)));
- if (POINTER_TYPE_P (base_type))
+ if (base_type && POINTER_TYPE_P (base_type))
combine_speculation_with (TYPE_MAIN_VARIANT (TREE_TYPE (base_type)),
offset,
true, NULL /* Do not change type here */);
/* TODO: There are multiple ways to derive a type. For instance
- if BASE_POINTER is passed to an constructor call prior our refernece.
+ if BASE_POINTER is passed to an constructor call prior our reference.
We do not make this type of flow sensitive analysis yet. */
if (instance)
*instance = base_pointer;
tree known_current_type;
HOST_WIDE_INT known_current_offset;
+ /* Set to nonzero if we possibly missed some dynamic type changes and we
+ should consider the set to be speculative. */
+ unsigned speculative;
+
/* Set to true if dynamic type change has been detected. */
bool type_maybe_changed;
/* Set to true if multiple types have been encountered. known_current_type
must be disregarded in that case. */
bool multiple_types_encountered;
- /* Set to true if we possibly missed some dynamic type changes and we should
- consider the set to be speculative. */
- bool speculative;
bool seen_unanalyzed_store;
};
and destructor functions. */
static bool
-noncall_stmt_may_be_vtbl_ptr_store (gimple stmt)
+noncall_stmt_may_be_vtbl_ptr_store (gimple *stmt)
{
if (is_gimple_assign (stmt))
{
if (TREE_CODE (lhs) == COMPONENT_REF
&& !DECL_VIRTUAL_P (TREE_OPERAND (lhs, 1)))
return false;
- /* In the future we might want to use get_base_ref_and_offset to find
+ /* In the future we might want to use get_ref_base_and_extent to find
if there is a field corresponding to the offset and if so, proceed
almost like if it was a component ref. */
}
for (tree block = gimple_block (stmt); block && TREE_CODE (block) == BLOCK;
block = BLOCK_SUPERCONTEXT (block))
if (BLOCK_ABSTRACT_ORIGIN (block)
- && TREE_CODE (BLOCK_ABSTRACT_ORIGIN (block)) == FUNCTION_DECL)
- {
- tree fn = BLOCK_ABSTRACT_ORIGIN (block);
-
- if (flags_from_decl_or_type (fn) & (ECF_PURE | ECF_CONST))
- return false;
- return (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
- && (DECL_CXX_CONSTRUCTOR_P (fn)
- || DECL_CXX_DESTRUCTOR_P (fn)));
- }
+ && TREE_CODE (block_ultimate_origin (block)) == FUNCTION_DECL)
+ return inlined_polymorphic_ctor_dtor_block_p (block, false);
return (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE
&& (DECL_CXX_CONSTRUCTOR_P (current_function_decl)
|| DECL_CXX_DESTRUCTOR_P (current_function_decl)));
in unknown way or ERROR_MARK_NODE if type is unchanged. */
static tree
-extr_type_from_vtbl_ptr_store (gimple stmt, struct type_change_info *tci,
+extr_type_from_vtbl_ptr_store (gimple *stmt, struct type_change_info *tci,
HOST_WIDE_INT *type_offset)
{
- HOST_WIDE_INT offset, size, max_size;
+ poly_int64 offset, size, max_size;
tree lhs, rhs, base;
+ bool reverse;
if (!gimple_assign_single_p (stmt))
return NULL_TREE;
;
else
{
- base = get_ref_base_and_extent (lhs, &offset, &size, &max_size);
+ base = get_ref_base_and_extent (lhs, &offset, &size, &max_size, &reverse);
if (DECL_P (tci->instance))
{
if (base != tci->instance)
print_generic_expr (dump_file, tci->instance, TDF_SLIM);
fprintf (dump_file, " with offset %i\n", (int)tci->offset);
}
- return tci->offset > GET_MODE_BITSIZE (Pmode) ? error_mark_node : NULL_TREE;
+ return tci->offset > POINTER_SIZE ? error_mark_node : NULL_TREE;
}
- if (offset != tci->offset
- || size != POINTER_SIZE
- || max_size != POINTER_SIZE)
+ if (maybe_ne (offset, tci->offset)
+ || maybe_ne (size, POINTER_SIZE)
+ || maybe_ne (max_size, POINTER_SIZE))
{
if (dump_file)
- fprintf (dump_file, " wrong offset %i!=%i or size %i\n",
- (int)offset, (int)tci->offset, (int)size);
- return offset + GET_MODE_BITSIZE (Pmode) <= tci->offset
- || (max_size != -1
- && tci->offset + GET_MODE_BITSIZE (Pmode) > offset + max_size)
- ? error_mark_node : NULL;
+ {
+ fprintf (dump_file, " wrong offset ");
+ print_dec (offset, dump_file);
+ fprintf (dump_file, "!=%i or size ", (int) tci->offset);
+ print_dec (size, dump_file);
+ fprintf (dump_file, "\n");
+ }
+ return (known_le (offset + POINTER_SIZE, tci->offset)
+ || (known_size_p (max_size)
+ && known_gt (tci->offset + POINTER_SIZE,
+ offset + max_size))
+ ? error_mark_node : NULL);
}
}
{
if (dump_file)
fprintf (dump_file, " Construction vtable used\n");
- /* FIXME: We should suport construction contexts. */
+ /* FIXME: We should support construction contexts. */
return NULL;
}
if (type
&& (offset
|| (TREE_CODE (type) != RECORD_TYPE
+ || !TYPE_BINFO (type)
|| !polymorphic_type_binfo_p (TYPE_BINFO (type)))))
{
ipa_polymorphic_call_context context;
tci->type_maybe_changed = true;
}
+
+/* The maximum number of may-defs we visit when looking for a must-def
+ that changes the dynamic type in check_stmt_for_type_change. Tuned
+ after the PR12392 testcase which unlimited spends 40% time within
+ these alias walks and 8% with the following limit. */
+
+static inline bool
+csftc_abort_walking_p (unsigned speculative)
+{
+ unsigned max = param_max_speculative_devirt_maydefs;
+ return speculative > max ? true : false;
+}
+
/* Callback of walk_aliased_vdefs and a helper function for
detect_type_change to check whether a particular statement may modify
the virtual table pointer, and if possible also determine the new type of
static bool
check_stmt_for_type_change (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef, void *data)
{
- gimple stmt = SSA_NAME_DEF_STMT (vdef);
+ gimple *stmt = SSA_NAME_DEF_STMT (vdef);
struct type_change_info *tci = (struct type_change_info *) data;
tree fn;
&& gimple_call_num_args (stmt))
{
tree op = walk_ssa_copies (gimple_call_arg (stmt, 0));
- tree type = method_class_type (TREE_TYPE (fn));
- HOST_WIDE_INT offset = 0, size, max_size;
+ tree type = TYPE_METHOD_BASETYPE (TREE_TYPE (fn));
+ HOST_WIDE_INT offset = 0;
+ bool reverse;
if (dump_file)
{
fprintf (dump_file, " Checking constructor call: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
/* See if THIS parameter seems like instance pointer. */
if (TREE_CODE (op) == ADDR_EXPR)
{
- op = get_ref_base_and_extent (TREE_OPERAND (op, 0),
- &offset, &size, &max_size);
- if (size != max_size || max_size == -1)
+ HOST_WIDE_INT size;
+ op = get_ref_base_and_extent_hwi (TREE_OPERAND (op, 0),
+ &offset, &size, &reverse);
+ if (!op)
{
- tci->speculative = true;
- return false;
+ tci->speculative++;
+ return csftc_abort_walking_p (tci->speculative);
}
- if (op && TREE_CODE (op) == MEM_REF)
+ if (TREE_CODE (op) == MEM_REF)
{
if (!tree_fits_shwi_p (TREE_OPERAND (op, 1)))
{
- tci->speculative = true;
- return false;
+ tci->speculative++;
+ return csftc_abort_walking_p (tci->speculative);
}
offset += tree_to_shwi (TREE_OPERAND (op, 1))
* BITS_PER_UNIT;
;
else
{
- tci->speculative = true;
- return false;
+ tci->speculative++;
+ return csftc_abort_walking_p (tci->speculative);
}
op = walk_ssa_copies (op);
}
&& TYPE_SIZE (type)
&& TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
&& tree_fits_shwi_p (TYPE_SIZE (type))
- && tree_to_shwi (TYPE_SIZE (type)) + offset > tci->offset)
+ && tree_to_shwi (TYPE_SIZE (type)) + offset > tci->offset
+ /* Some inlined constructors may look as follows:
+ _3 = operator new (16);
+ MEM[(struct &)_3] ={v} {CLOBBER};
+ MEM[(struct CompositeClass *)_3]._vptr.CompositeClass
+ = &MEM[(void *)&_ZTV14CompositeClass + 16B];
+ _7 = &MEM[(struct CompositeClass *)_3].object;
+ EmptyClass::EmptyClass (_7);
+
+ When determining dynamic type of _3 and because we stop at first
+ dynamic type found, we would stop on EmptyClass::EmptyClass (_7).
+ In this case the emptyclass is not even polymorphic and we miss
+ it is contained in an outer type that is polymorphic. */
+
+ && (tci->offset == offset || contains_polymorphic_type_p (type)))
{
record_known_type (tci, type, tci->offset - offset);
return true;
if (dump_file)
{
fprintf (dump_file, " Function call may change dynamic type:");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
- tci->speculative = true;
- return false;
+ tci->speculative++;
+ return csftc_abort_walking_p (tci->speculative);
}
/* Check for inlined virtual table store. */
else if (noncall_stmt_may_be_vtbl_ptr_store (stmt))
if (dump_file)
{
fprintf (dump_file, " Checking vtbl store: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
}
type = extr_type_from_vtbl_ptr_store (stmt, tci, &offset);
if (dump_file)
fprintf (dump_file, " Unanalyzed store may change type.\n");
tci->seen_unanalyzed_store = true;
- tci->speculative = true;
+ tci->speculative++;
}
else
record_known_type (tci, type, offset);
We do not include this analysis in the context analysis itself, because
it needs memory SSA to be fully built and the walk may be expensive.
- So it is not suitable for use withing fold_stmt and similar uses. */
+ So it is not suitable for use withing fold_stmt and similar uses.
+
+ AA_WALK_BUDGET_P, if not NULL, is how statements we should allow
+ walk_aliased_vdefs to examine. The value should be decremented by the
+ number of statements we examined or set to zero if exhausted. */
bool
ipa_polymorphic_call_context::get_dynamic_type (tree instance,
tree otr_object,
tree otr_type,
- gimple call)
+ gimple *call,
+ unsigned *aa_walk_budget_p)
{
struct type_change_info tci;
ao_ref ao;
bool function_entry_reached = false;
tree instance_ref = NULL;
- gimple stmt = call;
+ gimple *stmt = call;
/* Remember OFFSET before it is modified by restrict_to_inner_class.
This is because we do not update INSTANCE when walking inwards. */
HOST_WIDE_INT instance_offset = offset;
+ tree instance_outer_type = outer_type;
+
+ if (!instance)
+ return false;
if (otr_type)
otr_type = TYPE_MAIN_VARIANT (otr_type);
/* Walk into inner type. This may clear maybe_derived_type and save us
- from useless work. It also makes later comparsions with static type
+ from useless work. It also makes later comparisons with static type
easier. */
if (outer_type && otr_type)
{
if (!maybe_in_construction && !maybe_derived_type)
return false;
- /* We need to obtain refernce to virtual table pointer. It is better
+ /* If we are in fact not looking at any object object or the instance is
+ some placement new into a random load, give up straight away. */
+ if (TREE_CODE (instance) == MEM_REF)
+ return false;
+
+ /* We need to obtain reference to virtual table pointer. It is better
to look it up in the code rather than build our own. This require bit
of pattern matching, but we end up verifying that what we found is
correct.
if (gimple_code (call) == GIMPLE_CALL)
{
tree ref = gimple_call_fn (call);
- HOST_WIDE_INT offset2, size, max_size;
+ bool reverse;
if (TREE_CODE (ref) == OBJ_TYPE_REF)
{
ref = OBJ_TYPE_REF_EXPR (ref);
ref = walk_ssa_copies (ref);
+ /* If call target is already known, no need to do the expensive
+ memory walk. */
+ if (is_gimple_min_invariant (ref))
+ return false;
+
/* Check if definition looks like vtable lookup. */
if (TREE_CODE (ref) == SSA_NAME
&& !SSA_NAME_IS_DEFAULT_DEF (ref)
&& !SSA_NAME_IS_DEFAULT_DEF (ref)
&& gimple_assign_load_p (SSA_NAME_DEF_STMT (ref)))
{
+ HOST_WIDE_INT offset2, size;
tree ref_exp = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (ref));
- tree base_ref = get_ref_base_and_extent
- (ref_exp, &offset2, &size, &max_size);
+ tree base_ref
+ = get_ref_base_and_extent_hwi (ref_exp, &offset2,
+ &size, &reverse);
- /* Finally verify that what we found looks like read from OTR_OBJECT
- or from INSTANCE with offset OFFSET. */
+ /* Finally verify that what we found looks like read from
+ OTR_OBJECT or from INSTANCE with offset OFFSET. */
if (base_ref
&& ((TREE_CODE (base_ref) == MEM_REF
&& ((offset2 == instance_offset
&& TREE_OPERAND (base_ref, 0) == instance)
- || (!offset2 && TREE_OPERAND (base_ref, 0) == otr_object)))
+ || (!offset2
+ && TREE_OPERAND (base_ref, 0)
+ == otr_object)))
|| (DECL_P (instance) && base_ref == instance
&& offset2 == instance_offset)))
{
}
}
- /* If we failed to look up the refernece in code, build our own. */
+ /* If we failed to look up the reference in code, build our own. */
if (!instance_ref)
{
/* If the statement in question does not use memory, we can't tell
/* We look for vtbl pointer read. */
ao.size = POINTER_SIZE;
ao.max_size = ao.size;
+ /* We are looking for stores to vptr pointer within the instance of
+ outer type.
+ TODO: The vptr pointer type is globally known, we probably should
+ keep it and do that even when otr_type is unknown. */
if (otr_type)
- ao.ref_alias_set
- = get_deref_alias_set (TREE_TYPE (BINFO_VTABLE (TYPE_BINFO (otr_type))));
+ {
+ ao.base_alias_set
+ = get_alias_set (outer_type ? outer_type : otr_type);
+ ao.ref_alias_set
+ = get_alias_set (TREE_TYPE (BINFO_VTABLE (TYPE_BINFO (otr_type))));
+ }
if (dump_file)
{
fprintf (dump_file, "Determining dynamic type for call: ");
- print_gimple_stmt (dump_file, call, 0, 0);
+ print_gimple_stmt (dump_file, call, 0);
fprintf (dump_file, " Starting walk at: ");
- print_gimple_stmt (dump_file, stmt, 0, 0);
+ print_gimple_stmt (dump_file, stmt, 0);
fprintf (dump_file, " instance pointer: ");
print_generic_expr (dump_file, otr_object, TDF_SLIM);
fprintf (dump_file, " Outer instance pointer: ");
print_generic_expr (dump_file, instance, TDF_SLIM);
- fprintf (dump_file, " offset: %i (bits)", (int)offset);
+ fprintf (dump_file, " offset: %i (bits)", (int)instance_offset);
fprintf (dump_file, " vtbl reference: ");
print_generic_expr (dump_file, instance_ref, TDF_SLIM);
fprintf (dump_file, "\n");
}
- tci.offset = offset;
+ tci.offset = instance_offset;
tci.instance = instance;
tci.vtbl_ptr_ref = instance_ref;
- gcc_assert (TREE_CODE (instance) != MEM_REF);
tci.known_current_type = NULL_TREE;
tci.known_current_offset = 0;
tci.otr_type = otr_type;
tci.type_maybe_changed = false;
tci.multiple_types_encountered = false;
- tci.speculative = false;
+ tci.speculative = 0;
tci.seen_unanalyzed_store = false;
- walk_aliased_vdefs (&ao, gimple_vuse (stmt), check_stmt_for_type_change,
- &tci, NULL, &function_entry_reached);
+ unsigned aa_walk_budget = 0;
+ if (aa_walk_budget_p)
+ aa_walk_budget = *aa_walk_budget_p + 1;
+
+ int walked
+ = walk_aliased_vdefs (&ao, gimple_vuse (stmt), check_stmt_for_type_change,
+ &tci, NULL, &function_entry_reached, aa_walk_budget);
/* If we did not find any type changing statements, we may still drop
maybe_in_construction flag if the context already have outer type.
sub-objects and the code written by the user is run. Only this may
include calling virtual functions, directly or indirectly.
- 4) placement new can not be used to change type of non-POD statically
+ 4) placement new cannot be used to change type of non-POD statically
allocated variables.
There is no way to call a constructor of an ancestor sub-object in any
Therefore if the static outer type was found (outer_type)
we can safely ignore tci.speculative that is set on calls and give up
- only if there was dyanmic type store that may affect given variable
+ only if there was dynamic type store that may affect given variable
(seen_unanalyzed_store) */
+ if (walked < 0)
+ {
+ if (dump_file)
+ fprintf (dump_file, " AA walk budget exhausted.\n");
+ *aa_walk_budget_p = 0;
+ return false;
+ }
+ else if (aa_walk_budget_p)
+ *aa_walk_budget_p -= walked;
+
if (!tci.type_maybe_changed
|| (outer_type
&& !dynamic
&& !tci.seen_unanalyzed_store
&& !tci.multiple_types_encountered
- && offset == tci.offset
- && types_same_for_odr (tci.known_current_type,
- outer_type)))
+ && ((offset == tci.offset
+ && types_same_for_odr (tci.known_current_type,
+ outer_type))
+ || (instance_offset == offset
+ && types_same_for_odr (tci.known_current_type,
+ instance_outer_type)))))
{
if (!outer_type || tci.seen_unanalyzed_store)
return false;
ipa_polymorphic_call_context::speculation_consistent_p (tree spec_outer_type,
HOST_WIDE_INT spec_offset,
bool spec_maybe_derived_type,
- tree otr_type)
+ tree otr_type) const
{
if (!flag_devirtualize_speculatively)
return false;
return false;
/* restrict_to_inner_class may eliminate wrong speculation making our job
- easeier. */
+ easier. */
if (otr_type)
restrict_to_inner_class (otr_type);
}
/* Choose type that contains the other. This one either contains the outer
as a field (thus giving exactly one target) or is deeper in the type
- hiearchy. */
+ hierarchy. */
else if (speculative_outer_type
&& speculative_maybe_derived_type
&& (new_offset > speculative_offset
return false;
}
-/* Assume that both THIS and a given context is valid and strenghten THIS
- if possible. Return true if any strenghtening was made.
+/* Make speculation less specific so
+ NEW_OUTER_TYPE, NEW_OFFSET, NEW_MAYBE_DERIVED_TYPE is also included.
+ If OTR_TYPE is set, assume the context is used with OTR_TYPE. */
+
+bool
+ipa_polymorphic_call_context::meet_speculation_with
+ (tree new_outer_type, HOST_WIDE_INT new_offset, bool new_maybe_derived_type,
+ tree otr_type)
+{
+ if (!new_outer_type && speculative_outer_type)
+ {
+ clear_speculation ();
+ return true;
+ }
+
+ /* restrict_to_inner_class may eliminate wrong speculation making our job
+ easier. */
+ if (otr_type)
+ restrict_to_inner_class (otr_type);
+
+ if (!speculative_outer_type
+ || !speculation_consistent_p (speculative_outer_type,
+ speculative_offset,
+ speculative_maybe_derived_type,
+ otr_type))
+ return false;
+
+ if (!speculation_consistent_p (new_outer_type, new_offset,
+ new_maybe_derived_type, otr_type))
+ {
+ clear_speculation ();
+ return true;
+ }
+
+ else if (types_must_be_same_for_odr (speculative_outer_type,
+ new_outer_type))
+ {
+ if (speculative_offset != new_offset)
+ {
+ clear_speculation ();
+ return true;
+ }
+ else
+ {
+ if (!speculative_maybe_derived_type && new_maybe_derived_type)
+ {
+ speculative_maybe_derived_type = true;
+ return true;
+ }
+ else
+ return false;
+ }
+ }
+ /* See if one type contains the other as a field (not base). */
+ else if (contains_type_p (new_outer_type, new_offset - speculative_offset,
+ speculative_outer_type, false, false))
+ return false;
+ else if (contains_type_p (speculative_outer_type,
+ speculative_offset - new_offset,
+ new_outer_type, false, false))
+ {
+ speculative_outer_type = new_outer_type;
+ speculative_offset = new_offset;
+ speculative_maybe_derived_type = new_maybe_derived_type;
+ return true;
+ }
+ /* See if OUTER_TYPE is base of CTX.OUTER_TYPE. */
+ else if (contains_type_p (new_outer_type,
+ new_offset - speculative_offset,
+ speculative_outer_type, false, true))
+ {
+ if (!speculative_maybe_derived_type)
+ {
+ speculative_maybe_derived_type = true;
+ return true;
+ }
+ return false;
+ }
+ /* See if CTX.OUTER_TYPE is base of OUTER_TYPE. */
+ else if (contains_type_p (speculative_outer_type,
+ speculative_offset - new_offset, new_outer_type, false, true))
+ {
+ speculative_outer_type = new_outer_type;
+ speculative_offset = new_offset;
+ speculative_maybe_derived_type = true;
+ return true;
+ }
+ else
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "Giving up on speculative meet\n");
+ clear_speculation ();
+ return true;
+ }
+}
+
+/* Assume that both THIS and a given context is valid and strengthen THIS
+ if possible. Return true if any strengthening was made.
If actual type the context is being used in is known, OTR_TYPE should be
set accordingly. This improves quality of combined result. */
updated = true;
}
- /* If we do not know how the context is being used, we can
- not clear MAYBE_IN_CONSTRUCTION because it may be offseted
+ /* If we do not know how the context is being used, we cannot
+ clear MAYBE_IN_CONSTRUCTION because it may be offseted
to other component of OUTER_TYPE later and we know nothing
about it. */
if (otr_type && maybe_in_construction
goto invalidate;
}
}
- /* Pick variant deeper in the hiearchy. */
+ /* Pick variant deeper in the hierarchy. */
else
{
outer_type = ctx.outer_type;
fprintf (dump_file, "First context does not permit base -> invalid\n");
goto invalidate;
}
+ /* Pick the base type. */
+ else if (maybe_in_construction)
+ {
+ outer_type = ctx.outer_type;
+ maybe_in_construction = ctx.maybe_in_construction;
+ maybe_derived_type = ctx.maybe_derived_type;
+ offset = ctx.offset;
+ dynamic = ctx.dynamic;
+ updated = true;
+ }
}
}
- /* TODO handle merging using hiearchy. */
+ /* TODO handle merging using hierarchy. */
else if (dump_file && (dump_flags & TDF_DETAILS))
fprintf (dump_file, "Giving up on merge\n");
otr_type);
}
-/* Use when we can not track dynamic type change. This speculatively assume
+/* Use when we cannot track dynamic type change. This speculatively assume
type change is not happening. */
void
else if (in_poly_cdtor)
maybe_in_construction = true;
}
+
+/* Return TRUE if this context conveys the same information as OTHER. */
+
+bool
+ipa_polymorphic_call_context::equal_to
+ (const ipa_polymorphic_call_context &x) const
+{
+ if (useless_p ())
+ return x.useless_p ();
+ if (invalid)
+ return x.invalid;
+ if (x.useless_p () || x.invalid)
+ return false;
+
+ if (outer_type)
+ {
+ if (!x.outer_type
+ || !types_odr_comparable (outer_type, x.outer_type)
+ || !types_same_for_odr (outer_type, x.outer_type)
+ || offset != x.offset
+ || maybe_in_construction != x.maybe_in_construction
+ || maybe_derived_type != x.maybe_derived_type
+ || dynamic != x.dynamic)
+ return false;
+ }
+ else if (x.outer_type)
+ return false;
+
+
+ if (speculative_outer_type
+ && speculation_consistent_p (speculative_outer_type, speculative_offset,
+ speculative_maybe_derived_type, NULL_TREE))
+ {
+ if (!x.speculative_outer_type)
+ return false;
+
+ if (!types_odr_comparable (speculative_outer_type,
+ x.speculative_outer_type)
+ || !types_same_for_odr (speculative_outer_type,
+ x.speculative_outer_type)
+ || speculative_offset != x.speculative_offset
+ || speculative_maybe_derived_type != x.speculative_maybe_derived_type)
+ return false;
+ }
+ else if (x.speculative_outer_type
+ && x.speculation_consistent_p (x.speculative_outer_type,
+ x.speculative_offset,
+ x.speculative_maybe_derived_type,
+ NULL))
+ return false;
+
+ return true;
+}
+
+/* Modify context to be strictly less restrictive than CTX. */
+
+bool
+ipa_polymorphic_call_context::meet_with (ipa_polymorphic_call_context ctx,
+ tree otr_type)
+{
+ bool updated = false;
+
+ if (useless_p () || ctx.invalid)
+ return false;
+
+ /* Restricting context to inner type makes merging easier, however do not
+ do that unless we know how the context is used (OTR_TYPE is non-NULL) */
+ if (otr_type && !useless_p () && !ctx.useless_p ())
+ {
+ restrict_to_inner_class (otr_type);
+ ctx.restrict_to_inner_class (otr_type);
+ if(invalid)
+ return false;
+ }
+
+ if (equal_to (ctx))
+ return false;
+
+ if (ctx.useless_p () || invalid)
+ {
+ *this = ctx;
+ return true;
+ }
+
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "Polymorphic call context meet:");
+ dump (dump_file);
+ fprintf (dump_file, "With context: ");
+ ctx.dump (dump_file);
+ if (otr_type)
+ {
+ fprintf (dump_file, "To be used with type: ");
+ print_generic_expr (dump_file, otr_type, TDF_SLIM);
+ fprintf (dump_file, "\n");
+ }
+ }
+
+ if (!dynamic && ctx.dynamic)
+ {
+ dynamic = true;
+ updated = true;
+ }
+
+ /* If call is known to be invalid, we are done. */
+ if (!outer_type)
+ ;
+ else if (!ctx.outer_type)
+ {
+ clear_outer_type ();
+ updated = true;
+ }
+ /* If types are known to be same, merging is quite easy. */
+ else if (types_must_be_same_for_odr (outer_type, ctx.outer_type))
+ {
+ if (offset != ctx.offset
+ && TYPE_SIZE (outer_type)
+ && TREE_CODE (TYPE_SIZE (outer_type)) == INTEGER_CST)
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "Outer types match, offset mismatch -> clearing\n");
+ clear_outer_type ();
+ return true;
+ }
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "Outer types match, merging flags\n");
+ if (!maybe_in_construction && ctx.maybe_in_construction)
+ {
+ updated = true;
+ maybe_in_construction = true;
+ }
+ if (!maybe_derived_type && ctx.maybe_derived_type)
+ {
+ updated = true;
+ maybe_derived_type = true;
+ }
+ if (!dynamic && ctx.dynamic)
+ {
+ updated = true;
+ dynamic = true;
+ }
+ }
+ /* See if one type contains the other as a field (not base). */
+ else if (contains_type_p (ctx.outer_type, ctx.offset - offset,
+ outer_type, false, false))
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "Second type contain the first as a field\n");
+
+ /* The second type is more specified, so we keep the first.
+ We need to set DYNAMIC flag to avoid declaring context INVALID
+ of OFFSET ends up being out of range. */
+ if (!dynamic
+ && (ctx.dynamic
+ || (!otr_type
+ && (!TYPE_SIZE (ctx.outer_type)
+ || !TYPE_SIZE (outer_type)
+ || !operand_equal_p (TYPE_SIZE (ctx.outer_type),
+ TYPE_SIZE (outer_type), 0)))))
+ {
+ dynamic = true;
+ updated = true;
+ }
+ }
+ else if (contains_type_p (outer_type, offset - ctx.offset,
+ ctx.outer_type, false, false))
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "First type contain the second as a field\n");
+
+ if (!dynamic
+ && (ctx.dynamic
+ || (!otr_type
+ && (!TYPE_SIZE (ctx.outer_type)
+ || !TYPE_SIZE (outer_type)
+ || !operand_equal_p (TYPE_SIZE (ctx.outer_type),
+ TYPE_SIZE (outer_type), 0)))))
+ dynamic = true;
+ outer_type = ctx.outer_type;
+ offset = ctx.offset;
+ dynamic = ctx.dynamic;
+ maybe_in_construction = ctx.maybe_in_construction;
+ maybe_derived_type = ctx.maybe_derived_type;
+ updated = true;
+ }
+ /* See if OUTER_TYPE is base of CTX.OUTER_TYPE. */
+ else if (contains_type_p (ctx.outer_type,
+ ctx.offset - offset, outer_type, false, true))
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "First type is base of second\n");
+ if (!maybe_derived_type)
+ {
+ maybe_derived_type = true;
+ updated = true;
+ }
+ if (!maybe_in_construction && ctx.maybe_in_construction)
+ {
+ maybe_in_construction = true;
+ updated = true;
+ }
+ if (!dynamic && ctx.dynamic)
+ {
+ dynamic = true;
+ updated = true;
+ }
+ }
+ /* See if CTX.OUTER_TYPE is base of OUTER_TYPE. */
+ else if (contains_type_p (outer_type,
+ offset - ctx.offset, ctx.outer_type, false, true))
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "Second type is base of first\n");
+ outer_type = ctx.outer_type;
+ offset = ctx.offset;
+ updated = true;
+ if (!maybe_derived_type)
+ maybe_derived_type = true;
+ if (!maybe_in_construction && ctx.maybe_in_construction)
+ maybe_in_construction = true;
+ if (!dynamic && ctx.dynamic)
+ dynamic = true;
+ }
+ /* TODO handle merging using hierarchy. */
+ else
+ {
+ if (dump_file && (dump_flags & TDF_DETAILS))
+ fprintf (dump_file, "Giving up on meet\n");
+ clear_outer_type ();
+ updated = true;
+ }
+
+ updated |= meet_speculation_with (ctx.speculative_outer_type,
+ ctx.speculative_offset,
+ ctx.speculative_maybe_derived_type,
+ otr_type);
+
+ if (updated && dump_file && (dump_flags & TDF_DETAILS))
+ {
+ fprintf (dump_file, "Updated as: ");
+ dump (dump_file);
+ fprintf (dump_file, "\n");
+ }
+ return updated;
+}
projects / thirdparty / gcc.git / blobdiff