Re: More aggressive GCC 12 -Wmaybe-uninitialized when using <functional>

[Jonathan Wakely <jwakely@redhat.com>]

On Thu, 22 Jul 2021 at 10:23, Stephan Bergmann via Libstdc++
<libstdc++@gcc.gnu.org> wrote:
>
> Compared to GCC 11 (at least gcc-c++-11.1.1-3.fc34.x86_64), recent GCC
> 12 trunk emits two "unhelpful" -Wmaybe-uninitialized for
>
> > $ cat test.cc
> > #include <functional>
> > using fn = std::function<void()>;
> > fn f(fn x) {
> >     fn a;
> >     a = x;
> >     return x;
> > }
>
> > $ ~/gcc/trunk/inst/bin/g++ -c -Wmaybe-uninitialized -O2 test.cc
> > In file included from ~/gcc/trunk/inst/include/c++/12.0.0/bits/stl_function.h:60,
> >                  from ~/gcc/trunk/inst/include/c++/12.0.0/functional:49,
> >                  from test.cc:1:
> > In function ‘std::_Require<std::__not_<std::__is_tuple_like<_Tp> >, std::is_move_constructible<_Tp>, std::is_move_assignable<_Tp> > std::swap(_Tp&, _Tp&) [with _Tp = void (*)(const std::_Any_data&)]’,
> >     inlined from ‘void std::function<_Res(_ArgTypes ...)>::swap(std::function<_Res(_ArgTypes ...)>&) [with _Res = void; _ArgTypes = {}]’ at ~/gcc/trunk/inst/include/c++/12.0.0/bits/std_function.h:529:11,
> >     inlined from ‘std::function<_Res(_ArgTypes ...)>& std::function<_Res(_ArgTypes ...)>::operator=(const std::function<_Res(_ArgTypes ...)>&) [with _Res = void; _ArgTypes = {}]’ at ~/gcc/trunk/inst/include/c++/12.0.0/bits/std_function.h:442:20,
> >     inlined from ‘fn f(fn)’ at test.cc:5:9:
> > ~/gcc/trunk/inst/include/c++/12.0.0/bits/move.h:204:11: warning: ‘<unnamed>.std::function<void()>::_M_invoker’ may be used uninitialized [-Wmaybe-uninitialized]
> >   204 |       _Tp __tmp = _GLIBCXX_MOVE(__a);
> >       |           ^~~~~
> > In file included from ~/gcc/trunk/inst/include/c++/12.0.0/functional:59,
> >                  from test.cc:1:
> > ~/gcc/trunk/inst/include/c++/12.0.0/bits/std_function.h: In function ‘fn f(fn)’:
> > ~/gcc/trunk/inst/include/c++/12.0.0/bits/std_function.h:442:9: note: ‘<anonymous>’ declared here
> >   442 |         function(__x).swap(*this);
> >       |         ^~~~~~~~~~~~~
> > In file included from ~/gcc/trunk/inst/include/c++/12.0.0/bits/stl_function.h:60,
> >                  from ~/gcc/trunk/inst/include/c++/12.0.0/functional:49,
> >                  from test.cc:1:
> > In function ‘std::_Require<std::__not_<std::__is_tuple_like<_Tp> >, std::is_move_constructible<_Tp>, std::is_move_assignable<_Tp> > std::swap(_Tp&, _Tp&) [with _Tp = std::_Any_data]’,
> >     inlined from ‘void std::function<_Res(_ArgTypes ...)>::swap(std::function<_Res(_ArgTypes ...)>&) [with _Res = void; _ArgTypes = {}]’ at ~/gcc/trunk/inst/include/c++/12.0.0/bits/std_function.h:527:11,
> >     inlined from ‘std::function<_Res(_ArgTypes ...)>& std::function<_Res(_ArgTypes ...)>::operator=(const std::function<_Res(_ArgTypes ...)>&) [with _Res = void; _ArgTypes = {}]’ at ~/gcc/trunk/inst/include/c++/12.0.0/bits/std_function.h:442:20,
> >     inlined from ‘fn f(fn)’ at test.cc:5:9:
> > ~/gcc/trunk/inst/include/c++/12.0.0/bits/move.h:204:11: warning: ‘*(std::_Any_data*)((char*)&<unnamed> + offsetof(std::function, std::function<void()>::<unnamed>))’ may be used uninitialized [-Wmaybe-uninitialized]
> >   204 |       _Tp __tmp = _GLIBCXX_MOVE(__a);
> >       |           ^~~~~
> > In file included from ~/gcc/trunk/inst/include/c++/12.0.0/functional:59,
> >                  from test.cc:1:
> > ~/gcc/trunk/inst/include/c++/12.0.0/bits/std_function.h: In function ‘fn f(fn)’:
> > ~/gcc/trunk/inst/include/c++/12.0.0/bits/std_function.h:442:9: note: ‘<anonymous>’ declared here
> >   442 |         function(__x).swap(*this);
> >       |         ^~~~~~~~~~~~~
>
> This appears to be an issue with more aggressive -Wmaybe-uninitialized
> in GCC 12 vs. 11, rather than an issue with changes to <functional> in
> libstdc++ 12 vs. 11, as effectively the same warnings are emitted when I
> use GCC 12 with libstdc++ 11 with
>
> > $ ~/gcc/trunk/inst/bin/g++ -c -Wmaybe-uninitialized -O2 -nostdinc++ -isystem /usr/include/c++/11 -isystem /usr/include/c++/11/x86_64-redhat-linux test.cc
>
> The warnings may technically be correct, and I'm not sure whether this
> is something that should be addressed in the GCC code emitting the
> warnings or in the libstdc++ <functional> implementation.
>
> (I found this when building LibreOffice with recent GCC 12 trunk.)

The problem is that the _Function_base default constructor is
user-provided, so when std::function value-initializes its base class,
that doesn't do zero-init first. It just calls the default ctor, which
doesn't initialize the _M_fucntor member.

This should fix it:

--- a/libstdc++-v3/include/bits/std_function.h
+++ b/libstdc++-v3/include/bits/std_function.h
@@ -237,7 +237,7 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
       { __functor._M_access<_Functor*>() = new _Functor(std::move(__f)); }
      };

-    _Function_base() : _M_manager(nullptr) { }
+    _Function_base() = default;

    ~_Function_base()
    {
@@ -250,8 +250,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
    typedef bool (*_Manager_type)(_Any_data&, const _Any_data&,
                                 _Manager_operation);

-    _Any_data     _M_functor;
-    _Manager_type _M_manager;
+    _Any_data     _M_functor{};
+    _Manager_type _M_manager{};
  };

  template<typename _Signature, typename _Functor>
@@ -634,8 +634,8 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION

    private:
      using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
-      _Invoker_type _M_invoker;
-  };
+      _Invoker_type _M_invoker = nullptr;
+    };

#if __cpp_deduction_guides >= 201606
  template<typename>