[support.runtime] (original) (raw)

17 Language support library [support]

17.13 Other runtime support [support.runtime]

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 functiongetenv ([cstdlib.syn]) shall not introduce a data race ([res.on.data.races]) provided that nothing modifies the environment.

[ Note

Calls to the POSIX functionssetenv andputenv modify the environment.

— end note

]

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 setlocalefunction.

17.13.1 Header synopsis [cstdarg.syn]

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 theva_start macro in header <stdarg.h>are different in this document.

The parameterparmNis the rightmost parameter in the variable parameter list of the function definition (the one just before the...).216

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 parameterparmNis 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.

17.13.2 Header synopsis [csetjmp.syn]

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 signaturelongjmp(jmp_buf jbuf, int val)has more restricted behavior in this document.

A setjmp/longjmp call pair has undefined behavior if replacing the setjmp and longjmpby catch and throw would invoke any non-trivial destructors for any objects with automatic storage duration.

A call to setjmp or longjmp has undefined behavior if invoked in a suspension context of a coroutine ([expr.await]).

17.13.3 Header synopsis [csignal.syn]

namespace std { using sig_atomic_t = see below;

extern "C" using signal-handler = void(int);
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>.

17.13.4 Signal handlers [support.signal]

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 [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
: 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])217; 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.