[Bug c++/98995] New: Copy elision not applied to members declared with [[no_unique_address]]

[Bug c++/98995] New: Copy elision not applied to members declared with [[no_unique_address]]

[david at doublewise dot net]

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

            Bug ID: 98995
           Summary: Copy elision not applied to members declared with
                    [[no_unique_address]]
           Product: gcc
           Version: 11.0
            Status: UNCONFIRMED
          Severity: normal
          Priority: P3
         Component: c++
          Assignee: unassigned at gcc dot gnu.org
          Reporter: david at doublewise dot net
  Target Milestone: ---

The following valid translation unit is rejected by gcc 11:

```
struct non_movable {
        non_movable() = default;
        non_movable(non_movable &&) = delete;
};

struct wrapper {
        constexpr explicit wrapper(auto function):
                m(function())
        {
        }

        [[no_unique_address]] non_movable m;
};

constexpr auto w = wrapper{[]{ return non_movable(); }};
```

with the error message

```
<source>: In instantiation of 'constexpr wrapper::wrapper(auto:1) [with auto:1
= <lambda()>]':
<source>:15:55:   required from here
<source>:8:17: error: use of deleted function
'non_movable::non_movable(non_movable&&)'
    8 |                 m(function())
      |                 ^~~~~~~~~~~~~
<source>:3:9: note: declared here
    3 |         non_movable(non_movable &&) = delete;
      |         ^~~~~~~~~~~
Compiler returned: 1
```

See it live: https://godbolt.org/z/o1TbY9

This was accepted in gcc 10.2.

[Bug c++/98995] [11 Regression] Copy elision not applied to members declared with [[no_unique_address]]

[rguenth at gcc dot gnu.org]

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

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
           Keywords|                            |rejects-valid
            Summary|Copy elision not applied to |[11 Regression] Copy
                   |members declared with       |elision not applied to
                   |[[no_unique_address]]       |members declared with
                   |                            |[[no_unique_address]]
   Target Milestone|---                         |11.0

[Bug c++/98995] [11 Regression] Copy elision not applied to members declared with [[no_unique_address]]

[redi at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |jason at gcc dot gnu.org

--- Comment #1 from Jonathan Wakely <redi at gcc dot gnu.org> ---
Started with r11-2704:

    c++: Copy elision and [[no_unique_address]]. [PR93711]

    We don't elide a copy from a function returning a class by value into a
base
    because that can overwrite data laid out in the tail padding of the base
    class; we need to handle [[no_unique_address]] fields the same way, or we
    ICE when the middle-end wants to create a temporary object of a
    TYPE_NEEDS_CONSTRUCTING type.

    This means that we can't always express initialization of a field with
    INIT_EXPR from a TARGET_EXPR the way we usually do, so I needed
    to change several places that were assuming that was sufficient.

    This also fixes 90254, the same problem with C++17 aggregate initialization
    of a base.

[Bug c++/98995] [11 Regression] Copy elision not applied to members declared with [[no_unique_address]]

[jason at gcc dot gnu.org]

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

Jason Merrill <jason at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Last reconfirmed|                            |2021-02-08
             Status|UNCONFIRMED                 |SUSPENDED
     Ever confirmed|0                           |1

--- Comment #2 from Jason Merrill <jason at gcc dot gnu.org> ---
This was a deliberate change.  This language/ABI issue is tracked at
https://wg21.link/cwg2403 and
https://github.com/itanium-cxx-abi/cxx-abi/issues/107

The problem is that we can't safely initialize a base or
potentially-overlapping member from the result of a function call, at least
without a major ABI break, because it might clobber other data allocated into
the tail padding.

[Bug c++/98995] [11/12 Regression] Copy elision not applied to members declared with [[no_unique_address]]

[jakub at gcc dot gnu.org]

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

Jakub Jelinek <jakub at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|11.0                        |11.2

--- Comment #3 from Jakub Jelinek <jakub at gcc dot gnu.org> ---
GCC 11.1 has been released, retargeting bugs to GCC 11.2.

[Bug c++/98995] [11/12 Regression] Copy elision not applied to members declared with [[no_unique_address]]

[rguenth at gcc dot gnu.org]

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

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|11.2                        |11.3

--- Comment #4 from Richard Biener <rguenth at gcc dot gnu.org> ---
GCC 11.2 is being released, retargeting bugs to GCC 11.3

[Bug c++/98995] [11/12 Regression] Copy elision not applied to members declared with [[no_unique_address]]

[rguenth at gcc dot gnu.org]

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

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|11.3                        |11.4

--- Comment #5 from Richard Biener <rguenth at gcc dot gnu.org> ---
GCC 11.3 is being released, retargeting bugs to GCC 11.4.

[Bug c++/98995] [11/12/13 Regression] Copy elision not applied to members declared with [[no_unique_address]]

[davidfromonline at gmail dot com]

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

David Stone <davidfromonline at gmail dot com> changed:

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

--- Comment #6 from David Stone <davidfromonline at gmail dot com> ---
Until we get that ABI break, it would be nice if the error message explained
why this doesn't work.

[Bug c++/98995] [11/12/13 Regression] Copy elision not applied to members declared with [[no_unique_address]]

[pinskia at gcc dot gnu.org]

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

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

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

--- Comment #7 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
*** Bug 108333 has been marked as a duplicate of this bug. ***

[Bug c++/98995] [10/11/12/13 Regression] Copy elision not applied to members declared with [[no_unique_address]]

[pinskia at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|11.4                        |10.5
            Summary|[11/12/13 Regression] Copy  |[10/11/12/13 Regression]
                   |elision not applied to      |Copy elision not applied to
                   |members declared with       |members declared with
                   |[[no_unique_address]]       |[[no_unique_address]]

[Bug c++/98995] [10/11/12/13 Regression] Copy elision not applied to members declared with [[no_unique_address]] or a empty base class

[pinskia at gcc dot gnu.org]

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

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

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

--- Comment #8 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
*** Bug 108364 has been marked as a duplicate of this bug. ***

[Bug c++/98995] [10/11/12/13 Regression] Copy elision not applied to members declared with [[no_unique_address]] or a empty base class

[redi at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |davidledger at live dot com.au

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

[Bug c++/98995] [10/11/12/13 Regression] Copy elision not applied to members declared with [[no_unique_address]] or a empty base class

[pinskia at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |for.gcc.bugzilla at gmail dot com

--- Comment #10 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
*** Bug 82113 has been marked as a duplicate of this bug. ***

[Bug c++/98995] [10/11/12/13/14 Regression] Copy elision not applied to members declared with [[no_unique_address]] or a empty base class

[pinskia at gcc dot gnu.org]

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

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

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |eric.niebler at gmail dot com

--- Comment #11 from Andrew Pinski <pinskia at gcc dot gnu.org> ---
*** Bug 110507 has been marked as a duplicate of this bug. ***

[Bug c++/98995] [11/12/13/14 Regression] Copy elision not applied to members declared with [[no_unique_address]] or a empty base class

[rguenth at gcc dot gnu.org]

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

Richard Biener <rguenth at gcc dot gnu.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
   Target Milestone|10.5                        |11.5

--- Comment #12 from Richard Biener <rguenth at gcc dot gnu.org> ---
GCC 10 branch is being closed.

[Bug c++/98995] [11/12/13/14 Regression] Copy elision not applied to members declared with [[no_unique_address]] or a empty base class

[jan.kokemueller at gmail dot com]

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

Jan Kokemüller <jan.kokemueller at gmail dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |jan.kokemueller at gmail dot com

--- Comment #13 from Jan Kokemüller <jan.kokemueller at gmail dot com> ---
Sometimes, all of the padding bytes of a "[[no_unique_address]]" member are
known when designing a class. It would be great if there was a way to say:
"hey, it's OK to do guaranteed copy elision here". Example:

union U {
  [[no_unique_address]] Val val;
  [[no_unique_address]] Err err;
};

struct R {
  [[no_unique_address]] U union;
  [[no_unique_address]] bool has_val;
};

struct expected {
  R r;
};

In this example, "union U" and "struct R" are only used in the "struct
expected", by design. So it should be safe to allow guaranteed copy elision
when initializing the members "val" and "err" of the union since we have full
control over the tail padding bytes (there can only be "has_val" in there,
nothing else).

Maybe there could be an attribute, something like
"[[gnu::allow_guaranteed_copy_elision]]" or
"[[gnu::defer_temporary_materialization]]", to mark those members where
guaranteed copy elision is safe? So you could have:

union U {
  [[no_unique_address,gnu::defer_temporary_materialization]] Val val;
  [[no_unique_address,gnu::defer_temporary_materialization]] Err err;
};

What do you think?