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

Files changed (1) hide show

tmp/tmpjn0i2zxd/{from.md → to.md} +152 -177

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

@@ -6,61 +6,75 @@ 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;
 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
@@ -68,50 +82,47 @@ 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`
-  function ([[new.handler]]). If the called function returns, the loop
   repeats.
 - 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.
@@ -119,11 +130,11 @@ 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.
@@ -146,13 +157,13 @@ 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.
@@ -163,26 +174,26 @@ 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.
@@ -209,53 +220,48 @@ reclaimed storage will be allocated by subsequent calls to
 ``` 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.
@@ -265,12 +271,13 @@ 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.
@@ -278,11 +285,11 @@ 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.
@@ -296,13 +303,13 @@ 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.
@@ -313,26 +320,26 @@ 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.
@@ -350,48 +357,46 @@ 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.
@@ -406,11 +411,11 @@ Something* p = new (place) Something();
 ```
 — *end example*]
 ``` cpp
-void* operator new[](std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
@@ -419,132 +424,100 @@ void* operator new[](std::size_t size, void* ptr) noexcept;
 void operator delete(void* ptr, void*) noexcept;
 ```
 *Effects:* Intentionally performs no action.
-*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;
 ```
 *Effects:* Intentionally performs no action.
-*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>
 ``` cpp
 namespace std {
   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
 by the implementation to report a failure to allocate storage.
-``` cpp
-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
@@ -575,43 +548,45 @@ new_handler get_new_handler() noexcept;
 [*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*]

 ### Header `<new>` synopsis <a id="new.syn">[[new.syn]]</a>
 ``` cpp
 namespace std {
+  // [alloc.errors], storage allocation errors
   class bad_alloc;
   class bad_array_new_length;
+  struct destroying_delete_t {
+    explicit destroying_delete_t() = default;
+  };
+  inline constexpr destroying_delete_t destroying_delete{};
+  // global operator new control%
+  %
+  %
+  %
+  %
   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> [[nodiscard]] 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{};
 }
+// [new.delete], storage allocation and deallocation
+[[nodiscard]] void* operator new(std::size_t size);
+[[nodiscard]] void* operator new(std::size_t size, std::align_val_t alignment);
+[[nodiscard]] void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
+[[nodiscard]] 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;
+[[nodiscard]] void* operator new[](std::size_t size);
+[[nodiscard]] void* operator new[](std::size_t size, std::align_val_t alignment);
+[[nodiscard]] void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
+[[nodiscard]] 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;
+[[nodiscard]] void* operator new  (std::size_t size, void* ptr) noexcept;
+[[nodiscard]] void* operator new[](std::size_t size, void* ptr) noexcept;
 void  operator delete  (void* ptr, void*) noexcept;
 void  operator delete[](void* ptr, void*) noexcept;
 ```
 ### 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
 functions is not a valid alignment value, the behavior is undefined.
 #### Single-object forms <a id="new.delete.single">[[new.delete.single]]</a>
 ``` cpp
+[[nodiscard]] void* operator new(std::size_t size);
+[[nodiscard]] 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 the first form is called otherwise.
 *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`
+  function [[new.handler]]. If the called function returns, the loop
   repeats.
 - The loop terminates when an attempt to allocate the requested storage
   is successful or when a called `new_handler` function does not return.
 ``` cpp
+[[nodiscard]] void* operator new(std::size_t size, const std::nothrow_t&) noexcept;
+[[nodiscard]] 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.
 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*[[expr.delete]] 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.
 [*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*]
+*Preconditions:* `ptr` is a null pointer or its value represents 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`.
+*Preconditions:* If an implementation has strict pointer
+safety [[basic.stc.dynamic.safety]] then `ptr` is a safely-derived
+pointer.
+*Preconditions:* If the `alignment` parameter is not present, `ptr` was
+returned by an allocation function without an `alignment` parameter. If
+present, the `alignment` argument is equal to the `alignment` argument
+passed to the allocation function that returned `ptr`. If present, the
+`size` argument is equal to 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.
 ``` 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.
+*Preconditions:* `ptr` is a null pointer or its value represents 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`.
+*Preconditions:* If an implementation has strict pointer
+safety [[basic.stc.dynamic.safety]] then `ptr` is a safely-derived
+pointer.
+*Preconditions:* If the `alignment` parameter is not present, `ptr` was
+returned by an allocation function without an `alignment` parameter. If
+present, the `alignment` argument is equal to 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
+[[nodiscard]] void* operator new[](std::size_t size);
+[[nodiscard]] 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 the first form is called otherwise. [^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.
 *Default behavior:* Returns `operator new(size)`, or
 `operator new(size, alignment)`, respectively.
 ``` cpp
+[[nodiscard]] void* operator new[](std::size_t size, const std::nothrow_t&) noexcept;
+[[nodiscard]] 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.
 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.
 [*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*]
+*Preconditions:* `ptr` is a null pointer or its value represents 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[]`.
+*Preconditions:* If an implementation has strict pointer
+safety [[basic.stc.dynamic.safety]] then `ptr` is a safely-derived
+pointer.
+*Preconditions:* If the `alignment` parameter is not present, `ptr` was
+returned by an allocation function without an `alignment` parameter. If
+present, the `alignment` argument is equal to the `alignment` argument
+passed to the allocation function that returned `ptr`. If present, the
+`size` argument is equal to 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.
 ``` 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.
+*Preconditions:* `ptr` is a null pointer or its value represents 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[]`.
+*Preconditions:* If an implementation has strict pointer
+safety [[basic.stc.dynamic.safety]] then `ptr` is a safely-derived
+pointer.
+*Preconditions:* If the `alignment` parameter is not present, `ptr` was
+returned by an allocation function without an `alignment` parameter. If
+present, the `alignment` argument is equal to 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
+[[nodiscard]] void* operator new(std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
 ```
 — *end example*]
 ``` cpp
+[[nodiscard]] void* operator new[](std::size_t size, void* ptr) noexcept;
 ```
 *Returns:* `ptr`.
 *Remarks:* Intentionally performs no other action.
 void operator delete(void* ptr, void*) noexcept;
 ```
 *Effects:* Intentionally performs no action.
+*Preconditions:* If an implementation has strict pointer
+safety [[basic.stc.dynamic.safety]] then `ptr` is 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;
 ```
 *Effects:* Intentionally performs no action.
+*Preconditions:* If an implementation has strict pointer
+safety [[basic.stc.dynamic.safety]] then `ptr` is 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>
 ``` cpp
 namespace std {
   class bad_alloc : public exception {
   public:
+ // see [exception] for the specification of the special member functions
     const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_alloc` defines the type of objects thrown as exceptions
 by the implementation to report a failure to allocate storage.
 ``` cpp
 const char* what() const noexcept override;
 ```
 *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:
+ // see [exception] for the specification of the special member functions
     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
 const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 #### 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
 [*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> [[nodiscard]] constexpr T* launder(T* p) noexcept;
 ```
+*Mandates:* `!is_function_v<T> && !is_void_v<T>` is `true`.
+*Preconditions:* `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 *b* is reachable through a
+pointer value that points to an object *Y* if there is an object *Z*,
+pointer-interconvertible with *Y*, such that *b* is within the storage
+occupied by *Z*, or the immediately-enclosing array object if *Z* is an
+array element.
 [*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 its complete object is a const
+object or it is a base class subobject; 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 { int n; };
+const X *p = new const X{3};
 const int a = p->n;
+new (const_cast<X*>(p)) const X{5}; // p does not point to new object [basic.life] because its type is const
 const int b = p->n;                 // undefined behavior
 const int c = std::launder(p)->n;   // OK
 ```
 — *end example*]

Diff to HTML by rtfpessoa