meson: Ignore -Wredundant-move with gcc-13 and newer

Starting from 13.1, gcc implements the C++23 version of automatic move
from local variables in return statements (see
https://en.cppreference.com/w/cpp/language/return). As a result, some
previously required explicit `std::move()` in return statements generate
warnings. This is the case when a function returns an object whose type
is a class derived from the class type the function returns:

struct U { };
struct T : U { };

U f()
{
	T t;
	return t;
}

Up to C++20, the automatic move from local variables selects the move
constructor of class U, which is not the move constructor of the
expression. Overload resolution is then performed a second time, with t
considered as an lvalue. An explicit `std::move(t)` is needed in the
return statement to select the U move constructor.

Starting from C++23, `t` is treated as an xvalue, and the U move
constructor is selected without the need for an explicit `std::move(t)`.
An explicit `std:move()` then generates a redundant-move warning, as in
the valueOrTuple() function in src/py/libcamera/py_helpers.cpp.

Omitting the `std::move()` silences the warning, but selects the copy
constructor of U with older gcc versions and with clang, which
negatively impacts performance.

The easiest fix is to disable the warning. With -Wpessimizing-move
enabled, the compiler will still warn of pessimizing moves, only the
redundant but not pessimizing moves will be ignored.

Signed-off-by: Laurent Pinchart <[email protected]>
Reviewed-by: Kieran Bingham <[email protected]>
Signed-off-by: Kieran Bingham <[email protected]>

meson.build

@@ -136,6 +136,21 @@ if cc.get_id() == 'gcc'
         ]
     endif
 
+    # gcc 13 implements the C++23 version of automatic move from local
+    # variables in return statements (see
+    # https://en.cppreference.com/w/cpp/language/return). As a result, some
+    # previously required explicit std::move() in return statements generate
+    # warnings. Those moves can't be removed as older compiler versions could
+    # use copy constructors instead of move constructors. The easiest fix is to
+    # disable the warning. With -Wpessimizing-move enabled, the compiler will
+    # still warn of pessimizing moves, only the redundant but not pessimizing
+    # moves will be ignored.
+    if cc.version().version_compare('>=13')
+        cpp_arguments += [
+            '-Wno-redundant-move',
+        ]
+    endif
+
     # gcc 7.1 introduced processor-specific ABI breakages related to parameter
     # passing on ARM platforms. This generates a large number of messages
     # during compilation. Silence them.