From mboxrd@z Thu Jan  1 00:00:00 1970
Return-Path: <gcc-bugzilla@gcc.gnu.org>
Received: by sourceware.org (Postfix, from userid 48)
	id ED8AB3858D28; Sat,  8 Apr 2023 05:10:41 +0000 (GMT)
DKIM-Filter: OpenDKIM Filter v2.11.0 sourceware.org ED8AB3858D28
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gcc.gnu.org;
	s=default; t=1680930641;
	bh=Xwg/d7rxDjHWEdQEBuAkdkGv1OZ/2Cq9lW6AyvQ3Ur4=;
	h=From:To:Subject:Date:From;
	b=bRdMF2Gs40lNuUJunkLNoD34ZI3mNdL/e+vpSPfv4jC4vm4OI7mBVbrMe3XaR2wMk
	 mD6ROIgnEJzCa3hbiwifvF80H775ucrFIFydPTBq71BtbhP+PbNg/6gd8wv2ZFxfaX
	 wx3FhXvtx17I2fh6Zl+lfjkTdaAoea1NrGjQ2UCQ=
From: "jincikang at gmail dot com" <gcc-bugzilla@gcc.gnu.org>
To: gcc-bugs@gcc.gnu.org
Subject: =?UTF-8?B?W0J1ZyBjKysvMTA5NDQ4XSBOZXc6IF9NX2V4Y2VwdGlvbl9vYmpl?=
 =?UTF-8?B?Y3TigJkgbWF5IGJlIHVzZWQgdW5pbml0aWFsaXplZCBbLVdlcnJvcj1tYXli?=
 =?UTF-8?B?ZS11bmluaXRpYWxpemVkXQ==?=
Date: Sat, 08 Apr 2023 05:10:41 +0000
X-Bugzilla-Reason: CC
X-Bugzilla-Type: new
X-Bugzilla-Watch-Reason: None
X-Bugzilla-Product: gcc
X-Bugzilla-Component: c++
X-Bugzilla-Version: 12.2.1
X-Bugzilla-Keywords: 
X-Bugzilla-Severity: normal
X-Bugzilla-Who: jincikang at gmail dot com
X-Bugzilla-Status: UNCONFIRMED
X-Bugzilla-Resolution: 
X-Bugzilla-Priority: P3
X-Bugzilla-Assigned-To: unassigned at gcc dot gnu.org
X-Bugzilla-Target-Milestone: ---
X-Bugzilla-Flags: 
X-Bugzilla-Changed-Fields: bug_id short_desc product version bug_status
 bug_severity priority component assigned_to reporter target_milestone
Message-ID: <bug-109448-4@http.gcc.gnu.org/bugzilla/>
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable
X-Bugzilla-URL: http://gcc.gnu.org/bugzilla/
Auto-Submitted: auto-generated
MIME-Version: 1.0
List-Id: <gcc-bugs.sourceware.org>

https://gcc.gnu.org/bugzilla/show_bug.cgi?id=3D109448

            Bug ID: 109448
           Summary: _M_exception_object=E2=80=99 may be used uninitialized
                    [-Werror=3Dmaybe-uninitialized]
           Product: gcc
           Version: 12.2.1
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: jincikang at gmail dot com
  Target Milestone: ---

```cpp
// test.cpp
#include <variant>
#include <vector>
#include <cassert>
#include <cstdint>
#include <exception>
#include <atomic>

template <typename T>
class Try {
public:
    Try() =3D default;
    ~Try() =3D default;

    Try(Try<T>&& other) =3D default;

    Try& operator=3D(Try<T>&& other) =3D default;
    Try& operator=3D(std::exception_ptr error) {
        if (std::holds_alternative<std::exception_ptr>(_value) &&
            std::get<std::exception_ptr>(_value) =3D=3D error) {
            return *this;
        }

        _value.template emplace<std::exception_ptr>(error);
        return *this;
    }

    template <class... U>
    Try(U&&... value)
        requires std::is_constructible_v<T, U...>
        : _value(std::in_place_type<T>, std::forward<U>(value)...) {}

    Try(std::exception_ptr error) : _value(error) {}

private:
    Try(const Try&) =3D delete;
    Try& operator=3D(const Try&) =3D delete;

public:
    constexpr bool available() const noexcept {
        return !std::holds_alternative<std::monostate>(_value);
    }
    constexpr bool hasError() const noexcept {
        return std::holds_alternative<std::exception_ptr>(_value);
    }
    const T& value() const& {
        checkHasTry();
        return std::get<T>(_value);
    }
    T& value() & {
        checkHasTry();
        return std::get<T>(_value);
    }
    T&& value() && {
        checkHasTry();
        return std::move(std::get<T>(_value));
    }
    const T&& value() const&& {
        checkHasTry();
        return std::move(std::get<T>(_value));
    }

    template <class... Args>
    T& emplace(Args&&... args) {
        return _value.template emplace<T>(std::forward<Args>(args)...);
    }

    void setException(std::exception_ptr error) {
        if (std::holds_alternative<std::exception_ptr>(_value) &&
            std::get<std::exception_ptr>(_value) =3D=3D error) {
            return;
        }
        _value.template emplace<std::exception_ptr>(error);
    }
    std::exception_ptr getException() const {
        logicAssert(std::holds_alternative<std::exception_ptr>(_value),
                    "Try object do not has on error");
        return std::get<std::exception_ptr>(_value);
    }
private:
    inline void checkHasTry() const {
        if (std::holds_alternative<T>(_value))
           { return; }
        else if (std::holds_alternative<std::exception_ptr>(_value)) {
            std::rethrow_exception(std::get<std::exception_ptr>(_value));
        } else if (std::holds_alternative<std::monostate>(_value)) {
            throw std::logic_error("Try object is empty");
        } else {
            assert(false);
        }
    }

private:
    std::variant<std::monostate, T, std::exception_ptr> _value;
};


namespace detail {

enum class State : uint8_t {
    START =3D 0,
    ONLY_RESULT =3D 1 << 0,
    ONLY_CONTINUATION =3D 1 << 1,
    DONE =3D 1 << 5,
};

constexpr State operator|(State lhs, State rhs) {
    return State((uint8_t)lhs | (uint8_t)rhs);
}

constexpr State operator&(State lhs, State rhs) {
    return State((uint8_t)lhs & (uint8_t)rhs);
}

}  // namespace detail

template <class T>
struct TestPromise {
public:
    TestPromise() : _state(detail::State::START) {}
    ~TestPromise() {}

public:
    bool hasResult() const noexcept {
        constexpr auto allow =3D detail::State::DONE |
detail::State::ONLY_RESULT;
        auto state =3D _state.load(std::memory_order_acquire);
        return (state & allow) !=3D detail::State();
    }

    void setResult(Try<T>&& value) {
        assert(!hasResult());
        _try_value =3D std::move(value);
    }

    std::atomic<detail::State> _state;
    Try<T> _try_value;
};

struct Empty {};

int main() {
    int n =3D 10;
    std::vector<TestPromise<Empty>> promise(n);
    for (int i =3D 0; i < n; ++i) {
        promise[i].setResult(Empty());
    }
}
```

# no problem
$ g++-11 -std=3Dc++20 -Wall -Werror -O3 test.cpp

# no problem
$ g++ -std=3Dc++20 -Wall -Werror -O0 test.cpp

# Error=EF=BC=9A=E2=80=98*(std::__exception_ptr::exception_ptr*)((char*)&<u=
nnamed> +
offsetof(Try<Empty>,Try<Empty>::_value.std::variant<std::monostate, Empty,
std::__exception_ptr::exception_ptr>::<unnamed>.std::__detail::__variant::_=
Variant_base<std::monostate,
Empty,
std::__exception_ptr::exception_ptr>::<unnamed>.std::__detail::__variant::_=
Move_assign_base<false,
std::monostate, Empty,
std::__exception_ptr::exception_ptr>::<unnamed>.std::__detail::__variant::_=
Copy_assign_base<false,
std::monostate, Empty,
std::__exception_ptr::exception_ptr>::<unnamed>.std::__detail::__variant::_=
Move_ctor_base<false,
std::monostate, Empty,
std::__exception_ptr::exception_ptr>::<unnamed>.std::__detail::__variant::_=
Copy_ctor_base<false,
std::monostate, Empty,
std::__exception_ptr::exception_ptr>::<unnamed>.std::__detail::__variant::_=
Variant_storage<false,
std::monostate, Empty,
std::__exception_ptr::exception_ptr>::_M_u)).std::__exception_ptr::exceptio=
n_ptr::_M_exception_object=E2=80=99
may be used uninitialized [-Werror=3Dmaybe-uninitialized]
$ g++ -std=3Dc++20 -Wall -Werror -O3 test.cpp=