https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80635
Paul Fee <paul.f.fee at gmail dot com> changed:
What |Removed |Added
----------------------------------------------------------------------------
CC| |paul.f.fee at gmail dot com
--- Comment #65 from Paul Fee <paul.f.fee at gmail dot com> ---
Below is some code that produces unexpected -Wmaybe-uninitialized warnings. Is
this a variant of this bug or a separate bug?
I've tried a few configurations:
Unexpected warnings:
$ g++-10 -Wall -O2 warn.cpp -DBOOST
warn.cpp: In function ‘int main()’:
warn.cpp:19:10: warning: ‘*((void*)& i +1)’ may be used uninitialized in this
function [-Wmaybe-uninitialized]
19 | m_i(i)
| ^
warn.cpp:32:10: note: ‘*((void*)& i +1)’ was declared here
32 | optb i;
| ^
No warnings (c++17 flag not needed with GCC 11).
$ g++-10 -Wall -O2 warn.cpp -std=c++17
$ g++-11 -Wall -O2 warn.cpp -DBOOST
$ g++-11 -Wall -O2 warn.cpp
The constructor takes three optional<std::string> and one optional<bool>.
Adjusting the number and types of parameters makes a difference, but I don't
see why. Perhaps with less parameters, passing by register rather than stack
memory affects warning generation. However 4 x optional<std::string> gives no
warning and that would be larger than 3 x optional<std::string> plus 1 x
optional<bool>.
It's not clear why std::optional would be free from warnings, yet
boost::optional not. Is adoption of std::optional an effective way of avoiding
unnecessary -Wmaybe-uninitialized warnings?
It seems that GCC 11 has better behaviour. Is this expected or would some
other (perhaps larger) collection of parameters trigger the same warning with
GCC 11?
If GCC 11 incorporates a specific fix, will that be backported to GCC 10?
Tested with GCC on openSUSE Tumbleweed. Package versions:
gcc10-c++-10.3.0+git1587-2.1.x86_64
gcc11-c++-11.1.1+git340-1.1.x86_64
The source for warn.cpp:
========================
#include <string>
#ifdef BOOST
#include <boost/optional.hpp>
using opts = boost::optional<std::string>;
using optb = boost::optional<bool>;
#else
#include <optional>
using opts = std::optional<std::string>;
using optb = std::optional<bool>;
#endif
class foo
{
public:
foo(opts a, opts b, opts c,
optb i)
: m_a(a), m_b(b), m_c(c),
m_i(i)
{}
private:
opts m_a;
opts m_b;
opts m_c;
optb m_i;
};
int main()
{
opts a, b, c;
optb i;
foo bar(a, b, c, i);
}
