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

Files changed (1) hide show

tmp/tmp7ftnznb5/{from.md → to.md} +153 -62

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

@@ -870,14 +870,20 @@ namespace std {
 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 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 new  (std::size_t size, void* ptr) noexcept;
 void* operator new[](std::size_t size, void* ptr) noexcept;
 void  operator delete  (void* ptr, void*) noexcept;
 void  operator delete[](void* ptr, void*) noexcept;
@@ -948,24 +954,31 @@ is binding on a replacement version of this function.
 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 0 if it fails
 ```
 ``` cpp
 void operator delete(void* ptr) 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 this function
-signature that displaces the default version defined by the C++standard
-library.
 *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
@@ -973,37 +986,75 @@ 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.
 *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;
 ```
 *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 this function
-signature that displaces the default version defined by the C++standard
-library.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
-*Default behavior:* calls `operator delete(ptr)`.
 #### Array forms <a id="new.delete.array">[[new.delete.array]]</a>
 ``` cpp
 void* operator new[](std::size_t size);
@@ -1043,50 +1094,92 @@ requirement is binding on a replacement version of this function.
 normally, returns the result of that call. Otherwise, returns a null
 pointer.
 ``` cpp
 void operator delete[](void* ptr) 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 this function
-signature that displaces the default version defined by the C++standard
-library.
 *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 an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
-*Default behavior:* Calls `operator delete(ptr)`.
 ``` cpp
 void operator delete[](void* ptr, 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 this function
-signature that displaces the default version defined by the C++standard
-library.
 *Requires:* If an implementation has strict pointer
 safety ([[basic.stc.dynamic.safety]]) then `ptr` shall be a
 safely-derived pointer.
-*Default behavior:* 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
@@ -1147,22 +1240,18 @@ 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`, and the C standard library functions `calloc` and
-`malloc` shall behave as though they accessed and modified only the
-storage referenced by the return value. The library versions of
-`operator delete`, user replacement versions of `operator delete`, and
-the C standard library function `free` shall behave as though they
-accessed and modified only the storage referenced by their first
-argument. The C standard library function `realloc` shall behave as
-though it accessed and modified only the storage referenced by its first
-argument and by its return value. 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 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>
@@ -1468,11 +1557,11 @@ namespace std {
   exception_ptr current_exception() noexcept;
   [[noreturn]] void rethrow_exception(exception_ptr p);
   template<class E> exception_ptr make_exception_ptr(E e) noexcept;
- [[noreturn]] template <class T> void throw_with_nested(T&& t);
   template <class E> void rethrow_if_nested(const E& e);
 }
 ```
   [[except.special]].
@@ -1507,12 +1596,10 @@ of `rhs`, then `strcmp(lhs.what(), rhs.what())` shall equal 0.
 exception() noexcept;
 ```
 *Effects:* Constructs an object of class `exception`.
-*Remarks:* Does not throw any exceptions.
 ``` cpp
 exception(const exception& rhs) noexcept;
 exception& operator=(const exception& rhs) noexcept;
 ```
@@ -1525,12 +1612,10 @@ If `*this` and `rhs` both have dynamic type `exception` then
 virtual ~exception();
 ```
 *Effects:* Destroys an object of class `exception`.
-*Remarks:* Does not throw any exceptions.
 ``` cpp
 virtual const char* what() const noexcept;
 ```
 *Returns:* An *implementation-defined* NTBS.
@@ -1631,13 +1716,12 @@ value.
 [[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 evaluating the
-*throw-expression* ([[terminate.handler]]). 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.
@@ -1750,11 +1834,11 @@ namespace std {
     // access functions
     [[noreturn]] void rethrow_nested() const;
     exception_ptr nested_ptr() const noexcept;
   };
- [[noreturn]] template<class T> void throw_with_nested(T&& t);
   template <class E> void rethrow_if_nested(const E& e);
 }
 ```
 The class `nested_exception` is designed for use as a mixin through
@@ -1785,14 +1869,14 @@ exception_ptr nested_ptr() const noexcept;
 *Returns:* The stored exception captured by this `nested_exception`
 object.
 ``` cpp
-[[noreturn]] template <class T> void throw_with_nested(T&& t);
 ```
-Let `U` be `remove_reference<T>::type`.
 *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
@@ -1807,11 +1891,13 @@ template <class E> void rethrow_if_nested(const E& e);
 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 one type.
 ``` cpp
 namespace std {
   template<class E> class initializer_list {
   public:
@@ -1821,20 +1907,20 @@ namespace std {
     typedef size_t size_type;
     typedef const E* iterator;
     typedef const E* const_iterator;
-    initializer_list() noexcept;
-    size_t size() const noexcept;      // number of elements
-    const E* begin() const noexcept;   // first element
-    const E* end() const noexcept;     // one past the last element
   };
   // [support.initlist.range] initializer list range access
-  template<class E> const E* begin(initializer_list<E> il) noexcept;
-  template<class E> 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
@@ -1844,51 +1930,51 @@ 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
-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
-const E* begin() const noexcept;
 ```
 *Returns:* A pointer to the beginning of the array. If `size() == 0` the
 values of `begin()` and `end()` are unspecified but they shall be
 identical.
 ``` cpp
-const E* end() const noexcept;
 ```
 *Returns:* `begin() + size()`
 ``` cpp
-size_t size() const noexcept;
 ```
 *Returns:* The number of elements in the array.
-*Complexity:* constant time.
 ### Initializer list range access <a id="support.initlist.range">[[support.initlist.range]]</a>
 ``` cpp
-template<class E> const E* begin(initializer_list<E> il) noexcept;
 ```
 *Returns:* `il.begin()`.
 ``` cpp
-template<class E> const E* end(initializer_list<E> il) noexcept;
 ```
 *Returns:* `il.end()`.
 ## Other runtime support <a id="support.runtime">[[support.runtime]]</a>
@@ -1907,13 +1993,13 @@ 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 declared with a function, array, or reference type, or with 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`
@@ -1938,21 +2024,26 @@ 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`.
 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 functions defined in Clause
-[[atomics]] that are not member functions. All signal handlers shall
-have C linkage. A POF that could be used as a signal handler in a
-conforming C program does not produce undefined behavior when used as a
-signal handler in a C++program. The behavior of any other function 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

 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;
 void  operator delete[](void* ptr, void*) noexcept;
 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
 *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);
 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
 #### 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>
   exception_ptr current_exception() noexcept;
   [[noreturn]] void rethrow_exception(exception_ptr p);
   template<class E> exception_ptr make_exception_ptr(E e) noexcept;
+  template <class T> [[noreturn]] void throw_with_nested(T&& t);
   template <class E> void rethrow_if_nested(const E& e);
 }
 ```
   [[except.special]].
 exception() noexcept;
 ```
 *Effects:* Constructs an object of class `exception`.
 ``` cpp
 exception(const exception& rhs) noexcept;
 exception& operator=(const exception& rhs) noexcept;
 ```
 virtual ~exception();
 ```
 *Effects:* Destroys an object of class `exception`.
 ``` cpp
 virtual const char* what() const noexcept;
 ```
 *Returns:* An *implementation-defined* NTBS.
 [[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.
     // access functions
     [[noreturn]] void rethrow_nested() const;
     exception_ptr nested_ptr() const noexcept;
   };
+  template<class T> [[noreturn]] void throw_with_nested(T&& t);
   template <class E> void rethrow_if_nested(const E& e);
 }
 ```
 The class `nested_exception` is designed for use as a mixin through
 *Returns:* The stored exception captured by this `nested_exception`
 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 `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 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
 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;
 ```
 *Returns:* A pointer to the beginning of the array. If `size() == 0` the
 values of `begin()` and `end()` are unspecified but they shall be
 identical.
 ``` cpp
+constexpr const E* end() const noexcept;
 ```
 *Returns:* `begin() + size()`
 ``` cpp
+constexpr size_t size() const noexcept;
 ```
 *Returns:* The number of elements in the array.
+*Complexity:* Constant time.
 ### Initializer list range access <a id="support.initlist.range">[[support.initlist.range]]</a>
 ``` cpp
+template<class E> constexpr const E* begin(initializer_list<E> il) noexcept;
 ```
 *Returns:* `il.begin()`.
 ``` cpp
+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>
 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`
 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

Diff to HTML by rtfpessoa