[support.dynamic] - C++14 → C++17

Files changed (1) hide show

tmp/tmpfu8kst0o/{from.md → to.md} +342 -181

tmp/tmpfu8kst0o/{from.md → to.md} RENAMED Viewed

@@ -2,34 +2,54 @@
 The header `<new>` defines several functions that manage the allocation
 of dynamic storage in a program. It also defines components for
 reporting storage management errors.
 ``` cpp
 namespace std {
   class bad_alloc;
   class bad_array_new_length;
- struct nothrow_t {};
   extern const nothrow_t nothrow;
- typedef void (*new_handler)();
   new_handler get_new_handler() noexcept;
   new_handler set_new_handler(new_handler new_p) noexcept;
 }
 void* operator new(std::size_t size);
 void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
 void  operator delete(void* ptr) noexcept;
-void  operator delete(void* ptr, const std::nothrow_t&) noexcept;
 void  operator delete(void* ptr, std::size_t size) noexcept;
-void  operator delete(void* ptr, std::size_t size,
                       const std::nothrow_t&) noexcept;
 void* operator new[](std::size_t size);
 void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
 void  operator delete[](void* ptr) noexcept;
-void  operator delete[](void* ptr, const std::nothrow_t&) noexcept;
 void  operator delete[](void* ptr, std::size_t size) noexcept;
-void  operator delete[](void* ptr, std::size_t size,
                         const std::nothrow_t&) noexcept;
 void* operator new  (std::size_t size, void* ptr) noexcept;
 void* operator new[](std::size_t size, void* ptr) noexcept;
 void  operator delete  (void* ptr, void*) noexcept;
@@ -39,38 +59,46 @@ void  operator delete[](void* ptr, void*) noexcept;
   [[intro.memory]], [[basic.stc.dynamic]], [[expr.new]],
 [[expr.delete]], [[class.free]], [[memory]].
 ### Storage allocation and deallocation <a id="new.delete">[[new.delete]]</a>
-Except where otherwise specified, the provisions of (
-[[basic.stc.dynamic]]) apply to the library versions of `operator new`
 and `operator
-delete`.
 #### Single-object forms <a id="new.delete.single">[[new.delete.single]]</a>
 ``` cpp
 void* operator new(std::size_t size);
 ```
-*Effects:* The *allocation function* ([[basic.stc.dynamic.allocation]])
 called by a *new-expression* ([[expr.new]]) to allocate `size` bytes of
-storage suitably aligned to represent any object of that size.
-*Replaceable:* a C++program may define a function with this function
-signature that displaces the default version defined by the C++standard
-library.
 *Required behavior:* Return a non-null pointer to suitably aligned
 storage ([[basic.stc.dynamic]]), or else throw a `bad_alloc` exception.
-This requirement is binding on a replacement version of this function.
 *Default behavior:*
 - Executes a loop: Within the loop, the function first attempts to
   allocate the requested storage. Whether the attempt involves a call to
-  the Standard C library function `malloc` is unspecified.
 - Returns a pointer to the allocated storage if the attempt is
   successful. Otherwise, if the current
   `new_handler` ([[get.new.handler]]) is a null pointer value, throws
   `bad_alloc`.
 - Otherwise, the function calls the current `new_handler`
@@ -79,277 +107,308 @@ This requirement is binding on a replacement version of this function.
 - The loop terminates when an attempt to allocate the requested storage
   is successful or when a called `new_handler` function does not return.
 ``` cpp
 void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
 ```
-*Effects:* Same as above, except that it is called by a placement
 version of a *new-expression* when a C++program prefers a null pointer
 result as an error indication, instead of a `bad_alloc` exception.
-*Replaceable:* a C++program may define a function with this function
-signature that displaces the default version defined by the C++standard
-library.
 *Required behavior:* Return a non-null pointer to suitably aligned
-storage ([[basic.stc.dynamic]]), or else return a null pointer. This
-nothrow version of `operator new` returns a pointer obtained as if
-acquired from the (possibly replaced) ordinary version. This requirement
-is binding on a replacement version of this function.
-*Default behavior:* Calls `operator new(size)`. If the call returns
 normally, returns the result of that call. Otherwise, returns a null
 pointer.
 ``` cpp
 T* p1 = new T;                  // throws bad_alloc if it fails
 T* p2 = new(nothrow) T;         // returns nullptr if it fails
 ```
 ``` cpp
 void operator delete(void* ptr) noexcept;
 void operator delete(void* ptr, std::size_t size) noexcept;
 ```
-*Effects:* The *deallocation
-function* ([[basic.stc.dynamic.deallocation]]) called by a
 *delete-expression* to render the value of `ptr` invalid.
-*Replaceable:* a C++program may define a function with signature
-`void operator delete(void* ptr) noexcept` that displaces the default
-version defined by the C++standard library. If this function (without
-`size` parameter) is defined, the program should also define
-`void operator delete(void* ptr, std::size_t size) noexcept`. If this
-function with `size` parameter is defined, the program shall also define
-the version without the `size` parameter. The default behavior below may
-change in the future, which will require replacing both deallocation
-functions when replacing the allocation function.
-*Requires:* *ptr* shall be a null pointer or its value shall be a value
-returned by an earlier call to the (possibly replaced)
-`operator new(std::size_t)` or
-`operator new(std::size_t,const std::nothrow_t&)` which has not been
-invalidated by an intervening call to `operator delete(void*)`.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
-*Requires:* If present, the `std::size_t size` argument shall equal the
-size argument passed to the allocation function that returned `ptr`.
-*Required behavior:* Calls to
-`operator delete(void* ptr, std::size_t size)` may be changed to calls
-to `operator delete(void* ptr)` without affecting memory allocation. A
-conforming implementation is for
 `operator delete(void* ptr, std::size_t size)` to simply call
-`operator delete(ptr)`.
-*Default behavior:* the function
-`operator delete(void* ptr, std::size_t size)` calls
-`operator delete(ptr)`. See the note in the above *Replaceable*
-paragraph.
 *Default behavior:* If `ptr` is null, does nothing. Otherwise, reclaims
 the storage allocated by the earlier call to `operator new`.
 *Remarks:* It is unspecified under what conditions part or all of such
 reclaimed storage will be allocated by subsequent calls to
-`operator new` or any of `calloc`, `malloc`, or `realloc`, declared in
-`<cstdlib>`.
 ``` cpp
 void operator delete(void* ptr, const std::nothrow_t&) noexcept;
-void operator delete(void* ptr, std::size_t size, const std::nothrow_t&) noexcept;
 ```
-*Effects:* The *deallocation
-function* ([[basic.stc.dynamic.deallocation]]) called by the
 implementation to render the value of `ptr` invalid when the constructor
 invoked from a nothrow placement version of the *new-expression* throws
 an exception.
-*Replaceable:* a C++program may define a function with signature
-`void operator delete(void* ptr, const std::nothrow_t&) noexcept` that
-displaces the default version defined by the C++standard library. If
-this function (without `size` parameter) is defined, the program should
-also define
-`void operator delete(void* ptr, std::size_t size, const std::nothrow_t&) noexcept`.
-If this function with `size` parameter is defined, the program shall
-also define the version without the `size` parameter. The default
-behavior below may change in the future, which will require replacing
-both deallocation functions when replacing the allocation function.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
-*Requires:* If present, the `std::size_t size` argument must equal the
-size argument passed to the allocation function that returned `ptr`.
-*Required behavior:* Calls to
-`operator delete(void* ptr, std::size_t size, const std::nothrow_t&)`
-may be changed to calls to
-`operator delete(void* ptr, const std::nothrow_t&)` without affecting
-memory allocation. A conforming implementation is for
-`operator delete(void* ptr, std::size_t size, const std::nothrow_t&)` to
-simply call `operator delete(void* ptr, const std::nothrow_t&)`.
-*Default behavior:*
-`operator delete(void* ptr, std::size_t size, const std::nothrow_t&)`
-calls `operator delete(ptr, std::nothrow)`, and
-`operator delete(void* ptr, const std::nothrow_t&)` calls
-`operator delete(ptr)`.
 #### Array forms <a id="new.delete.array">[[new.delete.array]]</a>
 ``` cpp
 void* operator new[](std::size_t size);
 ```
-*Effects:* The *allocation function* ([[basic.stc.dynamic.allocation]])
 called by the array form of a *new-expression* ([[expr.new]]) to
-allocate `size` bytes of storage suitably aligned to represent any array
-object of that size or smaller.[^33]
-*Replaceable:* a C++program can define a function with this function
-signature that displaces the default version defined by the C++standard
-library.
-*Required behavior:* Same as for `operator new(std::size_t)`. This
-requirement is binding on a replacement version of this function.
-*Default behavior:* Returns `operator new(size)`.
 ``` cpp
 void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
 ```
-*Effects:* Same as above, except that it is called by a placement
 version of a *new-expression* when a C++program prefers a null pointer
 result as an error indication, instead of a `bad_alloc` exception.
-*Replaceable:* a C++program can define a function with this function
-signature that displaces the default version defined by the C++standard
-library.
 *Required behavior:* Return a non-null pointer to suitably aligned
-storage ([[basic.stc.dynamic]]), or return a null pointer. This
-requirement is binding on a replacement version of this function.
-*Default behavior:* Calls `operator new[](size)`. If the call returns
 normally, returns the result of that call. Otherwise, returns a null
 pointer.
 ``` cpp
 void operator delete[](void* ptr) noexcept;
 void operator delete[](void* ptr, std::size_t size) noexcept;
 ```
-*Effects:* The *deallocation
-function* ([[basic.stc.dynamic.deallocation]]) called by the array form
 of a *delete-expression* to render the value of `ptr` invalid.
-*Replaceable:* a C++program can define a function with signature
-`void operator delete[](void* ptr) noexcept` that displaces the default
-version defined by the C++standard library. If this function (without
-`size` parameter) is defined, the program should also define
-`void operator delete[](void* ptr, std::size_t size) noexcept`. If this
-function with `size` parameter is defined, the program shall also define
-the version without the `size` parameter. The default behavior below may
-change in the future, which will require replacing both deallocation
-functions when replacing the allocation function.
-*Requires:* *ptr* shall be a null pointer or its value shall be the
-value returned by an earlier call to `operator new[](std::size_t)` or
-`operator new[](std::size_t,const std::nothrow_t&)` which has not been
-invalidated by an intervening call to `operator delete[](void*)`.
-*Requires:* If present, the `std::size_t size` argument must equal the
-size argument passed to the allocation function that returned `ptr`.
-*Required behavior:* Calls to
-`operator delete[](void* ptr, std::size_t size)` may be changed to calls
-to `operator delete[](void* ptr)` without affecting memory allocation. A
-conforming implementation is for
 `operator delete[](void* ptr, std::size_t size)` to simply call
-`operator delete[](void* ptr)`.
-*Requires:* If an implementation has strict pointer
-safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
-safely-derived pointer.
-*Default behavior:* `operator delete[](void* ptr, std::size_t size)`
-calls `operator delete[](ptr)`, and `operator delete[](void* ptr)` calls
-`operator delete(ptr)`.
 ``` cpp
 void operator delete[](void* ptr, const std::nothrow_t&) noexcept;
-void operator delete[](void* ptr, std::size_t size, const std::nothrow_t&) noexcept;
 ```
-*Effects:* The *deallocation
-function* ([[basic.stc.dynamic.deallocation]]) called by the
 implementation to render the value of `ptr` invalid when the constructor
 invoked from a nothrow placement version of the array *new-expression*
 throws an exception.
-*Replaceable:* a C++program may define a function with signature
-`void operator delete[](void* ptr, const std::nothrow_t&) noexcept` that
-displaces the default version defined by the C++standard library. If
-this function (without `size` parameter) is defined, the program should
-also define
-`void operator delete[](void* ptr, std::size_t size, const std::nothrow_t&) noexcept`.
-If this function with `size` parameter is defined, the program shall
-also define the version without the `size` parameter. The default
-behavior below may change in the future, which will require replacing
-both deallocation functions when replacing the allocation function.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
-*Requires:* If present, the `std::size_t size` argument must equal the
-size argument passed to the allocation function that returned `ptr`.
-*Required behavior:* Calls to
-`operator delete[](void* ptr, std::size_t size, const std::nothrow_t&)`
-may be changed to calls to
-`operator delete[](void* ptr, const std::nothrow_t&)` without affecting
-memory allocation. A conforming implementation is for
-`operator delete[](void* ptr, std::size_t size, const std::nothrow_t&)`
-to simply call `operator delete[](void* ptr, const std::nothrow_t&)`.
-*Default behavior:*
-`operator delete[](void* ptr, std::size_t size, const std::nothrow_t&)`
-calls `operator delete[](ptr, std::nothrow)`, and
-`operator delete[](void* ptr, const std::nothrow_t&)` calls
-`operator delete[](ptr)`.
-#### Placement forms <a id="new.delete.placement">[[new.delete.placement]]</a>
-These functions are reserved, a C++program may not define functions that
-displace the versions in the Standard C++library ([[constraints]]). The
-provisions of ([[basic.stc.dynamic]]) do not apply to these reserved
 placement forms of `operator new` and `operator delete`.
 ``` cpp
 void* operator new(std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
 This can be useful for constructing an object at a known address:
 ``` cpp
 void* place = operator new(sizeof(Something));
 Something* p = new (place) Something();
 ```
 ``` cpp
 void* operator new[](std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
@@ -365,11 +424,11 @@ void operator delete(void* ptr, void*) noexcept;
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
 *Remarks:* Default function called when any part of the initialization
-in a placement new expression that invokes the library’s non-array
 placement operator new terminates by throwing an
 exception ([[expr.new]]).
 ``` cpp
 void operator delete[](void* ptr, void*) noexcept;
@@ -380,25 +439,27 @@ void operator delete[](void* ptr, void*) noexcept;
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
 *Remarks:* Default function called when any part of the initialization
-in a placement new expression that invokes the library’s array placement
-operator new terminates by throwing an exception ([[expr.new]]).
 #### Data races <a id="new.delete.dataraces">[[new.delete.dataraces]]</a>
 For purposes of determining the existence of data races, the library
 versions of `operator new`, user replacement versions of global
-`operator new`, the C standard library functions `calloc` and `malloc`,
-the library versions of `operator delete`, user replacement versions of
-`operator delete`, the C standard library function `free`, and the C
-standard library function `realloc` shall not introduce a data race (
-[[res.on.data.races]]). Calls to these functions that allocate or
-deallocate a particular unit of storage shall occur in a single total
-order, and each such deallocation call shall happen before (
-[[intro.multithread]]) the next allocation (if any) in this order.
 ### Storage allocation errors <a id="alloc.errors">[[alloc.errors]]</a>
 #### Class `bad_alloc` <a id="bad.alloc">[[bad.alloc]]</a>
@@ -407,11 +468,11 @@ namespace std {
   class bad_alloc : public exception {
   public:
     bad_alloc() noexcept;
     bad_alloc(const bad_alloc&) noexcept;
     bad_alloc& operator=(const bad_alloc&) noexcept;
- virtual const char* what() const noexcept;
   };
 }
 ```
 The class `bad_alloc` defines the type of objects thrown as exceptions
@@ -421,55 +482,64 @@ by the implementation to report a failure to allocate storage.
 bad_alloc() noexcept;
 ```
 *Effects:* Constructs an object of class `bad_alloc`.
-*Remarks:* The result of calling `what()` on the newly constructed
-object is implementation-defined.
 ``` cpp
 bad_alloc(const bad_alloc&) noexcept;
 bad_alloc& operator=(const bad_alloc&) noexcept;
 ```
 *Effects:* Copies an object of class `bad_alloc`.
 ``` cpp
-virtual const char* what() const noexcept;
 ```
 *Returns:* An *implementation-defined* NTBS.
 #### Class `bad_array_new_length` <a id="new.badlength">[[new.badlength]]</a>
 ``` cpp
 namespace std {
   class bad_array_new_length : public bad_alloc {
   public:
     bad_array_new_length() noexcept;
   };
 }
 ```
 The class `bad_array_new_length` defines the type of objects thrown as
 exceptions by the implementation to report an attempt to allocate an
-array of size less than zero or greater than an implementation-defined
 limit ([[expr.new]]).
 ``` cpp
 bad_array_new_length() noexcept;
 ```
 *Effects:* constructs an object of class `bad_array_new_length`.
-*Remarks:* the result of calling `what()` on the newly constructed
-object is implementation-defined.
 #### Type `new_handler` <a id="new.handler">[[new.handler]]</a>
 ``` cpp
-typedef void (*new_handler)();
 ```
 The type of a *handler function* to be called by `operator new()` or
 `operator new[]()` ([[new.delete]]) when they cannot satisfy a request
 for additional storage.
@@ -477,11 +547,11 @@ for additional storage.
 *Required behavior:* A `new_handler` shall perform one of the following:
 - make more storage available for allocation and then return;
 - throw an exception of type `bad_alloc` or a class derived from
   `bad_alloc`;
-- terminate execution of the program without returning to the caller;
 #### `set_new_handler` <a id="set.new.handler">[[set.new.handler]]</a>
 ``` cpp
 new_handler set_new_handler(new_handler new_p) noexcept;
@@ -498,7 +568,98 @@ new_handler set_new_handler(new_handler new_p) noexcept;
 ``` cpp
 new_handler get_new_handler() noexcept;
 ```
-*Returns:* The current `new_handler`. This may be a null pointer value.

 The header `<new>` defines several functions that manage the allocation
 of dynamic storage in a program. It also defines components for
 reporting storage management errors.
+### Header `<new>` synopsis <a id="new.syn">[[new.syn]]</a>
 ``` cpp
 namespace std {
   class bad_alloc;
   class bad_array_new_length;
+ enum class align_val_t : size_t {};
+  struct nothrow_t { explicit nothrow_t() = default; };
   extern const nothrow_t nothrow;
+ using new_handler = void (*)();
   new_handler get_new_handler() noexcept;
   new_handler set_new_handler(new_handler new_p) noexcept;
+  // [ptr.launder], pointer optimization barrier
+  template <class T> constexpr T* launder(T* p) noexcept;
+  // [hardware.interference], hardware interference size
+  inline constexpr size_t hardware_destructive_interference_size = implementation-defined{};
+  inline constexpr size_t hardware_constructive_interference_size = implementation-defined{};
 }
 void* operator new(std::size_t size);
+void* operator new(std::size_t size, std::align_val_t alignment);
 void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
+void* operator new(std::size_t size, std::align_val_t alignment,
+                   const std::nothrow_t&) noexcept;
 void  operator delete(void* ptr) noexcept;
 void  operator delete(void* ptr, std::size_t size) noexcept;
+void  operator delete(void* ptr, std::align_val_t alignment) noexcept;
+void  operator delete(void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
+void  operator delete(void* ptr, const std::nothrow_t&) noexcept;
+void  operator delete(void* ptr, std::align_val_t alignment,
                       const std::nothrow_t&) noexcept;
 void* operator new[](std::size_t size);
+void* operator new[](std::size_t size, std::align_val_t alignment);
 void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
+void* operator new[](std::size_t size, std::align_val_t alignment,
+                     const std::nothrow_t&) noexcept;
 void  operator delete[](void* ptr) noexcept;
 void  operator delete[](void* ptr, std::size_t size) noexcept;
+void  operator delete[](void* ptr, std::align_val_t alignment) noexcept;
+void  operator delete[](void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
+void  operator delete[](void* ptr, const std::nothrow_t&) noexcept;
+void  operator delete[](void* ptr, std::align_val_t alignment,
                         const std::nothrow_t&) noexcept;
 void* operator new  (std::size_t size, void* ptr) noexcept;
 void* operator new[](std::size_t size, void* ptr) noexcept;
 void  operator delete  (void* ptr, void*) noexcept;
   [[intro.memory]], [[basic.stc.dynamic]], [[expr.new]],
 [[expr.delete]], [[class.free]], [[memory]].
 ### Storage allocation and deallocation <a id="new.delete">[[new.delete]]</a>
+Except where otherwise specified, the provisions of
+[[basic.stc.dynamic]] apply to the library versions of `operator new`
 and `operator
+delete`. If the value of an alignment argument passed to any of these
+functions is not a valid alignment value, the behavior is undefined.
 #### Single-object forms <a id="new.delete.single">[[new.delete.single]]</a>
 ``` cpp
 void* operator new(std::size_t size);
+void* operator new(std::size_t size, std::align_val_t alignment);
 ```
+*Effects:* The allocation functions ([[basic.stc.dynamic.allocation]])
 called by a *new-expression* ([[expr.new]]) to allocate `size` bytes of
+storage. The second form is called for a type with new-extended
+alignment, and allocates storage with the specified alignment. The first
+form is called otherwise, and allocates storage suitably aligned to
+represent any object of that size provided the object’s type does not
+have new-extended alignment.
+*Replaceable:* A C++program may define functions with either of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
 *Required behavior:* Return a non-null pointer to suitably aligned
 storage ([[basic.stc.dynamic]]), or else throw a `bad_alloc` exception.
+This requirement is binding on any replacement versions of these
+functions.
 *Default behavior:*
 - Executes a loop: Within the loop, the function first attempts to
   allocate the requested storage. Whether the attempt involves a call to
+  the C standard library functions `malloc` or `aligned_alloc` is
+  unspecified.
 - Returns a pointer to the allocated storage if the attempt is
   successful. Otherwise, if the current
   `new_handler` ([[get.new.handler]]) is a null pointer value, throws
   `bad_alloc`.
 - Otherwise, the function calls the current `new_handler`
 - The loop terminates when an attempt to allocate the requested storage
   is successful or when a called `new_handler` function does not return.
 ``` cpp
 void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
+void* operator new(std::size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 ```
+*Effects:* Same as above, except that these are called by a placement
 version of a *new-expression* when a C++program prefers a null pointer
 result as an error indication, instead of a `bad_alloc` exception.
+*Replaceable:* A C++program may define functions with either of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
 *Required behavior:* Return a non-null pointer to suitably aligned
+storage ([[basic.stc.dynamic]]), or else return a null pointer. Each of
+these nothrow versions of `operator new` returns a pointer obtained as
+if acquired from the (possibly replaced) corresponding non-placement
+function. This requirement is binding on any replacement versions of
+these functions.
+*Default behavior:* Calls `operator new(size)`, or
+`operator new(size, alignment)`, respectively. If the call returns
 normally, returns the result of that call. Otherwise, returns a null
 pointer.
+[*Example 1*:
 ``` cpp
 T* p1 = new T;                  // throws bad_alloc if it fails
 T* p2 = new(nothrow) T;         // returns nullptr if it fails
 ```
+— *end example*]
 ``` cpp
 void operator delete(void* ptr) noexcept;
 void operator delete(void* ptr, std::size_t size) noexcept;
+void operator delete(void* ptr, std::align_val_t alignment) noexcept;
+void operator delete(void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
 ```
+*Effects:* The deallocation
+functions ([[basic.stc.dynamic.deallocation]]) called by a
 *delete-expression* to render the value of `ptr` invalid.
+*Replaceable:* A C++program may define functions with any of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
+If a function without a `size` parameter is defined, the program should
+also define the corresponding function with a `size` parameter. If a
+function with a `size` parameter is defined, the program shall also
+define the corresponding version without the `size` parameter.
+[*Note 1*: The default behavior below may change in the future, which
+will require replacing both deallocation functions when replacing the
+allocation function. — *end note*]
+*Requires:* `ptr` shall be a null pointer or its value shall represent
+the address of a block of memory allocated by an earlier call to a
+(possibly replaced) `operator new(std::size_t)` or
+`operator new(std::size_t, std::align_val_t)` which has not been
+invalidated by an intervening call to `operator delete`.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
+*Requires:* If the `alignment` parameter is not present, `ptr` shall
+have been returned by an allocation function without an `alignment`
+parameter. If present, the `alignment` argument shall equal the
+`alignment` argument passed to the allocation function that returned
+`ptr`. If present, the `size` argument shall equal the `size` argument
+passed to the allocation function that returned `ptr`.
+*Required behavior:* A call to an `operator delete` with a `size`
+parameter may be changed to a call to the corresponding
+`operator delete` without a `size` parameter, without affecting memory
+allocation.
+[*Note 2*: A conforming implementation is for
 `operator delete(void* ptr, std::size_t size)` to simply call
+`operator delete(ptr)`. — *end note*]
+*Default behavior:* The functions that have a `size` parameter forward
+their other parameters to the corresponding function without a `size`
+parameter.
+[*Note 3*: See the note in the above *Replaceable:*
+paragraph. — *end note*]
 *Default behavior:* If `ptr` is null, does nothing. Otherwise, reclaims
 the storage allocated by the earlier call to `operator new`.
 *Remarks:* It is unspecified under what conditions part or all of such
 reclaimed storage will be allocated by subsequent calls to
+`operator new` or any of `aligned_alloc`, `calloc`, `malloc`, or
+`realloc`, declared in `<cstdlib>`.
 ``` cpp
 void operator delete(void* ptr, const std::nothrow_t&) noexcept;
+void operator delete(void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 ```
+*Effects:* The deallocation
+functions ([[basic.stc.dynamic.deallocation]]) called by the
 implementation to render the value of `ptr` invalid when the constructor
 invoked from a nothrow placement version of the *new-expression* throws
 an exception.
+*Replaceable:* A C++program may define functions with either of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
+*Requires:* `ptr` shall be a null pointer or its value shall represent
+the address of a block of memory allocated by an earlier call to a
+(possibly replaced) `operator new(std::size_t)` or
+`operator new(std::size_t, std::align_val_t)` which has not been
+invalidated by an intervening call to `operator delete`.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
+*Requires:* If the `alignment` parameter is not present, `ptr` shall
+have been returned by an allocation function without an `alignment`
+parameter. If present, the `alignment` argument shall equal the
+`alignment` argument passed to the allocation function that returned
+`ptr`.
+*Default behavior:* Calls `operator delete(ptr)`, or
+`operator delete(ptr, alignment)`, respectively.
 #### Array forms <a id="new.delete.array">[[new.delete.array]]</a>
 ``` cpp
 void* operator new[](std::size_t size);
+void* operator new[](std::size_t size, std::align_val_t alignment);
 ```
+*Effects:* The allocation functions ([[basic.stc.dynamic.allocation]])
 called by the array form of a *new-expression* ([[expr.new]]) to
+allocate `size` bytes of storage. The second form is called for a type
+with new-extended alignment, and allocates storage with the specified
+alignment. The first form is called otherwise, and allocates storage
+suitably aligned to represent any array object of that size or smaller,
+provided the object’s type does not have new-extended alignment. [^33]
+*Replaceable:* A C++program may define functions with either of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
+*Required behavior:* Same as for the corresponding single-object forms.
+This requirement is binding on any replacement versions of these
+functions.
+*Default behavior:* Returns `operator new(size)`, or
+`operator new(size, alignment)`, respectively.
 ``` cpp
 void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
+void* operator new[](std::size_t size, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 ```
+*Effects:* Same as above, except that these are called by a placement
 version of a *new-expression* when a C++program prefers a null pointer
 result as an error indication, instead of a `bad_alloc` exception.
+*Replaceable:* A C++program may define functions with either of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
 *Required behavior:* Return a non-null pointer to suitably aligned
+storage ([[basic.stc.dynamic]]), or else return a null pointer. Each of
+these nothrow versions of `operator new[]` returns a pointer obtained as
+if acquired from the (possibly replaced) corresponding non-placement
+function. This requirement is binding on any replacement versions of
+these functions.
+*Default behavior:* Calls `operator new[](size)`, or
+`operator new[](size, alignment)`, respectively. If the call returns
 normally, returns the result of that call. Otherwise, returns a null
 pointer.
 ``` cpp
 void operator delete[](void* ptr) noexcept;
 void operator delete[](void* ptr, std::size_t size) noexcept;
+void operator delete[](void* ptr, std::align_val_t alignment) noexcept;
+void operator delete[](void* ptr, std::size_t size, std::align_val_t alignment) noexcept;
 ```
+*Effects:* The deallocation
+functions ([[basic.stc.dynamic.deallocation]]) called by the array form
 of a *delete-expression* to render the value of `ptr` invalid.
+*Replaceable:* A C++program may define functions with any of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
+If a function without a `size` parameter is defined, the program should
+also define the corresponding function with a `size` parameter. If a
+function with a `size` parameter is defined, the program shall also
+define the corresponding version without the `size` parameter.
+[*Note 1*: The default behavior below may change in the future, which
+will require replacing both deallocation functions when replacing the
+allocation function. — *end note*]
+*Requires:* `ptr` shall be a null pointer or its value shall represent
+the address of a block of memory allocated by an earlier call to a
+(possibly replaced) `operator new[](std::size_t)` or
+`operator new[](std::size_t, std::align_val_t)` which has not been
+invalidated by an intervening call to `operator delete[]`.
+*Requires:* If an implementation has strict pointer
+safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
+safely-derived pointer.
+*Requires:* If the `alignment` parameter is not present, `ptr` shall
+have been returned by an allocation function without an `alignment`
+parameter. If present, the `alignment` argument shall equal the
+`alignment` argument passed to the allocation function that returned
+`ptr`. If present, the `size` argument shall equal the `size` argument
+passed to the allocation function that returned `ptr`.
+*Required behavior:* A call to an `operator delete[]` with a `size`
+parameter may be changed to a call to the corresponding
+`operator delete[]` without a `size` parameter, without affecting memory
+allocation.
+[*Note 2*: A conforming implementation is for
 `operator delete[](void* ptr, std::size_t size)` to simply call
+`operator delete[](ptr)`. — *end note*]
+*Default behavior:* The functions that have a `size` parameter forward
+their other parameters to the corresponding function without a `size`
+parameter. The functions that do not have a `size` parameter forward
+their parameters to the corresponding `operator delete` (single-object)
+function.
 ``` cpp
 void operator delete[](void* ptr, const std::nothrow_t&) noexcept;
+void operator delete[](void* ptr, std::align_val_t alignment, const std::nothrow_t&) noexcept;
 ```
+*Effects:* The deallocation
+functions ([[basic.stc.dynamic.deallocation]]) called by the
 implementation to render the value of `ptr` invalid when the constructor
 invoked from a nothrow placement version of the array *new-expression*
 throws an exception.
+*Replaceable:* A C++program may define functions with either of these
+function signatures, and thereby displace the default versions defined
+by the C++standard library.
+*Requires:* `ptr` shall be a null pointer or its value shall represent
+the address of a block of memory allocated by an earlier call to a
+(possibly replaced) `operator new[](std::size_t)` or
+`operator new[](std::size_t, std::align_val_t)` which has not been
+invalidated by an intervening call to `operator delete[]`.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
+*Requires:* If the `alignment` parameter is not present, `ptr` shall
+have been returned by an allocation function without an `alignment`
+parameter. If present, the `alignment` argument shall equal the
+`alignment` argument passed to the allocation function that returned
+`ptr`.
+*Default behavior:* Calls `operator delete[](ptr)`, or
+`operator delete[](ptr, alignment)`, respectively.
+#### Non-allocating forms <a id="new.delete.placement">[[new.delete.placement]]</a>
+These functions are reserved; a C++program may not define functions that
+displace the versions in the C++standard library ([[constraints]]). The
+provisions of  [[basic.stc.dynamic]] do not apply to these reserved
 placement forms of `operator new` and `operator delete`.
 ``` cpp
 void* operator new(std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
+[*Example 1*:
 This can be useful for constructing an object at a known address:
 ``` cpp
 void* place = operator new(sizeof(Something));
 Something* p = new (place) Something();
 ```
+— *end example*]
 ``` cpp
 void* operator new[](std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
 *Remarks:* Default function called when any part of the initialization
+in a placement *new-expression* that invokes the library’s non-array
 placement operator new terminates by throwing an
 exception ([[expr.new]]).
 ``` cpp
 void operator delete[](void* ptr, void*) noexcept;
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
 *Remarks:* Default function called when any part of the initialization
+in a placement *new-expression* that invokes the library’s array
+placement operator new terminates by throwing an
+exception ([[expr.new]]).
 #### Data races <a id="new.delete.dataraces">[[new.delete.dataraces]]</a>
 For purposes of determining the existence of data races, the library
 versions of `operator new`, user replacement versions of global
+`operator new`, the C standard library functions `aligned_alloc`,
+`calloc`, and `malloc`, the library versions of `operator delete`, user
+replacement versions of `operator delete`, the C standard library
+function `free`, and the C standard library function `realloc` shall not
+introduce a data race ([[res.on.data.races]]). Calls to these functions
+that allocate or deallocate a particular unit of storage shall occur in
+a single total order, and each such deallocation call shall happen
+before ([[intro.multithread]]) the next allocation (if any) in this
+order.
 ### Storage allocation errors <a id="alloc.errors">[[alloc.errors]]</a>
 #### Class `bad_alloc` <a id="bad.alloc">[[bad.alloc]]</a>
   class bad_alloc : public exception {
   public:
     bad_alloc() noexcept;
     bad_alloc(const bad_alloc&) noexcept;
     bad_alloc& operator=(const bad_alloc&) noexcept;
+    const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_alloc` defines the type of objects thrown as exceptions
 bad_alloc() noexcept;
 ```
 *Effects:* Constructs an object of class `bad_alloc`.
 ``` cpp
 bad_alloc(const bad_alloc&) noexcept;
 bad_alloc& operator=(const bad_alloc&) noexcept;
 ```
 *Effects:* Copies an object of class `bad_alloc`.
 ``` cpp
+const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
+*Remarks:* The message may be a null-terminated multibyte
+string ([[multibyte.strings]]), suitable for conversion and display as
+a `wstring` ([[string.classes]], [[locale.codecvt]]).
 #### Class `bad_array_new_length` <a id="new.badlength">[[new.badlength]]</a>
 ``` cpp
 namespace std {
   class bad_array_new_length : public bad_alloc {
   public:
     bad_array_new_length() noexcept;
+    const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_array_new_length` defines the type of objects thrown as
 exceptions by the implementation to report an attempt to allocate an
+array of size less than zero or greater than an *implementation-defined*
 limit ([[expr.new]]).
 ``` cpp
 bad_array_new_length() noexcept;
 ```
 *Effects:* constructs an object of class `bad_array_new_length`.
+``` cpp
+const char* what() const noexcept override;
+```
+*Returns:* An *implementation-defined* NTBS.
+*Remarks:* The message may be a null-terminated multibyte
+string ([[multibyte.strings]]), suitable for conversion and display as
+a `wstring` ([[string.classes]], [[locale.codecvt]]).
 #### Type `new_handler` <a id="new.handler">[[new.handler]]</a>
 ``` cpp
+using new_handler = void (*)();
 ```
 The type of a *handler function* to be called by `operator new()` or
 `operator new[]()` ([[new.delete]]) when they cannot satisfy a request
 for additional storage.
 *Required behavior:* A `new_handler` shall perform one of the following:
 - make more storage available for allocation and then return;
 - throw an exception of type `bad_alloc` or a class derived from
   `bad_alloc`;
+- terminate execution of the program without returning to the caller.
 #### `set_new_handler` <a id="set.new.handler">[[set.new.handler]]</a>
 ``` cpp
 new_handler set_new_handler(new_handler new_p) noexcept;
 ``` cpp
 new_handler get_new_handler() noexcept;
 ```
+*Returns:* The current `new_handler`.
+[*Note 1*: This may be a null pointer value. — *end note*]
+### Pointer optimization barrier <a id="ptr.launder">[[ptr.launder]]</a>
+``` cpp
+template <class T> constexpr T* launder(T* p) noexcept;
+```
+*Requires:* `p` represents the address *A* of a byte in memory. An
+object *X* that is within its lifetime ([[basic.life]]) and whose type
+is similar ([[conv.qual]]) to `T` is located at the address *A*. All
+bytes of storage that would be reachable through the result are
+reachable through `p` (see below).
+*Returns:* A value of type `T *` that points to `X`.
+*Remarks:* An invocation of this function may be used in a core constant
+expression whenever the value of its argument may be used in a core
+constant expression. A byte of storage is reachable through a pointer
+value that points to an object *Y* if it is within the storage occupied
+by *Y*, an object that is pointer-interconvertible with *Y*, or the
+immediately-enclosing array object if *Y* is an array element. The
+program is ill-formed if `T` is a function type or cv `void`.
+[*Note 1*: If a new object is created in storage occupied by an
+existing object of the same type, a pointer to the original object can
+be used to refer to the new object unless the type contains `const` or
+reference members; in the latter cases, this function can be used to
+obtain a usable pointer to the new object.
+See  [[basic.life]]. — *end note*]
+[*Example 1*:
+``` cpp
+struct X { const int n; };
+X *p = new X{3};
+const int a = p->n;
+new (p) X{5};                       // p does not point to new object ([basic.life]) because X::n is const
+const int b = p->n;                 // undefined behavior
+const int c = std::launder(p)->n;   // OK
+```
+— *end example*]
+### Hardware interference size <a id="hardware.interference">[[hardware.interference]]</a>
+``` cpp
+inline constexpr size_t hardware_destructive_interference_size = implementation-defined{};
+```
+This number is the minimum recommended offset between two
+concurrently-accessed objects to avoid additional performance
+degradation due to contention introduced by the implementation. It shall
+be at least `alignof(max_align_t)`.
+[*Example 1*:
+``` cpp
+struct keep_apart {
+  alignas(hardware_destructive_interference_size) atomic<int> cat;
+  alignas(hardware_destructive_interference_size) atomic<int> dog;
+};
+```
+— *end example*]
+``` cpp
+inline constexpr size_t hardware_constructive_interference_size = implementation-defined{};
+```
+This number is the maximum recommended size of contiguous memory
+occupied by two objects accessed with temporal locality by concurrent
+threads. It shall be at least `alignof(max_align_t)`.
+[*Example 2*:
+``` cpp
+struct together {
+  atomic<int> dog;
+  int puppy;
+};
+struct kennel {
+  // Other data members...
+  alignas(sizeof(together)) together pack;
+  // Other data members...
+};
+static_assert(sizeof(together) <= hardware_constructive_interference_size);
+```
+— *end example*]

Diff to HTML by rtfpessoa