Merge 2018-03 CWG Motion 2

Author: zygoloid

source/basic.tex

@@ -2755,27 +2755,55 @@
 \defn{most derived object}.
 
 \pnum
+A \defn{potentially-overlapping subobject} is either:
+\begin{itemize}
+\item a base class subobject, or
+\item a non-static data member
+declared with the \tcode{no_unique_address} attribute\iref{dcl.attr.nouniqueaddr}.
+\end{itemize}
+
+\pnum
+\indextext{object!zero size}%
+\indextext{object!nonzero size}%
+An object has nonzero size if it
+\begin{itemize}
+\item is not a potentially-overlapping subobject, or
+\item is not of class type, or
+\item is of a class type with virtual member functions or virtual base classes, or
+\item has subobjects of nonzero size or bit-fields of nonzero length.
+\end{itemize}
+Otherwise, if the object is a base class subobject
+of a standard-layout class type
+with no non-static data members,
+it has zero size.
+Otherwise, the circumstances under which the object has zero size
+are \impldef{which non-standard-layout objects
+containing no data are considered empty}.
 \indextext{most derived object!bit-field}%
-Unless it is a bit-field\iref{class.bit}, a most derived object shall have a
-nonzero size and shall occupy one or more bytes of storage. Base class
-subobjects may have zero size. An object of trivially copyable or
+Unless it is a bit-field\iref{class.bit},
+an object with nonzero size
+shall occupy one or more bytes of storage,
+including every byte that is occupied in full or in part
+by any of its subobjects.
+An object of trivially copyable or
 standard-layout type\iref{basic.types} shall occupy contiguous bytes of
 storage.
 
 \pnum
 \indextext{most derived object!bit-field}%
 \indextext{most derived object!zero size subobject}%
-Unless an object is a bit-field or a base class subobject of zero size, the
+Unless an object is a bit-field or a subobject of zero size, the
 address of that object is the address of the first byte it occupies.
-Two objects \placeholder{a} and \placeholder{b}
+Two objects
 with overlapping lifetimes
 that are not bit-fields
 may have the same address
 if one is nested within the other,
 or
-if at least one is a base class subobject of zero size
+if at least one is a subobject of zero size
 and they are of different types;
-otherwise, they have distinct addresses.\footnote{Under the ``as-if'' rule an
+otherwise, they have distinct addresses
+and occupy disjoint bytes of storage.\footnote{Under the ``as-if'' rule an
 implementation is allowed to store two objects at the same machine address or
 not store an object at all if the program cannot observe the
 difference\iref{intro.execution}.}
@@ -2786,6 +2814,9 @@
 const bool b = &test1 != &test2;        // always \tcode{true}
 \end{codeblock}
 \end{example}
+The address of a non-bit-field subobject of zero size is
+the address of an unspecified byte of storage
+occupied by the complete object of that subobject.
 
 \pnum
 \begin{note}
@@ -2963,9 +2994,8 @@
 class type, does not contain any non-static data member whose type is
 const-qualified or a reference type, and
 
-\item the original object was a most derived object\iref{intro.object}
-of type \tcode{T} and the new object is a most derived object of type
-\tcode{T} (that is, they are not base class subobjects).
+\item neither the original object nor the new object
+is a potentially-overlapping subobject\iref{intro.object}.
 \end{itemize}
 \begin{example}
 \begin{codeblock}
@@ -3573,7 +3603,7 @@
 \pnum
 \indextext{object!byte copying and|(}%
 \indextext{type!trivially copyable}%
-For any object (other than a base-class subobject) of trivially copyable type
+For any object (other than a potentially-overlapping subobject) of trivially copyable type
 \tcode{T}, whether or not the object holds a valid value of type
 \tcode{T}, the underlying bytes\iref{intro.memory} making up the
 object can be copied into an array of
@@ -3597,7 +3627,7 @@
 \pnum
 For any trivially copyable type \tcode{T}, if two pointers to \tcode{T} point to
 distinct \tcode{T} objects \tcode{obj1} and \tcode{obj2}, where neither
-\tcode{obj1} nor \tcode{obj2} is a base-class subobject, if the underlying
+\tcode{obj1} nor \tcode{obj2} is a potentially-overlapping subobject, if the underlying
 bytes\iref{intro.memory} making up
 \tcode{obj1} are copied into \tcode{obj2},\footnote{By using, for example,
 the library functions\iref{headers} \tcode{std::memcpy} or \tcode{std::memmove}.}

source/classes.tex

@@ -101,8 +101,14 @@
 \end{example}
 
 \pnum
-Complete objects and member subobjects of class type shall have nonzero
-size.\footnote{Base class subobjects are not so constrained.}
+\begin{note}
+Complete objects of class type have nonzero size.
+Base class subobjects and
+members declared with the \tcode{no_unique_address} attribute\iref{dcl.attr.nouniqueaddr}
+are not so constrained.
+\end{note}
+
+\pnum
 \begin{note}
 Class objects can be assigned, passed as arguments to functions, and
 returned by functions (except objects of classes for which copying or moving has
@@ -175,8 +181,11 @@
 inherited\iref{class.derived}) non-static data members, the set
 $M(\mathtt{X})$ is empty.
 
-\item If \tcode{X} is a non-union class type whose first non-static data
-member has type $\mathtt{X}_0$ (where said member may be an anonymous union),
+\item If \tcode{X} is a non-union class type with a non-static data
+member of type $\mathtt{X}_0$
+that is either of zero size or
+is the first non-static data member of \tcode{X}
+(where said member may be an anonymous union),
 the set $M(\mathtt{X})$ consists of $\mathtt{X}_0$ and the elements of
 $M(\mathtt{X}_0)$.
 
@@ -193,8 +202,7 @@
 \end{itemize}
 
 \begin{note} $M(\mathtt{X})$ is the set of the types of all non-base-class subobjects
-that are guaranteed in a standard-layout class to be at a zero offset
-in \tcode{X}. \end{note}
+that may be at a zero offset in \tcode{X}. \end{note}
 
 \begin{example}
 \begin{codeblock}
@@ -743,8 +751,12 @@
 types is the longest sequence of non-static data
 members and bit-fields in declaration order, starting with the first
 such entity in each of the structs, such that corresponding entities
-have layout-compatible types and either neither entity is a bit-field or
-both are bit-fields with the same width.
+have layout-compatible types,
+either both entities are declared with
+the \tcode{no_unique_address} attribute\iref{dcl.attr.nouniqueaddr}
+or neither is,
+and either both entities are bit-fields with the same width
+or neither is a bit-field.
 \begin{example}
 \begin{codeblock}
   struct A { int a; char b; };

source/declarations.tex

@@ -4141,3 +4141,42 @@
 }
 \end{codeblock}
 \end{example}
+
+\rSec2[dcl.attr.nouniqueaddr]{No unique address attribute}%
+\indextext{attribute!no unique address}
+
+\pnum
+The \grammarterm{attribute-token} \tcode{no_unique_address}
+specifies that a non-static data member
+is a potentially-overlapping subobject\iref{intro.object}.
+It shall appear at most once in each \grammarterm{attribute-list}
+and no \grammarterm{attribute-argument-clause} shall be present.
+The attribute may appertain to a non-static data member
+other than a bit-field.
+
+\pnum
+\begin{note}
+The non-static data member can share the address of
+another non-static data member or that of a base class,
+and any padding that would normally be inserted
+at the end of the object
+can be reused as storage for other members.
+\end{note}
+\begin{example}
+\begin{codeblock}
+template<typename Key, typename Value,
+         typename Hash, typename Pred, typename Allocator>
+class hash_map {
+  [[no_unique_address]] Hash hasher;
+  [[no_unique_address]] Pred pred;
+  [[no_unique_address]] Allocator alloc;
+  Bucket *buckets;
+  // ...
+public:
+  // ...
+};
+\end{codeblock}
+Here, \tcode{hasher}, \tcode{pred}, and \tcode{alloc}
+could have the same address as \tcode{buckets}
+if their respective types are all empty.
+\end{example}

source/expressions.tex

@@ -3579,8 +3579,9 @@
 \indextext{expression!\idxcode{sizeof}}%
 \indextext{operator!\idxcode{sizeof}}%
 \indextext{byte}%
-The \tcode{sizeof} operator yields the number of bytes in the object
-representation of its operand. The operand is either an expression,
+The \tcode{sizeof} operator yields the number of bytes
+occupied by a non-potentially-overlapping object of the type
+of its operand. The operand is either an expression,
 which is an unevaluated operand\iref{expr.prop}, or a parenthesized
 \grammarterm{type-id}.
 \indextext{type!incomplete}%
@@ -3611,12 +3612,14 @@
 \indextext{class object!\idxcode{sizeof}}%
 When applied to a class, the result is the number of bytes in an object
 of that class including any padding required for placing objects of that
-type in an array. The size of a most derived class shall be greater than
-zero\iref{intro.object}. The result of applying \tcode{sizeof} to a
-base class subobject is the size of the base class type.\footnote{The actual
-size of a base class subobject may be less than the result of
+type in an array.
+The result of applying \tcode{sizeof} to a
+potentially-overlapping subobject is
+the size of the type, not the size of the subobject.%
+\footnote{The actual size of a potentially-overlapping subobject
+may be less than the result of
 applying \tcode{sizeof} to the subobject, due to virtual base classes
-and less strict padding requirements on base class subobjects.}
+and less strict padding requirements on potentially-overlapping subobjects.}
 \indextext{array!\idxcode{sizeof}}%
 When applied to an array, the result is the total number of bytes in the
 array. This implies that the size of an array of \term{n} elements is
@@ -5076,10 +5079,10 @@
 
 \item If two pointers point to different non-static data members of the same
 object, or to subobjects of such members, recursively,
-the pointer to the later declared member compares greater provided the
-two members
-have the same access control\iref{class.access}
-and provided their class is not a union.
+the pointer to the later declared member compares greater provided
+the two members have the same access control\iref{class.access},
+neither member is a subobject of zero size,
+and their class is not a union.
 
 \item Otherwise, neither pointer compares greater than the other.
 

source/utilities.tex

@@ -15977,7 +15977,7 @@
 \tcode{template<class T>}\br
  \tcode{struct is_empty;}               &
  \tcode{T} is a class type, but not a union type, with no non-static data
- members other than bit-fields of length 0, no virtual member functions,
+ members other than subobjects of zero size, no virtual member functions,
  no virtual base classes, and no base class \tcode{B} for
  which \tcode{is_empty_v<B>} is \tcode{false}. &
  If \tcode{T} is a non-union class type, \tcode{T} shall be a complete type.                               \\ \rowsep