[Bug c++/57533] New: When throwing local variable, it's being move-constructed even if not going out of scope.

[Bug c++/57533] New: When throwing local variable, it's being move-constructed even if not going out of scope.

[asaelr at gmail dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57533

            Bug ID: 57533
           Summary: When throwing local variable, it's being
                    move-constructed even if not going out of scope.
           Product: gcc
           Version: 4.7.3
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: asaelr at gmail dot com

Created attachment 30260
  --> http://gcc.gnu.org/bugzilla/attachment.cgi?id=30260&action=edit
example file. (compile with -std=c++0x, and look at the string s)

When throwing variable, a copy of it is actually being throwed.
In c++0x, The compiler may optimize it to move (instead of copy), if this
variable is local, and is going out of scope (for example, if it's not in a try
block, the function will end).
However, gcc 4.7.3 does this optimization even if the variable is not going out
of scope.
As a result, the variable becomes invalid.

[Bug c++/57533] When throwing local variable, it's being move-constructed even if not going out of scope.

[redi at gcc dot gnu.org]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57533

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |NEW
   Last reconfirmed|                            |2013-06-05
     Ever confirmed|0                           |1
      Known to fail|                            |4.7.3, 4.8.1, 4.9.0

--- Comment #1 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Reduced to remove library dependencies:

struct X
{
    bool moved = false;

    X() = default;
    X(const X&) = default;
    X(X&& x) { x.moved = true; }
};

int main()
{
    X x;
    try {
        throw x;
    }
    catch(...) {
    }
    if (x.moved)
        __builtin_abort();
}

[Bug c++/57533] When throwing local variable, it's being move-constructed even if not going out of scope.

[paolo.carlini at oracle dot com]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57533

Paolo Carlini <paolo.carlini at oracle dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Priority|P3                          |P2

[Bug c++/57533] When throwing local variable, it's being move-constructed even if not going out of scope.

[dmitriy-hshg at mail dot ru]

http://gcc.gnu.org/bugzilla/show_bug.cgi?id=57533

Dmitry <dmitriy-hshg at mail dot ru> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |dmitriy-hshg at mail dot ru

--- Comment #2 from Dmitry <dmitriy-hshg at mail dot ru> ---
*** Bug 58629 has been marked as a duplicate of this bug. ***

[Bug c++/57533] When throwing local variable, it's being move-constructed even if not going out of scope.

[ville.voutilainen at gmail dot com]

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

Ville Voutilainen <ville.voutilainen at gmail dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |tsimpson at ubuntu dot com

--- Comment #3 from Ville Voutilainen <ville.voutilainen at gmail dot com> ---
*** Bug 62172 has been marked as a duplicate of this bug. ***

[Bug c++/57533] When throwing local variable, it's being move-constructed even if not going out of scope.

[redi at gcc dot gnu.org]

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

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |frankhb1989 at gmail dot com

--- Comment #4 from Jonathan Wakely <redi at gcc dot gnu.org> ---
*** Bug 65748 has been marked as a duplicate of this bug. ***

[Bug c++/57533] When throwing local variable, it's being move-constructed even if not going out of scope.

[redi at gcc dot gnu.org]

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

Jonathan Wakely <redi at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |njormrod at fb dot com

--- Comment #5 from Jonathan Wakely <redi at gcc dot gnu.org> ---
*** Bug 98938 has been marked as a duplicate of this bug. ***

[Bug c++/57533] When throwing local variable, it's being move-constructed even if not going out of scope.

[redi at gcc dot gnu.org]

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

--- Comment #6 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Seems to be fixed on trunk since

commit 1722e2013f05f1f1f99379dbaa0c0df356da731f
Author: Jason Merrill
Date:   Tue Jul 21 05:19:49 2020

    c++: Implement C++20 implicit move changes. [PR91427]

[Bug c++/57533] When throwing local variable, it's being move-constructed even if not going out of scope.

[redi at gcc dot gnu.org]

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

--- Comment #7 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Most of that commit only affects C++20 mode, but it includes:

            * typeck.c (treat_lvalue_as_rvalue_p): Overhaul.

The new treat_lvalue_as_rvalue_p code says:

+  /* if the operand of a throw-expression is a (possibly parenthesized)
+     id-expression that names an implicitly movable entity whose scope does
not
+     extend beyond the compound-statement of the innermost try-block or
+     function-try-block (if any) whose compound-statement or ctor-initializer
+     encloses the throw-expression, */

The "whose scope does not extend" part is what was missing before.

[Bug c++/57533] When throwing local variable, it's being move-constructed even if not going out of scope.

[pinskia at gcc dot gnu.org]

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

Andrew Pinski <pinskia at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
      Known to work|                            |11.1.0
      Known to fail|                            |10.3.0

--- Comment #8 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
I think we should just add the testcase and be done with it.