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

Files changed (1) hide show

tmp/tmpl1fnkic5/{from.md → to.md} +1228 -610

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

@@ -17,119 +17,367 @@ other runtime support, as summarized in Table
 **Table: Language support library summary** <a id="tab:lang.sup.lib.summary">[tab:lang.sup.lib.summary]</a>
 | Subclause              |                           | Header               |
 | ---------------------- | ------------------------- | -------------------- |
-| [[support.types]]      | Types                     | `<cstddef>`          |
-|                        |                           | `<limits>` |
-| [[support.limits]]     | Implementation properties | `<climits>` |
 |                        |                           | `<cfloat>`           |
 | [[cstdint]]            | Integer types             | `<cstdint>`          |
 | [[support.start.term]] | Start and termination     | `<cstdlib>`          |
 | [[support.dynamic]]    | Dynamic memory management | `<new>`              |
 | [[support.rtti]]       | Type identification       | `<typeinfo>`         |
 | [[support.exception]]  | Exception handling        | `<exception>`        |
 | [[support.initlist]]   | Initializer lists         | `<initializer_list>` |
-| | | `<csignal>`          |
 |                        |                           | `<csetjmp>`          |
-|                        |                           | `<cstdalign>` |
-| [[support.runtime]]    | Other runtime support     | `<cstdarg>`          |
-|                        |                           | `<cstdbool>`         |
 |                        |                           | `<cstdlib>`          |
-|                        |                           | `<ctime>`            |
-## Types <a id="support.types">[[support.types]]</a>
-Table  [[tab:support.hdr.cstddef]] describes the header `<cstddef>`.
-The contents are the same as the Standard C library header `<stddef.h>`,
-with the following changes:
-The macro `NULL` is an implementation-defined C++null pointer constant
-in this International Standard ([[conv.ptr]]).[^1]
-The macro `offsetof`(*type*, *member-designator*) accepts a restricted
-set of *type* arguments in this International Standard. If *type* is not
-a standard-layout class (Clause  [[class]]), the results are
-undefined.[^2] The expression `offsetof`(*type*, *member-designator*) is
-never type-dependent ([[temp.dep.expr]]) and it is value-dependent (
-[[temp.dep.constexpr]]) if and only if *type* is dependent. The result
-of applying the `offsetof` macro to a field that is a static data member
-or a function member is undefined. No operation invoked by the
-`offsetof` macro shall throw an exception and
-`noexcept(offsetof(type, member-designator))` shall be `true`.
 The type `ptrdiff_t` is an *implementation-defined* signed integer type
 that can hold the difference of two subscripts in an array object, as
 described in  [[expr.add]].
 The type `size_t` is an *implementation-defined* unsigned integer type
 that is large enough to contain the size in bytes of any object.
-It is recommended that implementations choose types for `ptrdiff_t` and
-`size_t` whose integer conversion ranks ([[conv.rank]]) are no greater
-than that of `signed long int` unless a larger size is necessary to
-contain all the possible values.
 The type `max_align_t` is a POD type whose alignment requirement is at
 least as great as that of every scalar type, and whose alignment
 requirement is supported in every context.
-`nullptr_t` is defined as follows:
-``` cpp
-namespace std {
-  typedef decltype(nullptr) nullptr_t;
-}
-```
-The type for which `nullptr_t` is a synonym has the characteristics
-described in  [[basic.fundamental]] and  [[conv.ptr]]. Although
-`nullptr`’s address cannot be taken, the address of another `nullptr_t`
-object that is an lvalue can be taken.
 Alignment ([[basic.align]]), Sizeof ([[expr.sizeof]]), Additive
-operators ([[expr.add]]), Free store ([[class.free]]), and ISO
-C 7.1.6.
 ## Implementation properties <a id="support.limits">[[support.limits]]</a>
-### In general <a id="support.limits.general">[[support.limits.general]]</a>
-The headers `<limits>` ([[limits]]), `<climits>`, and `<cfloat>` (
-[[c.limits]]) supply characteristics of implementation-dependent
-arithmetic types ([[basic.fundamental]]).
-### Numeric limits <a id="limits">[[limits]]</a>
-#### Class template `numeric_limits` <a id="limits.numeric">[[limits.numeric]]</a>
-The `numeric_limits` class template provides a C++program with
-information about various properties of the implementation’s
-representation of the arithmetic types.
-Specializations shall be provided for each arithmetic type, both
-floating point and integer, including `bool`. The member
-`is_specialized` shall be `true` for all such specializations of
-`numeric_limits`.
-For all members declared `static` `constexpr` in the `numeric_limits`
-template, specializations shall define these values in such a way that
-they are usable as constant expressions.
-Non-arithmetic standard types, such as `complex<T>` ([[complex]]),
-shall not have specializations.
-#### Header `<limits>` synopsis <a id="limits.syn">[[limits.syn]]</a>
 ``` cpp
 namespace std {
- template<class T> class numeric_limits;
   enum float_round_style;
   enum float_denorm_style;
   template<> class numeric_limits<bool>;
   template<> class numeric_limits<char>;
   template<> class numeric_limits<signed char>;
   template<> class numeric_limits<unsigned char>;
@@ -150,11 +398,62 @@ namespace std {
   template<> class numeric_limits<double>;
   template<> class numeric_limits<long double>;
 }
 ```
-#### Class template `numeric_limits` <a id="numeric.limits">[[numeric.limits]]</a>
 ``` cpp
 namespace std {
   template<class T> class numeric_limits {
   public:
@@ -201,26 +500,41 @@ namespace std {
   template<class T> class numeric_limits<volatile T>;
   template<class T> class numeric_limits<const volatile T>;
 }
 ```
 The default `numeric_limits<T>` template shall have all members, but
 with 0 or `false` values.
 The value of each member of a specialization of `numeric_limits` on a
-*cv*-qualified type `cv T` shall be equal to the value of the
 corresponding member of the specialization on the unqualified type `T`.
 #### `numeric_limits` members <a id="numeric.limits.members">[[numeric.limits.members]]</a>
 ``` cpp
 static constexpr T min() noexcept;
 ```
 Minimum finite value.[^3]
-For floating types with denormalization, returns the minimum positive
 normalized value.
 Meaningful for all specializations in which `is_bounded != false`, or
 `is_bounded == false && is_signed == false`.
@@ -247,11 +561,11 @@ static constexpr int digits;
 Number of `radix` digits that can be represented without change.
 For integer types, the number of non-sign bits in the representation.
-For floating point types, the number of `radix` digits in the
 mantissa.[^6]
 ``` cpp
 static constexpr int digits10;
 ```
@@ -265,33 +579,33 @@ static constexpr int max_digits10;
 ```
 Number of base 10 digits required to ensure that values which differ are
 always differentiated.
-Meaningful for all floating point types.
 ``` cpp
 static constexpr bool is_signed;
 ```
-True if the type is signed.
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool is_integer;
 ```
-True if the type is integer.
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool is_exact;
 ```
-True if the type uses an exact representation. All integer types are
 exact, but not all exact types are integer. For example, rational and
 fixed-exponent representations are exact but not integer.
 Meaningful for all specializations.
@@ -311,11 +625,11 @@ static constexpr T epsilon() noexcept;
 ```
 Machine epsilon: the difference between 1 and the least value greater
 than 1 that is representable.[^10]
-Meaningful for all floating point types.
 ``` cpp
 static constexpr T round_error() noexcept;
 ```
@@ -324,89 +638,89 @@ Measure of the maximum rounding error.[^11]
 ``` cpp
 static constexpr int  min_exponent;
 ```
 Minimum negative integer such that `radix` raised to the power of one
-less than that integer is a normalized floating point number.[^12]
-Meaningful for all floating point types.
 ``` cpp
 static constexpr int  min_exponent10;
 ```
 Minimum negative integer such that 10 raised to that power is in the
-range of normalized floating point numbers.[^13]
-Meaningful for all floating point types.
 ``` cpp
 static constexpr int  max_exponent;
 ```
 Maximum positive integer such that `radix` raised to the power one less
-than that integer is a representable finite floating point number.[^14]
-Meaningful for all floating point types.
 ``` cpp
 static constexpr int  max_exponent10;
 ```
 Maximum positive integer such that 10 raised to that power is in the
-range of representable finite floating point numbers.[^15]
-Meaningful for all floating point types.
 ``` cpp
 static constexpr bool has_infinity;
 ```
-True if the type has a representation for positive infinity.
-Meaningful for all floating point types.
 Shall be `true` for all specializations in which `is_iec559 != false`.
 ``` cpp
 static constexpr bool has_quiet_NaN;
 ```
-True if the type has a representation for a quiet (non-signaling) “Not a
-Number.”[^16]
-Meaningful for all floating point types.
 Shall be `true` for all specializations in which `is_iec559 != false`.
 ``` cpp
 static constexpr bool has_signaling_NaN;
 ```
-True if the type has a representation for a signaling “Not a
-Number.”[^17]
-Meaningful for all floating point types.
 Shall be `true` for all specializations in which `is_iec559 != false`.
 ``` cpp
 static constexpr float_denorm_style has_denorm;
 ```
-`denorm_present` if the type allows denormalized values (variable number
-of exponent bits)[^18], `denorm_absent` if the type does not allow
-denormalized values, and `denorm_indeterminate` if it is indeterminate
-at compile time whether the type allows denormalized values.
-Meaningful for all floating point types.
 ``` cpp
 static constexpr bool has_denorm_loss;
 ```
-True if loss of accuracy is detected as a denormalization loss, rather
 than as an inexact result.[^19]
 ``` cpp
 static constexpr T infinity() noexcept;
 ```
@@ -418,65 +732,70 @@ Required in specializations for which `is_iec559 != false`.
 ``` cpp
 static constexpr T quiet_NaN() noexcept;
 ```
-Representation of a quiet “Not a Number,” if available.[^21]
 Meaningful for all specializations for which `has_quiet_NaN != false`.
 Required in specializations for which `is_iec559 != false`.
 ``` cpp
 static constexpr T signaling_NaN() noexcept;
 ```
-Representation of a signaling “Not a Number,” if available.[^22]
 Meaningful for all specializations for which
 `has_signaling_NaN != false`. Required in specializations for which
 `is_iec559 != false`.
 ``` cpp
 static constexpr T denorm_min() noexcept;
 ```
-Minimum positive denormalized value.[^23]
-Meaningful for all floating point types.
 In specializations for which `has_denorm == false`, returns the minimum
 positive normalized value.
 ``` cpp
 static constexpr bool is_iec559;
 ```
-True if and only if the type adheres to IEC 559 standard.[^24]
-Meaningful for all floating point types.
 ``` cpp
 static constexpr bool is_bounded;
 ```
-True if the set of values representable by the type is finite.[^25] All
-fundamental types ([[basic.fundamental]]) are bounded. This member
-would be false for arbitrary precision types.
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool is_modulo;
 ```
-True if the type is modulo.[^26] A type is modulo if, for any operation
-involving `+`, `-`, or `*` on values of that type whose result would
-fall outside the range \[`min()`, `max()`\], the value returned differs
-from the true value by an integer multiple of `max() - min() + 1`.
-On most machines, this is `false` for floating types, `true` for
-unsigned integers, and `true` for signed integers.
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool traps;
@@ -491,94 +810,51 @@ Meaningful for all specializations.
 static constexpr bool tinyness_before;
 ```
 `true` if tinyness is detected before rounding.[^28]
-Meaningful for all floating point types.
 ``` cpp
 static constexpr float_round_style round_style;
 ```
 The rounding style for the type.[^29]
-Meaningful for all floating point types. Specializations for integer
 types shall return `round_toward_zero`.
-#### Type `float_round_style` <a id="round.style">[[round.style]]</a>
-``` cpp
-namespace std {
-  enum float_round_style {
-    round_indeterminate       = -1,
-    round_toward_zero         =  0,
-    round_to_nearest          =  1,
-    round_toward_infinity     =  2,
-    round_toward_neg_infinity =  3
-  };
-}
-```
-The rounding mode for floating point arithmetic is characterized by the
-values:
-- `round_indeterminate` if the rounding style is indeterminable
-- `round_toward_zero` if the rounding style is toward zero
-- `round_to_nearest` if the rounding style is to the nearest
-  representable value
-- `round_toward_infinity` if the rounding style is toward infinity
-- `round_toward_neg_infinity` if the rounding style is toward negative
-  infinity
-#### Type `float_denorm_style` <a id="denorm.style">[[denorm.style]]</a>
-``` cpp
-namespace std {
-  enum float_denorm_style {
-    denorm_indeterminate = -1,
-    denorm_absent = 0,
-    denorm_present = 1
-  };
-}
-```
-The presence or absence of denormalization (variable number of exponent
-bits) is characterized by the values:
-- `denorm_indeterminate` if it cannot be determined whether or not the
-  type allows denormalized values
-- `denorm_absent` if the type does not allow denormalized values
-- `denorm_present` if the type does allow denormalized values
 #### `numeric_limits` specializations <a id="numeric.special">[[numeric.special]]</a>
 All members shall be provided for all specializations. However, many
 values are only required to be meaningful under certain conditions (for
 example, `epsilon()` is only meaningful if `is_integer` is `false`). Any
 value that is not “meaningful” shall be set to 0 or `false`.
 ``` cpp
 namespace std {
   template<> class numeric_limits<float> {
   public:
     static constexpr bool is_specialized = true;
- inline static constexpr float min() noexcept { return 1.17549435E-38F; }
- inline static constexpr float max() noexcept { return 3.40282347E+38F; }
- inline static constexpr float lowest() noexcept { return -3.40282347E+38F; }
     static constexpr int digits   = 24;
     static constexpr int digits10 =  6;
     static constexpr int max_digits10 =  9;
     static constexpr bool is_signed  = true;
     static constexpr bool is_integer = false;
     static constexpr bool is_exact   = false;
     static constexpr int radix = 2;
- inline static constexpr float epsilon() noexcept     { return 1.19209290E-07F; }
- inline static constexpr float round_error() noexcept { return 0.5F; }
     static constexpr int min_exponent   = -125;
     static constexpr int min_exponent10 = - 37;
     static constexpr int max_exponent   = +128;
     static constexpr int max_exponent10 = + 38;
@@ -587,14 +863,14 @@ namespace std {
     static constexpr bool has_quiet_NaN            = true;
     static constexpr bool has_signaling_NaN        = true;
     static constexpr float_denorm_style has_denorm = denorm_absent;
     static constexpr bool has_denorm_loss          = false;
- inline static constexpr float infinity()      noexcept { return value; }
- inline static constexpr float quiet_NaN()     noexcept { return value; }
- inline static constexpr float signaling_NaN() noexcept { return value; }
- inline static constexpr float denorm_min()    noexcept { return min(); }
     static constexpr bool is_iec559  = true;
     static constexpr bool is_bounded = true;
     static constexpr bool is_modulo  = false;
     static constexpr bool traps      = true;
@@ -603,10 +879,12 @@ namespace std {
     static constexpr float_round_style round_style = round_to_nearest;
   };
 }
 ```
 The specialization for `bool` shall be provided as follows:
 ``` cpp
 namespace std {
    template<> class numeric_limits<bool> {
@@ -651,66 +929,135 @@ namespace std {
      static constexpr float_round_style round_style = round_toward_zero;
    };
 }
 ```
-### C library <a id="c.limits">[[c.limits]]</a>
-Table  [[tab:support.hdr.climits]] describes the header `<climits>`.
-The contents are the same as the Standard C library header `<limits.h>`.
-The types of the constants defined by macros in `<climits>` are not
-required to match the types to which the macros refer.
-Table  [[tab:support.hdr.cfloat]] describes the header `<cfloat>`.
-The contents are the same as the Standard C library header `<float.h>`.
-ISO C 7.1.5, 5.2.4.2.2, 5.2.4.2.1.
 ## Integer types <a id="cstdint">[[cstdint]]</a>
 ### Header `<cstdint>` synopsis <a id="cstdint.syn">[[cstdint.syn]]</a>
 ``` cpp
 namespace std {
- typedef signed integer type int8_t; // optional
- typedef signed integer type int16_t;  // optional
- typedef signed integer type int32_t;  // optional
- typedef signed integer type int64_t;  // optional
- typedef signed integer type int_fast8_t;
- typedef signed integer type int_fast16_t;
- typedef signed integer type int_fast32_t;
- typedef signed integer type int_fast64_t;
- typedef signed integer type int_least8_t;
- typedef signed integer type int_least16_t;
- typedef signed integer type int_least32_t;
- typedef signed integer type int_least64_t;
- typedef signed integer type intmax_t;
- typedef signed integer type intptr_t; // optional
- typedef unsigned integer type uint8_t; // optional
- typedef unsigned integer type uint16_t; // optional
- typedef unsigned integer type uint32_t; // optional
- typedef unsigned integer type uint64_t; // optional
- typedef unsigned integer type uint_fast8_t;
- typedef unsigned integer type uint_fast16_t;
- typedef unsigned integer type uint_fast32_t;
- typedef unsigned integer type uint_fast64_t;
- typedef unsigned integer type uint_least8_t;
- typedef unsigned integer type uint_least16_t;
- typedef unsigned integer type uint_least32_t;
- typedef unsigned integer type uint_least64_t;
- typedef unsigned integer type uintmax_t;
- typedef unsigned integer type uintptr_t; // optional
-} // namespace std
 ```
 The header also defines numerous macros of the form:
 ``` cpp
@@ -726,70 +1073,68 @@ plus function macros of the form:
 ``` cpp
 [U]INT{8 16 32 64 MAX}_C
 ```
-The header defines all functions, types, and macros the same as 7.18 in
-the C standard. The macros defined by `<cstdint>` are provided
-unconditionally. In particular, the symbols `__STDC_LIMIT_MACROS` and
-`__STDC_CONSTANT_MACROS` (mentioned in footnotes 219, 220, and 222 in
-the C standard) play no role in C++.
 ## Start and termination <a id="support.start.term">[[support.start.term]]</a>
-Table  [[tab:support.hdr.cstdlib]] describes some of the contents of the
-header `<cstdlib>`.
-The contents are the same as the Standard C library header `<stdlib.h>`,
-with the following changes:
 ``` cpp
 [[noreturn]] void _Exit(int status) noexcept;
 ```
-The function `_Exit(int status)` has additional behavior in this
-International Standard:
-- The program is terminated without executing destructors for objects of
- automatic, thread, or static storage duration and without calling
- functions passed to `atexit()` ([[basic.start.term]]).
 ``` cpp
-[[noreturn]] void abort(void) noexcept;
 ```
-The function `abort()` has additional behavior in this International
-Standard:
-- The program is terminated without executing destructors for objects of
- automatic, thread, or static storage duration and without calling
- functions passed to `atexit()` ([[basic.start.term]]).
 ``` cpp
-extern "C" int atexit(void (*f)(void)) noexcept;
-extern "C++" int atexit(void (*f)(void)) noexcept;
 ```
 *Effects:* The `atexit()` functions register the function pointed to by
 `f` to be called without arguments at normal program termination. It is
 unspecified whether a call to `atexit()` that does not happen
-before ([[intro.multithread]]) a call to `exit()` will succeed. The
-`atexit()` functions do not introduce a data
-race ([[res.on.data.races]]).
 *Implementation limits:* The implementation shall support the
 registration of at least 32 functions.
 *Returns:* The `atexit()` function returns zero if the registration
-succeeds, non-zero if it fails.
 ``` cpp
-[[noreturn]] void exit(int status)
 ```
-The function `exit()` has additional behavior in this International
-Standard:
 - First, objects with thread storage duration and associated with the
   current thread are destroyed. Next, objects with static storage
   duration are destroyed and functions registered by calling `atexit`
   are called.[^30] See  [[basic.start.term]] for the order of
@@ -808,29 +1153,33 @@ Standard:
   an *implementation-defined* form of the status *unsuccessful
   termination* is returned. Otherwise the status returned is
   *implementation-defined*.[^32]
 ``` cpp
-extern "C" int at_quick_exit(void (*f)(void)) noexcept;
-extern "C++" int at_quick_exit(void (*f)(void)) noexcept;
 ```
 *Effects:* The `at_quick_exit()` functions register the function pointed
 to by `f` to be called without arguments when `quick_exit` is called. It
 is unspecified whether a call to `at_quick_exit()` that does not happen
 before ([[intro.multithread]]) all calls to `quick_exit` will succeed.
-The `at_quick_exit()` functions do not introduce a data
-race ([[res.on.data.races]]). The order of registration may be
-indeterminate if `at_quick_exit` was called from more than one thread.
-The `at_quick_exit` registrations are distinct from the `atexit`
-registrations, and applications may need to call both registration
-functions with the same argument.
 *Implementation limits:* The implementation shall support the
 registration of at least 32 functions.
-*Returns:* Zero if the registration succeeds, non-zero if it fails.
 ``` cpp
 [[noreturn]] void quick_exit(int status) noexcept;
 ```
@@ -841,48 +1190,75 @@ been called at the time it was registered. Objects shall not be
 destroyed as a result of calling `quick_exit`. If control leaves a
 registered function called by `quick_exit` because the function does not
 provide a handler for a thrown exception, `std::terminate()` shall be
 called.
-`at_quick_exit` may call a registered function from a different thread
-than the one that registered it, so registered functions should not rely
-on the identity of objects with thread storage duration. After calling
-registered functions, `quick_exit` shall call `_Exit(status)`. The
-standard file buffers are not flushed. ISO C 7.20.4.4.
-  [[basic.start]], [[basic.start.term]], ISO C 7.10.4.
 ## Dynamic memory management <a id="support.dynamic">[[support.dynamic]]</a>
 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;
@@ -892,38 +1268,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`
@@ -932,277 +1316,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`.
@@ -1218,11 +1633,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;
@@ -1233,25 +1648,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>
@@ -1260,11 +1677,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
@@ -1274,55 +1691,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.
@@ -1330,11 +1756,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;
@@ -1351,19 +1777,110 @@ 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.
 ## Type identification <a id="support.rtti">[[support.rtti]]</a>
 The header `<typeinfo>` defines a type associated with type information
 generated by the implementation. It also defines two types for reporting
 dynamic type identification errors.
-\synopsis{Header \texttt{\<typeinfo\>} synopsis}
 ``` cpp
 namespace std {
   class type_info;
   class bad_cast;
@@ -1427,12 +1944,12 @@ size_t hash_code() const noexcept;
 *Returns:* An unspecified value, except that within a single execution
 of the program, it shall return the same value for any two `type_info`
 objects which compare equal.
-an implementation should return different values for two `type_info`
-objects which do not compare equal.
 ``` cpp
 const char* name() const noexcept;
 ```
@@ -1449,37 +1966,34 @@ namespace std {
   class bad_cast : public exception {
   public:
     bad_cast() noexcept;
     bad_cast(const bad_cast&) noexcept;
     bad_cast& operator=(const bad_cast&) noexcept;
- virtual const char* what() const noexcept;
   };
 }
 ```
 The class `bad_cast` defines the type of objects thrown as exceptions by
-the implementation to report the execution of an invalid *dynamic-cast*
 expression ([[expr.dynamic.cast]]).
 ``` cpp
 bad_cast() noexcept;
 ```
 *Effects:* Constructs an object of class `bad_cast`.
-*Remarks:* The result of calling `what()` on the newly constructed
-object is implementation-defined.
 ``` cpp
 bad_cast(const bad_cast&) noexcept;
 bad_cast& operator=(const bad_cast&) noexcept;
 ```
 *Effects:* Copies an object of class `bad_cast`.
 ``` cpp
-virtual const char* what() const noexcept;
 ```
 *Returns:* An *implementation-defined* NTBS.
 *Remarks:* The message may be a null-terminated multibyte
@@ -1493,37 +2007,34 @@ namespace std {
   class bad_typeid : public exception {
   public:
     bad_typeid() noexcept;
     bad_typeid(const bad_typeid&) noexcept;
     bad_typeid& operator=(const bad_typeid&) noexcept;
- virtual const char* what() const noexcept;
   };
 }
 ```
 The class `bad_typeid` defines the type of objects thrown as exceptions
-by the implementation to report a null pointer in a *typeid*
 expression ([[expr.typeid]]).
 ``` cpp
 bad_typeid() noexcept;
 ```
 *Effects:* Constructs an object of class `bad_typeid`.
-*Remarks:* The result of calling `what()` on the newly constructed
-object is implementation-defined.
 ``` cpp
 bad_typeid(const bad_typeid&) noexcept;
 bad_typeid& operator=(const bad_typeid&) noexcept;
 ```
 *Effects:* Copies an object of class `bad_typeid`.
 ``` cpp
-virtual const char* what() const noexcept;
 ```
 *Returns:* An *implementation-defined* NTBS.
 *Remarks:* The message may be a null-terminated multibyte
@@ -1533,29 +2044,26 @@ a `wstring` ([[string.classes]], [[locale.codecvt]])
 ## Exception handling <a id="support.exception">[[support.exception]]</a>
 The header `<exception>` defines several types and functions related to
 the handling of exceptions in a C++program.
 ``` cpp
 namespace std {
   class exception;
   class bad_exception;
   class nested_exception;
- typedef void (*unexpected_handler)();
-  unexpected_handler get_unexpected() noexcept;
-  unexpected_handler set_unexpected(unexpected_handler f) noexcept;
-  [[noreturn]] void unexpected();
-  typedef void (*terminate_handler)();
   terminate_handler get_terminate() noexcept;
   terminate_handler set_terminate(terminate_handler f) noexcept;
   [[noreturn]] void terminate() noexcept;
- bool uncaught_exception() noexcept;
- typedef unspecified exception_ptr;
   exception_ptr current_exception() noexcept;
   [[noreturn]] void rethrow_exception(exception_ptr p);
   template<class E> exception_ptr make_exception_ptr(E e) noexcept;
@@ -1603,11 +2111,12 @@ exception(const exception& rhs) noexcept;
 exception& operator=(const exception& rhs) noexcept;
 ```
 *Effects:* Copies an `exception` object.
-If `*this` and `rhs` both have dynamic type `exception` then
 `strcmp(what(), rhs.what())` shall equal 0.
 ``` cpp
 virtual ~exception();
 ```
@@ -1634,36 +2143,35 @@ namespace std {
   class bad_exception : public exception {
   public:
     bad_exception() noexcept;
     bad_exception(const bad_exception&) noexcept;
     bad_exception& operator=(const bad_exception&) noexcept;
- virtual const char* what() const noexcept;
   };
 }
 ```
-The class `bad_exception` defines the type of objects thrown as
-described in ([[except.unexpected]]).
 ``` cpp
 bad_exception() noexcept;
 ```
 *Effects:* Constructs an object of class `bad_exception`.
-*Remarks:* The result of calling `what()` on the newly constructed
-object is implementation-defined.
 ``` cpp
 bad_exception(const bad_exception&) noexcept;
 bad_exception& operator=(const bad_exception&) noexcept;
 ```
 *Effects:* Copies an object of class `bad_exception`.
 ``` cpp
-virtual const char* what() const noexcept;
 ```
 *Returns:* An *implementation-defined* NTBS.
 *Remarks:* The message may be a null-terminated multibyte
@@ -1673,11 +2181,11 @@ a `wstring` ([[string.classes]], [[locale.codecvt]]).
 ### Abnormal termination <a id="exception.terminate">[[exception.terminate]]</a>
 #### Type `terminate_handler` <a id="terminate.handler">[[terminate.handler]]</a>
 ``` cpp
-typedef void (*terminate_handler)();
 ```
 The type of a *handler function* to be called by `std::terminate()` when
 terminating exception processing.
@@ -1705,51 +2213,51 @@ default `terminate_handler`.
 ``` cpp
 terminate_handler get_terminate() noexcept;
 ```
-*Returns:* The current `terminate_handler`. This may be a null pointer
-value.
 #### `terminate` <a id="terminate">[[terminate]]</a>
 ``` cpp
 [[noreturn]] void terminate() noexcept;
 ```
 *Remarks:* Called by the implementation when exception handling must be
-abandoned for any of several reasons ([[except.terminate]]), in effect
-immediately after throwing the exception. May also be called directly by
-the program.
-*Effects:* Calls the current `terminate_handler` function. A default
-`terminate_handler` is always considered a callable handler in this
-context.
-### `uncaught_exception` <a id="uncaught">[[uncaught]]</a>
 ``` cpp
-bool uncaught_exception() noexcept;
 ```
-*Returns:* `true` after the current thread has initialized an exception
-object ([[except.throw]]) until a handler for the exception (including
-`std::unexpected()` or `std::terminate()`) is
-activated ([[except.handle]]). This includes stack
-unwinding ([[except.ctor]]).
-*Remarks:* When `uncaught_exception()` returns `true`, throwing an
-exception can result in a call of
 `std::terminate()` ([[except.terminate]]).
 ### Exception propagation <a id="propagation">[[propagation]]</a>
 ``` cpp
-typedef unspecified exception_ptr;
 ```
-The type exception_ptr can be used to refer to an exception object.
 `exception_ptr` shall satisfy the requirements of
 `NullablePointer` ([[nullablepointer.requirements]]).
 Two non-null values of type `exception_ptr` are equivalent and compare
@@ -1759,22 +2267,24 @@ The default constructor of `exception_ptr` produces the null value of
 the type.
 `exception_ptr` shall not be implicitly convertible to any arithmetic,
 enumeration, or pointer type.
-An implementation might use a reference-counted smart pointer as
-`exception_ptr`.
 For purposes of determining the presence of a data race, operations on
 `exception_ptr` objects shall access and modify only the `exception_ptr`
 objects themselves and not the exceptions they refer to. Use of
 `rethrow_exception` on `exception_ptr` objects that refer to the same
-exception object shall not introduce a data race. if `rethrow_exception`
-rethrows the same exception object (rather than a copy), concurrent
-access to that rethrown exception object may introduce a data race.
-Changes in the number of `exception_ptr` objects that refer to a
-particular exception do not introduce a data race.
 ``` cpp
 exception_ptr current_exception() noexcept;
 ```
@@ -1784,43 +2294,49 @@ handled exception, or a null `exception_ptr` object if no exception is
 being handled. The referenced object shall remain valid at least as long
 as there is an `exception_ptr` object that refers to it. If the function
 needs to allocate memory and the attempt fails, it returns an
 `exception_ptr` object that refers to an instance of `bad_alloc`. It is
 unspecified whether the return values of two successive calls to
-`current_exception` refer to the same exception object. That is, it is
-unspecified whether `current_exception` creates a new copy each time it
-is called. If the attempt to copy the current exception object throws an
-exception, the function returns an `exception_ptr` object that refers to
-the thrown exception or, if this is not possible, to an instance of
-`bad_exception`. The copy constructor of the thrown exception may also
-fail, so the implementation is allowed to substitute a `bad_exception`
-object to avoid infinite recursion.
 ``` cpp
 [[noreturn]] void rethrow_exception(exception_ptr p);
 ```
 *Requires:* `p` shall not be a null pointer.
-*Throws:* the exception object to which `p` refers.
 ``` cpp
 template<class E> exception_ptr make_exception_ptr(E e) noexcept;
 ```
 *Effects:* Creates an `exception_ptr` object that refers to a copy of
-`e`, as if
 ``` cpp
 try {
   throw e;
 } catch(...) {
   return current_exception();
 }
 ```
-This function is provided for convenience and efficiency reasons.
 ### `nested_exception` <a id="except.nested">[[except.nested]]</a>
 ``` cpp
 namespace std {
@@ -1843,12 +2359,13 @@ namespace std {
 The class `nested_exception` is designed for use as a mixin through
 multiple inheritance. It captures the currently handled exception and
 stores it for later use.
-`nested_exception` has a virtual destructor to make it a polymorphic
-class. Its presence can be tested for with `dynamic_cast`.
 ``` cpp
 nested_exception() noexcept;
 ```
@@ -1872,74 +2389,88 @@ object.
 ``` cpp
 template <class T> [[noreturn]] void throw_with_nested(T&& t);
 ```
-Let `U` be `remove_reference_t<T>`.
 *Requires:* `U` shall be `CopyConstructible`.
-*Throws:* if `U` is a non-union class type not derived from
-`nested_exception`, an exception of unspecified type that is publicly
-derived from both `U` and `nested_exception` and constructed from
 `std::forward<T>(t)`, otherwise `std::forward<T>(t)`.
 ``` cpp
 template <class E> void rethrow_if_nested(const E& e);
 ```
-*Effects:* If the dynamic type of `e` is publicly and unambiguously
-derived from `nested_exception`, calls `dynamic_cast<const`
-`nested_exception&>(e).rethrow_nested()`.
 ## Initializer lists <a id="support.initlist">[[support.initlist]]</a>
 The header `<initializer_list>` defines a class template and several
 support functions related to list-initialization (see
-[[dcl.init.list]]).
 ``` cpp
 namespace std {
   template<class E> class initializer_list {
   public:
- typedef E value_type;
- typedef const E& reference;
- typedef const E& const_reference;
- typedef size_t size_type;
- typedef const E* iterator;
- typedef const E* const_iterator;
     constexpr initializer_list() noexcept;
     constexpr size_t size() const noexcept;     // number of elements
     constexpr const E* begin() const noexcept;  // first element
     constexpr const E* end() const noexcept;    // one past the last element
   };
-  // [support.initlist.range] initializer list range access
   template<class E> constexpr const E* begin(initializer_list<E> il) noexcept;
   template<class E> constexpr const E* end(initializer_list<E> il) noexcept;
 }
 ```
 An object of type `initializer_list<E>` provides access to an array of
-objects of type `const E`. A pair of pointers or a pointer plus a length
-would be obvious representations for `initializer_list`.
-`initializer_list` is used to implement initializer lists as specified
-in  [[dcl.init.list]]. Copying an initializer list does not copy the
-underlying elements.
 ### Initializer list constructors <a id="support.initlist.cons">[[support.initlist.cons]]</a>
 ``` cpp
 constexpr initializer_list() noexcept;
 ```
-*Effects:* constructs an empty `initializer_list` object.
-`size() == 0`
 ### Initializer list access <a id="support.initlist.access">[[support.initlist.access]]</a>
 ``` cpp
 constexpr const E* begin() const noexcept;
@@ -1951,11 +2482,11 @@ identical.
 ``` cpp
 constexpr const E* end() const noexcept;
 ```
-*Returns:* `begin() + size()`
 ``` cpp
 constexpr size_t size() const noexcept;
 ```
@@ -1978,122 +2509,210 @@ template<class E> constexpr const E* end(initializer_list<E> il) noexcept;
 *Returns:* `il.end()`.
 ## Other runtime support <a id="support.runtime">[[support.runtime]]</a>
 Headers `<csetjmp>` (nonlocal jumps), `<csignal>` (signal handling),
-`<cstdalign> (alignment),` `<cstdarg>` (variable arguments),
-`<cstdbool>` (`\xname{bool_true_false_are_defined}`). `<cstdlib>`
-(runtime environment `getenv(), system()`), and `<ctime>` (system clock
-`clock(), time()`) provide further compatibility with C code.
-The contents of these headers are the same as the Standard C library
-headers `<setjmp.h>`, `<signal.h>`, `<stdalign.h>`, `<stdarg.h>`,
-`<stdbool.h>`, `<stdlib.h>`, and `<time.h>`, respectively, with the
-following changes:
-The restrictions that ISO C places on the second parameter to the
-`va_start()` macro in header `<stdarg.h>` are different in this
-International Standard. The parameter `parmN` is the identifier of the
-rightmost parameter in the variable parameter list of the function
-definition (the one just before the `...`).[^34] If the parameter
-`parmN` is of a reference type, or of a type that is not compatible with
-the type that results when passing an argument for which there is no
-parameter, the behavior is undefined.
-ISO C 4.8.1.1.
 The function signature `longjmp(jmp_buf jbuf, int val)` has more
 restricted behavior in this International Standard. A `setjmp`/`longjmp`
 call pair has undefined behavior if replacing the `setjmp` and `longjmp`
 by `catch` and `throw` would invoke any non-trivial destructors for any
 automatic objects.
-ISO C 7.10.4, 7.8, 7.6, 7.12.
-Calls to the function `getenv` shall not introduce a data race (
-[[res.on.data.races]]) provided that nothing modifies the environment.
-Calls to the POSIX functions `setenv` and `putenv` modify the
-environment.
-A call to the `setlocale` function may introduce a data race with other
-calls to the `setlocale` function or with calls to functions that are
-affected by the current C locale. The implementation shall behave as if
-no library function other than `locale::global()` calls the `setlocale`
-function.
-The header `<cstdalign>` and the header `<stdalign.h>` shall not define
-a macro named `alignas`.
-The header `<cstdbool>` and the header `<stdbool.h>` shall not define
-macros named `bool`, `true`, or `false`.
 A call to the function `signal` synchronizes with any resulting
 invocation of the signal handler so installed.
-The common subset of the C and C++languages consists of all
-declarations, definitions, and expressions that may appear in a well
-formed C++program and also in a conforming C program. A POF (“plain old
-function”) is a function that uses only features from this common
-subset, and that does not directly or indirectly use any function that
-is not a POF, except that it may use plain lock-free atomic operations.
-A *plain lock-free atomic operation* is an invocation of a function *f*
-from Clause  [[atomics]], such that *f* is not a member function, and
-either *f* is the function `atomic_is_lock_free`, or for every atomic
-argument `A` passed to *f*, `atomic_is_lock_free(A)` yields `true`. All
-signal handlers shall have C linkage. The behavior of any function other
-than a POF used as a signal handler in a C++program is
-*implementation-defined*.[^35]
 <!-- Link reference definitions -->
 [alloc.errors]: #alloc.errors
 [atomics]: atomics.md#atomics
 [bad.alloc]: #bad.alloc
 [bad.cast]: #bad.cast
 [bad.exception]: #bad.exception
 [bad.typeid]: #bad.typeid
 [basic.align]: basic.md#basic.align
 [basic.fundamental]: basic.md#basic.fundamental
 [basic.start]: basic.md#basic.start
 [basic.start.term]: basic.md#basic.start.term
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [basic.stc.dynamic.safety]: basic.md#basic.stc.dynamic.safety
-[c.limits]: #c.limits
 [class]: class.md#class
 [class.free]: special.md#class.free
 [complex]: numerics.md#complex
 [constraints]: library.md#constraints
 [conv.ptr]: conv.md#conv.ptr
 [conv.rank]: conv.md#conv.rank
 [cstdint]: #cstdint
 [cstdint.syn]: #cstdint.syn
 [dcl.init.list]: dcl.md#dcl.init.list
 [denorm.style]: #denorm.style
-[except.ctor]: except.md#except.ctor
 [except.handle]: except.md#except.handle
 [except.nested]: #except.nested
 [except.special]: except.md#except.special
 [except.terminate]: except.md#except.terminate
-[except.throw]: except.md#except.throw
-[except.unexpected]: except.md#except.unexpected
 [exception]: #exception
 [exception.terminate]: #exception.terminate
 [expr.add]: expr.md#expr.add
 [expr.delete]: expr.md#expr.delete
 [expr.dynamic.cast]: expr.md#expr.dynamic.cast
 [expr.new]: expr.md#expr.new
 [expr.sizeof]: expr.md#expr.sizeof
 [expr.typeid]: expr.md#expr.typeid
 [get.new.handler]: #get.new.handler
 [get.terminate]: #get.terminate
-[intro.execution]: intro.md#intro.execution
 [intro.memory]: intro.md#intro.memory
 [intro.multithread]: intro.md#intro.multithread
 [language.support]: #language.support
-[limits]: #limits
-[limits.numeric]: #limits.numeric
 [limits.syn]: #limits.syn
 [locale.codecvt]: localization.md#locale.codecvt
 [memory]: utilities.md#memory
 [multibyte.strings]: library.md#multibyte.strings
 [new.badlength]: #new.badlength
@@ -2101,19 +2720,22 @@ than a POF used as a signal handler in a C++program is
 [new.delete.array]: #new.delete.array
 [new.delete.dataraces]: #new.delete.dataraces
 [new.delete.placement]: #new.delete.placement
 [new.delete.single]: #new.delete.single
 [new.handler]: #new.handler
 [nullablepointer.requirements]: library.md#nullablepointer.requirements
 [numeric.limits]: #numeric.limits
 [numeric.limits.members]: #numeric.limits.members
 [numeric.special]: #numeric.special
 [propagation]: #propagation
 [res.on.data.races]: library.md#res.on.data.races
 [round.style]: #round.style
 [set.new.handler]: #set.new.handler
 [set.terminate]: #set.terminate
 [string.classes]: strings.md#string.classes
 [support.dynamic]: #support.dynamic
 [support.exception]: #support.exception
 [support.general]: #support.general
 [support.initlist]: #support.initlist
@@ -2122,23 +2744,25 @@ than a POF used as a signal handler in a C++program is
 [support.initlist.range]: #support.initlist.range
 [support.limits]: #support.limits
 [support.limits.general]: #support.limits.general
 [support.rtti]: #support.rtti
 [support.runtime]: #support.runtime
 [support.start.term]: #support.start.term
 [support.types]: #support.types
 [tab:lang.sup.lib.summary]: #tab:lang.sup.lib.summary
-[tab:support.hdr.cfloat]: #tab:support.hdr.cfloat
-[tab:support.hdr.climits]: #tab:support.hdr.climits
-[tab:support.hdr.cstddef]: #tab:support.hdr.cstddef
-[tab:support.hdr.cstdlib]: #tab:support.hdr.cstdlib
 [temp.dep.constexpr]: temp.md#temp.dep.constexpr
 [temp.dep.expr]: temp.md#temp.dep.expr
 [terminate]: #terminate
 [terminate.handler]: #terminate.handler
 [type.info]: #type.info
-[uncaught]: #uncaught
 [^1]: Possible definitions include `0` and `0L`, but not `(void*)0`.
 [^2]: Note that `offsetof` is required to work as specified even if
     unary `operator&` is overloaded for any of the types involved.
@@ -2159,13 +2783,12 @@ than a POF used as a signal handler in a C++program is
 [^9]: Distinguishes types with bases other than 2 (e.g. BCD).
 [^10]: Equivalent to `FLT_EPSILON`, `DBL_EPSILON`, `LDBL_EPSILON`.
-[^11]: Rounding error is described in ISO/IEC 10967-1 Language
- independent arithmetic - Part 1 Section 5.2.8 and Annex A Rationale
-    Section A.5.2.8 - Rounding constants.
 [^12]: Equivalent to `FLT_MIN_EXP`, `DBL_MIN_EXP`, `LDBL_MIN_EXP`.
 [^13]: Equivalent to `FLT_MIN_10_EXP`, `DBL_MIN_10_EXP`,
     `LDBL_MIN_10_EXP`.
@@ -2179,55 +2802,50 @@ than a POF used as a signal handler in a C++program is
 [^17]: Required by LIA-1.
 [^18]: Required by LIA-1.
-[^19]: See IEC 559.
 [^20]: Required by LIA-1.
 [^21]: Required by LIA-1.
 [^22]: Required by LIA-1.
 [^23]: Required by LIA-1.
-[^24]: International Electrotechnical Commission standard 559 is the
-    same as IEEE 754.
 [^25]: Required by LIA-1.
 [^26]: Required by LIA-1.
 [^27]: Required by LIA-1.
-[^28]: Refer to IEC 559. Required by LIA-1.
 [^29]: Equivalent to `FLT_ROUNDS`. Required by LIA-1.
 [^30]: A function is called for every time it is registered.
 [^31]: Objects with automatic storage duration are all destroyed in a
-    program whose function `main()` contains no automatic objects and
-    executes the call to `exit()`. Control can be transferred directly
-    to such a `main()` by throwing an exception that is caught in
-    `main()`.
 [^32]: The macros `EXIT_FAILURE` and `EXIT_SUCCESS` are defined in
     `<cstdlib>`.
-[^33]: It is not the direct responsibility of
-    `operator new[](std::size_t)` or `operator delete[](void*)` to note
-    the repetition count or element size of the array. Those operations
- are performed elsewhere in the array `new` and `delete` expressions.
- The array `new` expression, may, however, increase the `size`
- argument to `operator new[](std::size_t)` to obtain space to store
-    supplemental information.
 [^34]: Note that `va_start` is required to work as specified even if
     unary `operator&` is overloaded for the type of `parmN`.
-[^35]: In particular, a signal handler using exception handling is very
- likely to have problems. Also, invoking `std::exit` may cause
-    destruction of objects, including those of the standard library
-    implementation, which, in general, yields undefined behavior in a
-    signal handler (see  [[intro.execution]]).

 **Table: Language support library summary** <a id="tab:lang.sup.lib.summary">[tab:lang.sup.lib.summary]</a>
 | Subclause              |                           | Header               |
 | ---------------------- | ------------------------- | -------------------- |
+| [[support.types]]      | Common definitions        | `<cstddef>`          |
+|                        |                           | `<cstdlib>` |
+| [[support.limits]]     | Implementation properties | `<limits>` |
+|                        |                           | `<climits>`          |
 |                        |                           | `<cfloat>`           |
 | [[cstdint]]            | Integer types             | `<cstdint>`          |
 | [[support.start.term]] | Start and termination     | `<cstdlib>`          |
 | [[support.dynamic]]    | Dynamic memory management | `<new>`              |
 | [[support.rtti]]       | Type identification       | `<typeinfo>`         |
 | [[support.exception]]  | Exception handling        | `<exception>`        |
 | [[support.initlist]]   | Initializer lists         | `<initializer_list>` |
+| [[support.runtime]]    | Other runtime support     | `<csignal>`          |
 |                        |                           | `<csetjmp>`          |
+|                        |                           | `<cstdarg>` |
 |                        |                           | `<cstdlib>`          |
+## Common definitions <a id="support.types">[[support.types]]</a>
+### Header `<cstddef>` synopsis <a id="cstddef.syn">[[cstddef.syn]]</a>
+``` cpp
+namespace std {
+  using ptrdiff_t = see below;
+  using size_t = see below;
+  using max_align_t = see below;
+  using nullptr_t = decltype(nullptr);
+  enum class byte : unsigned char {};
+  // [support.types.byteops], byte type operations
+  template <class IntType>
+    constexpr byte& operator<<=(byte& b, IntType shift) noexcept;
+  template <class IntType>
+    constexpr byte operator<<(byte b, IntType shift) noexcept;
+  template <class IntType>
+    constexpr byte& operator>>=(byte& b, IntType shift) noexcept;
+  template <class IntType>
+    constexpr byte operator>>(byte b, IntType shift) noexcept;
+  constexpr byte& operator|=(byte& l, byte r) noexcept;
+  constexpr byte operator|(byte l, byte r) noexcept;
+  constexpr byte& operator&=(byte& l, byte r) noexcept;
+  constexpr byte operator&(byte l, byte r) noexcept;
+  constexpr byte& operator^=(byte& l, byte r) noexcept;
+  constexpr byte operator^(byte l, byte r) noexcept;
+  constexpr byte operator~(byte b) noexcept;
+  template <class IntType>
+    constexpr IntType to_integer(byte b) noexcept;
+}
+#define NULL see below
+#define offsetof(P, D) see below
+```
+The contents and meaning of the header `<cstddef>` are the same as the C
+standard library header `<stddef.h>`, except that it does not declare
+the type `wchar_t`, that it also declares the type `byte` and its
+associated operations ([[support.types.byteops]]), and as noted in
+[[support.types.nullptr]] and [[support.types.layout]].
+ISO C 7.19
+### Header `<cstdlib>` synopsis <a id="cstdlib.syn">[[cstdlib.syn]]</a>
+``` cpp
+namespace std {
+  using size_t = see below;
+  using div_t = see below;
+  using ldiv_t = see below;
+  using lldiv_t = see below;
+}
+#define NULL see below
+#define EXIT_FAILURE see below
+#define EXIT_SUCCESS see below
+#define RAND_MAX see below
+#define MB_CUR_MAX see below
+namespace std {
+  // Exposition-only function type aliases
+  extern "C" using c-atexit-handler = void();                        // exposition only
+  extern "C++" using atexit-handler = void();                        // exposition only
+  extern "C" using c-compare-pred = int(const void*, const void*);   // exposition only
+  extern "C++" using compare-pred = int(const void*, const void*);   // exposition only
+  // [support.start.term], start and termination
+  [[noreturn]] void abort() noexcept;
+  int atexit(c-atexit-handler* func) noexcept;
+  int atexit(atexit-handler* func) noexcept;
+  int at_quick_exit(c-atexit-handler* func) noexcept;
+  int at_quick_exit(atexit-handler* func) noexcept;
+  [[noreturn]] void exit(int status);
+  [[noreturn]] void _Exit(int status) noexcept;
+  [[noreturn]] void quick_exit(int status) noexcept;
+  char* getenv(const char* name);
+  int system(const char* string);
+  // [c.malloc], C library memory allocation
+  void* aligned_alloc(size_t alignment, size_t size);
+  void* calloc(size_t nmemb, size_t size);
+  void free(void* ptr);
+  void* malloc(size_t size);
+  void* realloc(void* ptr, size_t size);
+  double atof(const char* nptr);
+  int atoi(const char* nptr);
+  long int atol(const char* nptr);
+  long long int atoll(const char* nptr);
+  double strtod(const char* nptr, char** endptr);
+  float strtof(const char* nptr, char** endptr);
+  long double strtold(const char* nptr, char** endptr);
+  long int strtol(const char* nptr, char** endptr, int base);
+  long long int strtoll(const char* nptr, char** endptr, int base);
+  unsigned long int strtoul(const char* nptr, char** endptr, int base);
+  unsigned long long int strtoull(const char* nptr, char** endptr, int base);
+  // [c.mb.wcs], multibyte / wide string and character conversion functions
+  int mblen(const char* s, size_t n);
+  int mbtowc(wchar_t* pwc, const char* s, size_t n);
+  int wctomb(char* s, wchar_t wchar);
+  size_t mbstowcs(wchar_t* pwcs, const char* s, size_t n);
+  size_t wcstombs(char* s, const wchar_t* pwcs, size_t n);
+  // [alg.c.library], C standard library algorithms
+  void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
+                c-compare-pred* compar);
+  void* bsearch(const void* key, const void* base, size_t nmemb, size_t size,
+                compare-pred* compar);
+  void qsort(void* base, size_t nmemb, size_t size, c-compare-pred* compar);
+  void qsort(void* base, size_t nmemb, size_t size, compare-pred* compar);
+  // [c.math.rand], low-quality random number generation
+  int rand();
+  void srand(unsigned int seed);
+  // [c.math.abs], absolute values
+  int abs(int j);
+  long int abs(long int j);
+  long long int abs(long long int j);
+  float abs(float j);
+  double abs(double j);
+  long double abs(long double j);
+  long int labs(long int j);
+  long long int llabs(long long int j);
+  div_t div(int numer, int denom);
+  ldiv_t div(long int numer, long int denom);             // see [library.c]
+  lldiv_t div(long long int numer, long long int denom);  // see [library.c]
+  ldiv_t ldiv(long int numer, long int denom);
+  lldiv_t lldiv(long long int numer, long long int denom);
+}
+```
+The contents and meaning of the header `<cstdlib>` are the same as the C
+standard library header `<stdlib.h>`, except that it does not declare
+the type `wchar_t`, and except as noted in [[support.types.nullptr]],
+[[support.types.layout]], [[support.start.term]], [[c.malloc]],
+[[c.mb.wcs]], [[alg.c.library]], [[c.math.rand]], and [[c.math.abs]].
+[*Note 1*: Several functions have additional overloads in this
+International Standard, but they have the same behavior as in the C
+standard library ([[library.c]]). — *end note*]
+ISO C 7.22
+### Null pointers <a id="support.types.nullptr">[[support.types.nullptr]]</a>
+The type `nullptr_t` is a synonym for the type of a `nullptr`
+expression, and it has the characteristics described in
+[[basic.fundamental]] and  [[conv.ptr]].
+[*Note 1*: Although `nullptr`’s address cannot be taken, the address of
+another `nullptr_t` object that is an lvalue can be
+taken. — *end note*]
+The macro `NULL` is an *implementation-defined* null pointer constant.
+[^1]
+### Sizes, alignments, and offsets <a id="support.types.layout">[[support.types.layout]]</a>
+The macro `offsetof(type, member-designator)` has the same semantics as
+the corresponding macro in the C standard library header `<stddef.h>`,
+but accepts a restricted set of `type` arguments in this International
+Standard. Use of the `offsetof` macro with a `type` other than a
+standard-layout class (Clause  [[class]]) is
+conditionally-supported.[^2] The expression
+`offsetof(type, member-designator)` is never type-dependent (
+[[temp.dep.expr]]) and it is value-dependent ([[temp.dep.constexpr]])
+if and only if `type` is dependent. The result of applying the
+`offsetof` macro to a static data member or a function member is
+undefined. No operation invoked by the `offsetof` macro shall throw an
+exception and `noexcept(offsetof(type, member-designator))` shall be
+`true`.
 The type `ptrdiff_t` is an *implementation-defined* signed integer type
 that can hold the difference of two subscripts in an array object, as
 described in  [[expr.add]].
 The type `size_t` is an *implementation-defined* unsigned integer type
 that is large enough to contain the size in bytes of any object.
+[*Note 1*: It is recommended that implementations choose types for
+`ptrdiff_t` and `size_t` whose integer conversion ranks ([[conv.rank]])
+are no greater than that of `signed long int` unless a larger size is
+necessary to contain all the possible values. — *end note*]
 The type `max_align_t` is a POD type whose alignment requirement is at
 least as great as that of every scalar type, and whose alignment
 requirement is supported in every context.
 Alignment ([[basic.align]]), Sizeof ([[expr.sizeof]]), Additive
+operators ([[expr.add]]), Free store ([[class.free]]), and ISO C 7.19.
+### `byte` type operations <a id="support.types.byteops">[[support.types.byteops]]</a>
+``` cpp
+template <class IntType>
+  constexpr byte& operator<<=(byte& b, IntType shift) noexcept;
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `is_integral_v<IntType>` is `true`.
+*Effects:* Equivalent to:
+`return b = byte(static_cast<unsigned char>(b) << shift);`
+``` cpp
+template <class IntType>
+  constexpr byte operator<<(byte b, IntType shift) noexcept;
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `is_integral_v<IntType>` is `true`.
+*Effects:* Equivalent to:
+`return byte(static_cast<unsigned char>(b) << shift);`
+``` cpp
+template <class IntType>
+  constexpr byte& operator>>=(byte& b, IntType shift) noexcept;
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `is_integral_v<IntType>` is `true`.
+*Effects:* Equivalent to:
+`return b = byte(static_cast<unsigned char>(b) >> shift);`
+``` cpp
+template <class IntType>
+  constexpr byte operator>>(byte b, IntType shift) noexcept;
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `is_integral_v<IntType>` is `true`.
+*Effects:* Equivalent to:
+`return byte(static_cast<unsigned char>(b) >> shift);`
+``` cpp
+constexpr byte& operator|=(byte& l, byte r) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return l = byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
+```
+``` cpp
+constexpr byte operator|(byte l, byte r) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return byte(static_cast<unsigned char>(l) | static_cast<unsigned char>(r));
+```
+``` cpp
+constexpr byte& operator&=(byte& l, byte r) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return l = byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
+```
+``` cpp
+constexpr byte operator&(byte l, byte r) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return byte(static_cast<unsigned char>(l) & static_cast<unsigned char>(r));
+```
+``` cpp
+constexpr byte& operator^=(byte& l, byte r) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return l = byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
+```
+``` cpp
+constexpr byte operator^(byte l, byte r) noexcept;
+```
+*Effects:* Equivalent to:
+``` cpp
+return byte(static_cast<unsigned char>(l) ^ static_cast<unsigned char>(r));
+```
+``` cpp
+constexpr byte operator~(byte b) noexcept;
+```
+*Effects:* Equivalent to: `return byte(s̃tatic_cast<unsigned char>(b));`
+``` cpp
+template <class IntType>
+  constexpr IntType to_integer(byte b) noexcept;
+```
+*Remarks:* This function shall not participate in overload resolution
+unless `is_integral_v<IntType>` is `true`.
+*Effects:* Equivalent to: `return IntType(b);`
 ## Implementation properties <a id="support.limits">[[support.limits]]</a>
+### General <a id="support.limits.general">[[support.limits.general]]</a>
+The headers `<limits>` ([[limits.syn]]), `<climits>` (
+[[climits.syn]]), and `<cfloat>` ([[cfloat.syn]]) supply
+characteristics of implementation-dependent arithmetic types (
+[[basic.fundamental]]).
+### Header `<limits>` synopsis <a id="limits.syn">[[limits.syn]]</a>
 ``` cpp
 namespace std {
+ // [fp.style], floating-point type properties
   enum float_round_style;
   enum float_denorm_style;
+  // [numeric.limits], class template numeric_limits
+  template<class T> class numeric_limits;
   template<> class numeric_limits<bool>;
   template<> class numeric_limits<char>;
   template<> class numeric_limits<signed char>;
   template<> class numeric_limits<unsigned char>;
   template<> class numeric_limits<double>;
   template<> class numeric_limits<long double>;
 }
 ```
+### Floating-point type properties <a id="fp.style">[[fp.style]]</a>
+#### Type `float_round_style` <a id="round.style">[[round.style]]</a>
+``` cpp
+namespace std {
+  enum float_round_style {
+    round_indeterminate       = -1,
+    round_toward_zero         =  0,
+    round_to_nearest          =  1,
+    round_toward_infinity     =  2,
+    round_toward_neg_infinity =  3
+  };
+}
+```
+The rounding mode for floating-point arithmetic is characterized by the
+values:
+- `round_indeterminate` if the rounding style is indeterminable
+- `round_toward_zero` if the rounding style is toward zero
+- `round_to_nearest` if the rounding style is to the nearest
+  representable value
+- `round_toward_infinity` if the rounding style is toward infinity
+- `round_toward_neg_infinity` if the rounding style is toward negative
+  infinity
+#### Type `float_denorm_style` <a id="denorm.style">[[denorm.style]]</a>
+``` cpp
+namespace std {
+  enum float_denorm_style {
+    denorm_indeterminate = -1,
+    denorm_absent = 0,
+    denorm_present = 1
+  };
+}
+```
+The presence or absence of subnormal numbers (variable number of
+exponent bits) is characterized by the values:
+- `denorm_indeterminate` if it cannot be determined whether or not the
+  type allows subnormal values
+- `denorm_absent` if the type does not allow subnormal values
+- `denorm_present` if the type does allow subnormal values
+### Class template `numeric_limits` <a id="numeric.limits">[[numeric.limits]]</a>
+The `numeric_limits` class template provides a C++program with
+information about various properties of the implementation’s
+representation of the arithmetic types.
 ``` cpp
 namespace std {
   template<class T> class numeric_limits {
   public:
   template<class T> class numeric_limits<volatile T>;
   template<class T> class numeric_limits<const volatile T>;
 }
 ```
+For all members declared `static` `constexpr` in the `numeric_limits`
+template, specializations shall define these values in such a way that
+they are usable as constant expressions.
 The default `numeric_limits<T>` template shall have all members, but
 with 0 or `false` values.
+Specializations shall be provided for each arithmetic type, both
+floating-point and integer, including `bool`. The member
+`is_specialized` shall be `true` for all such specializations of
+`numeric_limits`.
 The value of each member of a specialization of `numeric_limits` on a
+cv-qualified type `cv T` shall be equal to the value of the
 corresponding member of the specialization on the unqualified type `T`.
+Non-arithmetic standard types, such as `complex<T>` ([[complex]]),
+shall not have specializations.
 #### `numeric_limits` members <a id="numeric.limits.members">[[numeric.limits.members]]</a>
+Each member function defined in this subclause is signal-safe (
+[[csignal.syn]]).
 ``` cpp
 static constexpr T min() noexcept;
 ```
 Minimum finite value.[^3]
+For floating types with subnormal numbers, returns the minimum positive
 normalized value.
 Meaningful for all specializations in which `is_bounded != false`, or
 `is_bounded == false && is_signed == false`.
 Number of `radix` digits that can be represented without change.
 For integer types, the number of non-sign bits in the representation.
+For floating-point types, the number of `radix` digits in the
 mantissa.[^6]
 ``` cpp
 static constexpr int digits10;
 ```
 ```
 Number of base 10 digits required to ensure that values which differ are
 always differentiated.
+Meaningful for all floating-point types.
 ``` cpp
 static constexpr bool is_signed;
 ```
+`true` if the type is signed.
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool is_integer;
 ```
+`true` if the type is integer.
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool is_exact;
 ```
+`true` if the type uses an exact representation. All integer types are
 exact, but not all exact types are integer. For example, rational and
 fixed-exponent representations are exact but not integer.
 Meaningful for all specializations.
 ```
 Machine epsilon: the difference between 1 and the least value greater
 than 1 that is representable.[^10]
+Meaningful for all floating-point types.
 ``` cpp
 static constexpr T round_error() noexcept;
 ```
 ``` cpp
 static constexpr int  min_exponent;
 ```
 Minimum negative integer such that `radix` raised to the power of one
+less than that integer is a normalized floating-point number.[^12]
+Meaningful for all floating-point types.
 ``` cpp
 static constexpr int  min_exponent10;
 ```
 Minimum negative integer such that 10 raised to that power is in the
+range of normalized floating-point numbers.[^13]
+Meaningful for all floating-point types.
 ``` cpp
 static constexpr int  max_exponent;
 ```
 Maximum positive integer such that `radix` raised to the power one less
+than that integer is a representable finite floating-point number.[^14]
+Meaningful for all floating-point types.
 ``` cpp
 static constexpr int  max_exponent10;
 ```
 Maximum positive integer such that 10 raised to that power is in the
+range of representable finite floating-point numbers.[^15]
+Meaningful for all floating-point types.
 ``` cpp
 static constexpr bool has_infinity;
 ```
+`true` if the type has a representation for positive infinity.
+Meaningful for all floating-point types.
 Shall be `true` for all specializations in which `is_iec559 != false`.
 ``` cpp
 static constexpr bool has_quiet_NaN;
 ```
+`true` if the type has a representation for a quiet (non-signaling) “Not
+a Number”.[^16]
+Meaningful for all floating-point types.
 Shall be `true` for all specializations in which `is_iec559 != false`.
 ``` cpp
 static constexpr bool has_signaling_NaN;
 ```
+`true` if the type has a representation for a signaling “Not a
+Number”.[^17]
+Meaningful for all floating-point types.
 Shall be `true` for all specializations in which `is_iec559 != false`.
 ``` cpp
 static constexpr float_denorm_style has_denorm;
 ```
+`denorm_present` if the type allows subnormal values (variable number of
+exponent bits)[^18], `denorm_absent` if the type does not allow
+subnormal values, and `denorm_indeterminate` if it is indeterminate at
+compile time whether the type allows subnormal values.
+Meaningful for all floating-point types.
 ``` cpp
 static constexpr bool has_denorm_loss;
 ```
+`true` if loss of accuracy is detected as a denormalization loss, rather
 than as an inexact result.[^19]
 ``` cpp
 static constexpr T infinity() noexcept;
 ```
 ``` cpp
 static constexpr T quiet_NaN() noexcept;
 ```
+Representation of a quiet “Not a Number”, if available.[^21]
 Meaningful for all specializations for which `has_quiet_NaN != false`.
 Required in specializations for which `is_iec559 != false`.
 ``` cpp
 static constexpr T signaling_NaN() noexcept;
 ```
+Representation of a signaling “Not a Number”, if available.[^22]
 Meaningful for all specializations for which
 `has_signaling_NaN != false`. Required in specializations for which
 `is_iec559 != false`.
 ``` cpp
 static constexpr T denorm_min() noexcept;
 ```
+Minimum positive subnormal value.[^23]
+Meaningful for all floating-point types.
 In specializations for which `has_denorm == false`, returns the minimum
 positive normalized value.
 ``` cpp
 static constexpr bool is_iec559;
 ```
+`true` if and only if the type adheres to ISO/IEC/IEEE 60559.[^24]
+Meaningful for all floating-point types.
 ``` cpp
 static constexpr bool is_bounded;
 ```
+`true` if the set of values representable by the type is finite.[^25]
+[*Note 1*: All fundamental types ([[basic.fundamental]]) are bounded.
+This member would be `false` for arbitrary precision
+types. — *end note*]
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool is_modulo;
 ```
+`true` if the type is modulo.[^26] A type is modulo if, for any
+operation involving `+`, `-`, or `*` on values of that type whose result
+would fall outside the range \[`min()`, `max()`\], the value returned
+differs from the true value by an integer multiple of
+`max() - min() + 1`.
+[*Example 1*: `is_modulo` is `false` for signed integer
+types ([[basic.fundamental]]) unless an implementation, as an extension
+to this International Standard, defines signed integer overflow to
+wrap. — *end example*]
 Meaningful for all specializations.
 ``` cpp
 static constexpr bool traps;
 static constexpr bool tinyness_before;
 ```
 `true` if tinyness is detected before rounding.[^28]
+Meaningful for all floating-point types.
 ``` cpp
 static constexpr float_round_style round_style;
 ```
 The rounding style for the type.[^29]
+Meaningful for all floating-point types. Specializations for integer
 types shall return `round_toward_zero`.
 #### `numeric_limits` specializations <a id="numeric.special">[[numeric.special]]</a>
 All members shall be provided for all specializations. However, many
 values are only required to be meaningful under certain conditions (for
 example, `epsilon()` is only meaningful if `is_integer` is `false`). Any
 value that is not “meaningful” shall be set to 0 or `false`.
+[*Example 1*:
 ``` cpp
 namespace std {
   template<> class numeric_limits<float> {
   public:
     static constexpr bool is_specialized = true;
+    static constexpr float min() noexcept { return 1.17549435E-38F; }
+    static constexpr float max() noexcept { return 3.40282347E+38F; }
+    static constexpr float lowest() noexcept { return -3.40282347E+38F; }
     static constexpr int digits   = 24;
     static constexpr int digits10 =  6;
     static constexpr int max_digits10 =  9;
     static constexpr bool is_signed  = true;
     static constexpr bool is_integer = false;
     static constexpr bool is_exact   = false;
     static constexpr int radix = 2;
+    static constexpr float epsilon() noexcept     { return 1.19209290E-07F; }
+    static constexpr float round_error() noexcept { return 0.5F; }
     static constexpr int min_exponent   = -125;
     static constexpr int min_exponent10 = - 37;
     static constexpr int max_exponent   = +128;
     static constexpr int max_exponent10 = + 38;
     static constexpr bool has_quiet_NaN            = true;
     static constexpr bool has_signaling_NaN        = true;
     static constexpr float_denorm_style has_denorm = denorm_absent;
     static constexpr bool has_denorm_loss          = false;
+    static constexpr float infinity()      noexcept { return value; }
+    static constexpr float quiet_NaN()     noexcept { return value; }
+    static constexpr float signaling_NaN() noexcept { return value; }
+    static constexpr float denorm_min()    noexcept { return min(); }
     static constexpr bool is_iec559  = true;
     static constexpr bool is_bounded = true;
     static constexpr bool is_modulo  = false;
     static constexpr bool traps      = true;
     static constexpr float_round_style round_style = round_to_nearest;
   };
 }
 ```
+— *end example*]
 The specialization for `bool` shall be provided as follows:
 ``` cpp
 namespace std {
    template<> class numeric_limits<bool> {
      static constexpr float_round_style round_style = round_toward_zero;
    };
 }
 ```
+### Header `<climits>` synopsis <a id="climits.syn">[[climits.syn]]</a>
+``` cpp
+#define CHAR_BIT see below
+#define SCHAR_MIN see below
+#define SCHAR_MAX see below
+#define UCHAR_MAX see below
+#define CHAR_MIN see below
+#define CHAR_MAX see below
+#define MB_LEN_MAX see below
+#define SHRT_MIN see below
+#define SHRT_MAX see below
+#define USHRT_MAX see below
+#define INT_MIN see below
+#define INT_MAX see below
+#define UINT_MAX see below
+#define LONG_MIN see below
+#define LONG_MAX see below
+#define ULONG_MAX see below
+#define LLONG_MIN see below
+#define LLONG_MAX see below
+#define ULLONG_MAX see below
+```
+The header `<climits>` defines all macros the same as the C standard
+library header `<limits.h>`.
+[*Note 1*: The types of the constants defined by macros in `<climits>`
+are not required to match the types to which the macros
+refer. — *end note*]
+ISO C 5.2.4.2.1
+### Header `<cfloat>` synopsis <a id="cfloat.syn">[[cfloat.syn]]</a>
+``` cpp
+#define FLT_ROUNDS see below
+#define FLT_EVAL_METHOD see below
+#define FLT_HAS_SUBNORM see below
+#define DBL_HAS_SUBNORM see below
+#define LDBL_HAS_SUBNORM see below
+#define FLT_RADIX see below
+#define FLT_MANT_DIG see below
+#define DBL_MANT_DIG see below
+#define LDBL_MANT_DIG see below
+#define FLT_DECIMAL_DIG see below
+#define DBL_DECIMAL_DIG see below
+#define LDBL_DECIMAL_DIG see below
+#define DECIMAL_DIG see below
+#define FLT_DIG see below
+#define DBL_DIG see below
+#define LDBL_DIG see below
+#define FLT_MIN_EXP see below
+#define DBL_MIN_EXP see below
+#define LDBL_MIN_EXP see below
+#define FLT_MIN_10_EXP see below
+#define DBL_MIN_10_EXP see below
+#define LDBL_MIN_10_EXP see below
+#define FLT_MAX_EXP see below
+#define DBL_MAX_EXP see below
+#define LDBL_MAX_EXP see below
+#define FLT_MAX_10_EXP see below
+#define DBL_MAX_10_EXP see below
+#define LDBL_MAX_10_EXP see below
+#define FLT_MAX see below
+#define DBL_MAX see below
+#define LDBL_MAX see below
+#define FLT_EPSILON see below
+#define DBL_EPSILON see below
+#define LDBL_EPSILON see below
+#define FLT_MIN see below
+#define DBL_MIN see below
+#define LDBL_MIN see below
+#define FLT_TRUE_MIN see below
+#define DBL_TRUE_MIN see below
+#define LDBL_TRUE_MIN see below
+```
+The header `<cfloat>` defines all macros the same as the C standard
+library header `<float.h>`.
+ISO C 5.2.4.2.2
 ## Integer types <a id="cstdint">[[cstdint]]</a>
 ### Header `<cstdint>` synopsis <a id="cstdint.syn">[[cstdint.syn]]</a>
 ``` cpp
 namespace std {
+ using int8_t         = signed integer type; // optional
+ using int16_t        = signed integer type;  // optional
+ using int32_t        = signed integer type;  // optional
+ using int64_t        = signed integer type;  // optional
+ using int_fast8_t    = signed integer type;
+ using int_fast16_t   = signed integer type;
+ using int_fast32_t   = signed integer type;
+ using int_fast64_t   = signed integer type;
+ using int_least8_t   = signed integer type;
+ using int_least16_t  = signed integer type;
+ using int_least32_t  = signed integer type;
+ using int_least64_t  = signed integer type;
+ using intmax_t       = signed integer type;
+ using intptr_t       = signed integer type; // optional
+ using uint8_t        = unsigned integer type; // optional
+ using uint16_t       = unsigned integer type; // optional
+ using uint32_t       = unsigned integer type; // optional
+ using uint64_t       = unsigned integer type; // optional
+ using uint_fast8_t   = unsigned integer type;
+ using uint_fast16_t  = unsigned integer type;
+ using uint_fast32_t  = unsigned integer type;
+ using uint_fast64_t  = unsigned integer type;
+ using uint_least8_t  = unsigned integer type;
+ using uint_least16_t = unsigned integer type;
+ using uint_least32_t = unsigned integer type;
+ using uint_least64_t = unsigned integer type;
+ using uintmax_t      = unsigned integer type;
+ using uintptr_t      = unsigned integer type; // optional
+}
 ```
 The header also defines numerous macros of the form:
 ``` cpp
 ``` cpp
 [U]INT{8 16 32 64 MAX}_C
 ```
+The header defines all types and macros the same as the C standard
+library header `<stdint.h>`.
+ISO C 7.20.
 ## Start and termination <a id="support.start.term">[[support.start.term]]</a>
+[*Note 1*: The header `<cstdlib>` ([[cstdlib.syn]]) declares the
+functions described in this subclause. — *end note*]
 ``` cpp
 [[noreturn]] void _Exit(int status) noexcept;
 ```
+*Effects:* This function has the semantics specified in the C standard
+library.
+*Remarks:* The program is terminated without executing destructors for
+objects of automatic, thread, or static storage duration and without
+calling functions passed to `atexit()` ([[basic.start.term]]). The
+function `_Exit` is signal-safe ([[csignal.syn]]).
 ``` cpp
+[[noreturn]] void abort() noexcept;
 ```
+*Effects:* This function has the semantics specified in the C standard
+library.
+*Remarks:* The program is terminated without executing destructors for
+objects of automatic, thread, or static storage duration and without
+calling functions passed to `atexit()` ([[basic.start.term]]). The
+function `abort` is signal-safe ([[csignal.syn]]).
 ``` cpp
+int atexit(c-atexit-handler* f) noexcept;
+int atexit(atexit-handler* f) noexcept;
 ```
 *Effects:* The `atexit()` functions register the function pointed to by
 `f` to be called without arguments at normal program termination. It is
 unspecified whether a call to `atexit()` that does not happen
+before ([[intro.multithread]]) a call to `exit()` will succeed.
+[*Note 1*: The `atexit()` functions do not introduce a data
+race ([[res.on.data.races]]). — *end note*]
 *Implementation limits:* The implementation shall support the
 registration of at least 32 functions.
 *Returns:* The `atexit()` function returns zero if the registration
+succeeds, nonzero if it fails.
 ``` cpp
+[[noreturn]] void exit(int status);
 ```
+*Effects:*
 - First, objects with thread storage duration and associated with the
   current thread are destroyed. Next, objects with static storage
   duration are destroyed and functions registered by calling `atexit`
   are called.[^30] See  [[basic.start.term]] for the order of
   an *implementation-defined* form of the status *unsuccessful
   termination* is returned. Otherwise the status returned is
   *implementation-defined*.[^32]
 ``` cpp
+int at_quick_exit(c-atexit-handler* f) noexcept;
+int at_quick_exit(atexit-handler* f) noexcept;
 ```
 *Effects:* The `at_quick_exit()` functions register the function pointed
 to by `f` to be called without arguments when `quick_exit` is called. It
 is unspecified whether a call to `at_quick_exit()` that does not happen
 before ([[intro.multithread]]) all calls to `quick_exit` will succeed.
+[*Note 2*: The `at_quick_exit()` functions do not introduce a data
+race ([[res.on.data.races]]). — *end note*]
+[*Note 3*: The order of registration may be indeterminate if
+`at_quick_exit` was called from more than one thread. — *end note*]
+[*Note 4*: The `at_quick_exit` registrations are distinct from the
+`atexit` registrations, and applications may need to call both
+registration functions with the same argument. — *end note*]
 *Implementation limits:* The implementation shall support the
 registration of at least 32 functions.
+*Returns:* Zero if the registration succeeds, nonzero if it fails.
 ``` cpp
 [[noreturn]] void quick_exit(int status) noexcept;
 ```
 destroyed as a result of calling `quick_exit`. If control leaves a
 registered function called by `quick_exit` because the function does not
 provide a handler for a thrown exception, `std::terminate()` shall be
 called.
+[*Note 5*: A function registered via `at_quick_exit` is invoked by the
+thread that calls `quick_exit`, which can be a different thread than the
+one that registered it, so registered functions should not rely on the
+identity of objects with thread storage duration. — *end note*]
+After calling registered functions, `quick_exit` shall call
+`_Exit(status)`.
+[*Note 6*: The standard file buffers are not flushed. — *end note*]
+*Remarks:* The function `quick_exit` is signal-safe ([[csignal.syn]])
+when the functions registered with `at_quick_exit` are.
+  [[basic.start]], [[basic.start.term]], ISO C 7.22.4.
 ## Dynamic memory management <a id="support.dynamic">[[support.dynamic]]</a>
 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*]
 ## Type identification <a id="support.rtti">[[support.rtti]]</a>
 The header `<typeinfo>` defines a type associated with type information
 generated by the implementation. It also defines two types for reporting
 dynamic type identification errors.
+### Header `<typeinfo>` synopsis <a id="typeinfo.syn">[[typeinfo.syn]]</a>
 ``` cpp
 namespace std {
   class type_info;
   class bad_cast;
 *Returns:* An unspecified value, except that within a single execution
 of the program, it shall return the same value for any two `type_info`
 objects which compare equal.
+*Remarks:* An implementation should return different values for two
+`type_info` objects which do not compare equal.
 ``` cpp
 const char* name() const noexcept;
 ```
   class bad_cast : public exception {
   public:
     bad_cast() noexcept;
     bad_cast(const bad_cast&) noexcept;
     bad_cast& operator=(const bad_cast&) noexcept;
+    const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_cast` defines the type of objects thrown as exceptions by
+the implementation to report the execution of an invalid `dynamic_cast`
 expression ([[expr.dynamic.cast]]).
 ``` cpp
 bad_cast() noexcept;
 ```
 *Effects:* Constructs an object of class `bad_cast`.
 ``` cpp
 bad_cast(const bad_cast&) noexcept;
 bad_cast& operator=(const bad_cast&) noexcept;
 ```
 *Effects:* Copies an object of class `bad_cast`.
 ``` cpp
+const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 *Remarks:* The message may be a null-terminated multibyte
   class bad_typeid : public exception {
   public:
     bad_typeid() noexcept;
     bad_typeid(const bad_typeid&) noexcept;
     bad_typeid& operator=(const bad_typeid&) noexcept;
+    const char* what() const noexcept override;
   };
 }
 ```
 The class `bad_typeid` defines the type of objects thrown as exceptions
+by the implementation to report a null pointer in a `typeid`
 expression ([[expr.typeid]]).
 ``` cpp
 bad_typeid() noexcept;
 ```
 *Effects:* Constructs an object of class `bad_typeid`.
 ``` cpp
 bad_typeid(const bad_typeid&) noexcept;
 bad_typeid& operator=(const bad_typeid&) noexcept;
 ```
 *Effects:* Copies an object of class `bad_typeid`.
 ``` cpp
+const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 *Remarks:* The message may be a null-terminated multibyte
 ## Exception handling <a id="support.exception">[[support.exception]]</a>
 The header `<exception>` defines several types and functions related to
 the handling of exceptions in a C++program.
+### Header `<exception>` synopsis <a id="exception.syn">[[exception.syn]]</a>
 ``` cpp
 namespace std {
   class exception;
   class bad_exception;
   class nested_exception;
+ using terminate_handler = void (*)();
   terminate_handler get_terminate() noexcept;
   terminate_handler set_terminate(terminate_handler f) noexcept;
   [[noreturn]] void terminate() noexcept;
+ int uncaught_exceptions() noexcept;
+ using exception_ptr = unspecified;
   exception_ptr current_exception() noexcept;
   [[noreturn]] void rethrow_exception(exception_ptr p);
   template<class E> exception_ptr make_exception_ptr(E e) noexcept;
 exception& operator=(const exception& rhs) noexcept;
 ```
 *Effects:* Copies an `exception` object.
+*Postconditions:* If `*this` and `rhs` both have dynamic type
+`exception` then the value of the expression
 `strcmp(what(), rhs.what())` shall equal 0.
 ``` cpp
 virtual ~exception();
 ```
   class bad_exception : public exception {
   public:
     bad_exception() noexcept;
     bad_exception(const bad_exception&) noexcept;
     bad_exception& operator=(const bad_exception&) noexcept;
+    const char* what() const noexcept override;
   };
 }
 ```
+The class `bad_exception` defines the type of the object referenced by
+the `exception_ptr` returned from a call to `current_exception` (
+[[propagation]]) when the currently active exception object fails to
+copy.
 ``` cpp
 bad_exception() noexcept;
 ```
 *Effects:* Constructs an object of class `bad_exception`.
 ``` cpp
 bad_exception(const bad_exception&) noexcept;
 bad_exception& operator=(const bad_exception&) noexcept;
 ```
 *Effects:* Copies an object of class `bad_exception`.
 ``` cpp
+const char* what() const noexcept override;
 ```
 *Returns:* An *implementation-defined* NTBS.
 *Remarks:* The message may be a null-terminated multibyte
 ### Abnormal termination <a id="exception.terminate">[[exception.terminate]]</a>
 #### Type `terminate_handler` <a id="terminate.handler">[[terminate.handler]]</a>
 ``` cpp
+using terminate_handler = void (*)();
 ```
 The type of a *handler function* to be called by `std::terminate()` when
 terminating exception processing.
 ``` cpp
 terminate_handler get_terminate() noexcept;
 ```
+*Returns:* The current `terminate_handler`.
+[*Note 1*: This may be a null pointer value. — *end note*]
 #### `terminate` <a id="terminate">[[terminate]]</a>
 ``` cpp
 [[noreturn]] void terminate() noexcept;
 ```
 *Remarks:* Called by the implementation when exception handling must be
+abandoned for any of several reasons ([[except.terminate]]). May also
+be called directly by the program.
+*Effects:* Calls a `terminate_handler` function. It is unspecified which
+`terminate_handler` function will be called if an exception is active
+during a call to `set_terminate`. Otherwise calls the current
+`terminate_handler` function.
+[*Note 1*: A default `terminate_handler` is always considered a
+callable handler in this context. — *end note*]
+### `uncaught_exceptions` <a id="uncaught.exceptions">[[uncaught.exceptions]]</a>
 ``` cpp
+int uncaught_exceptions() noexcept;
 ```
+*Returns:* The number of uncaught exceptions ([[except.uncaught]]).
+*Remarks:* When `uncaught_exceptions() > 0`, throwing an exception can
+result in a call of
 `std::terminate()` ([[except.terminate]]).
 ### Exception propagation <a id="propagation">[[propagation]]</a>
 ``` cpp
+using exception_ptr = unspecified;
 ```
+The type `exception_ptr` can be used to refer to an exception object.
 `exception_ptr` shall satisfy the requirements of
 `NullablePointer` ([[nullablepointer.requirements]]).
 Two non-null values of type `exception_ptr` are equivalent and compare
 the type.
 `exception_ptr` shall not be implicitly convertible to any arithmetic,
 enumeration, or pointer type.
+[*Note 1*: An implementation might use a reference-counted smart
+pointer as `exception_ptr`. — *end note*]
 For purposes of determining the presence of a data race, operations on
 `exception_ptr` objects shall access and modify only the `exception_ptr`
 objects themselves and not the exceptions they refer to. Use of
 `rethrow_exception` on `exception_ptr` objects that refer to the same
+exception object shall not introduce a data race.
+[*Note 2*: If `rethrow_exception` rethrows the same exception object
+(rather than a copy), concurrent access to that rethrown exception
+object may introduce a data race. Changes in the number of
+`exception_ptr` objects that refer to a particular exception do not
+introduce a data race. — *end note*]
 ``` cpp
 exception_ptr current_exception() noexcept;
 ```
 being handled. The referenced object shall remain valid at least as long
 as there is an `exception_ptr` object that refers to it. If the function
 needs to allocate memory and the attempt fails, it returns an
 `exception_ptr` object that refers to an instance of `bad_alloc`. It is
 unspecified whether the return values of two successive calls to
+`current_exception` refer to the same exception object.
+[*Note 3*: That is, it is unspecified whether `current_exception`
+creates a new copy each time it is called. — *end note*]
+If the attempt to copy the current exception object throws an exception,
+the function returns an `exception_ptr` object that refers to the thrown
+exception or, if this is not possible, to an instance of
+`bad_exception`.
+[*Note 4*: The copy constructor of the thrown exception may also fail,
+so the implementation is allowed to substitute a `bad_exception` object
+to avoid infinite recursion. — *end note*]
 ``` cpp
 [[noreturn]] void rethrow_exception(exception_ptr p);
 ```
 *Requires:* `p` shall not be a null pointer.
+*Throws:* The exception object to which `p` refers.
 ``` cpp
 template<class E> exception_ptr make_exception_ptr(E e) noexcept;
 ```
 *Effects:* Creates an `exception_ptr` object that refers to a copy of
+`e`, as if:
 ``` cpp
 try {
   throw e;
 } catch(...) {
   return current_exception();
 }
 ```
+[*Note 5*: This function is provided for convenience and efficiency
+reasons. — *end note*]
 ### `nested_exception` <a id="except.nested">[[except.nested]]</a>
 ``` cpp
 namespace std {
 The class `nested_exception` is designed for use as a mixin through
 multiple inheritance. It captures the currently handled exception and
 stores it for later use.
+[*Note 1*: `nested_exception` has a virtual destructor to make it a
+polymorphic class. Its presence can be tested for with
+`dynamic_cast`. — *end note*]
 ``` cpp
 nested_exception() noexcept;
 ```
 ``` cpp
 template <class T> [[noreturn]] void throw_with_nested(T&& t);
 ```
+Let `U` be `decay_t<T>`.
 *Requires:* `U` shall be `CopyConstructible`.
+*Throws:* If
+`is_class_v<U> && !is_final_v<U> && !is_base_of_v<nested_exception, U>`
+is `true`, an exception of unspecified type that is publicly derived
+from both `U` and `nested_exception` and constructed from
 `std::forward<T>(t)`, otherwise `std::forward<T>(t)`.
 ``` cpp
 template <class E> void rethrow_if_nested(const E& e);
 ```
+*Effects:* If `E` is not a polymorphic class type, or if
+`nested_exception` is an inaccessible or ambiguous base class of `E`,
+there is no effect. Otherwise, performs:
+``` cpp
+if (auto p = dynamic_cast<const nested_exception*>(addressof(e)))
+  p->rethrow_nested();
+```
 ## Initializer lists <a id="support.initlist">[[support.initlist]]</a>
 The header `<initializer_list>` defines a class template and several
 support functions related to list-initialization (see
+[[dcl.init.list]]). All functions specified in this subclause are
+signal-safe ([[csignal.syn]]).
+### Header `<initializer_list>` synopsis <a id="initializer_list.syn">[[initializer_list.syn]]</a>
 ``` cpp
 namespace std {
   template<class E> class initializer_list {
   public:
+ using value_type      = E;
+ using reference       = const E&;
+ using const_reference = const E&;
+ using size_type       = size_t;
+ using iterator        = const E*;
+ using const_iterator  = const E*;
     constexpr initializer_list() noexcept;
     constexpr size_t size() const noexcept;     // number of elements
     constexpr const E* begin() const noexcept;  // first element
     constexpr const E* end() const noexcept;    // one past the last element
   };
+  // [support.initlist.range], initializer list range access
   template<class E> constexpr const E* begin(initializer_list<E> il) noexcept;
   template<class E> constexpr const E* end(initializer_list<E> il) noexcept;
 }
 ```
 An object of type `initializer_list<E>` provides access to an array of
+objects of type `const E`.
+[*Note 1*: A pair of pointers or a pointer plus a length would be
+obvious representations for `initializer_list`. `initializer_list` is
+used to implement initializer lists as specified in  [[dcl.init.list]].
+Copying an initializer list does not copy the underlying
+elements. — *end note*]
+If an explicit specialization or partial specialization of
+`initializer_list` is declared, the program is ill-formed.
 ### Initializer list constructors <a id="support.initlist.cons">[[support.initlist.cons]]</a>
 ``` cpp
 constexpr initializer_list() noexcept;
 ```
+*Effects:* Constructs an empty `initializer_list` object.
+*Postconditions:* `size() == 0`.
 ### Initializer list access <a id="support.initlist.access">[[support.initlist.access]]</a>
 ``` cpp
 constexpr const E* begin() const noexcept;
 ``` cpp
 constexpr const E* end() const noexcept;
 ```
+*Returns:* `begin() + size()`.
 ``` cpp
 constexpr size_t size() const noexcept;
 ```
 *Returns:* `il.end()`.
 ## Other runtime support <a id="support.runtime">[[support.runtime]]</a>
 Headers `<csetjmp>` (nonlocal jumps), `<csignal>` (signal handling),
+`<cstdarg>` (variable arguments), and `<cstdlib>` (runtime environment
+`getenv, system`), provide further compatibility with C code.
+Calls to the function `getenv` ([[cstdlib.syn]]) shall not introduce a
+data race ([[res.on.data.races]]) provided that nothing modifies the
+environment.
+[*Note 1*: Calls to the POSIX functions `setenv` and `putenv` modify
+the environment. — *end note*]
+A call to the `setlocale` function ([[c.locales]]) may introduce a data
+race with other calls to the `setlocale` function or with calls to
+functions that are affected by the current C locale. The implementation
+shall behave as if no library function other than `locale::global` calls
+the `setlocale` function.
+### Header `<cstdarg>` synopsis <a id="cstdarg.syn">[[cstdarg.syn]]</a>
+``` cpp
+namespace std {
+  using va_list = see below;
+}
+#define va_arg(V, P) see below
+#define va_copy(VDST, VSRC) see below
+#define va_end(V) see below
+#define va_start(V, P) see below
+```
+The contents of the header `<cstdarg>` are the same as the C standard
+library header `<stdarg.h>`, with the following changes: The
+restrictions that ISO C places on the second parameter to the `va_start`
+macro in header `<stdarg.h>` are different in this International
+Standard. The parameter `parmN` is the rightmost parameter in the
+variable parameter list of the function definition (the one just before
+the `...`).[^34] If the parameter `parmN` is a pack expansion (
+[[temp.variadic]]) or an entity resulting from a lambda capture (
+[[expr.prim.lambda]]), the program is ill-formed, no diagnostic
+required. If the parameter `parmN` is of a reference type, or of a type
+that is not compatible with the type that results when passing an
+argument for which there is no parameter, the behavior is undefined.
+ISO C 7.16.1.1.
+### Header `<csetjmp>` synopsis <a id="csetjmp.syn">[[csetjmp.syn]]</a>
+``` cpp
+namespace std {
+  using jmp_buf = see below;
+  [[noreturn]] void longjmp(jmp_buf env, int val);
+}
+#define setjmp(env) see below
+```
+The contents of the header `<csetjmp>` are the same as the C standard
+library header `<setjmp.h>`.
 The function signature `longjmp(jmp_buf jbuf, int val)` has more
 restricted behavior in this International Standard. A `setjmp`/`longjmp`
 call pair has undefined behavior if replacing the `setjmp` and `longjmp`
 by `catch` and `throw` would invoke any non-trivial destructors for any
 automatic objects.
+ISO C 7.13.
+### Header `<csignal>` synopsis <a id="csignal.syn">[[csignal.syn]]</a>
+``` cpp
+namespace std {
+  using sig_atomic_t = see below;
+  // [support.signal], signal handlers
+  extern "C" using signal-handler = void(int);  // exposition only
+  signal-handler* signal(int sig, signal-handler* func);
+  int raise(int sig);
+}
+#define SIG_DFL see below
+#define SIG_ERR see below
+#define SIG_IGN see below
+#define SIGABRT see below
+#define SIGFPE see below
+#define SIGILL see below
+#define SIGINT see below
+#define SIGSEGV see below
+#define SIGTERM see below
+```
+The contents of the header `<csignal>` are the same as the C standard
+library header `<signal.h>`.
+### Signal handlers <a id="support.signal">[[support.signal]]</a>
 A call to the function `signal` synchronizes with any resulting
 invocation of the signal handler so installed.
+A *plain lock-free atomic operation* is an invocation of a function `f`
+from Clause  [[atomics]], such that:
+- `f` is the function `atomic_is_lock_free()`, or
+- `f` is the member function `is_lock_free()`, or
+- `f` is a non-static member function invoked on an object `A`, such
+  that `A.is_lock_free()` yields `true`, or
+- `f` is a non-member function, and for every pointer-to-atomic argument
+  `A` passed to `f`, `atomic_is_lock_free(A)` yields `true`.
+An evaluation is *signal-safe* unless it includes one of the following:
+- a call to any standard library function, except for plain lock-free
+  atomic operations and functions explicitly identified as signal-safe.
+  \[*Note 1*: This implicitly excludes the use of `new` and `delete`
+  expressions that rely on a library-provided memory
+  allocator. — *end note*]
+- an access to an object with thread storage duration;
+- a `dynamic_cast` expression;
+- throwing of an exception;
+- control entering a *try-block* or *function-try-block*;
+- initialization of a variable with static storage duration requiring
+  dynamic initialization ([[basic.start.dynamic]], [[stmt.dcl]]) [^35];
+  or
+- waiting for the completion of the initialization of a variable with
+  static storage duration ([[stmt.dcl]]).
+A signal handler invocation has undefined behavior if it includes an
+evaluation that is not signal-safe.
+The function `signal` is signal-safe if it is invoked with the first
+argument equal to the signal number corresponding to the signal that
+caused the invocation of the handler.
+ISO C 7.14.
 <!-- Link reference definitions -->
+[alg.c.library]: algorithms.md#alg.c.library
 [alloc.errors]: #alloc.errors
 [atomics]: atomics.md#atomics
 [bad.alloc]: #bad.alloc
 [bad.cast]: #bad.cast
 [bad.exception]: #bad.exception
 [bad.typeid]: #bad.typeid
 [basic.align]: basic.md#basic.align
+[basic.def.odr]: basic.md#basic.def.odr
 [basic.fundamental]: basic.md#basic.fundamental
+[basic.life]: basic.md#basic.life
 [basic.start]: basic.md#basic.start
+[basic.start.dynamic]: basic.md#basic.start.dynamic
 [basic.start.term]: basic.md#basic.start.term
 [basic.stc.dynamic]: basic.md#basic.stc.dynamic
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [basic.stc.dynamic.safety]: basic.md#basic.stc.dynamic.safety
+[c.locales]: localization.md#c.locales
+[c.malloc]: utilities.md#c.malloc
+[c.math.abs]: numerics.md#c.math.abs
+[c.math.rand]: numerics.md#c.math.rand
+[c.mb.wcs]: strings.md#c.mb.wcs
+[cfloat.syn]: #cfloat.syn
 [class]: class.md#class
 [class.free]: special.md#class.free
+[climits.syn]: #climits.syn
 [complex]: numerics.md#complex
 [constraints]: library.md#constraints
 [conv.ptr]: conv.md#conv.ptr
+[conv.qual]: conv.md#conv.qual
 [conv.rank]: conv.md#conv.rank
+[csetjmp.syn]: #csetjmp.syn
+[csignal.syn]: #csignal.syn
+[cstdarg.syn]: #cstdarg.syn
+[cstddef.syn]: #cstddef.syn
 [cstdint]: #cstdint
 [cstdint.syn]: #cstdint.syn
+[cstdlib.syn]: #cstdlib.syn
 [dcl.init.list]: dcl.md#dcl.init.list
 [denorm.style]: #denorm.style
 [except.handle]: except.md#except.handle
 [except.nested]: #except.nested
 [except.special]: except.md#except.special
 [except.terminate]: except.md#except.terminate
+[except.uncaught]: except.md#except.uncaught
 [exception]: #exception
+[exception.syn]: #exception.syn
 [exception.terminate]: #exception.terminate
 [expr.add]: expr.md#expr.add
 [expr.delete]: expr.md#expr.delete
 [expr.dynamic.cast]: expr.md#expr.dynamic.cast
 [expr.new]: expr.md#expr.new
+[expr.prim.lambda]: expr.md#expr.prim.lambda
 [expr.sizeof]: expr.md#expr.sizeof
 [expr.typeid]: expr.md#expr.typeid
+[fp.style]: #fp.style
 [get.new.handler]: #get.new.handler
 [get.terminate]: #get.terminate
+[hardware.interference]: #hardware.interference
+[initializer_list.syn]: #initializer_list.syn
 [intro.memory]: intro.md#intro.memory
 [intro.multithread]: intro.md#intro.multithread
 [language.support]: #language.support
+[library.c]: library.md#library.c
 [limits.syn]: #limits.syn
 [locale.codecvt]: localization.md#locale.codecvt
 [memory]: utilities.md#memory
 [multibyte.strings]: library.md#multibyte.strings
 [new.badlength]: #new.badlength
 [new.delete.array]: #new.delete.array
 [new.delete.dataraces]: #new.delete.dataraces
 [new.delete.placement]: #new.delete.placement
 [new.delete.single]: #new.delete.single
 [new.handler]: #new.handler
+[new.syn]: #new.syn
 [nullablepointer.requirements]: library.md#nullablepointer.requirements
 [numeric.limits]: #numeric.limits
 [numeric.limits.members]: #numeric.limits.members
 [numeric.special]: #numeric.special
 [propagation]: #propagation
+[ptr.launder]: #ptr.launder
 [res.on.data.races]: library.md#res.on.data.races
 [round.style]: #round.style
 [set.new.handler]: #set.new.handler
 [set.terminate]: #set.terminate
+[stmt.dcl]: stmt.md#stmt.dcl
 [string.classes]: strings.md#string.classes
 [support.dynamic]: #support.dynamic
 [support.exception]: #support.exception
 [support.general]: #support.general
 [support.initlist]: #support.initlist
 [support.initlist.range]: #support.initlist.range
 [support.limits]: #support.limits
 [support.limits.general]: #support.limits.general
 [support.rtti]: #support.rtti
 [support.runtime]: #support.runtime
+[support.signal]: #support.signal
 [support.start.term]: #support.start.term
 [support.types]: #support.types
+[support.types.byteops]: #support.types.byteops
+[support.types.layout]: #support.types.layout
+[support.types.nullptr]: #support.types.nullptr
 [tab:lang.sup.lib.summary]: #tab:lang.sup.lib.summary
 [temp.dep.constexpr]: temp.md#temp.dep.constexpr
 [temp.dep.expr]: temp.md#temp.dep.expr
+[temp.variadic]: temp.md#temp.variadic
 [terminate]: #terminate
 [terminate.handler]: #terminate.handler
 [type.info]: #type.info
+[typeinfo.syn]: #typeinfo.syn
+[uncaught.exceptions]: #uncaught.exceptions
 [^1]: Possible definitions include `0` and `0L`, but not `(void*)0`.
 [^2]: Note that `offsetof` is required to work as specified even if
     unary `operator&` is overloaded for any of the types involved.
 [^9]: Distinguishes types with bases other than 2 (e.g. BCD).
 [^10]: Equivalent to `FLT_EPSILON`, `DBL_EPSILON`, `LDBL_EPSILON`.
+[^11]: Rounding error is described in LIA-1 Section 5.2.4 and Annex C
+ Rationale Section C.5.2.4 — Rounding and rounding constants.
 [^12]: Equivalent to `FLT_MIN_EXP`, `DBL_MIN_EXP`, `LDBL_MIN_EXP`.
 [^13]: Equivalent to `FLT_MIN_10_EXP`, `DBL_MIN_10_EXP`,
     `LDBL_MIN_10_EXP`.
 [^17]: Required by LIA-1.
 [^18]: Required by LIA-1.
+[^19]: See ISO/IEC/IEEE 60559.
 [^20]: Required by LIA-1.
 [^21]: Required by LIA-1.
 [^22]: Required by LIA-1.
 [^23]: Required by LIA-1.
+[^24]: ISO/IEC/IEEE 60559:2011 is the same as IEEE 754-2008.
 [^25]: Required by LIA-1.
 [^26]: Required by LIA-1.
 [^27]: Required by LIA-1.
+[^28]: Refer to ISO/IEC/IEEE 60559. Required by LIA-1.
 [^29]: Equivalent to `FLT_ROUNDS`. Required by LIA-1.
 [^30]: A function is called for every time it is registered.
 [^31]: Objects with automatic storage duration are all destroyed in a
+    program whose `main` function ([[basic.start.main]]) contains no
+ automatic objects and executes the call to `exit()`. Control can be
+ transferred directly to such a `main` function by throwing an
+ exception that is caught in `main`.
 [^32]: The macros `EXIT_FAILURE` and `EXIT_SUCCESS` are defined in
     `<cstdlib>`.
+[^33]: It is not the direct responsibility of `operator new[]` or
+    `operator delete[]` to note the repetition count or element size of
+    the array. Those operations are performed elsewhere in the array
+    `new` and `delete` expressions. The array `new` expression, may,
+    however, increase the `size` argument to `operator new[]` to obtain
+    space to store supplemental information.
 [^34]: Note that `va_start` is required to work as specified even if
     unary `operator&` is overloaded for the type of `parmN`.
+[^35]: Such initialization might occur because it is the first odr-use (
+ [[basic.def.odr]]) of that variable.

Diff to HTML by rtfpessoa