+2014-07-05 Jan Hubicka <hubicka@ucw.cz>
+
+ * cgraph.c (cgraph_create_indirect_edge): Update call of
+ get_polymorphic_call_info.
+ * ipa-utils.h (get_polymorphic_call_info): Add parameter CALL.
+ (possible_polymorphic_call_targets): Add parameter call.
+ (decl_maybe_in_construction_p): New predicate.
+ (get_polymorphic_call_info): Add parameter call;
+ use decl_maybe_in_construction_p.
+ * gimple-fold.c (fold_gimple_assign): Update use of
+ possible_polymorphic_call_targets.
+ (gimple_fold_call): Likewise.
+ * ipa-prop.c: Inlcude calls.h
+ (ipa_binfo_from_known_type_jfunc): Check that known type is record.
+ (param_type_may_change_p): New predicate.
+ (detect_type_change_from_memory_writes): Break out from ...
+ (detect_type_change): ... this one; use
+ param_type_may_change_p.
+ (detect_type_change_ssa): Use param_type_may_change_p.
+ (compute_known_type_jump_func): Use decl_maybe_in_construction_p.
+
2014-07-05 Charles Baylis <charles.baylis@linaro.org>
PR target/49423
get_polymorphic_call_info (caller->decl,
target,
&otr_type, &otr_token,
- &context);
+ &context, call_stmt);
/* Only record types can have virtual calls. */
gcc_assert (TREE_CODE (otr_type) == RECORD_TYPE);
{
bool final;
vec <cgraph_node *>targets
- = possible_polymorphic_call_targets (val, &final);
+ = possible_polymorphic_call_targets (val, stmt, &final);
if (final && targets.length () <= 1 && dbg_cnt (devirt))
{
tree fndecl;
{
bool final;
vec <cgraph_node *>targets
- = possible_polymorphic_call_targets (callee, &final);
+ = possible_polymorphic_call_targets (callee, stmt, &final);
if (final && targets.length () <= 1 && dbg_cnt (devirt))
{
tree lhs = gimple_call_lhs (stmt);
offset, vtable);
}
+/* We know that the instance is stored in variable or parameter
+ (not dynamically allocated) and we want to disprove the fact
+ that it may be in construction at invocation of CALL.
+
+ For the variable to be in construction we actually need to
+ be in constructor of corresponding global variable or
+ the inline stack of CALL must contain the constructor.
+ Check this condition. This check works safely only before
+ IPA passes, because inline stacks may become out of date
+ later. */
+
+bool
+decl_maybe_in_construction_p (tree base, tree outer_type,
+ gimple call, tree function)
+{
+ outer_type = TYPE_MAIN_VARIANT (outer_type);
+ gcc_assert (DECL_P (base));
+
+ /* After inlining the code unification optimizations may invalidate
+ inline stacks. Also we need to give up on global variables after
+ IPA, because addresses of these may have been propagated to their
+ constructors. */
+ 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. */
+ if (!auto_var_in_fn_p (base, function)
+ && flags_from_decl_or_type (function) & (ECF_PURE | ECF_CONST))
+ return false;
+
+ 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)
+ {
+ 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
+ || !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;
+
+ /* FIXME: this can go away once we have ODR types equivalency on
+ LTO level. */
+ if (in_lto_p && !polymorphic_type_binfo_p (TYPE_BINFO (outer_type)))
+ return true;
+ tree type = TYPE_MAIN_VARIANT (method_class_type (TREE_TYPE (fn)));
+ if (types_same_for_odr (type, outer_type))
+ return true;
+ }
+
+ if (TREE_CODE (base) == VAR_DECL
+ && is_global_var (base))
+ {
+ if (TREE_CODE (TREE_TYPE (function)) != METHOD_TYPE
+ || (!DECL_CXX_CONSTRUCTOR_P (function)
+ || !DECL_CXX_DESTRUCTOR_P (function)))
+ {
+ if (!DECL_ABSTRACT_ORIGIN (function))
+ return false;
+ /* Watch for clones where we constant propagated the first
+ argument (pointer to the instance). */
+ function = DECL_ABSTRACT_ORIGIN (function);
+ if (!function
+ || TREE_CODE (TREE_TYPE (function)) != METHOD_TYPE
+ || (!DECL_CXX_CONSTRUCTOR_P (function)
+ || !DECL_CXX_DESTRUCTOR_P (function)))
+ return false;
+ }
+ /* FIXME: this can go away once we have ODR types equivalency on
+ LTO level. */
+ if (in_lto_p && !polymorphic_type_binfo_p (TYPE_BINFO (outer_type)))
+ return true;
+ tree type = TYPE_MAIN_VARIANT (method_class_type (TREE_TYPE (function)));
+ if (types_same_for_odr (type, outer_type))
+ return true;
+ }
+ return false;
+}
+
/* Proudce polymorphic call context for call method of instance
that is located within BASE (that is assumed to be a decl) at OFFSET. */
/* 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
+ the context is used.
Return pointer to object described by the context */
tree
tree ref,
tree *otr_type,
HOST_WIDE_INT *otr_token,
- ipa_polymorphic_call_context *context)
+ ipa_polymorphic_call_context *context,
+ gimple call)
{
tree base_pointer;
*otr_type = obj_type_ref_class (ref);
}
get_polymorphic_call_info_for_decl (context, base,
context->offset + offset2);
+ if (context->maybe_in_construction && call)
+ context->maybe_in_construction
+ = decl_maybe_in_construction_p (base,
+ context->outer_type,
+ call,
+ current_function_decl);
return NULL;
}
else
#include "dbgcnt.h"
#include "domwalk.h"
#include "builtins.h"
+#include "calls.h"
/* Intermediate information that we get from alias analysis about a particular
parameter in a particular basic_block. When a parameter or the memory it
tree
ipa_binfo_from_known_type_jfunc (struct ipa_jump_func *jfunc)
{
+ if (!RECORD_OR_UNION_TYPE_P (jfunc->value.known_type.base_type))
+ return NULL_TREE;
+
tree base_binfo = TYPE_BINFO (jfunc->value.known_type.base_type);
+
if (!base_binfo)
return NULL_TREE;
return get_binfo_at_offset (base_binfo,
return false;
}
+/* See if ARG is PARAM_DECl describing instance passed by pointer
+ or reference in FUNCTION. Return false if the dynamic type may change
+ in between beggining of the function until CALL is invoked.
+ Generally functions are not allowed to change type of such instances,
+ but they call destructors. We assume that methods can not destroy the THIS
+ pointer. Also as a special cases, constructor and destructors may change
+ type of the THIS pointer. */
+
+static bool
+param_type_may_change_p (tree function, tree arg, gimple call)
+{
+ /* Pure functions can not do any changes on the dynamic type;
+ that require writting to memory. */
+ if (flags_from_decl_or_type (function) & (ECF_PURE | ECF_CONST))
+ return false;
+ /* We need to check if we are within inlined consturctor
+ or destructor (ideally we would have way to check that the
+ inline cdtor is actually working on ARG, but we don't have
+ easy tie on this, so punt on all non-pure cdtors.
+ We may also record the types of cdtors and once we know type
+ of the instance match them.
+
+ Also code unification optimizations may merge calls from
+ different blocks making return values unreliable. So
+ do nothing during late optimization. */
+ if (DECL_STRUCT_FUNCTION (function)->after_inlining)
+ return true;
+ if (TREE_CODE (arg) == SSA_NAME
+ && SSA_NAME_IS_DEFAULT_DEF (arg)
+ && TREE_CODE (SSA_NAME_VAR (arg)) == PARM_DECL)
+ {
+ /* Normal (non-THIS) argument. */
+ if ((SSA_NAME_VAR (arg) != DECL_ARGUMENTS (function)
+ || TREE_CODE (TREE_TYPE (function)) != METHOD_TYPE)
+ /* THIS pointer of an method - here we we want to watch constructors
+ and destructors as those definitely may change the dynamic
+ type. */
+ || (TREE_CODE (TREE_TYPE (function)) == METHOD_TYPE
+ && !DECL_CXX_CONSTRUCTOR_P (function)
+ && !DECL_CXX_DESTRUCTOR_P (function)
+ && (SSA_NAME_VAR (arg) == DECL_ARGUMENTS (function))))
+ {
+ /* Walk the inline stack and watch out for ctors/dtors. */
+ 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)
+ {
+ tree fn = BLOCK_ABSTRACT_ORIGIN (block);
+
+ if (flags_from_decl_or_type (fn) & (ECF_PURE | ECF_CONST))
+ continue;
+ if (TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
+ && (DECL_CXX_CONSTRUCTOR_P (fn)
+ || DECL_CXX_DESTRUCTOR_P (fn)))
+ return true;
+ }
+ return false;
+ }
+ }
+ return true;
+}
/* Detect whether the dynamic type of ARG of COMP_TYPE has changed (before
callsite CALL) by looking for assignments to its virtual table pointer. If
it is, return true and fill in the jump function JFUNC with relevant type
information or set it to unknown. ARG is the object itself (not a pointer
to it, unless dereferenced). BASE is the base of the memory access as
- returned by get_ref_base_and_extent, as is the offset. */
+ returned by get_ref_base_and_extent, as is the offset.
+
+ This is helper function for detect_type_change and detect_type_change_ssa
+ that does the heavy work which is usually unnecesary. */
static bool
-detect_type_change (tree arg, tree base, tree comp_type, gimple call,
- struct ipa_jump_func *jfunc, HOST_WIDE_INT offset)
+detect_type_change_from_memory_writes (tree arg, tree base, tree comp_type,
+ gimple call, struct ipa_jump_func *jfunc,
+ HOST_WIDE_INT offset)
{
struct type_change_info tci;
ao_ref ao;
comp_type = TYPE_MAIN_VARIANT (comp_type);
- if (!flag_devirtualize)
- return false;
-
- /* C++ methods are not allowed to change THIS pointer unless they
- are constructors or destructors. */
- if (TREE_CODE (base) == MEM_REF
- && TREE_CODE (TREE_OPERAND (base, 0)) == SSA_NAME
- && SSA_NAME_IS_DEFAULT_DEF (TREE_OPERAND (base, 0))
- && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND (base, 0))) == PARM_DECL
- && TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE
- && !DECL_CXX_CONSTRUCTOR_P (current_function_decl)
- && !DECL_CXX_DESTRUCTOR_P (current_function_decl)
- && (SSA_NAME_VAR (TREE_OPERAND (base, 0))
- == DECL_ARGUMENTS (current_function_decl)))
- {
- gcc_assert (comp_type);
- return false;
- }
-
/* Const calls cannot call virtual methods through VMT and so type changes do
not matter. */
if (!flag_devirtualize || !gimple_vuse (call)
return true;
}
+/* Detect whether the dynamic type of ARG of COMP_TYPE may have changed.
+ If it is, return true and fill in the jump function JFUNC with relevant type
+ information or set it to unknown. ARG is the object itself (not a pointer
+ to it, unless dereferenced). BASE is the base of the memory access as
+ returned by get_ref_base_and_extent, as is the offset. */
+
+static bool
+detect_type_change (tree arg, tree base, tree comp_type, gimple call,
+ struct ipa_jump_func *jfunc, HOST_WIDE_INT offset)
+{
+ if (!flag_devirtualize)
+ return false;
+
+ if (TREE_CODE (base) == MEM_REF
+ && !param_type_may_change_p (current_function_decl,
+ TREE_OPERAND (base, 0),
+ call))
+ return false;
+ return detect_type_change_from_memory_writes (arg, base, comp_type,
+ call, jfunc, offset);
+}
+
/* Like detect_type_change but ARG is supposed to be a non-dereferenced pointer
SSA name (its dereference will become the base and the offset is assumed to
be zero). */
|| !POINTER_TYPE_P (TREE_TYPE (arg)))
return false;
+ if (!param_type_may_change_p (current_function_decl, arg, call))
+ return false;
+
arg = build2 (MEM_REF, ptr_type_node, arg,
build_int_cst (ptr_type_node, 0));
- return detect_type_change (arg, arg, comp_type, call, jfunc, 0);
+ return detect_type_change_from_memory_writes (arg, arg, comp_type,
+ call, jfunc, 0);
}
/* Callback of walk_aliased_vdefs. Flags that it has been invoked to the
if (!DECL_P (base)
|| max_size == -1
|| max_size != size
- || !contains_polymorphic_type_p (TREE_TYPE (base))
- || is_global_var (base))
+ || !contains_polymorphic_type_p (TREE_TYPE (base)))
return;
- if (detect_type_change (op, base, expected_type, call, jfunc, offset))
+ if (decl_maybe_in_construction_p (base, TREE_TYPE (base),
+ call, current_function_decl)
+ /* Even if the var seems to be in construction by inline call stack,
+ we may work out the actual type by walking memory writes. */
+ && (!is_global_var (base)
+ && detect_type_change (op, base, expected_type, call, jfunc, offset)))
return;
ipa_set_jf_known_type (jfunc, offset, TREE_TYPE (base),
tree method_class_type (const_tree);
tree get_polymorphic_call_info (tree, tree, tree *,
HOST_WIDE_INT *,
- ipa_polymorphic_call_context *);
+ ipa_polymorphic_call_context *,
+ gimple call = NULL);
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);
tree vtable_pointer_value_to_binfo (const_tree);
bool vtable_pointer_value_to_vtable (const_tree, tree *, unsigned HOST_WIDE_INT *);
bool contains_polymorphic_type_p (const_tree);
/* Same as above but taking OBJ_TYPE_REF as an parameter. */
inline vec <cgraph_node *>
-possible_polymorphic_call_targets (tree call,
+possible_polymorphic_call_targets (tree ref,
+ gimple call,
bool *final = NULL,
void **cache_token = NULL)
{
ipa_polymorphic_call_context context;
get_polymorphic_call_info (current_function_decl,
- call,
- &otr_type, &otr_token, &context);
- return possible_polymorphic_call_targets (obj_type_ref_class (call),
+ ref,
+ &otr_type, &otr_token, &context, call);
+ return possible_polymorphic_call_targets (obj_type_ref_class (ref),
tree_to_uhwi
- (OBJ_TYPE_REF_TOKEN (call)),
+ (OBJ_TYPE_REF_TOKEN (ref)),
context,
final, cache_token);
}
+2014-07-05 Jan Hubicka <hubicka@ucw.cz>
+
+ * g++.dg/ipa/devirt-26.C: Update testcase.
+ * g++.dg/ipa/imm-devirt-1.C: Update testcase.
+ * g++.dg/ipa/imm-devirt-2.C: Update testcase.
+
2014-07-04 Tobias Burnus <burnus@net-b.de>
* gfortran.dg/coarray/coindexed_3.f90: New.
/* { dg-do compile } */
-/* { dg-options "-O3 -fdump-ipa-devirt-details" } */
+/* { dg-options "-O3 -fdump-tree-ccp1" } */
struct A
{
int a;
return d->foo()+b->foo();
}
/* The call to b->foo() is perfectly devirtualizable because C can not be in construction
- when &c was used, but we can not analyze that so far. Test that we at least speculate
- that type is in the construction. */
-/* { dg-final { scan-ipa-dump "speculatively devirtualizing" "devirt" } } */
-/* { dg-final { cleanup-ipa-dump "devirt" } } */
+ when &c was used. */
+/* { dg-final { scan-tree-dump-not "OBJ_TYPE_REF" "ccp1" } } */
+/* { dg-final { cleanup-tree-dump "ccp1" } } */
/* Verify that virtual calls are folded even early inlining puts them into one
function with the definition. */
/* { dg-do run } */
-/* { dg-options "-O2 -fdump-tree-fre1-details" } */
+/* { dg-options "-O2 -fdump-tree-einline" } */
extern "C" void abort (void);
return 0;
}
-/* { dg-final { scan-tree-dump "converting indirect call to function virtual int B::foo" "fre1" } } */
-/* { dg-final { cleanup-tree-dump "fre1" } } */
+/* middleman_2 gets early inlined and the virtual call should get turned to
+ a direct call. */
+/* { dg-final { scan-tree-dump "Inlining int middleman_1" "einline" } } */
+/* { dg-final { scan-tree-dump "Inlining int middleman_2" "einline" } } */
+/* { dg-final { scan-tree-dump "B::foo (" "einline" } } */
+/* { dg-final { scan-tree-dump-times "OBJ_TYPE_REF" 2 "einline" } } */
+/* { dg-final { cleanup-tree-dump "einline" } } */
/* Verify that virtual calls are folded even early inlining puts them into one
function with the definition. */
/* { dg-do run } */
-/* { dg-options "-O2 -fdump-tree-fre1-details" } */
+/* { dg-options "-O2 -fdump-tree-einline" } */
extern "C" void abort (void);
return 0;
}
-/* { dg-final { scan-tree-dump "converting indirect call to function" "fre1" } } */
-/* { dg-final { cleanup-tree-dump "fre1" } } */
+/* We fold into thunk of C. Eventually we should inline the thunk. */
+/* { dg-final { scan-tree-dump "C::_ZThn24_N1C3fooEi (" "einline" } } */
+/* { dg-final { cleanup-tree-dump "einline" } } */
projects / thirdparty / gcc.git / commitdiff
