aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--gcc/cp/call.cc66
-rw-r--r--gcc/cp/decl.cc4
-rw-r--r--gcc/testsuite/g++.dg/cpp23/static-operator-call4.C37
-rw-r--r--gcc/testsuite/g++.dg/cpp23/subscript10.C46
-rw-r--r--gcc/testsuite/g++.dg/cpp23/subscript11.C11
5 files changed, 148 insertions, 16 deletions
diff --git a/gcc/cp/call.cc b/gcc/cp/call.cc
index dbb01ec..459e86b 100644
--- a/gcc/cp/call.cc
+++ b/gcc/cp/call.cc
@@ -5017,6 +5017,33 @@ build_operator_new_call (tree fnname, vec<tree, va_gc> **args,
return ret;
}
+/* Evaluate side-effects from OBJ before evaluating call
+ to FN in RESULT expression.
+ This is for expressions of the form `obj->fn(...)'
+ where `fn' turns out to be a static member function and
+ `obj' needs to be evaluated. `fn' could be also static operator[]
+ or static operator(), in which cases the source expression
+ would be `obj[...]' or `obj(...)'. */
+
+static tree
+keep_unused_object_arg (tree result, tree obj, tree fn)
+{
+ if (result == NULL_TREE
+ || result == error_mark_node
+ || TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE
+ || !TREE_SIDE_EFFECTS (obj))
+ return result;
+
+ /* But avoid the implicit lvalue-rvalue conversion when `obj' is
+ volatile. */
+ tree a = obj;
+ if (TREE_THIS_VOLATILE (a))
+ a = build_this (a);
+ if (TREE_SIDE_EFFECTS (a))
+ return build2 (COMPOUND_EXPR, TREE_TYPE (result), a, result);
+ return result;
+}
+
/* Build a new call to operator(). This may change ARGS. */
tree
@@ -5137,7 +5164,13 @@ build_op_call (tree obj, vec<tree, va_gc> **args, tsubst_flags_t complain)
else if (TREE_CODE (cand->fn) == FUNCTION_DECL
&& DECL_OVERLOADED_OPERATOR_P (cand->fn)
&& DECL_OVERLOADED_OPERATOR_IS (cand->fn, CALL_EXPR))
- result = build_over_call (cand, LOOKUP_NORMAL, complain);
+ {
+ result = build_over_call (cand, LOOKUP_NORMAL, complain);
+ /* In an expression of the form `a()' where cand->fn
+ which is operator() turns out to be a static member function,
+ `a' is none-the-less evaluated. */
+ result = keep_unused_object_arg (result, obj, cand->fn);
+ }
else
{
if (TREE_CODE (cand->fn) == FUNCTION_DECL)
@@ -7046,6 +7079,12 @@ build_new_op (const op_location_t &loc, enum tree_code code, int flags,
gcc_unreachable ();
}
}
+
+ /* In an expression of the form `a[]' where cand->fn
+ which is operator[] turns out to be a static member function,
+ `a' is none-the-less evaluated. */
+ if (code == ARRAY_REF)
+ result = keep_unused_object_arg (result, arg1, cand->fn);
}
else
{
@@ -7302,6 +7341,11 @@ build_op_subscript (const op_location_t &loc, tree obj,
/* Specify evaluation order as per P0145R2. */
CALL_EXPR_ORDERED_ARGS (call) = op_is_ordered (ARRAY_REF) == 1;
}
+
+ /* In an expression of the form `a[]' where cand->fn
+ which is operator[] turns out to be a static member function,
+ `a' is none-the-less evaluated. */
+ result = keep_unused_object_arg (result, obj, cand->fn);
}
else
gcc_unreachable ();
@@ -11494,21 +11538,11 @@ build_new_method_call (tree instance, tree fns, vec<tree, va_gc> **args,
/* In an expression of the form `a->f()' where `f' turns
out to be a static member function, `a' is
none-the-less evaluated. */
- if (TREE_CODE (TREE_TYPE (fn)) != METHOD_TYPE
- && !is_dummy_object (instance)
- && TREE_SIDE_EFFECTS (instance))
- {
- /* But avoid the implicit lvalue-rvalue conversion when 'a'
- is volatile. */
- tree a = instance;
- if (TREE_THIS_VOLATILE (a))
- a = build_this (a);
- if (TREE_SIDE_EFFECTS (a))
- call = build2 (COMPOUND_EXPR, TREE_TYPE (call), a, call);
- }
- else if (call != error_mark_node
- && DECL_DESTRUCTOR_P (cand->fn)
- && !VOID_TYPE_P (TREE_TYPE (call)))
+ if (!is_dummy_object (instance))
+ call = keep_unused_object_arg (call, instance, fn);
+ if (call != error_mark_node
+ && DECL_DESTRUCTOR_P (cand->fn)
+ && !VOID_TYPE_P (TREE_TYPE (call)))
/* An explicit call of the form "x->~X()" has type
"void". However, on platforms where destructors
return "this" (i.e., those where
diff --git a/gcc/cp/decl.cc b/gcc/cp/decl.cc
index 0234919..d28889e 100644
--- a/gcc/cp/decl.cc
+++ b/gcc/cp/decl.cc
@@ -15404,6 +15404,10 @@ grok_op_properties (tree decl, bool complain)
pedwarn (loc, OPT_Wc__23_extensions, "%qD may be a static member "
"function only with %<-std=c++23%> or %<-std=gnu++23%>",
decl);
+ if (operator_code == ARRAY_REF)
+ /* static operator[] should have exactly one argument
+ for C++20 and earlier, so that it isn't multidimensional. */
+ op_flags = OVL_OP_FLAG_UNARY;
}
else if (DECL_STATIC_FUNCTION_P (decl))
{
diff --git a/gcc/testsuite/g++.dg/cpp23/static-operator-call4.C b/gcc/testsuite/g++.dg/cpp23/static-operator-call4.C
new file mode 100644
index 0000000..83ccde3
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/static-operator-call4.C
@@ -0,0 +1,37 @@
+// PR c++/107624
+// { dg-do run { target c++11 } }
+// { dg-options "" }
+
+int n[3];
+struct S {
+ static void operator() (int x) { n[0] |= (1 << x); } // { dg-warning "may be a static member function only with" "" { target c++20_down } }
+ static void baz (int x) { n[1] |= (1 << x); }
+ int s;
+};
+volatile S s[2];
+
+S &
+foo (int x)
+{
+ static S t;
+ n[2] |= (1 << x);
+ return t;
+}
+
+int
+main ()
+{
+ int i = 0;
+ foo (0) (0);
+ if (n[0] != 1 || n[1] || n[2] != 1)
+ __builtin_abort ();
+ foo (1).baz (1);
+ if (n[0] != 1 || n[1] != 2 || n[2] != 3)
+ __builtin_abort ();
+ s[i++] (2);
+ if (i != 1 || n[0] != 5 || n[1] != 2 || n[2] != 3)
+ __builtin_abort ();
+ s[--i].baz (3);
+ if (i != 0 || n[0] != 5 || n[1] != 10 || n[2] != 3)
+ __builtin_abort ();
+}
diff --git a/gcc/testsuite/g++.dg/cpp23/subscript10.C b/gcc/testsuite/g++.dg/cpp23/subscript10.C
new file mode 100644
index 0000000..96e5e1f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/subscript10.C
@@ -0,0 +1,46 @@
+// PR c++/107624
+// { dg-do run { target c++11 } }
+// { dg-options "" }
+
+int n[3];
+struct S {
+ static int &operator[] (int x) { n[0] |= (1 << x); return n[2]; } // { dg-warning "may be a static member function only with" "" { target c++20_down } }
+#if __cpp_multidimensional_subscript >= 202211L
+ static int &operator[] () { n[0] |= (1 << 8); return n[2]; }
+ static int &operator[] (int y, int z, int w) { n[0] |= (1 << y) | (1 << z) | (1 << w); return n[2]; }
+#endif
+ int s;
+};
+volatile S s[2];
+
+S &
+foo (int x)
+{
+ static S t;
+ n[1] |= (1 << x);
+ return t;
+}
+
+int
+main ()
+{
+ int i = 0;
+ foo (0) [0]++;
+ if (n[0] != 1 || n[1] != 1 || n[2] != 1)
+ __builtin_abort ();
+ s[i++][2]++;
+ if (i != 1 || n[0] != 5 || n[1] != 1 || n[2] != 2)
+ __builtin_abort ();
+#if __cpp_multidimensional_subscript >= 202211L
+ foo (3) []++;
+ if (n[0] != 261 || n[1] != 9 || n[2] != 3)
+ __builtin_abort ();
+ int y = 10;
+ int z = 10;
+ int w = 13;
+ foo (4) [y++, ++z, w++]++;
+ if (n[0] != 11525 || n[1] != 25 || n[2] != 4
+ || y != 11 || z != 11 || w != 14)
+ __builtin_abort ();
+#endif
+}
diff --git a/gcc/testsuite/g++.dg/cpp23/subscript11.C b/gcc/testsuite/g++.dg/cpp23/subscript11.C
new file mode 100644
index 0000000..990a703
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp23/subscript11.C
@@ -0,0 +1,11 @@
+// { dg-do compile { target c++11 } }
+// { dg-options "" }
+
+struct S {
+ static int &operator[] (int); // { dg-warning "may be a static member function only with" "" { target c++20_down } }
+ static int &operator[] (); // { dg-warning "may be a static member function only with" "" { target c++20_down } }
+ // { dg-error "'static int& S::operator\\\[\\\]\\\(\\\)' must have exactly one argument" "" { target c++20_down } .-1 }
+ static int &operator[] (int, int, int); // { dg-warning "may be a static member function only with" "" { target c++20_down } }
+ // { dg-error "'static int& S::operator\\\[\\\]\\\(int, int, int\\\)' must have exactly one argument" "" { target c++20_down } .-1 }
+ int s;
+};
generated by cgit v1.1 at 2025-04-15 18:43:33 +0000