[except] - C++23 → Trunk

Files changed (1) hide show

tmp/tmpvjdnrrqp/{from.md → to.md} +133 -101

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

@@ -183,15 +183,15 @@ When an exception is thrown, control is transferred to the nearest
 handler with a matching type [[except.handle]]; “nearest” means the
 handler for which the *compound-statement* or *ctor-initializer*
 following the `try` keyword was most recently entered by the thread of
 control and not yet exited.
-Throwing an exception copy-initializes [[dcl.init]], [[class.copy.ctor]]
-a temporary object, called the *exception object*. If the type of the
-exception object would be an incomplete type, an abstract class type
-[[class.abstract]], or a pointer to an incomplete type other than
-cv `void` the program is ill-formed.
 The memory for the exception object is allocated in an unspecified way,
 except as noted in  [[basic.stc.dynamic.allocation]]. If a handler exits
 by rethrowing, control is passed to another handler for the same
 exception object. The points of potential destruction for the exception
@@ -216,27 +216,40 @@ object; any such deallocation is done in an unspecified way.
 [*Note 3*: A thrown exception does not propagate to other threads
 unless caught, stored, and rethrown using appropriate library functions;
 see  [[propagation]] and  [[futures]]. — *end note*]
-When the thrown object is a class object, the constructor selected for
-the copy-initialization as well as the constructor selected for a
-copy-initialization considering the thrown object as an lvalue shall be
-non-deleted and accessible, even if the copy/move operation is elided
-[[class.copy.elision]]. The destructor is potentially invoked
-[[class.dtor]].
 An exception is considered caught when a handler for that exception
 becomes active [[except.handle]].
-[*Note 4*: An exception can have active handlers and still be
 considered uncaught if it is rethrown. — *end note*]
 If the exception handling mechanism handling an uncaught exception
-[[except.uncaught]] directly invokes a function that exits via an
-exception, the function `std::terminate` is invoked
-[[except.terminate]].
 [*Example 2*:
 ``` cpp
 struct C {
@@ -256,14 +269,14 @@ int main() {
 }
 ```
 — *end example*]
-[*Note 5*: If a destructor directly invoked by stack unwinding exits
 via an exception, `std::terminate` is invoked. — *end note*]
-## Constructors and destructors <a id="except.ctor">[[except.ctor]]</a>
 As control passes from the point where an exception is thrown to a
 handler, objects are destroyed by a process, specified in this
 subclause, called *stack unwinding*.
@@ -309,12 +322,12 @@ initialization and whose initialization has completed [[dcl.init]].
 [*Note 1*: If such an object has a reference member that extends the
 lifetime of a temporary object, this ends the lifetime of the reference
 member, so the lifetime of the temporary object is effectively not
 extended. — *end note*]
-A subobject is *known to be initialized* if its initialization is
-specified
 - in [[class.base.init]] for initialization by constructor,
 - in [[class.copy.ctor]] for initialization by defaulted copy/move
   constructor,
 - in [[class.inhctor.init]] for initialization by inherited constructor,
@@ -418,36 +431,60 @@ The handlers for a try block are tried in order of appearance.
 [*Note 2*: This makes it possible to write handlers that can never be
 executed, for example by placing a handler for a final derived class
 after a handler for a corresponding unambiguous public base
 class. — *end note*]
-A `...` in a handler’s *exception-declaration* functions similarly to
-`...` in a function parameter declaration; it specifies a match for any
 exception. If present, a `...` handler shall be the last handler for its
 try block.
 If no match is found among the handlers for a try block, the search for
 a matching handler continues in a dynamically surrounding try block of
 the same thread.
 A handler is considered *active* when initialization is complete for the
 parameter (if any) of the catch clause.
-[*Note 3*: The stack will have been unwound at that
 point. — *end note*]
 Also, an implicit handler is considered active when the function
 `std::terminate` is entered due to a throw. A handler is no longer
 considered active when the catch clause exits.
 The exception with the most recently activated handler that is still
 active is called the *currently handled exception*.
-If no matching handler is found, the function `std::terminate` is
-invoked; whether or not the stack is unwound before this invocation of
-`std::terminate` is *implementation-defined* [[except.terminate]].
 Referring to any non-static member or base class of an object in the
 handler for a *function-try-block* of a constructor or destructor for
 that object results in undefined behavior.
 Exceptions thrown in destructors of objects with static storage duration
@@ -479,14 +516,14 @@ follows:
 The lifetime of the variable ends when the handler exits, after the
 destruction of any objects with automatic storage duration initialized
 within the handler.
-When the handler declares an object, any changes to that object will not
-affect the exception object. When the handler declares a reference to an
-object, any changes to the referenced object are changes to the
-exception object and will have effect should that object be rethrown.
 ## Exception specifications <a id="except.spec">[[except.spec]]</a>
 The predicate indicating whether a function cannot exit via an exception
 is called the *exception specification* of the function. If the
@@ -559,46 +596,19 @@ The declaration of `D::f` is ill-formed because it has a
 potentially-throwing exception specification, whereas `B::f` has a
 non-throwing exception specification.
 — *end example*]
-Whenever an exception is thrown and the search for a handler
-[[except.handle]] encounters the outermost block of a function with a
-non-throwing exception specification, the function `std::terminate` is
-invoked [[except.terminate]].
-[*Note 1*: An implementation is not permitted to reject an expression
-merely because, when executed, it throws or might throw an exception
-from a function with a non-throwing exception
-specification. — *end note*]
-[*Example 3*:
-``` cpp
-extern void f();                // potentially-throwing
-void g() noexcept {
-  f();                          // valid, even if f throws
-  throw 42;                     // valid, effectively a call to std::terminate
-}
-```
-The call to `f` is well-formed despite the possibility for it to throw
-an exception.
-— *end example*]
 An expression E is *potentially-throwing* if
 - E is a function call [[expr.call]] whose *postfix-expression* has a
   function type, or a pointer-to-function type, with a
   potentially-throwing exception specification, or
 - E implicitly invokes a function (such as an overloaded operator, an
   allocation function in a *new-expression*, a constructor for a
-  function argument, or a destructor if E is a full-expression
- [[intro.execution]]) that has a potentially-throwing exception
-  specification, or
 - E is a *throw-expression* [[expr.throw]], or
 - E is a `dynamic_cast` expression that casts to a reference type and
   requires a runtime check [[expr.dynamic.cast]], or
 - E is a `typeid` expression applied to a (possibly parenthesized)
   built-in unary `*` operator applied to a pointer to a polymorphic
@@ -616,11 +626,11 @@ only if any of the following constructs is potentially-throwing:
   potentially constructed subobject, or
 - a subexpression of such an initialization, such as a default argument
   expression, or,
 - for a default constructor, a default member initializer.
-[*Note 2*: Even though destructors for fully-constructed subobjects are
 invoked when an exception is thrown during the execution of a
 constructor [[except.ctor]], their exception specifications do not
 contribute to the exception specification of the constructor, because an
 exception thrown from such a destructor would call the function
 `std::terminate` rather than escape the constructor
@@ -646,11 +656,11 @@ specification.
 The exception specification for a comparison operator function
 [[over.binary]] without a *noexcept-specifier* that is defaulted on its
 first declaration is potentially-throwing if and only if any expression
 in the implicit definition is potentially-throwing.
-[*Example 4*:
 ``` cpp
 struct A {
   A(int = (A(5), 0)) noexcept;
   A(const A&) noexcept;
@@ -682,43 +692,45 @@ base class function has a non-throwing exception specification.
 An exception specification is considered to be *needed* when:
 - in an expression, the function is selected by overload resolution
   [[over.match]], [[over.over]];
-- the function is odr-used [[term.odr.use]] or, if it appears in an
-  unevaluated operand, would be odr-used if the expression were
-  potentially-evaluated;
 - the exception specification is compared to that of another declaration
   (e.g., an explicit specialization or an overriding virtual function);
 - the function is defined; or
 - the exception specification is needed for a defaulted function that
-  calls the function. \[*Note 3*: A defaulted declaration does not
   require the exception specification of a base member function to be
   evaluated until the implicit exception specification of the derived
   function is needed, but an explicit *noexcept-specifier* needs the
   implicit exception specification to compare against. — *end note*]
 The exception specification of a defaulted function is evaluated as
 described above only when needed; similarly, the *noexcept-specifier* of
-a specialization of a function template or member function of a class
-template is instantiated only when needed.
 ## Special functions <a id="except.special">[[except.special]]</a>
 ### General <a id="except.special.general">[[except.special.general]]</a>
 The function `std::terminate` [[except.terminate]] is used by the
 exception handling mechanism for coping with errors related to the
 exception handling mechanism itself. The function
-`std::current_exception()` [[propagation]] and the class
 `std::nested_exception` [[except.nested]] can be used by a program to
 capture the currently handled exception.
 ### The `std::terminate` function <a id="except.terminate">[[except.terminate]]</a>
-In some situations exception handling is abandoned for less subtle error
-handling techniques.
 [*Note 1*:
 These situations are:
@@ -726,13 +738,16 @@ These situations are:
   initialization of the exception object but before activation of a
   handler for the exception [[except.throw]], calls a function that
   exits via an exception, or
 - when the exception handling mechanism cannot find a handler for a
   thrown exception [[except.handle]], or
-- when the search for a handler [[except.handle]] encounters the
- outermost block of a function with a non-throwing exception
- specification [[except.spec]], or
 - when the destruction of an object during stack unwinding
   [[except.ctor]] terminates by throwing an exception, or
 - when initialization of a non-block variable with static or thread
   storage duration [[basic.start.dynamic]] exits via an exception, or
 - when destruction of an object with static or thread storage duration
@@ -755,55 +770,64 @@ These situations are:
   object of type `std::thread` that refers to a joinable thread
   [[thread.thread.destr]], [[thread.thread.assign]], or
 - when a call to a `wait()`, `wait_until()`, or `wait_for()` function on
   a condition variable
   [[thread.condition.condvar]], [[thread.condition.condvarany]] fails to
-  meet a postcondition.
 — *end note*]
-In such cases, the function `std::terminate` is invoked
-[[exception.terminate]]. In the situation where no matching handler is
-found, it is *implementation-defined* whether or not the stack is
-unwound before `std::terminate` is invoked. In the situation where the
-search for a handler [[except.handle]] encounters the outermost block of
-a function with a non-throwing exception specification [[except.spec]],
-it is *implementation-defined* whether the stack is unwound, unwound
 partially, or not unwound at all before the function `std::terminate` is
 invoked. In all other situations, the stack shall not be unwound before
 the function `std::terminate` is invoked. An implementation is not
 permitted to finish stack unwinding prematurely based on a determination
 that the unwind process will eventually cause an invocation of the
 function `std::terminate`.
-### The `std::uncaught_exceptions` function <a id="except.uncaught">[[except.uncaught]]</a>
-An exception is considered uncaught after completing the initialization
-of the exception object [[except.throw]] until completing the activation
-of a handler for the exception [[except.handle]].
-[*Note 1*: As a consequence, an exception is considered uncaught during
-any stack unwinding resulting from it being thrown. — *end note*]
-If an exception is rethrown [[expr.throw]], [[propagation]], it is
-considered uncaught from the point of rethrow until the rethrown
-exception is caught. The function `std::uncaught_exceptions`
-[[uncaught.exceptions]] returns the number of uncaught exceptions in the
-current thread.
 <!-- Link reference definitions -->
 [algorithms.parallel.defns]: algorithms.md#algorithms.parallel.defns
 [algorithms.parallel.exceptions]: algorithms.md#algorithms.parallel.exceptions
 [basic.start.dynamic]: basic.md#basic.start.dynamic
 [basic.start.main]: basic.md#basic.start.main
 [basic.start.term]: basic.md#basic.start.term
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
 [class.abstract]: class.md#class.abstract
 [class.base.init]: class.md#class.base.init
 [class.copy.ctor]: class.md#class.copy.ctor
-[class.copy.elision]: class.md#class.copy.elision
 [class.dtor]: class.md#class.dtor
 [class.inhctor.init]: class.md#class.inhctor.init
 [conv.fctptr]: expr.md#conv.fctptr
 [conv.ptr]: expr.md#conv.ptr
 [conv.qual]: expr.md#conv.qual
@@ -819,15 +843,19 @@ current thread.
 [except.spec]: #except.spec
 [except.special]: #except.special
 [except.special.general]: #except.special.general
 [except.terminate]: #except.terminate
 [except.throw]: #except.throw
-[except.uncaught]: #except.uncaught
 [exception.terminate]: support.md#exception.terminate
-[execpol.par]: utilities.md#execpol.par
-[execpol.parunseq]: utilities.md#execpol.parunseq
-[execpol.seq]: utilities.md#execpol.seq
 [expr.call]: expr.md#expr.call
 [expr.const]: expr.md#expr.const
 [expr.dynamic.cast]: expr.md#expr.dynamic.cast
 [expr.new]: expr.md#expr.new
 [expr.prim.lambda.capture]: expr.md#expr.prim.lambda.capture
@@ -842,10 +870,14 @@ current thread.
 [propagation]: support.md#propagation
 [stmt.jump]: stmt.md#stmt.jump
 [stmt.label]: stmt.md#stmt.label
 [stmt.pre]: stmt.md#stmt.pre
 [stmt.return]: stmt.md#stmt.return
 [structure.specifications]: library.md#structure.specifications
 [support.start.term]: support.md#support.start.term
 [temp.explicit]: temp.md#temp.explicit
 [term.odr.use]: basic.md#term.odr.use
 [thread.condition.condvar]: thread.md#thread.condition.condvar

 handler with a matching type [[except.handle]]; “nearest” means the
 handler for which the *compound-statement* or *ctor-initializer*
 following the `try` keyword was most recently entered by the thread of
 control and not yet exited.
+Throwing an exception initializes an object with dynamic storage
+duration, called the *exception object*. If the type of the exception
+object would be an incomplete type [[basic.types.general]], an abstract
+class type [[class.abstract]], or a pointer to an incomplete type other
+than cv `void` [[basic.compound]], the program is ill-formed.
 The memory for the exception object is allocated in an unspecified way,
 except as noted in  [[basic.stc.dynamic.allocation]]. If a handler exits
 by rethrowing, control is passed to another handler for the same
 exception object. The points of potential destruction for the exception
 [*Note 3*: A thrown exception does not propagate to other threads
 unless caught, stored, and rethrown using appropriate library functions;
 see  [[propagation]] and  [[futures]]. — *end note*]
+Let `T` denote the type of the exception object. Copy-initialization of
+an object of type `T` from an lvalue of type `const T` in a context
+unrelated to `T` shall be well-formed. If `T` is a class type, the
+selected constructor is odr-used [[basic.def.odr]] and the destructor of
+`T` is potentially invoked [[class.dtor]].
+An exception is considered *uncaught* after completing the
+initialization of the exception object until completing the activation
+of a handler for the exception [[except.handle]].
+[*Note 4*: As a consequence, an exception is considered uncaught during
+any stack unwinding resulting from it being thrown. — *end note*]
+If an exception is rethrown [[expr.throw]], [[propagation]], it is
+considered uncaught from the point of rethrow until the rethrown
+exception is caught.
+[*Note 5*: The function `std::uncaught_exceptions`
+[[uncaught.exceptions]] returns the number of uncaught exceptions in the
+current thread. — *end note*]
 An exception is considered caught when a handler for that exception
 becomes active [[except.handle]].
+[*Note 6*: An exception can have active handlers and still be
 considered uncaught if it is rethrown. — *end note*]
 If the exception handling mechanism handling an uncaught exception
+directly invokes a function that exits via an exception, the function
+`std::terminate` is invoked [[except.terminate]].
 [*Example 2*:
 ``` cpp
 struct C {
 }
 ```
 — *end example*]
+[*Note 7*: If a destructor directly invoked by stack unwinding exits
 via an exception, `std::terminate` is invoked. — *end note*]
+## Stack unwinding <a id="except.ctor">[[except.ctor]]</a>
 As control passes from the point where an exception is thrown to a
 handler, objects are destroyed by a process, specified in this
 subclause, called *stack unwinding*.
 [*Note 1*: If such an object has a reference member that extends the
 lifetime of a temporary object, this ends the lifetime of the reference
 member, so the lifetime of the temporary object is effectively not
 extended. — *end note*]
+A subobject is *known to be initialized* if it is not an anonymous union
+member and its initialization is specified
 - in [[class.base.init]] for initialization by constructor,
 - in [[class.copy.ctor]] for initialization by defaulted copy/move
   constructor,
 - in [[class.inhctor.init]] for initialization by inherited constructor,
 [*Note 2*: This makes it possible to write handlers that can never be
 executed, for example by placing a handler for a final derived class
 after a handler for a corresponding unambiguous public base
 class. — *end note*]
+A `...` in a handler’s *exception-declaration* specifies a match for any
 exception. If present, a `...` handler shall be the last handler for its
 try block.
 If no match is found among the handlers for a try block, the search for
 a matching handler continues in a dynamically surrounding try block of
 the same thread.
+If the search for a handler exits the function body of a function with a
+non-throwing exception specification, the function `std::terminate`
+[[except.terminate]] is invoked.
+[*Note 3*: An implementation is not permitted to reject an expression
+merely because, when executed, it throws or might throw an exception
+from a function with a non-throwing exception
+specification. — *end note*]
+[*Example 2*:
+``` cpp
+extern void f();                // potentially-throwing
+void g() noexcept {
+  f();                          // valid, even if f throws
+  throw 42;                     // valid, effectively a call to std::terminate
+}
+```
+The call to `f` is well-formed despite the possibility for it to throw
+an exception.
+— *end example*]
+If no matching handler is found, the function `std::terminate` is
+invoked; whether or not the stack is unwound before this invocation of
+`std::terminate` is *implementation-defined* [[except.terminate]].
 A handler is considered *active* when initialization is complete for the
 parameter (if any) of the catch clause.
+[*Note 4*: The stack will have been unwound at that
 point. — *end note*]
 Also, an implicit handler is considered active when the function
 `std::terminate` is entered due to a throw. A handler is no longer
 considered active when the catch clause exits.
 The exception with the most recently activated handler that is still
 active is called the *currently handled exception*.
 Referring to any non-static member or base class of an object in the
 handler for a *function-try-block* of a constructor or destructor for
 that object results in undefined behavior.
 Exceptions thrown in destructors of objects with static storage duration
 The lifetime of the variable ends when the handler exits, after the
 destruction of any objects with automatic storage duration initialized
 within the handler.
+[*Note 5*: When the handler declares an object, any changes to that
+object will not affect the exception object. When the handler declares a
+reference to an object, any changes to the referenced object are changes
+to the exception object. — *end note*]
 ## Exception specifications <a id="except.spec">[[except.spec]]</a>
 The predicate indicating whether a function cannot exit via an exception
 is called the *exception specification* of the function. If the
 potentially-throwing exception specification, whereas `B::f` has a
 non-throwing exception specification.
 — *end example*]
 An expression E is *potentially-throwing* if
 - E is a function call [[expr.call]] whose *postfix-expression* has a
   function type, or a pointer-to-function type, with a
   potentially-throwing exception specification, or
 - E implicitly invokes a function (such as an overloaded operator, an
   allocation function in a *new-expression*, a constructor for a
+  function argument, or a destructor) that has a potentially-throwing
+ exception specification, or
 - E is a *throw-expression* [[expr.throw]], or
 - E is a `dynamic_cast` expression that casts to a reference type and
   requires a runtime check [[expr.dynamic.cast]], or
 - E is a `typeid` expression applied to a (possibly parenthesized)
   built-in unary `*` operator applied to a pointer to a polymorphic
   potentially constructed subobject, or
 - a subexpression of such an initialization, such as a default argument
   expression, or,
 - for a default constructor, a default member initializer.
+[*Note 1*: Even though destructors for fully-constructed subobjects are
 invoked when an exception is thrown during the execution of a
 constructor [[except.ctor]], their exception specifications do not
 contribute to the exception specification of the constructor, because an
 exception thrown from such a destructor would call the function
 `std::terminate` rather than escape the constructor
 The exception specification for a comparison operator function
 [[over.binary]] without a *noexcept-specifier* that is defaulted on its
 first declaration is potentially-throwing if and only if any expression
 in the implicit definition is potentially-throwing.
+[*Example 3*:
 ``` cpp
 struct A {
   A(int = (A(5), 0)) noexcept;
   A(const A&) noexcept;
 An exception specification is considered to be *needed* when:
 - in an expression, the function is selected by overload resolution
   [[over.match]], [[over.over]];
+- the function is odr-used [[term.odr.use]];
 - the exception specification is compared to that of another declaration
   (e.g., an explicit specialization or an overriding virtual function);
 - the function is defined; or
 - the exception specification is needed for a defaulted function that
+  calls the function. \[*Note 2*: A defaulted declaration does not
   require the exception specification of a base member function to be
   evaluated until the implicit exception specification of the derived
   function is needed, but an explicit *noexcept-specifier* needs the
   implicit exception specification to compare against. — *end note*]
 The exception specification of a defaulted function is evaluated as
 described above only when needed; similarly, the *noexcept-specifier* of
+a specialization of a templated function is instantiated only when
+needed.
 ## Special functions <a id="except.special">[[except.special]]</a>
 ### General <a id="except.special.general">[[except.special.general]]</a>
 The function `std::terminate` [[except.terminate]] is used by the
 exception handling mechanism for coping with errors related to the
 exception handling mechanism itself. The function
+`std::uncaught_exceptions` [[uncaught.exceptions]] reports how many
+exceptions are uncaught in the current thread. The function
+`std::current_exception` [[propagation]] and the class
 `std::nested_exception` [[except.nested]] can be used by a program to
 capture the currently handled exception.
 ### The `std::terminate` function <a id="except.terminate">[[except.terminate]]</a>
+Some errors in a program cannot be recovered from, such as when an
+exception is not handled or a `std::thread` object is destroyed while
+its thread function is still executing. In such cases, the function
+`std::terminate` [[exception.terminate]] is invoked.
 [*Note 1*:
 These situations are:
   initialization of the exception object but before activation of a
   handler for the exception [[except.throw]], calls a function that
   exits via an exception, or
 - when the exception handling mechanism cannot find a handler for a
   thrown exception [[except.handle]], or
+- when the search for a handler [[except.handle]] exits the function
+ body of a function with a non-throwing exception specification
+  [[except.spec]], including when a contract-violation handler invoked
+  from an evaluation of a function contract assertion
+  [[basic.contract.eval]] associated with the function exits via an
+  exception, or
 - when the destruction of an object during stack unwinding
   [[except.ctor]] terminates by throwing an exception, or
 - when initialization of a non-block variable with static or thread
   storage duration [[basic.start.dynamic]] exits via an exception, or
 - when destruction of an object with static or thread storage duration
   object of type `std::thread` that refers to a joinable thread
   [[thread.thread.destr]], [[thread.thread.assign]], or
 - when a call to a `wait()`, `wait_until()`, or `wait_for()` function on
   a condition variable
   [[thread.condition.condvar]], [[thread.condition.condvarany]] fails to
+  meet a postcondition, or
+- when a callback invocation exits via an exception when requesting stop
+  on a `std::stop_source` or a `std::inplace_stop_source`
+  [[stopsource.mem]], [[stopsource.inplace.mem]], or in the constructor
+  of `std::stop_callback` or `std::inplace_stop_callback`
+  [[stopcallback.cons]], [[stopcallback.inplace.cons]] when a callback
+  invocation exits via an exception, or
+- when a `run_loop` object is destroyed that is still in the `running`
+  state [[exec.run.loop]], or
+- when `unhandled_stopped` is called on a `with_awaitable_senders<T>`
+  object [[exec.with.awaitable.senders]] whose continuation is not a
+  handle to a coroutine whose promise type has an `unhandled_stopped`
+  member function, or
+- when an object `scope` of type `std::execution::simple_counting_scope`
+  or `std::execution::counting_scope` is destroyed and `scope.state` is
+  not equal to *`joined`*, *`unused`*, or *`unused-and-closed`*
+  [[exec.simple.counting.ctor]], or
+- when `std::execution::get_parallel_scheduler` is called and
+  `std::execution::system_context_replaceability::query_parallel_scheduler_backend()`
+  returns a null pointer value [[exec.par.scheduler]], or
+- when an exception is thrown from a coroutine `std::execution::task`
+  [[exec.task]] which doesn’t support a
+  `std::execution::set_error_t(std::exception_ptr)` completion.
 — *end note*]
+In the situation where no matching handler is found, it is
+*implementation-defined* whether or not the stack is unwound before
+`std::terminate` is invoked. In the situation where the search for a
+handler [[except.handle]] exits the function body of a function with a
+non-throwing exception specification [[except.spec]], it is
+*implementation-defined* whether the stack is unwound, unwound
 partially, or not unwound at all before the function `std::terminate` is
 invoked. In all other situations, the stack shall not be unwound before
 the function `std::terminate` is invoked. An implementation is not
 permitted to finish stack unwinding prematurely based on a determination
 that the unwind process will eventually cause an invocation of the
 function `std::terminate`.
 <!-- Link reference definitions -->
 [algorithms.parallel.defns]: algorithms.md#algorithms.parallel.defns
 [algorithms.parallel.exceptions]: algorithms.md#algorithms.parallel.exceptions
+[basic.compound]: basic.md#basic.compound
+[basic.contract.eval]: basic.md#basic.contract.eval
+[basic.def.odr]: basic.md#basic.def.odr
 [basic.start.dynamic]: basic.md#basic.start.dynamic
 [basic.start.main]: basic.md#basic.start.main
 [basic.start.term]: basic.md#basic.start.term
 [basic.stc.dynamic.allocation]: basic.md#basic.stc.dynamic.allocation
 [basic.stc.dynamic.deallocation]: basic.md#basic.stc.dynamic.deallocation
+[basic.types.general]: basic.md#basic.types.general
 [class.abstract]: class.md#class.abstract
 [class.base.init]: class.md#class.base.init
 [class.copy.ctor]: class.md#class.copy.ctor
 [class.dtor]: class.md#class.dtor
 [class.inhctor.init]: class.md#class.inhctor.init
 [conv.fctptr]: expr.md#conv.fctptr
 [conv.ptr]: expr.md#conv.ptr
 [conv.qual]: expr.md#conv.qual
 [except.spec]: #except.spec
 [except.special]: #except.special
 [except.special.general]: #except.special.general
 [except.terminate]: #except.terminate
 [except.throw]: #except.throw
 [exception.terminate]: support.md#exception.terminate
+[exec.par.scheduler]: exec.md#exec.par.scheduler
+[exec.run.loop]: exec.md#exec.run.loop
+[exec.simple.counting.ctor]: exec.md#exec.simple.counting.ctor
+[exec.task]: exec.md#exec.task
+[exec.with.awaitable.senders]: exec.md#exec.with.awaitable.senders
+[execpol.par]: algorithms.md#execpol.par
+[execpol.parunseq]: algorithms.md#execpol.parunseq
+[execpol.seq]: algorithms.md#execpol.seq
 [expr.call]: expr.md#expr.call
 [expr.const]: expr.md#expr.const
 [expr.dynamic.cast]: expr.md#expr.dynamic.cast
 [expr.new]: expr.md#expr.new
 [expr.prim.lambda.capture]: expr.md#expr.prim.lambda.capture
 [propagation]: support.md#propagation
 [stmt.jump]: stmt.md#stmt.jump
 [stmt.label]: stmt.md#stmt.label
 [stmt.pre]: stmt.md#stmt.pre
 [stmt.return]: stmt.md#stmt.return
+[stopcallback.cons]: thread.md#stopcallback.cons
+[stopcallback.inplace.cons]: thread.md#stopcallback.inplace.cons
+[stopsource.inplace.mem]: thread.md#stopsource.inplace.mem
+[stopsource.mem]: thread.md#stopsource.mem
 [structure.specifications]: library.md#structure.specifications
 [support.start.term]: support.md#support.start.term
 [temp.explicit]: temp.md#temp.explicit
 [term.odr.use]: basic.md#term.odr.use
 [thread.condition.condvar]: thread.md#thread.condition.condvar

Diff to HTML by rtfpessoa