From: Marek Polacek <polacek@redhat.com>
Date: Mon, 22 Aug 2022 23:13:16 +0000 (-0400)
Subject: c++: Quash bogus -Wredundant-move warning
X-Git-Tag: basepoints/gcc-14~5045
X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=8567d9491d06832ea34b564c6bace9f7d43099ae;p=thirdparty%2Fgcc.git

c++: Quash bogus -Wredundant-move warning

This patch fixes a pretty stoopid thinko.  When I added code to warn
about pessimizing std::move in initializations like

  T t{std::move(T())};

I also added code to unwrap the expression from { }.  But when we have

  return {std::move(t)};

we cannot warn about a redundant std::move because the implicit move
wouldn't happen for "return {t};" because the expression isn't just
a name.  However, we still want to warn about

  return {std::move(T())};

so let's not disable the -Wpessimizing-move warning.  Tests added for
both cases.

gcc/cp/ChangeLog:

	* typeck.cc (maybe_warn_pessimizing_move): Don't warn about
	redundant std::move when the expression was wrapped in { }.

gcc/testsuite/ChangeLog:

	* g++.dg/cpp0x/Wpessimizing-move10.C: New test.
	* g++.dg/cpp0x/Wredundant-move12.C: New test.
---

diff --git a/gcc/cp/typeck.cc b/gcc/cp/typeck.cc
index 992ebfd99fb6..7fde65adaa49 100644
--- a/gcc/cp/typeck.cc
+++ b/gcc/cp/typeck.cc
@@ -10397,11 +10397,15 @@ maybe_warn_pessimizing_move (tree expr, tree type, bool return_p)
   if (!CLASS_TYPE_P (type))
     return;
 
+  bool wrapped_p = false;
   /* A a = std::move (A());  */
   if (TREE_CODE (expr) == TREE_LIST)
     {
       if (list_length (expr) == 1)
-	expr = TREE_VALUE (expr);
+	{
+	  expr = TREE_VALUE (expr);
+	  wrapped_p = true;
+	}
       else
 	return;
     }
@@ -10410,7 +10414,10 @@ maybe_warn_pessimizing_move (tree expr, tree type, bool return_p)
   else if (TREE_CODE (expr) == CONSTRUCTOR)
     {
       if (CONSTRUCTOR_NELTS (expr) == 1)
-	expr = CONSTRUCTOR_ELT (expr, 0)->value;
+	{
+	  expr = CONSTRUCTOR_ELT (expr, 0)->value;
+	  wrapped_p = true;
+	}
       else
 	return;
     }
@@ -10458,6 +10465,8 @@ maybe_warn_pessimizing_move (tree expr, tree type, bool return_p)
       /* Warn if the move is redundant.  It is redundant when we would
 	 do maybe-rvalue overload resolution even without std::move.  */
       else if (warn_redundant_move
+	       /* This doesn't apply for return {std::move (t)};.  */
+	       && !wrapped_p
 	       && !warning_suppressed_p (expr, OPT_Wredundant_move)
 	       && (moved = treat_lvalue_as_rvalue_p (arg, /*return*/true)))
 	{
diff --git a/gcc/testsuite/g++.dg/cpp0x/Wpessimizing-move10.C b/gcc/testsuite/g++.dg/cpp0x/Wpessimizing-move10.C
new file mode 100644
index 000000000000..77314141da33
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/Wpessimizing-move10.C
@@ -0,0 +1,30 @@
+// { dg-do compile { target c++11 } }
+// { dg-options "-Wpessimizing-move" }
+
+// Define std::move.
+namespace std {
+  template<typename _Tp>
+    struct remove_reference
+    { typedef _Tp   type; };
+
+  template<typename _Tp>
+    struct remove_reference<_Tp&>
+    { typedef _Tp   type; };
+
+  template<typename _Tp>
+    struct remove_reference<_Tp&&>
+    { typedef _Tp   type; };
+
+  template<typename _Tp>
+    constexpr typename std::remove_reference<_Tp>::type&&
+    move(_Tp&& __t) noexcept
+    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
+}
+
+struct S { };
+
+S
+f ()
+{
+   return {std::move(S())}; // { dg-warning "moving a temporary object prevents copy elision" }
+}
diff --git a/gcc/testsuite/g++.dg/cpp0x/Wredundant-move12.C b/gcc/testsuite/g++.dg/cpp0x/Wredundant-move12.C
new file mode 100644
index 000000000000..192d981ba5e3
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/Wredundant-move12.C
@@ -0,0 +1,36 @@
+// { dg-do compile { target c++11 } }
+// { dg-options "-Wredundant-move" }
+
+// Define std::move.
+namespace std {
+  template<typename _Tp>
+    struct remove_reference
+    { typedef _Tp   type; };
+
+  template<typename _Tp>
+    struct remove_reference<_Tp&>
+    { typedef _Tp   type; };
+
+  template<typename _Tp>
+    struct remove_reference<_Tp&&>
+    { typedef _Tp   type; };
+
+  template<typename _Tp>
+    constexpr typename std::remove_reference<_Tp>::type&&
+    move(_Tp&& __t) noexcept
+    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
+}
+
+struct S1 {
+     S1();
+     S1(S1 const &) = delete;
+     S1(S1 &&);
+     S1 operator =(S1 const &) = delete;
+     S1 operator =(S1 &&);
+};
+
+struct S2 { S2(S1); };
+S2 f() {
+   S1 s;
+   return { std::move(s) }; // { dg-bogus "redundant move" }
+}