/* Dummy polymorphic call context. */
const ipa_polymorphic_call_context ipa_dummy_polymorphic_call_context
- = {0, NULL, false, true};
+ = {0, 0, NULL, NULL, false, true, true};
/* Pointer set of all call targets appearing in the cache. */
static pointer_set_t *cached_polymorphic_call_targets;
bool odr_violated;
};
+static bool contains_type_p (tree, HOST_WIDE_INT, tree);
+
/* Return true if BINFO corresponds to a type with virtual methods.
hash = iterative_hash_hashval_t (TYPE_UID (odr_query->context.outer_type),
hash);
hash = iterative_hash_host_wide_int (odr_query->context.offset, hash);
+ if (odr_query->context.speculative_outer_type)
+ {
+ hash = iterative_hash_hashval_t
+ (TYPE_UID (odr_query->context.speculative_outer_type), hash);
+ hash = iterative_hash_host_wide_int (odr_query->context.speculative_offset,
+ hash);
+ }
return iterative_hash_hashval_t
- (((int)odr_query->context.maybe_in_construction << 1)
+ (((int)odr_query->context.maybe_in_construction << 2)
+ | ((int)odr_query->context.speculative_maybe_derived_type << 1)
| (int)odr_query->context.maybe_derived_type, hash);
}
{
return (t1->type == t2->type && t1->otr_token == t2->otr_token
&& t1->context.offset == t2->context.offset
+ && t1->context.speculative_offset == t2->context.speculative_offset
&& t1->context.outer_type == t2->context.outer_type
+ && t1->context.speculative_outer_type == t2->context.speculative_outer_type
&& t1->context.maybe_in_construction
== t2->context.maybe_in_construction
- && t1->context.maybe_derived_type == t2->context.maybe_derived_type);
+ && t1->context.maybe_derived_type == t2->context.maybe_derived_type
+ && (t1->context.speculative_maybe_derived_type
+ == t2->context.speculative_maybe_derived_type));
}
/* Remove entry in polymorphic call target cache hash. */
{
tree type = context->outer_type;
HOST_WIDE_INT offset = context->offset;
-
+ bool speculative = false;
+ bool speculation_valid = false;
+ bool valid = false;
+
+ if (!context->outer_type)
+ {
+ context->outer_type = expected_type;
+ context->offset = offset;
+ }
+ /* See if speculative type seem to be derrived from outer_type.
+ Then speculation is valid only if it really is a derivate and derived types
+ are allowed.
+
+ The test does not really look for derivate, but also accepts the case where
+ outer_type is a field of speculative_outer_type. In this case eiter
+ MAYBE_DERIVED_TYPE is false and we have full non-speculative information or
+ the loop bellow will correctly update SPECULATIVE_OUTER_TYPE
+ and SPECULATIVE_MAYBE_DERIVED_TYPE. */
+ if (context->speculative_outer_type
+ && context->speculative_offset >= context->offset
+ && contains_type_p (context->speculative_outer_type,
+ context->offset - context->speculative_offset,
+ context->outer_type))
+ speculation_valid = context->maybe_derived_type;
+ else
+ {
+ context->speculative_outer_type = NULL;
+ context->speculative_offset = 0;
+ context->speculative_maybe_derived_type = false;
+ }
+
/* Find the sub-object the constant actually refers to and mark whether it is
- an artificial one (as opposed to a user-defined one). */
+ an artificial one (as opposed to a user-defined one).
+
+ This loop is performed twice; first time for outer_type and second time
+ for speculative_outer_type. The second iteration has SPECULATIVE set. */
while (true)
{
HOST_WIDE_INT pos, size;
if (TREE_CODE (type) == TREE_CODE (expected_type)
&& types_same_for_odr (type, expected_type))
{
- /* Type can not contain itself on an non-zero offset. In that case
- just give up. */
- if (offset != 0)
- goto give_up;
- gcc_assert (offset == 0);
- return true;
+ if (speculative)
+ {
+ gcc_assert (speculation_valid);
+ gcc_assert (valid);
+
+ /* If we did not match the offset, just give up on speculation. */
+ if (offset != 0
+ || (types_same_for_odr (context->speculative_outer_type,
+ context->outer_type)
+ && (context->maybe_derived_type
+ == context->speculative_maybe_derived_type)))
+ {
+ context->speculative_outer_type = NULL;
+ context->speculative_offset = 0;
+ }
+ return true;
+ }
+ else
+ {
+ /* Type can not contain itself on an non-zero offset. In that case
+ just give up. */
+ if (offset != 0)
+ {
+ valid = false;
+ goto give_up;
+ }
+ valid = true;
+ /* If speculation is not valid or we determined type precisely,
+ we are done. */
+ if (!speculation_valid
+ || !context->maybe_derived_type)
+ {
+ context->speculative_outer_type = NULL;
+ context->speculative_offset = 0;
+ return true;
+ }
+ /* Otherwise look into speculation now. */
+ else
+ {
+ speculative = true;
+ type = context->speculative_outer_type;
+ offset = context->speculative_offset;
+ continue;
+ }
+ }
}
/* Walk fields and find corresponding on at OFFSET. */
/* DECL_ARTIFICIAL represents a basetype. */
if (!DECL_ARTIFICIAL (fld))
{
- context->outer_type = type;
- context->offset = offset;
- /* As soon as we se an field containing the type,
- we know we are not looking for derivations. */
- context->maybe_derived_type = false;
+ if (!speculative)
+ {
+ context->outer_type = type;
+ context->offset = offset;
+ /* As soon as we se an field containing the type,
+ we know we are not looking for derivations. */
+ context->maybe_derived_type = false;
+ }
+ else
+ {
+ context->speculative_outer_type = type;
+ context->speculative_offset = offset;
+ context->speculative_maybe_derived_type = false;
+ }
}
}
else if (TREE_CODE (type) == ARRAY_TYPE)
goto give_up;
offset = offset % tree_to_shwi (TYPE_SIZE (subtype));
type = subtype;
- context->outer_type = type;
- context->offset = offset;
- context->maybe_derived_type = false;
+ if (!speculative)
+ {
+ context->outer_type = type;
+ context->offset = offset;
+ context->maybe_derived_type = false;
+ }
+ else
+ {
+ context->speculative_outer_type = type;
+ context->speculative_offset = offset;
+ context->speculative_maybe_derived_type = false;
+ }
}
/* Give up on anything else. */
else
/* If we failed to find subtype we look for, give up and fall back to the
most generic query. */
give_up:
+ context->speculative_outer_type = NULL;
+ context->speculative_offset = 0;
+ context->speculative_maybe_derived_type = false;
+ if (valid)
+ return true;
context->outer_type = expected_type;
context->offset = 0;
context->maybe_derived_type = true;
if ((TREE_CODE (type) != RECORD_TYPE
|| !TYPE_BINFO (type)
|| !polymorphic_type_binfo_p (TYPE_BINFO (type)))
- && (TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
+ && (!TYPE_SIZE (type)
+ || TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST
|| (offset + tree_to_uhwi (TYPE_SIZE (expected_type)) <=
tree_to_uhwi (TYPE_SIZE (type)))))
return true;
contains_type_p (tree outer_type, HOST_WIDE_INT offset,
tree otr_type)
{
- ipa_polymorphic_call_context context = {offset,
+ ipa_polymorphic_call_context context = {offset, 0,
TYPE_MAIN_VARIANT (outer_type),
- false, true};
+ NULL, false, true, false};
return get_class_context (&context, otr_type);
}
context->outer_type = TYPE_MAIN_VARIANT (TREE_TYPE (base));
context->offset = offset;
+ context->speculative_outer_type = NULL;
+ context->speculative_offset = 0;
+ context->speculative_maybe_derived_type = true;
/* Make very conservative assumption that all objects
may be in construction.
TODO: ipa-prop already contains code to tell better.
return true;
}
+/* See if OP is SSA name initialized as a copy or by single assignment.
+ If so, walk the SSA graph up. */
+
+static tree
+walk_ssa_copies (tree op)
+{
+ STRIP_NOPS (op);
+ while (TREE_CODE (op) == SSA_NAME
+ && !SSA_NAME_IS_DEFAULT_DEF (op)
+ && SSA_NAME_DEF_STMT (op)
+ && gimple_assign_single_p (SSA_NAME_DEF_STMT (op)))
+ {
+ if (gimple_assign_load_p (SSA_NAME_DEF_STMT (op)))
+ return op;
+ op = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (op));
+ STRIP_NOPS (op);
+ }
+ return op;
+}
+
/* Given REF call in FNDECL, determine class of the polymorphic
call (OTR_TYPE), its token (OTR_TOKEN) and CONTEXT.
CALL is optional argument giving the actual statement (usually call) where
*otr_token = tree_to_uhwi (OBJ_TYPE_REF_TOKEN (ref));
/* Set up basic info in case we find nothing interesting in the analysis. */
+ context->speculative_outer_type = NULL;
+ context->speculative_offset = 0;
+ context->speculative_maybe_derived_type = true;
context->outer_type = TYPE_MAIN_VARIANT (*otr_type);
context->offset = 0;
base_pointer = OBJ_TYPE_REF_OBJECT (ref);
/* Walk SSA for outer object. */
do
{
- if (TREE_CODE (base_pointer) == SSA_NAME
- && !SSA_NAME_IS_DEFAULT_DEF (base_pointer)
- && SSA_NAME_DEF_STMT (base_pointer)
- && gimple_assign_single_p (SSA_NAME_DEF_STMT (base_pointer)))
- {
- base_pointer = gimple_assign_rhs1 (SSA_NAME_DEF_STMT (base_pointer));
- STRIP_NOPS (base_pointer);
- }
- else if (TREE_CODE (base_pointer) == ADDR_EXPR)
+ base_pointer = walk_ssa_copies (base_pointer);
+ if (TREE_CODE (base_pointer) == ADDR_EXPR)
{
HOST_WIDE_INT size, max_size;
HOST_WIDE_INT offset2;
context->outer_type,
call,
current_function_decl);
- return NULL;
+ return base_pointer;
}
else
break;
return base_pointer;
}
}
+
+ tree base_type = TREE_TYPE (base_pointer);
+
+ if (TREE_CODE (base_pointer) == SSA_NAME
+ && SSA_NAME_IS_DEFAULT_DEF (base_pointer)
+ && TREE_CODE (SSA_NAME_VAR (base_pointer)) != PARM_DECL)
+ {
+ /* Use OTR_TOKEN = INT_MAX as a marker of probably type inconsistent
+ code sequences; we arrange the calls to be builtin_unreachable
+ later. */
+ *otr_token = INT_MAX;
+ return base_pointer;
+ }
+ if (TREE_CODE (base_pointer) == SSA_NAME
+ && SSA_NAME_DEF_STMT (base_pointer)
+ && gimple_assign_single_p (SSA_NAME_DEF_STMT (base_pointer)))
+ base_type = TREE_TYPE (gimple_assign_rhs1
+ (SSA_NAME_DEF_STMT (base_pointer)));
+
+ if (POINTER_TYPE_P (base_type)
+ && contains_type_p (TYPE_MAIN_VARIANT (TREE_TYPE (base_type)),
+ context->offset,
+ *otr_type))
+ {
+ context->speculative_outer_type = TYPE_MAIN_VARIANT
+ (TREE_TYPE (base_type));
+ context->speculative_offset = context->offset;
+ context->speculative_maybe_derived_type = true;
+ }
/* TODO: There are multiple ways to derive a type. For instance
if BASE_POINTER is passed to an constructor call prior our refernece.
We do not make this type of flow sensitive analysis yet. */
type inheritance graph. */
struct ipa_polymorphic_call_context {
/* The called object appears in an object of type OUTER_TYPE
- at offset OFFSET. */
+ at offset OFFSET. When information is not 100% reliable, we
+ use SPECULATIVE_OUTER_TYPE and SPECULATIVE_OFFSET. */
HOST_WIDE_INT offset;
+ HOST_WIDE_INT speculative_offset;
tree outer_type;
+ tree speculative_outer_type;
/* True if outer object may be in construction or destruction. */
bool maybe_in_construction;
/* True if outer object may be of derived type. */
bool maybe_derived_type;
+ /* True if speculative outer object may be of derived type. We always
+ speculate that construction does not happen. */
+ bool speculative_maybe_derived_type;
};
/* Context representing "I know nothing". */
HOST_WIDE_INT *,
ipa_polymorphic_call_context *,
gimple call = NULL);
+bool get_dynamic_type (tree, ipa_polymorphic_call_context *, tree, gimple);
bool get_polymorphic_call_info_from_invariant (ipa_polymorphic_call_context *,
tree, tree, HOST_WIDE_INT);
bool decl_maybe_in_construction_p (tree, tree, gimple, tree);
{
gcc_checking_assert (e->indirect_info->polymorphic);
ipa_polymorphic_call_context context = {e->indirect_info->offset,
+ e->indirect_info->speculative_offset,
e->indirect_info->outer_type,
+ e->indirect_info->speculative_outer_type,
e->indirect_info->maybe_in_construction,
- e->indirect_info->maybe_derived_type};
+ e->indirect_info->maybe_derived_type,
+ e->indirect_info->speculative_maybe_derived_type};
return possible_polymorphic_call_targets (e->indirect_info->otr_type,
e->indirect_info->otr_token,
context,
{
gcc_checking_assert (e->indirect_info->polymorphic);
ipa_polymorphic_call_context context = {e->indirect_info->offset,
+ e->indirect_info->speculative_offset,
e->indirect_info->outer_type,
+ e->indirect_info->speculative_outer_type,
e->indirect_info->maybe_in_construction,
- e->indirect_info->maybe_derived_type};
+ e->indirect_info->maybe_derived_type,
+ e->indirect_info->speculative_maybe_derived_type};
dump_possible_polymorphic_call_targets (f, e->indirect_info->otr_type,
e->indirect_info->otr_token,
context);
possible_polymorphic_call_target_p (struct cgraph_edge *e,
struct cgraph_node *n)
{
- ipa_polymorphic_call_context context = {e->indirect_info->offset,
- e->indirect_info->outer_type,
+ ipa_polymorphic_call_context context = {e->indirect_info->offset, 0,
+ e->indirect_info->outer_type, NULL,
e->indirect_info->maybe_in_construction,
- e->indirect_info->maybe_derived_type};
+ e->indirect_info->maybe_derived_type,
+ false};
return possible_polymorphic_call_target_p (e->indirect_info->otr_type,
e->indirect_info->otr_token,
context, n);
projects / thirdparty / gcc.git / commitdiff
