/* Analysis of polymorphic call context.
- Copyright (C) 2013-2017 Free Software Foundation, Inc.
+ Copyright (C) 2013-2020 Free Software Foundation, Inc.
Contributed by Jan Hubicka
This file is part of GCC.
#include "tree-dfa.h"
#include "gimple-pretty-print.h"
#include "tree-into-ssa.h"
-#include "params.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
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 allocation of new polymorphic type inside by means
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 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)
&& 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,
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.
{
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;
}
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
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;
/* 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;
cst = TREE_OPERAND (cst, 0);
base = get_ref_base_and_extent (cst, &offset2, &size, &max_size, &reverse);
- if (!DECL_P (base) || max_size == -1 || max_size != size)
+ 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
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;
+ HOST_WIDE_INT offset2, size;
bool reverse;
tree base
- = get_ref_base_and_extent (TREE_OPERAND (base_pointer, 0),
- &offset2, &size, &max_size, &reverse);
+ = 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_ref_offset (base) * BITS_PER_UNIT;
+ offset_int o = mem_offset * BITS_PER_UNIT;
o += offset;
o += offset2;
if (!wi::fits_shwi_p (o))
{
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
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;
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. */
}
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;
}
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 + POINTER_SIZE <= tci->offset
- || (max_size != -1
- && tci->offset + POINTER_SIZE > 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;
}
static inline bool
csftc_abort_walking_p (unsigned speculative)
{
- unsigned max = PARAM_VALUE (PARAM_MAX_SPECULATIVE_DEVIRT_MAYDEFS);
+ unsigned max = param_max_speculative_devirt_maydefs;
return speculative > max ? true : false;
}
{
tree op = walk_ssa_copies (gimple_call_arg (stmt, 0));
tree type = TYPE_METHOD_BASETYPE (TREE_TYPE (fn));
- HOST_WIDE_INT offset = 0, size, max_size;
+ HOST_WIDE_INT offset = 0;
bool reverse;
if (dump_file)
/* 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, &reverse);
- 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++;
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)))
{
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;
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 (TREE_CODE (instance) == MEM_REF)
return false;
- /* We need to obtain refernce to virtual table pointer. It is better
+ /* 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)
&& !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, &reverse);
+ = 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. */
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
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
}
/* restrict_to_inner_class may eliminate wrong speculation making our job
- easeier. */
+ easier. */
if (otr_type)
restrict_to_inner_class (otr_type);
}
}
-/* Assume that both THIS and a given context is valid and strenghten THIS
- if possible. Return true if any strenghtening was made.
+/* 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;
}
}
}
- /* 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
if (!dynamic && ctx.dynamic)
dynamic = true;
}
- /* TODO handle merging using hiearchy. */
+ /* TODO handle merging using hierarchy. */
else
{
if (dump_file && (dump_flags & TDF_DETAILS))
projects / thirdparty / gcc.git / blobdiff