On 05/03/2012 03:27 AM, Paolo Carlini wrote:
Hi,
Vincenzo reported today that the work done by Roberto on
devirtualizing final methods, doesn't cover operators (of all sorts).
Thus I prepared the below, which passes the testsuite on x86_64-linux.
... I have an alternate proposal, which probably I like better, and also
commonizes the bits added by Roberto to a function working on the
LOOKUP_* flags. Also passes testing on x86_64-linux.
Thanks,
Paolo.
//////////////////////////
/cp
2012-05-03 Paolo Carlini <paolo.carl...@oracle.com>
PR c++/53186
* call.c (maybe_final_flags): New.
(build_op_call_1, build_new_op_1, convert_like_real,
build_new_method_call_1): Use it.
/testsuite
2012-05-03 Paolo Carlini <paolo.carl...@oracle.com>
PR c++/53186
* g++.dg/other/final2.C: New.
Index: cp/call.c
===================================================================
--- cp/call.c (revision 187058)
+++ cp/call.c (working copy)
@@ -4031,6 +4031,27 @@ build_operator_new_call (tree fnname, VEC(tree,gc)
return build_over_call (cand, LOOKUP_NORMAL, complain);
}
+/* If CAND can be devirtualized, because either the individual
+ method or the whole class type is declared final, return
+ FLAGS | LOOKUP_NONVIRTUAL, otherwise FLAGS. */
+
+static int
+maybe_final_flags (struct z_candidate *cand, int flags)
+{
+ tree fn = cand->fn;
+ tree fntype = TREE_TYPE (fn);
+
+ gcc_assert (TREE_CODE (fn) == FUNCTION_DECL);
+
+ if (DECL_FINAL_P (fn)
+ || (TREE_CODE (fntype) == METHOD_TYPE
+ && CLASSTYPE_FINAL (TYPE_METHOD_BASETYPE (fntype))))
+ /* We can devirtualize. */
+ flags |= LOOKUP_NONVIRTUAL;
+
+ return flags;
+}
+
/* Build a new call to operator(). This may change ARGS. */
static tree
@@ -4149,7 +4170,8 @@ build_op_call_1 (tree obj, VEC(tree,gc) **args, ts
DECL_NAME here. */
else if (TREE_CODE (cand->fn) == FUNCTION_DECL
&& DECL_OVERLOADED_OPERATOR_P (cand->fn) == CALL_EXPR)
- result = build_over_call (cand, LOOKUP_NORMAL, complain);
+ result = build_over_call (cand, maybe_final_flags (cand, LOOKUP_NORMAL),
+ complain);
else
{
obj = convert_like_with_context (cand->convs[0], obj, cand->fn, -1,
@@ -5163,7 +5185,9 @@ build_new_op_1 (enum tree_code code, int flags, tr
if (resolve_args (arglist, complain) == NULL)
result = error_mark_node;
else
- result = build_over_call (cand, LOOKUP_NORMAL, complain);
+ result = build_over_call (cand,
+ maybe_final_flags (cand, LOOKUP_NORMAL),
+ complain);
}
else
{
@@ -5755,7 +5779,8 @@ convert_like_real (conversion *convs, tree expr, t
for (i = 0; i < cand->num_convs; ++i)
cand->convs[i]->user_conv_p = true;
- expr = build_over_call (cand, LOOKUP_NORMAL, complain);
+ expr = build_over_call (cand, maybe_final_flags (cand, LOOKUP_NORMAL),
+ complain);
/* If this is a constructor or a function returning an aggr type,
we need to build up a TARGET_EXPR. */
@@ -7417,9 +7442,9 @@ build_new_method_call_1 (tree instance, tree fns,
{
/* Optimize away vtable lookup if we know that this function
can't be overridden. */
+ flags = maybe_final_flags (cand, flags);
if (DECL_VINDEX (fn) && ! (flags & LOOKUP_NONVIRTUAL)
- && (resolves_to_fixed_type_p (instance, 0)
- || DECL_FINAL_P (fn) || CLASSTYPE_FINAL (basetype)))
+ && resolves_to_fixed_type_p (instance, 0))
flags |= LOOKUP_NONVIRTUAL;
if (explicit_targs)
flags |= LOOKUP_EXPLICIT_TMPL_ARGS;
Index: testsuite/g++.dg/other/final2.C
===================================================================
--- testsuite/g++.dg/other/final2.C (revision 0)
+++ testsuite/g++.dg/other/final2.C (revision 0)
@@ -0,0 +1,27 @@
+// PR c++/53186
+// { dg-options "-fdump-tree-original -std=c++11" }
+
+struct F1
+{
+ virtual void operator()() final;
+ virtual operator int() final;
+ virtual int operator++() final;
+};
+
+struct F2 final
+{
+ virtual void operator()();
+ virtual operator int();
+ virtual int operator++();
+};
+
+void fooF1(F1& a) { a(); int m = a; ++a; }
+void fooF2(F2& a) { a(); int m = a; ++a; }
+
+// { dg-final { scan-tree-dump-times "F1::operator\\(\\)" 1 "original" } }
+// { dg-final { scan-tree-dump-times "F1::operator int" 1 "original" } }
+// { dg-final { scan-tree-dump-times "F1::operator\\+\\+" 1 "original" } }
+// { dg-final { scan-tree-dump-times "F2::operator\\(\\)" 1 "original" } }
+// { dg-final { scan-tree-dump-times "F2::operator int" 1 "original" } }
+// { dg-final { scan-tree-dump-times "F2::operator\\+\\+" 1 "original" } }
+// { dg-final { cleanup-tree-dump "original" } }
