[gcc/devel/omp/gcc-14] c++: tweak for -Wrange-loop-construct [PR116731]

[Tobias Burnus via Gcc-cvs]

https://gcc.gnu.org/g:fb9ba80b91b5328e43eeaf83cafe150ee861043d

commit fb9ba80b91b5328e43eeaf83cafe150ee861043d
Author: Marek Polacek <pola...@redhat.com>
Date:   Tue Sep 17 16:58:37 2024 -0400

    c++: tweak for -Wrange-loop-construct [PR116731]
    
    This PR reports that the warning would be better off using a check
    for trivially constructible rather than trivially copyable.
    
    LLVM accepted a similar fix:
    https://github.com/llvm/llvm-project/issues/47355
    
            PR c++/116731
    
    gcc/cp/ChangeLog:
    
            * parser.cc (warn_for_range_copy): Check if TYPE is trivially
            constructible, not copyable.
    
    gcc/testsuite/ChangeLog:
    
            * g++.dg/warn/Wrange-loop-construct3.C: New test.
    
    Reviewed-by: Jason Merrill <ja...@redhat.com>
    (cherry picked from commit 6ac4e2f4b2ca9980670e7d3815a9140730df1005)

Diff:
---
 gcc/cp/parser.cc                                   |  8 +--
 gcc/testsuite/g++.dg/warn/Wrange-loop-construct3.C | 57 ++++++++++++++++++++++
 2 files changed, 62 insertions(+), 3 deletions(-)

diff --git a/gcc/cp/parser.cc b/gcc/cp/parser.cc
index b1a29c8f1b52..5461719370c9 100644
--- a/gcc/cp/parser.cc
+++ b/gcc/cp/parser.cc
@@ -14494,11 +14494,13 @@ warn_for_range_copy (tree decl, tree expr)
   else if (!CP_TYPE_CONST_P (type))
     return;
 
-  /* Since small trivially copyable types are cheap to copy, we suppress the
-     warning for them.  64B is a common size of a cache line.  */
+  /* Since small trivially constructible types are cheap to construct, we
+     suppress the warning for them.  64B is a common size of a cache line.  */
+  tree vec = make_tree_vec (1);
+  TREE_VEC_ELT (vec, 0) = TREE_TYPE (expr);
   if (TREE_CODE (TYPE_SIZE_UNIT (type)) != INTEGER_CST
       || (tree_to_uhwi (TYPE_SIZE_UNIT (type)) <= 64
-         && trivially_copyable_p (type)))
+         && is_trivially_xible (INIT_EXPR, type, vec)))
     return;
 
   /* If we can initialize a reference directly, suggest that to avoid the
diff --git a/gcc/testsuite/g++.dg/warn/Wrange-loop-construct3.C 
b/gcc/testsuite/g++.dg/warn/Wrange-loop-construct3.C
new file mode 100644
index 000000000000..3d9d0c9088e6
--- /dev/null
+++ b/gcc/testsuite/g++.dg/warn/Wrange-loop-construct3.C
@@ -0,0 +1,57 @@
+// PR c++/116731
+// { dg-do compile { target c++11 } }
+// { dg-options "-Wrange-loop-construct" }
+
+void
+f0 ()
+{
+  struct S {
+    char a[64];
+    S& operator=(const S&) { return *this; };
+  };
+
+  S arr[8];
+  for (const auto r : arr)
+    (void) r;
+}
+
+void
+f1 ()
+{
+  struct S {
+    char a[65];
+    S& operator=(const S&) { return *this; };
+  };
+
+  S arr[8];
+  for (const auto r : arr) // { dg-warning "creates a copy" }
+    (void) r;
+}
+
+void
+f2 ()
+{
+  struct S {
+    char a[64];
+    S& operator=(const S&) { return *this; };
+    ~S() { }
+  };
+
+  S arr[8];
+  for (const auto r : arr) // { dg-warning "creates a copy" }
+    (void) r;
+}
+
+void
+f3 ()
+{
+  struct S {
+    char a[65];
+    S& operator=(const S&) { return *this; };
+    ~S() { }
+  };
+
+  S arr[8];
+  for (const auto r : arr) // { dg-warning "creates a copy" }
+    (void) r;
+}