thrd_signal_handle.h

Go to the documentation of this file.

/* Proposed WG14 improved signals support
(C) 2025 - 2026 Niall Douglas <http://www.nedproductions.biz/>
File Created: Feb 2025
 
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License in the accompanying file
Licence.txt or at
 
http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
 
#ifndef WG14_SIGNALS_THREAD_LOCAL_SIGNAL_HANDLE_H
#define WG14_SIGNALS_THREAD_LOCAL_SIGNAL_HANDLE_H
 
#include "config.h"
 
#include <signal.h>
#include <stdbool.h>
#include <stdint.h>
 
#if __GLIBC__
// glibc defines a userspace siginfo_t as an unnamed struct. No
// choice here but to drag in the relevant header.
#include <bits/types/siginfo_t.h>
#endif
 
 
#ifdef __cplusplus
extern "C"
{
#endif
 
#ifdef _WIN32
  // MSVC may be missing necessary signal support
  typedef uint32_t sigset_t;
  static inline void sigemptyset(sigset_t *ss)
  {
    *ss = 0;
  }
  static inline void sigfillset(sigset_t *ss)
  {
    *ss = UINT32_MAX;
  }
  static inline void sigaddset(sigset_t *ss, const int signo)
  {
    *ss |= (1u << (signo - 1));
  }
  static inline void sigdelset(sigset_t *ss, const int signo)
  {
    *ss &= ~(1u << (signo - 1));
  }
  static inline bool sigismember(const sigset_t *ss, const int signo)
  {
    return (*ss & (1u << (signo - 1))) != 0;
  }
 
// MSVC appears to follow the Linux signal numbering
#ifndef SIGBUS
#define SIGBUS (7)
#endif
#ifndef SIGKILL
#define SIGKILL (9)
#endif
#ifndef SIGSTOP
#define SIGSTOP (19)
#endif
#endif
 
#ifndef WG14_SIGNALS_DISABLE_SIGFENCE_MACRO
  WG14_SIGNALS_EXTERN void WG14_SIGNALS_PREFIX(sigfence_force_escaped)(int,
                                                                       ...);
#define SIGFENCE_GLUE(x, y) x y
#define SIGFENCE_RETURN_ARG_COUNT(_1_, _2_, _3_, _4_, _5_, _6_, _7_, _8_,      \
                                  count, ...)                                  \
  count
#define SIGFENCE_EXPAND_ARGS(args) SIGFENCE_RETURN_ARG_COUNT args
#define SIGFENCE_COUNT_ARGS_MAX8(...)                                          \
  SIGFENCE_EXPAND_ARGS((__VA_ARGS__ __VA_OPT__(, ) 8, 7, 6, 5, 4, 3, 2, 1, 0))
#define SIGFENCE_OVERLOAD_MACRO2(name, count) name##count
#define SIGFENCE_OVERLOAD_MACRO1(name, count)                                  \
  SIGFENCE_OVERLOAD_MACRO2(name, count)
#define SIGFENCE_OVERLOAD_MACRO(name, count)                                   \
  SIGFENCE_OVERLOAD_MACRO1(name, count)
#define SIGFENCE_CALL_OVERLOAD(name, ...)                                      \
  SIGFENCE_GLUE(                                                               \
  SIGFENCE_OVERLOAD_MACRO(name, SIGFENCE_COUNT_ARGS_MAX8(__VA_ARGS__)),        \
  (__VA_ARGS__))
 
#if defined(__GNUC__) || defined(__clang__)
// On compilers with extended inline asm, we can tell the compiler that a
// specific list of variables must be specifically written out and reloaded
// around the fence. You may find https://godbolt.org/z/chh8ee6Mj useful to
// review.
#define SIGFENCE_IMPL_0() __asm__ volatile(";" : : : "memory")
#define SIGFENCE_IMPL_1(a) __asm__ volatile(";" : "+m"(a) : : "memory")
#define SIGFENCE_IMPL_2(a, b)                                                  \
  __asm__ volatile(";" : "+m"(a), "+m"(b) : : "memory")
#define SIGFENCE_IMPL_3(a, b, c)                                               \
  __asm__ volatile(";" : "+m"(a), "+m"(b), "+m"(c) : : "memory")
#define SIGFENCE_IMPL_4(a, b, c, d)                                            \
  __asm__ volatile(";" : "+m"(a), "+m"(b), "+m"(c), "+m"(d) : : "memory")
#define SIGFENCE_IMPL_5(a, b, c, d, e)                                         \
  __asm__ volatile(";"                                                         \
                   : "+m"(a), "+m"(b), "+m"(c), "+m"(d), "+m"(e)               \
                   :                                                           \
                   : "memory")
#define SIGFENCE_IMPL_6(a, b, c, d, e, f)                                      \
  __asm__ volatile(";"                                                         \
                   : "+m"(a), "+m"(b), "+m"(c), "+m"(d), "+m"(e), "+m"(f)      \
                   :                                                           \
                   : "memory")
#define SIGFENCE_IMPL_7(a, b, c, d, e, f, g)                                   \
  __asm__ volatile(";"                                                         \
                   : "+m"(a), "+m"(b), "+m"(c), "+m"(d), "+m"(e), "+m"(f),     \
                     "+m"(g)                                                   \
                   :                                                           \
                   : "memory")
#define SIGFENCE_IMPL_8(a, b, c, d, e, f, g, h)                                \
  __asm__ volatile(";"                                                         \
                   : "+m"(a), "+m"(b), "+m"(c), "+m"(d), "+m"(e), "+m"(f),     \
                     "+m"(g), "+m"(h)                                          \
                   :                                                           \
                   : "memory")
#else
  // This is a much less efficient way of forcing the compiler to treat
  // variables as having escaped, but it's portable.
#define SIGFENCE_IMPL_0() WG14_SIGNALS_PREFIX(sigfence_force_escaped)(0)
#define SIGFENCE_IMPL_1(a) WG14_SIGNALS_PREFIX(sigfence_force_escaped)(0, &(a))
#define SIGFENCE_IMPL_2(a, b)                                                  \
  WG14_SIGNALS_PREFIX(sigfence_force_escaped)(0, &(a), &(b))
#define SIGFENCE_IMPL_3(a, b, c)                                               \
  WG14_SIGNALS_PREFIX(sigfence_force_escaped)(0, &(a), &(b), &(c))
#define SIGFENCE_IMPL_4(a, b, c, d)                                            \
  WG14_SIGNALS_PREFIX(sigfence_force_escaped)(0, &(a), &(b), &(c), &(d))
#define SIGFENCE_IMPL_5(a, b, c, d, e)                                         \
  WG14_SIGNALS_PREFIX(sigfence_force_escaped)(0, &(a), &(b), &(c), &(d), &(e))
#define SIGFENCE_IMPL_6(a, b, c, d, e, f)                                      \
  WG14_SIGNALS_PREFIX(sigfence_force_escaped)(0, &(a), &(b), &(c), &(d), &(e), \
                                              &(f))
#define SIGFENCE_IMPL_7(a, b, c, d, e, f, g)                                   \
  WG14_SIGNALS_PREFIX(sigfence_force_escaped)(0, &(a), &(b), &(c), &(d), &(e), \
                                              &(f), &(g))
#define SIGFENCE_IMPL_8(a, b, c, d, e, f, g, h)                                \
  WG14_SIGNALS_PREFIX(sigfence_force_escaped)(0, &(a), &(b), &(c), &(d), &(e), \
                                              &(f), &(g), &(h))
#endif
#define sigfence(...) SIGFENCE_CALL_OVERLOAD(SIGFENCE_IMPL_, __VA_ARGS__)
#endif
 
#ifdef _MSC_VER
#pragma warning(push)
#pragma warning(disable : 4190)  // C-linkage with UDTs
#endif
#if defined(__clang__) && defined(__cplusplus)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wreturn-type-c-linkage"
#endif

  union WG14_SIGNALS_PREFIX(stdc_siginfo_value)
  {
    intptr_t int_value;
    void *ptr_value;
#if defined(__cplusplus)
    constexpr WG14_SIGNALS_PREFIX(stdc_siginfo_value)()
        : int_value(0)
    {
    }
    constexpr WG14_SIGNALS_PREFIX(stdc_siginfo_value)(int v)
        : int_value(v)
    {
    }
    constexpr WG14_SIGNALS_PREFIX(stdc_siginfo_value)(void *v)
        : ptr_value(v)
    {
    }
#endif
  };

#ifdef _WIN32
  typedef long WG14_SIGNALS_PREFIX(thrd_raised_signal_error_code_t);
#else
typedef int WG14_SIGNALS_PREFIX(thrd_raised_signal_error_code_t);
#endif

#ifdef _WIN32
  typedef struct _EXCEPTION_RECORD WG14_SIGNALS_PREFIX(stdc_siginfo_siginfo_t);
#elif __GLIBC__
typedef siginfo_t WG14_SIGNALS_PREFIX(stdc_siginfo_siginfo_t);
#elif __ANDROID__
typedef struct siginfo WG14_SIGNALS_PREFIX(stdc_siginfo_siginfo_t);
#else
typedef struct __siginfo WG14_SIGNALS_PREFIX(stdc_siginfo_siginfo_t);
#endif

#ifdef _WIN32
  typedef struct _CONTEXT WG14_SIGNALS_PREFIX(stdc_siginfo_context_t);
#else
typedef ucontext_t WG14_SIGNALS_PREFIX(stdc_siginfo_context_t);
#endif

  struct WG14_SIGNALS_PREFIX(stdc_siginfo)
  {
    int signo;  

    WG14_SIGNALS_PREFIX(thrd_raised_signal_error_code_t) error_code;
    void *addr;  
    union WG14_SIGNALS_PREFIX(
    stdc_siginfo_value) value;  

    WG14_SIGNALS_PREFIX(stdc_siginfo_siginfo_t) * raw_info;
    WG14_SIGNALS_PREFIX(stdc_siginfo_context_t) * raw_context;
  };

  typedef union WG14_SIGNALS_PREFIX(stdc_siginfo_value)(WG14_SIGNALS_PREFIX(
  sig_func_t))(union WG14_SIGNALS_PREFIX(stdc_siginfo_value));

  typedef union WG14_SIGNALS_PREFIX(stdc_siginfo_value)(WG14_SIGNALS_PREFIX(
  sig_recover_t))(const struct WG14_SIGNALS_PREFIX(stdc_siginfo) *);

  enum WG14_SIGNALS_PREFIX(sig_decision_t)
  {
    WG14_SIGNALS_PREFIX(sig_decision_next_decider),
    WG14_SIGNALS_PREFIX(sig_decision_resume_execution),
    WG14_SIGNALS_PREFIX(sig_decision_invoke_recovery)
  };

  typedef enum WG14_SIGNALS_PREFIX(sig_decision_t)(WG14_SIGNALS_PREFIX(
  sig_decide_t))(struct WG14_SIGNALS_PREFIX(stdc_siginfo) *);

  WG14_SIGNALS_EXTERN int
  WG14_SIGNALS_PREFIX(sigfillset_synchronous)(sigset_t *set);

  WG14_SIGNALS_EXTERN int
  WG14_SIGNALS_PREFIX(sigfillset_asynchronous_nondebug)(sigset_t *set);

  WG14_SIGNALS_EXTERN int
  WG14_SIGNALS_PREFIX(sigfillset_asynchronous_debug)(sigset_t *set);

  WG14_SIGNALS_EXTERN union WG14_SIGNALS_PREFIX(stdc_siginfo_value)
  WG14_SIGNALS_PREFIX(sigguarded)(const sigset_t *signals,
                                  WG14_SIGNALS_PREFIX(sig_func_t) guarded,
                                  WG14_SIGNALS_PREFIX(sig_recover_t) recovery,
                                  WG14_SIGNALS_PREFIX(sig_decide_t) decider,
                                  union WG14_SIGNALS_PREFIX(stdc_siginfo_value)
                                  value);
#if defined(__clang__) && defined(__cplusplus)
#pragma clang diagnostic pop
#endif
#ifdef _MSC_VER
#pragma warning(pop)
#endif

  WG14_SIGNALS_EXTERN bool WG14_SIGNALS_PREFIX(stdc_raise)(
  int signo, WG14_SIGNALS_PREFIX(stdc_siginfo_siginfo_t) * raw_info,
  WG14_SIGNALS_PREFIX(stdc_siginfo_context_t) * raw_context);

  WG14_SIGNALS_EXTERN void *
  WG14_SIGNALS_PREFIX(siginstall)(const sigset_t *guarded);
  WG14_SIGNALS_EXTERN int WG14_SIGNALS_PREFIX(siguninstall)(void *i);
  WG14_SIGNALS_EXTERN int WG14_SIGNALS_PREFIX(siguninstall_system)(int version);

  WG14_SIGNALS_EXTERN void *WG14_SIGNALS_PREFIX(signal_decider_create)(
  const sigset_t *guarded, bool callfirst,
  WG14_SIGNALS_PREFIX(sig_decide_t) decider,
  union WG14_SIGNALS_PREFIX(stdc_siginfo_value) value);
  WG14_SIGNALS_EXTERN int
  WG14_SIGNALS_PREFIX(signal_decider_destroy)(void *decider);
 
 
#ifdef __cplusplus
}
#endif
 
#if WG14_SIGNALS_ENABLE_HEADER_ONLY
#ifdef _WIN32
#include "detail/impl/thrd_signal_handle_windows.c.ipp"
#else
#include "detail/impl/thrd_signal_handle_posix.c.ipp"
#endif
#endif
 
 
#endif