[basic.life] p2 Creating an object in the part of the storage region occupied by another object is considered to reuse the storage?

[xmh0511]

Full name of submitter (unless configured in github; will be published with the issue): Jim X

[basic.life] p2 says:

The lifetime of an object o of type T ends when:

• [...]
• the storage which the object occupies is released, or is reused by an object that is not nested within o ([intro.object]).

Consider this example:

alignas(int) unsigned char buffer[8];

int main() {
    auto ptr = new (buffer) int{}; // #1
    new (buffer) char{}; // #2
}

Assuming sizeof(int)==4, #1 starts the lifetime of an object of type int that occupies the storage with 4 bytes. However, #2 uses a part of the storage region, which only uses the head byte. Is the whole 4-byte storage considered to be reused?

Suggested Resolution:

Maybe we need to say that a storage is considered to be reused if any part of the storage is reused.

[safocl]

I believe that the example from [class.union#general-6] (as well as the rule from [class.union#general-5]) and the rule from [class.union#general-2] allow us to legitimately assume that executing #2 could mean reuse if there were no undefined behavior there (in my opinion), since according to [basic.life#2.1] only if storage of the required size is provided (which is naturally not the case in the given example) can the lifetime of an object be started.
(The storage size of u.c is 1 byte, but the object created in this storage has a size of 4 bytes)

upd.
If we accept that line #2 meant not getting a pointer to the array itself, but a pointer to its zero element, then I believe that according to [intro.object#3] (in particular, the note [intro.object#note-3] and the example [intro.object#example-1]), the storage occupied by the object of type int was reused for an object of type char and, accordingly, the lifetime of the object of type int ended.

    new (buffer) char{}; // #2

instead of

    new (&buffer) char{}; // #2

[intro.object#note-3]

[Note 3: If that portion of the array previously provided storage for another object, the lifetime of that object ends because its storage was reused ([basic.life]).
— end note]

[xmh0511]

I believe that the example from [class.union#general-6] (as well as the rule from [class.union#general-5]) and the rule from [class.union#general-2] allow us to legitimately assume that executing #2 could mean reuse if there were no undefined behavior there (in my opinion), since according to [basic.life#2.1] only if storage of the required size is provided (which is naturally not the case in the given example) can the lifetime of an object be started. (The storage size of u.c is 1 byte, but the object created in this storage has a size of 4 bytes)

I fixed my example. There is a typo before.

[safocl]

Here, I think we should also consider what will happen if we use addition or subtraction for &buffer? According to [expr.add#6]:

For addition or subtraction, if the expressions P or Q have type “pointer to cv T”, where T and the array element type are not similar, the behavior is undefined.

But a new object of type char has already been created in the array's place.

alignas(int) unsigned char buffer[8];

int main() {
    auto ptr = new (buffer) int{}; // #1
    new (&buffer) char{}; // #2
    auto ptr_end = &buffer + 1; // #3 -- is this UB?
                                // `&buffer` is a pointer to an array, 
                                // but this array object is replaced by an object of type `char`.
}

[expr.add#footnote-60]:

60) As specified in [basic.compound], an object that is not an array element is considered to belong to a single-element array for this purpose and a pointer past the last element of an array of n elements is considered to be equivalent to a pointer to a hypothetical array element n for this purpose.

[xmh0511]

The key issue is what exactly "the storage is reused" means. Is only using the whole storage considered to reuse the storage? Or, is using any overlapped storage of the storage considered to reuse the storage? The current wording is ambiguous, although the example you mentioned in [intro.object] p3 implies the intended meaning should be the latter one. However, the formal wording is not explicit.

[t3nsor]

I think it's obvious that if int is 4 bytes and you reuse a subset of those bytes for an object of a smaller type, the int object's lifetime must end. If it weren't so, then we would have a loophole by which the spirit of the strict aliasing rule could be violated. Let's saying that we created a new short, with size 2 bytes, inside the storage occupied by the int . If it were allowed for both objects to be alive simultaneously, then the compiler would not be able to assume that a write through a short pointer cannot change the value of an int object.

I do believe that the current wording needs some clarification for the case of array and class objects, e.g., if you have an array of 2 ints and you create a new short object in the storage occupied by one of the two elements, whether the entire array's lifetime ends.

[xmh0511]

If it were allowed for both objects to be alive simultaneously, then the compiler would not be able to assume that a write through a short pointer cannot change the value of an int object.

However, this inference in turn requires us to state that the lifetime of the int object has ended by the created short object, which in turn depends on [basic.life] p2 to render that creating an object of a smaller type ends the object that occupies the containing storage or vice versa.

IIUC, how storage is considered for reuse needs clarification.

[safocl]

The key issue is what exactly "the storage is reused" means. Is only using the whole storage considered to reuse the storage? Or, is using any overlapped storage of the storage considered to reuse the storage? The current wording is ambiguous, although the example you mentioned in [intro.object] p3 implies the intended meaning should be the latter one. However, the formal wording is not explicit.

but doesn't [intro.object#2] clarify this meaning?:

If an object is created in storage associated with a subobject e (which may or may not be within its lifetime), the created object is a subobject of e's containing object if
(2.1) the lifetime of e's containing object has begun and not ended, and
(2.2) the storage for the new object exactly overlays the storage location associated with e, and
(2.3) e is not a potentially-overlapping subobject, and
(2.4) the new object is of the same type as e (ignoring cv-qualification).

In this case, e and the created object are corresponding direct subobjects.

in conjunction with https://eel.is/c++draft/basic.life#2.5:

(2.5) the storage which the object occupies is released, or is reused by an object that is not nested within o ([intro.object]).

That is, everything else makes sense as a reuse of the complete object itself, which is located in storage.

[xmh0511]

The key issue is what exactly "the storage is reused" means. Is only using the whole storage considered to reuse the storage? Or, is using any overlapped storage of the storage considered to reuse the storage? The current wording is ambiguous, although the example you mentioned in [intro.object] p3 implies the intended meaning should be the latter one. However, the formal wording is not explicit.

but doesn't [intro.object#2] clarify this meaning?:

If an object is created in storage associated with a subobject e (which may or may not be within its lifetime), the created object is a subobject of e's containing object if
(2.1) the lifetime of e's containing object has begun and not ended, and
(2.2) the storage for the new object exactly overlays the storage location associated with e, and
(2.3) e is not a potentially-overlapping subobject, and
(2.4) the new object is of the same type as e (ignoring cv-qualification).
In this case, e and the created object are corresponding direct subobjects.

That is, everything else makes sense as a reuse of the complete object itself, which is located in storage.

I don't see that the rule you cited is relevant here. The issue talks about whether the char object created at #2 kills the int object created at #1. Creating objects in the provided array does not require that the element is within its lifetime.

[safocl]

Maybe we need to say that a storage is considered to be reused if any part of the storage is reused.

It just turns out that the proposed wording is already contained in the Standard text -- [intro.object#note-3] -- as a note. Do you think it's worth reformulating the issue to move this definition to [intro.defs]?

[safocl]

Creating objects in the provided array does not require that the element is within its lifetime.

here is the rule according to which it is determined whether a newly created object is a subobject of a complete object or not -- since [basic.life#2.5] is talking specifically about the case when a newly created object is not nested in the same complete object that is provided with the initial storage.
as specified here [intro.object#4]:

4 An object a is nested within another object b if
(4.1) a is a subobject of b, or
(4.2) b provides storage for a, or
(4.3) there exists an object c where a is nested within c, and c is nested within b.

[safocl]

That's why it seems to me that the entire current discussion, ideologically speaking, actually boils down to defining the status of storage reuse in the corresponding section of [intro.defs].
This seems like a perfectly adequate improvement to me.

[safocl]

In this case, an explicit definition for released should also be introduced. The following example releases storage, creating a new one in its place (according to rule [basic.life#10], the previous storage name can be used as is):

alignas(int) unsigned char buffer[8];

int main() {
    auto ptr = new (buffer) int{}; // #1
    auto storage_ptr = new (&buffer) unsigned char[8]; // #2 // create new object of unsigned char[8]
    int i = *ptr; // UB: The lifetime of an `int` object was ended — its storage was released.
}

According to rule [basic.life#10], ptr is not valid for such use (its storage was released).