SealSignal.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
//<<<<<< INCLUDES                                                       >>>>>>
 
#include "CxxUtils/SealCommon.h"               // wlav
#include "CxxUtils/SealSignal.h"               // wlav
#include "CxxUtils/SealDebug.h"                // wlav
#include "CxxUtils/SealSharedLib.h"            // wlav
// wlav copied from SealBase/sysapi/Signal.h
static const int SIGNAL_MESSAGE_BUFSIZE = 2048;
// end copy from SealBase/sysapi/Signal.h
#include <cassert>
#include <cstring>
#include <cerrno>                              // wlav
#include <cstdio>                              // wlav
#include <cstdlib>                             // sss
#include <sys/stat.h>
#include <unistd.h>                            // krasznaa
 
#if defined(__aarch64__) && defined(__linux)
# include "arm_helpers.h"
#endif
 
/* http://dmawww.epfl.ch/ebt-bin/nph-dweb/dynaweb/SGI_Developer/
     T_IRIX_Prog/@Generic__BookTextView/7525
 
  POSIX             SVR4              BSD 4.2
  =========================================================
  sigaction(2)          sigset(2)         sigvec(3) 
  sigsetops(3)          signal(2)         signal(3) 
  sigaltstack(2)    
            
  sigqueue(2)           sigsend(2)        kill(3)   
  kill(2)               kill(2)           killpg(3)
  pthread_kill(3P)  
            
  sigprocmask(2)        sighold(2)        sigblock(3)  
  pthread_sigmask(3P)   sigrelse(2)       sigsetmask(3)
            
  sigpending(2)         n.a.              n.a.
            
  sigsuspend(2)         sigpause(2)       sigpause(3)
            
  sigwait(2)            n.a.              n.a.
  sigwaitinfo(2) 
  sigtimedwait(2)
*/
 
 
// wlav copied from SealBase/src/ProcessInfo.cpp
static pid_t
ProcessInfo__pid (void)
{
#ifdef _WIN32
    return GetCurrentProcessId ();
#else
    return ::getpid ();
#endif
}
 
static pid_t
ProcessInfo__ppid (void)
{
#ifdef _WIN32
    PROCESS_BASIC_INFORMATION pbi;
    if (NtQueryInformationProcess (GetCurrentProcess(),ProcessBasicInformation,
                   &pbi, sizeof (pbi), 0) == STATUS_SUCCESS)
    return pbi.InheritedFromUniqueProcessId;
 
    // FIXME: throw systemerror!
    assert (false);
    return -1;
#else
    return ::getppid ();
#endif
}
 
 
//namespace seal {                                wlav
namespace Athena {                             // wlav
//<<<<<< PRIVATE DEFINES                                                >>>>>>
//<<<<<< PRIVATE CONSTANTS                                              >>>>>>
//<<<<<< PRIVATE TYPES                                                  >>>>>>
 
extern "C" { typedef void (*DummyHandlerType) (int); }
 
//<<<<<< PRIVATE VARIABLE DEFINITIONS                                   >>>>>>
 
static SharedLibrary::InfoHandler *SignalDumpCallback = 0;
 
//<<<<<< PUBLIC VARIABLE DEFINITIONS                                    >>>>>>
//<<<<<< CLASS STRUCTURE INITIALIZATION                                 >>>>>>
 
bool            Signal::s_crashed = false;
 
int         Signal::s_inFatal = 0;
 
// This would in principle be better as a thread_local, but then
// accessing it might allocate memory, which we don't to happen
// during error handling.
// Doing it like this should be good enough.
std::atomic<unsigned long>           Signal::s_lastSP (0);
 
const char      *Signal::s_applicationName = 0;
 
IOFD            Signal::s_fatalFd = IOFD_INVALID;
 
Signal::FatalHook   Signal::s_fatalHook = 0;
 
Signal::FatalReturn Signal::s_fatalReturn = 0;
 
unsigned        Signal::s_fatalOptions = 0;
 
Signal::QuitHook    Signal::s_quitHook = 0;
 
#if !HAVE_POSIX_SIGNALS || !SA_SIGINFO
 
Signal::HandlerType Signal::s_trampolines [NSIG];
#endif
 
//<<<<<< PRIVATE FUNCTION DEFINITIONS                                   >>>>>>
 
static void
SignalDumpLibs (const SharedLibrary::LibraryInfo &info, IOFD fd)
{
    const int buf_size = BitTraits<unsigned long>::HexDigits + 5;
    char buf [buf_size];
    MYWRITE (fd, buf, snprintf (buf, buf_size, " 0x%08lx ", info.m_text_start));
    MYWRITE (fd, info.m_filename, strlen (info.m_filename));
    MYWRITE (fd, "\n", 1);
}
 
#ifdef _WIN32
 
static LONG CALLBACK
SEHFatal (PEXCEPTION_POINTERS info)
{
    Signal::fatal (SIGABRT, info->ExceptionRecord, info->ContextRecord);
    return EXCEPTION_EXECUTE_HANDLER;
}
#endif // _WIN32
 
//<<<<<< PUBLIC FUNCTION DEFINITIONS                                    >>>>>>
//<<<<<< MEMBER FUNCTION DEFINITIONS                                    >>>>>>
 
#if !HAVE_POSIX_SIGNALS
 
void
Signal::trampoline (int sig)
{
    assert (sig > 0 && sig < NSIG);
    assert (s_trampolines [sig]);
    siginfo_t info;
    memset (&info, 0, sizeof (info));
    s_trampolines [sig] (sig, &info, 0);
}
#endif
 
const char *
Signal::name (int sig)
{
#if HAVE_STRSIGNAL
    return strsignal (sig);
#elif HAVE_SYS_SIGLIST
    return sys_siglist [sig];
#else
    // This is not thread safe.  But if you have threads, you probably
    // have strsignal() as well (FIXME: check WIN32).
    static const int buf_size = 8 + BitTraits<int>::Digits;
    static char buf [NSIG] [buf_size];
    if (! buf [sig][0])
    snprintf (buf [sig], buf_size, "Signal %d", sig);
    return buf [sig];
#endif
}
 
Signal::HandlerType
Signal::handler (int sig, sigset_t *mask /* = 0 */)
{
    assert (sig > 0 && sig < NSIG);
 
    // Get the handler
#if HAVE_POSIX_SIGNALS
    struct sigaction old;
    STDC::memset (&old, 0, sizeof (old));
    if (sigaction (sig, &old, 0) == 0)
    {
    if (mask)
        *mask = old.sa_mask;
    return (HandlerType) (void*) old.sa_handler;
    }
    else
      return (HandlerType) (void*)SIG_ERR;
#else // ! HAVE_POSIX_SIGNALS
    HandlerType old = (HandlerType) signal (sig, SIG_DFL);
    signal (sig, (DummyHandlerType) old);
    return old;
#endif // HAVE_POSIX_SIGNALS
}
 
Signal::HandlerType
Signal::handle (int sig, HandlerType handler, const sigset_t *blockMask /*=0*/)
{
    assert (sig > 0 && sig < NSIG);
 //    LOG (0, trace, LFsignal, "[" << sig << "] (" << name (sig) << ") = "
 //  << (void *) handler << '\n');            // wlav
 
    HandlerType oldhandler;
#if !HAVE_POSIX_SIGNALS || !SA_SIGINFO
    // Switch to using trampoline if we don't have the necessary
    // arguments.  FIXME: multiple threads; WIN32?
    oldhandler = s_trampolines [sig];
    if (handler == (HandlerType) SIG_IGN || handler == (HandlerType) SIG_DFL)
    s_trampolines [sig] = 0;
    else
    {
        s_trampolines [sig] = handler;
        handler = (HandlerType) &trampoline;
    }
#endif
 
    // Set the handler
#if HAVE_POSIX_SIGNALS
    struct sigaction old, act;
    STDC::memset (&act, 0, sizeof (act));
    STDC::memset (&old, 0, sizeof (old));
    act.sa_flags = SA_RESTART | SA_SIGINFO;
    act.sa_sigaction = handler;
    sigemptyset (&act.sa_mask);
    if (blockMask)
    act.sa_mask = *blockMask;
    else if (sigaction (sig, &old, 0) == 0)
    act.sa_mask = old.sa_mask;
    else
    sigemptyset (&act.sa_mask);
 
    // There isn't much we can do to check the return status.  We get
    // called in all sorts fragile places like signal handlers, and
    // those are not the place for throwing exceptions or asserting.
    if (sigaction (sig, &act, &old) == -1)
      return (HandlerType) (void*)SIG_ERR;
    oldhandler = (HandlerType) old.sa_sigaction;
#else // ! HAVE_POSIX_SIGNALS
    (HandlerType) ::signal (sig, (DummyHandlerType) handler);
#endif // HAVE_POSIX_SIGNALS
    return oldhandler;
}
 
void
Signal::revert (int sig)
{ handle (sig, (HandlerType) (void*)SIG_DFL); }
 
void
Signal::ignore (int sig)
{ handle (sig, (HandlerType) (void*)SIG_IGN); }
 
void
Signal::block (int sig, bool sense)
{
#if HAVE_POSIX_SIGNALS
    // FIXME: threads -- need to use pthread_sigmask
    sigset_t mask;
    sigemptyset (&mask);
    sigaddset (&mask, sig);
    block (&mask, sense);
#endif
}
 
void
Signal::block (const sigset_t *mask, bool sense)
{
#if HAVE_POSIX_SIGNALS
    // FIXME: threads -- need to use pthread_sigmask
    sigprocmask (sense ? SIG_BLOCK : SIG_UNBLOCK, mask, 0);
#endif
}
 
void
Signal::mask (const sigset_t *mask, sigset_t *old /* = 0 */)
{
#if HAVE_POSIX_SIGNALS
    // FIXME: threads -- need to use pthread_sigmask
    sigprocmask (SIG_SETMASK, mask, old);
#endif
}
 
 
int
Signal::raise (int sig)
{
#if HAVE_RAISE
    return ::raise (sig);
#else
    return ::kill (getpid (), sig);
#endif
}
 
int
Signal::kill (pid_t process, int sig)
{
    // FIXME: sending signals to threads?
#ifndef _WIN32
    return ::kill (process, sig);
#else
    return 0;
#endif
}
 
#if HAVE_POSIX_RT_SIGNALS
int
Signal::queue (pid_t process, int sig, int value /* = 0 */)
{
    union sigval v;
    v.sival_int = value;
    return sigqueue (process, sig, v);
}
#else
int
Signal::queue (pid_t /*process*/, int /*sig*/, int /*value = 0 */)
{
    return 0;
}
#endif
 
#if HAVE_POSIX_RT_SIGNALS
int
Signal::queue (pid_t process, int sig, void *value)
{
    union sigval v;
    v.sival_ptr = value;
    return sigqueue (process, sig, v);
}
#else
int
Signal::queue (pid_t /*process*/, int /*sig*/, void */*value*/)
{
    return 0;
}
#endif
 
#if HAVE_POSIX_RT_SIGNALS
int
Signal::queue (int sig, int value /* = 0 */)
{
    return queue (getpid (), sig, value);
}
#else
int
Signal::queue (int /*sig*/, int /*value  = 0 */)
{
    return 0;
}
#endif
 
#if HAVE_POSIX_RT_SIGNALS
int
Signal::queue (int sig, void *value)
{
    return queue (getpid (), sig, value);
}
#else
int
Signal::queue (int /*sig*/, void */*value*/)
{
    return 0;
}
#endif
 
bool
Signal::pending (int sig)
{ sigset_t s; pending (&s); return sigismember (&s, sig); }
 
#if HAVE_POSIX_SIGNALS
void
Signal::pending (sigset_t *mask)
{
    assert (mask);
    sigpending (mask);
}
#else
void
Signal::pending (sigset_t */*mask*/)
{
}
#endif
 
#if HAVE_POSIX_SIGNALS
void
Signal::suspend (const sigset_t *mask)
{
    assert (mask);
    sigsuspend (mask);
}
#else
void
Signal::suspend (const sigset_t */*mask*/)
{
}
#endif
 
bool
Signal::wait (int sig, siginfo_t *info /* = 0 */, long msecs /* = -1 */)
{
    sigset_t s;
    sigemptyset (&s);
    sigaddset (&s, sig);
    // cppcheck-suppress uninitvar
    return wait (&s, info, msecs) == sig;
}
 
#if HAVE_POSIX_RT_SIGNALS
int
Signal::wait (const sigset_t *mask,
          siginfo_t *info /* = 0 */,
          long msecs /* = -1 */)
{
    siginfo_t   myinfo;
    timespec    ts;
 
    if (msecs < 0)
    sigwaitinfo (mask, &myinfo);
    else
    {
    ts.tv_sec = msecs / 1000;
    ts.tv_nsec = (msecs % 1000) * 1000000;
    if (sigtimedwait (mask, &myinfo, &ts) == -1 && errno == EINTR)
        // FIXME: deal with other error codes (NB: EAGAIN == timed out)
        return -1;
    }
 
    if (info)
    *info = myinfo;
 
    return myinfo.si_signo;
}
#else
int
Signal::wait (const sigset_t */*mask*/,
          siginfo_t */*info = 0 */,
          long /*msecs = -1 */)
{
    return 0;
}
#endif
 
/* Install #quit() as the handler for quitting-related signals.
 
   This method installs #quit() as the handler for quitting-related
   signals such as SIGHUP, SIGTERM and SIGQUIT.  Upon signal delivery
   @a hook will be invoked; if it returns @c true, #quit() proceeds to
   exit by re-raising the signal (in order to make the program's exit
   status reflect the signal exit).  If the @a hook returns @c false,
   the signal is effectively ignored.  Note however that certain
   options to #fatal() also cause the quit hook to be invoked.  */
void
Signal::handleQuit ATLAS_NOT_THREAD_SAFE (QuitHook hook /* = 0 */)
{
    static int hups [] = {
#ifdef SIGHUP
    // hang up (lost terminal or process group leader)
    SIGHUP,
#endif
#ifdef SIGTERM
    // terminate (e.g. system going down)
    SIGTERM,
#endif
#ifdef SIGQUIT
    // user request to quit and leave debuggable state (from quit
    // key on controlling terminal)
    SIGQUIT,
#endif
    -1
    };
 
    if (hook)
    s_quitHook = hook;
 
    for (unsigned sig = 0; hups [sig] != -1; ++sig)
    handle (hups [sig], quit);
}
 
void
Signal::handleFatal ATLAS_NOT_THREAD_SAFE  (const char  *applicationName /* = 0 */,
                                            IOFD     fd /* = IOFD_INVALID */,
                                            FatalHook    hook /* = 0 */,
                                            FatalReturn mainreturn /* = 0 */,
                                            unsigned    options /* = FATAL_DEFAULT */)
{
    // FIXME: Provide means to install handlers for fatal signals that
    // an application has requested and app was supposed to register a
    // handler before making the request?  (So that if the app handler
    // is not installed for some reason, an internal error hook can
    // run?)  Such fatal signals include:
    //   - SIGPIPE: read or write to broken pipe; child died
    //     (read or write to socket with ASYNC io?)
    //   - SIGLOST: lost a resource (e.g., lock on nfs server reboot)
    //   - SIGALRM: interval timer elapsed
    //   - SIGUSR1, SIGUSR2
    //   - SIGPOLL: pollable streams device events
    //   - SIGIO: i/o possible (from async i/o)
    //   - SIGVTALRM: virtual timer expired
    //   - SIGPROF: profiling timer expired
    //   - SIGRTMIN - SIGRTMAX: POSIX real-time signals
    //
    // Some of these the application should probably just #block()
    // (e.g. SIGPIPE).  Some of them the app should block and then
    // wait or poll for events (SIGPOLL, SIGIO, possibly SIGALRM, the
    // real-time signals if they are used).
 
    static const int hups [] = {
#ifdef SIGHUP
    SIGHUP,     // hang up (lost terminal or process group leader)
#endif
#ifdef SIGTERM
    SIGTERM,    // terminate (e.g. system going down)
#endif
#ifdef SIGQUIT
    SIGQUIT,    /* user request to quit and leave debuggable
               state (from quit key on controlling
               terminal) */
 
#endif
    -1
    };
 
    static int fatals [] = {
#ifdef SIGFPE
    SIGFPE,     // arithmetic exception
#endif
#ifdef SIGILL
    SIGILL,     // illegal instruction
#endif
#ifdef SIGSEGV
    SIGSEGV,    // illegal address
#endif
#ifdef SIGBUS
    SIGBUS,     // hardware exception
#endif
#ifdef SIGIOT
    SIGIOT,     /* IOT trap.  Before SIGABRT so that if SIGIOT
               == SIGABRT then SIGABRT overrides SIGIOT;
               SIGABRT is in ISO C and POSIX.1, SIGIOT is
               not. */
#endif
#ifdef SIGABRT
    SIGABRT,    // abort
 
#endif
#ifdef SIGTRAP
    SIGTRAP,    // trace/breakpoint reached
#endif
#ifdef SIGEMT
    SIGEMT,     // emulation trap (may be used by profiler?)
#endif
#ifdef SIGSYS
    SIGSYS,     // invalid system call
#endif
#ifdef SIGXCPU
    SIGXCPU,    // cpu time limit exceeded
#endif
#ifdef SIGXFSZ
    SIGXFSZ,    // file size limit exceeded
#endif
    -1
    };
 
    // Make sure `strsignal' is properly initialised.
    name (1);
 
    // Remember app name if specified
    if (applicationName && *applicationName)
    s_applicationName = applicationName;
 
    // Automatically initialise s_fatalFd on first access
    if (s_fatalFd == IOFD_INVALID)
    s_fatalFd = STDERR_HANDLE;
 
    // Remember the fatal output fd if defined
    if (fd != IOFD_INVALID)
    s_fatalFd = fd;
 
    // Now that we know the fd, setup a callback for dumping shared
    // libraries via #SignalDumpLibs.  This avoids having to allocate
    // memory for the callback implementation in the middle of a fatal
    // signal, and on the other hand avoids a global object which
    // might not be initialised yet.
    delete SignalDumpCallback;
    SignalDumpCallback = new SharedLibrary::InfoHandler
             (CreateCallback (&SignalDumpLibs, s_fatalFd));
 
    // Remember the hooks if specified
    if (hook)
    s_fatalHook = hook;
 
    if (mainreturn)
    s_fatalReturn = mainreturn;
 
    // Remember the new options
    s_fatalOptions = options;
 
    // Signal::fatal() requires this, otherwise weird things can happen.
    // Programs not wanting to return to main should set FATAL_AUTO_EXIT.
    assert (s_fatalReturn || (s_fatalOptions & FATAL_AUTO_EXIT));
 
    // Install signal handlers.
    if (options & FATAL_ON_QUIT)
    for (unsigned sig = 0; hups [sig] != -1; ++sig)
        handle (hups [sig], fatal);
 
    for (unsigned sig = 0; fatals [sig] != -1; ++sig)
    handle (fatals [sig], fatal);
 
#ifdef SIGINT
    // interrupt key from controlling terminal
    if (options & FATAL_ON_INT)
    handle (SIGINT, fatal);
#endif
 
#ifdef SIGUSR1
    // program-defined signals SIGUSR1 and SIGUSR2
    if (options & USR1_DUMP_CORE)
    handle (SIGUSR1, (HandlerType) DebugAids::coredump);
#endif
 
#ifdef _WIN32
    SetUnhandledExceptionFilter (&SEHFatal);
#endif
}
 
void
Signal::quit ATLAS_NOT_THREAD_SAFE (int sig, siginfo_t *info, void *x)
{
    // Quit if no hook has been registered: we are coming in via
    // FATAL_AUTO_EXIT in fatal and the application did not call
    // handleQuit.
    if (! s_quitHook || (*s_quitHook) (sig, info, x))
    {
    // Reactivate the default signal handling behaviour for this
    // signal, which is to terminate the application one way or
    // the other.  Then exit through the signal.  This makes the
    // process exit status correct.
    revert (sig);
    raise (sig);
    }
}
 
void
Signal::fatal ATLAS_NOT_THREAD_SAFE (int sig, siginfo_t *info, void *x)
{
    assert (s_fatalReturn || (s_fatalOptions & FATAL_AUTO_EXIT));
 
#if !HAVE_POSIX_SIGNALS
    // Reinstall the handler for poor SVR4 systems that reset signal
    // handlers upon delivery.  I doubt this code ever gets run on a
    // system without sigaction, but let's be ultracorrect.
    handle (sig, &fatal);
#endif
 
    // Unblock the signal itself so that if we get this again, we'll
    // enter the handler again.  Otherwise if the user's hook or
    // fatalDump has trouble, we'll hang until someone sends us a
    // different signal.
    block (sig, false);
 
    // Check that we aren't going too deep in fatal handlers.  We
    // allow a little nesting as sometimes the handlers gets tangled
    // up producing a dump, but after an extra signal can finish.  If
    // the nesting exceeds our limit, we give up and exit with default
    // signal behaviour: no hooks any more, they've had their chance.
    if (++s_inFatal > 4)
    {
    revert (sig);
    raise (sig);
    }
 
    // Check if this signal is fatal.  If so, indicate we've crashed.
    bool fatal = (sig != SIGINT) || (s_fatalOptions & FATAL_ON_INT);
    if (fatal)
    s_crashed = true;
 
    // Create core file if requested (without interrupting the program)
    bool haveCore = false;
    if (s_inFatal == 1 && fatal && (s_fatalOptions & FATAL_DUMP_CORE))
    {
        DebugAids::coredump (sig);
#ifndef _WIN32
    struct stat st;
    haveCore = (::stat ("core", &st) == 0
            && S_ISREG (st.st_mode)
            && st.st_size > 0);
#endif
    }
 
    // Check if we are done -- if so, commit a suicide, it should be
    // painless.  s_fatalHook and s_quitHook ought to be protected
    // from infinitely looping signals, either using #fatalLevel() or
    // deregistering themselves on the first call.
    if (s_inFatal > 1 || (s_fatalOptions & FATAL_AUTO_EXIT))
    {
    if (s_fatalHook
        ? (*s_fatalHook) (haveCore ? -sig : sig, info, x)
        : fatalDump (haveCore ? -sig : sig, info, x))
        // Suicide: re-raise the signal; we'll die as we return.
        quit (sig, info, x);
        return;
    }
 
    // Prevent possible infinite recursion...
    if (!s_fatalReturn) // sss
      std::abort();     // sss
 
    // Return to main program.
    --s_inFatal;
 
    (*s_fatalReturn) (haveCore ? -sig : sig, info, x);
}
 
const char *
Signal::describe (int sig, int code)
{
    static const struct { int sig; int code; const char *desc; } infos [] = {
#if HAVE_POSIX_SIGNALS
    { -1,      SI_USER, "user sent: kill, sigsend or raise" },
# ifdef SI_KERNEL
    { -1,      SI_KERNEL,   "kernel" },
# endif
    { -1,      SI_QUEUE,    "sigqueue" },
    { -1,      SI_TIMER,    "timer expired" },
    { -1,      SI_MESGQ,    "mesq state changed" },
    { -1,      SI_ASYNCIO,  "AIO completed" },
# ifdef SI_SIGIO // not solaris
    { -1,      SI_SIGIO,    "queued SIGIO" },
# endif
 
# ifdef ILL_NOOP // darwin
    { SIGILL,  ILL_NOOP,    "noop" },
# endif
    { SIGILL,  ILL_ILLOPC,  "illegal opcode" },
# ifdef ILL_ILLOPN // not darwin
    { SIGILL,  ILL_ILLOPN,  "illegal operand" },
# endif
# ifdef ILL_ILLADR // not darwin
    { SIGILL,  ILL_ILLADR,  "illegal addressing mode" },
# endif
    { SIGILL,  ILL_ILLTRP,  "illegal trap" },
    { SIGILL,  ILL_PRVOPC,  "privileged opcode" },
# ifdef ILL_PRVREG // not darwin
    { SIGILL,  ILL_PRVREG,  "privileged register" },
# endif
# ifdef ILL_COPROC // not darwin
    { SIGILL,  ILL_COPROC,  "coprocessor error" },
# endif
# ifdef ILL_BADSTK // not darwin
    { SIGILL,  ILL_BADSTK,  "internal stack error" },
# endif
 
# ifdef FPE_NOOP // darwin
    { SIGFPE,  FPE_NOOP,    "noop" },
# endif
# ifdef FPE_INTDIV // not darwin
    { SIGFPE,  FPE_INTDIV,  "integer divide by zero" },
# endif
# ifdef FPE_INTOVF // not darwin
    { SIGFPE,  FPE_INTOVF,  "integer overflow" },
# endif
    { SIGFPE,  FPE_FLTDIV,  "floating point divide by zero" },
    { SIGFPE,  FPE_FLTOVF,  "floating point overflow" },
    { SIGFPE,  FPE_FLTUND,  "floating point underflow" },
    { SIGFPE,  FPE_FLTRES,  "floating point inexact result" },
    { SIGFPE,  FPE_FLTINV,  "floating point invalid operation" },
# ifdef FPE_FLTSUB // not darwin
    { SIGFPE,  FPE_FLTSUB,  "subscript out of range" },
# endif
 
# ifdef SEGV_NOOP // darwin
    { SIGSEGV, SEGV_NOOP,   "noop" },
# endif
    { SIGSEGV, SEGV_MAPERR, "address not mapped to object" },
    { SIGSEGV, SEGV_ACCERR, "invalid permissions for mapped object" },
 
# ifdef BUS_NOOP // darwin
    { SIGBUS,  BUS_NOOP,    "noop" },
# endif
    { SIGBUS,  BUS_ADRALN,  "invalid address alignment" },
# ifdef BUS_ADRERR // not darwin
    { SIGBUS,  BUS_ADRERR,  "non-existent physical address" },
# endif
# ifdef BUS_OBJERR // not darwin
    { SIGBUS,  BUS_OBJERR,  "object specific hardware error" },
# endif
 
# ifdef TRAP_BRKPT // not darwin
    { SIGTRAP, TRAP_BRKPT,  "process break point" },
# endif
# ifdef TRAP_TRACE // not darwin
    { SIGTRAP, TRAP_TRACE,  "process trace trap" },
# endif
        
# ifdef CLD_NOOP // darwin
    { SIGCHLD, CLD_NOOP,    "noop" },
# endif
    { SIGCHLD, CLD_EXITED,  "child has exited" },
    { SIGCHLD, CLD_KILLED,  "child was killed" },
    { SIGCHLD, CLD_DUMPED,  "child terminated abnormally" },
    { SIGCHLD, CLD_TRAPPED, "traced child has trapped" },
    { SIGCHLD, CLD_STOPPED, "child has stopped" },
    { SIGCHLD, CLD_CONTINUED,"stopped child has continued" },
 
# ifdef SIGPOLL // not darwin
    { SIGPOLL, POLL_IN, "data input available" },
    { SIGPOLL, POLL_OUT,    "output buffers available" },
    { SIGPOLL, POLL_MSG,    "input message available" },
    { SIGPOLL, POLL_ERR,    "i/o error" },
    { SIGPOLL, POLL_PRI,    "high priority input available" },
    { SIGPOLL, POLL_HUP,    "device disconnected" },
# endif
#endif  // HAVE_POSIX_SIGNALS
 
    { -1,      -1,      0 }
    };
 
    for (unsigned i = 0; infos [i].desc; ++i)
    if ((infos [i].sig == -1 || infos [i].sig == sig)
        && infos [i].code == code)
        return infos [i].desc;
 
    return "*unknown reason*";
}
 
void
Signal::dumpInfo (IOFD fd, char *buf, unsigned int buf_size, int sig, const siginfo_t *info)
{
    if (! info)
    return;
 
#ifdef _WIN32
# define DOCODE(x) case x: name = #x
    // NB: siginfo_t == EXCEPTION_RECORD.
    const char *name = 0;
 
    switch (info->ExceptionCode)
    {
    DOCODE(STATUS_ABANDONED_WAIT_0);
    DOCODE(STATUS_ACCESS_VIOLATION);
    DOCODE(STATUS_ARRAY_BOUNDS_EXCEEDED);
    DOCODE(STATUS_BREAKPOINT);
    DOCODE(STATUS_CONTROL_C_EXIT);
    DOCODE(STATUS_DATATYPE_MISALIGNMENT);
    DOCODE(STATUS_FLOAT_DENORMAL_OPERAND);
    DOCODE(STATUS_FLOAT_DIVIDE_BY_ZERO);
    DOCODE(STATUS_FLOAT_INEXACT_RESULT);
    DOCODE(STATUS_FLOAT_INVALID_OPERATION);
    DOCODE(STATUS_FLOAT_OVERFLOW);
    DOCODE(STATUS_FLOAT_STACK_CHECK);
    DOCODE(STATUS_FLOAT_UNDERFLOW);
    DOCODE(STATUS_GUARD_PAGE_VIOLATION);
    DOCODE(STATUS_ILLEGAL_INSTRUCTION);
    DOCODE(STATUS_INTEGER_DIVIDE_BY_ZERO);
    DOCODE(STATUS_INTEGER_OVERFLOW);
    DOCODE(STATUS_INVALID_DISPOSITION);
    DOCODE(STATUS_IN_PAGE_ERROR);
    DOCODE(STATUS_NONCONTINUABLE_EXCEPTION);
    DOCODE(STATUS_NO_MEMORY);
    DOCODE(STATUS_PENDING);
    DOCODE(STATUS_PRIVILEGED_INSTRUCTION);
    DOCODE(STATUS_SINGLE_STEP);
    DOCODE(STATUS_STACK_OVERFLOW);
    DOCODE(STATUS_TIMEOUT);
    DOCODE(STATUS_USER_APC);
    DOCODE(STATUS_WAIT_0);
    }
    // -> DWORD ExceptionCode
    // -> DWORD ExceptionFlags
    // -> EXCEPTION_RECORD *ExceptionRecord
    // -> PVOID ExceptionAddress
    // -> DWORD NumberParameters
    // -> DWORD ExceptionInfo [MAX_PARAMETERS (15)]
    if (name)
        MYWRITE (fd, buf, snprintf (buf, buf_size, "Exception: %s\n", name));
    else
        MYWRITE (fd, buf, snprintf (buf, buf_size, "Exception %lu\n",
                                    info->ExceptionCode));
    MYWRITE (fd, buf, snprintf (buf, buf_size, "  addr = %08lx", info->ExceptionAddress));
 
#elif HAVE_POSIX_SIGNALS
    // These should always be set.
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                               "  signo  = %d, errno = %d, code = %d (%s)\n",
                               info->si_signo, info->si_errno, info->si_code,
                               describe (sig, info->si_code)));
 
    // These are set if the signal was sent by kill, POSIX signal
    // send or SIGCHLD.
    MYWRITE (fd, buf, snprintf (buf, buf_size, "  pid    = %ld, uid = %ld\n",
                                (long) info->si_pid, (long) info->si_uid));
 
    // Child status for SIGCHLD.
    if (sig == SIGCHLD) {
       // Create temporary variables, as MacOS/clang doesn't want to
       // accept the on-the-fly conversion of the following variables
       // without printing some warnings.
       const long status = info->si_status;
       const long utime = info->si_utime;
       const long stime = info->si_stime;
       MYWRITE (fd, buf, snprintf (buf, buf_size,
                                   "  status = %ld, utime = %ld, stime = %ld\n",
                                   status, utime, stime));
    }
 
    // These are set if the POSIX signal sender passed them.
    MYWRITE (fd, buf, snprintf (buf, buf_size, "  value  = (%d, %p)\n",
                                info->si_int, info->si_ptr));
 
    // This is the interesting address for memory faults.
    if (sig == SIGILL || sig == SIGFPE || sig == SIGSEGV || sig == SIGBUS)
    MYWRITE (fd, buf, snprintf (buf, buf_size, "  addr   = %p\n", info->si_addr));
 
# ifdef SIGPOLL // not darwin
    // SIGPOLL status data.
    if (sig == SIGPOLL)
    MYWRITE (fd, buf, snprintf (buf, buf_size, "  band   = %ld, fd = %d\n",
                                    (long) info->si_band, info->si_fd));
# endif
#endif // HAVE_POSIX_SIGNALS
}
 
void
Signal::dumpMemory (IOFD fd, char *buf, unsigned int buf_size, const void *data, size_t n)
{
    for (size_t i = 0; i < n; )
    {
        size_t m = snprintf (buf, buf_size, "\n ");
    for (size_t j = 0; i < n && j < 32; ++j, ++i)
        m += snprintf (buf + m, buf_size-m, "%s%02x",
              j % 4 == 0 ? " " : "",
              (unsigned int) (((const unsigned char *) data) [i]));
 
    MYWRITE (fd, buf, m);
    }
}
 
unsigned long
Signal::dumpContext (IOFD fd, char *buf, unsigned int buf_size, const void *context)
{
     unsigned long sp = 0;
#if defined _WIN32 && defined _M_IX86
    const CONTEXT *uc = static_cast<const CONTEXT *> (context);
    sp = uc->Esp;
    MYWRITE (fd, buf, snprintf (buf, buf_size, "\n"
                                "\n  eip: %04lx:%08lx           eflags: %08lx"
                                "\n  eax: %08lx   ebx: %08lx"
                                "   ecx: %08lx   edx: %08lx"
                                "\n  esi: %08lx   edi: %08lx"
                                "   ebp: %08lx   esp: %08lx"
                                "\n   ds: %04lx        es: %04lx"
                                "    fs: %04lx        ss: %04lx",
                                uc->SegCs, uc->Eip, uc->EFlags,
                                uc->Eax, uc->Ebx, uc->Ecx, uc->Edx,
                                uc->Esi, uc->Edi, uc->Ebp, uc->Esp,
                                uc->SegDs, uc->SegEs, uc->SegFs, uc->SegSs));
 
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                                "\n  FPU:  control = %08lx"
                                "\n        status  = %08lx"
                                "\n        tag     = %08lx"
                                "\n        ip      = %04lx:%08lx"
                                "\n        data    = %04lx:%08lx"
                                "\n        state   = %08lx",
                                uc->FloatSave.ControlWord,
                                uc->FloatSave.StatusWord,
                                uc->FloatSave.TagWord,
                                uc->FloatSave.ErrorSelector,
                                uc->FloatSave.ErrorOffset,
                                uc->FloatSave.DataSelector,
                                uc->FloatSave.DataOffset,
                                uc->FloatSave.Cr0NpxState));
 
    for (int i = 0; i < 8; ++i)
    MYWRITE (fd, buf, snprintf (buf, buf_size.
                                    "\n    %%fp%d = [%02x%02x:%02x%02x%02x%02x"
                                    "%02x%02x%02x%02x]",
                                    i,
                                    uc->FloatSave.RegisterArea [i * 10 + 0],
                                    uc->FloatSave.RegisterArea [i * 10 + 1],
                                    uc->FloatSave.RegisterArea [i * 10 + 2],
                                    uc->FloatSave.RegisterArea [i * 10 + 3],
                                    uc->FloatSave.RegisterArea [i * 10 + 4],
                                    uc->FloatSave.RegisterArea [i * 10 + 5],
                                    uc->FloatSave.RegisterArea [i * 10 + 6],
                                    uc->FloatSave.RegisterArea [i * 10 + 7],
                                    uc->FloatSave.RegisterArea [i * 10 + 8],
                                    uc->FloatSave.RegisterArea [i * 10 + 9]));
    MYWRITE (fd, "\n", 1);
 
#elif HAVE_POSIX_SIGNALS
    // FIXME: how much of this is defined in POSIX or ABIs?
    const ucontext_t *uc = static_cast<const ucontext_t *> (context);
    const mcontext_t *mc = &uc->uc_mcontext;
    MYWRITE (fd, buf, snprintf (buf, buf_size, "  stack  = (%x, %x, %p)",
                                uc->uc_stack.ss_flags,
                                unsigned(uc->uc_stack.ss_size),
                                uc->uc_stack.ss_sp));
 
    MYWRITE (fd, "\n", 1);
#if defined __i386 && defined __linux
# if !defined REG_CS && defined CS
#  define REG_CS    CS
#  define REG_DS    DS
#  define REG_ES    ES
#  define REG_FS    FS
#  define REG_SS    SS
#  define REG_EIP   EIP
#  define REG_EFL   EFL
#  define REG_EAX   EAX
#  define REG_EBX   EBX
#  define REG_ECX   ECX
#  define REG_EDX   EDX
#  define REG_ESI   ESI
#  define REG_EDI   EDI
#  define REG_EBP   EBP
#  define REG_ESP   ESP
#  define REG_UESP  UESP
#  define REG_TRAPNO    TRAPNO
#  define REG_ERR   ERR
# endif
    sp = mc->gregs[REG_ESP];
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                                "\n  eip: %04x:%08x           eflags: %08x"
                                "\n  eax: %08x   ebx: %08x"
                                "   ecx: %08x   edx: %08x"
                                "\n  esi: %08x   edi: %08x"
                                "   ebp: %08x   esp: %08x"
                                "\n   ds: %04x        es: %04x"
                                "        fs: %04x        ss: %04x",
                                mc->gregs [REG_CS] & 0xffff, mc->gregs [REG_EIP],
                                mc->gregs [REG_EFL],
                                mc->gregs [REG_EAX], mc->gregs [REG_EBX],
                                mc->gregs [REG_ECX], mc->gregs [REG_EDX],
                                mc->gregs [REG_ESI], mc->gregs [REG_EDI],
                                mc->gregs [REG_EBP], mc->gregs [REG_ESP],
                                mc->gregs [REG_DS] & 0xffff,
                                mc->gregs [REG_ES] & 0xffff,
                                mc->gregs [REG_FS] & 0xffff,
                                mc->gregs [REG_SS] & 0xffff));
 
    MYWRITE (fd, buf, snprintf (buf, buf__size,
                                "\n\n  signal esp: %08x"
                                "  trap: %d/%d"
                                "  oldmask: %08lx   cr2: %08lx",
                                mc->gregs [REG_UESP],
                                mc->gregs [REG_TRAPNO], mc->gregs [REG_ERR],
                                mc->oldmask, mc->cr2));
 
    if (mc->fpregs)
    {
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                                    "\n"
                                    "\n  FPU:  control = %08lx"
                                    "\n        status  = %08lx"
                                    "\n        tag     = %08lx"
                                    "\n        ip      = %04lx:%08lx"
                                    "\n        data    = %04lx:%08lx"
                                    "\n        state   = %08lx",
                                    mc->fpregs->cw, mc->fpregs->sw, mc->fpregs->tag,
                                    mc->fpregs->cssel & 0xffff, mc->fpregs->ipoff,
                                    mc->fpregs->datasel & 0xffff, mc->fpregs->dataoff,
                                    mc->fpregs->status));
 
    for (int i = 0; i < 8; ++i)
        MYWRITE (fd, buf, snprintf (buf, buf_size,
                                        "\n    %%fp%d = [%04hx:%04hx%04hx%04hx%04hx]",
                                        i,
                                        mc->fpregs->_st [i].exponent,
                                        mc->fpregs->_st [i].significand [0],
                                        mc->fpregs->_st [i].significand [1],
                                        mc->fpregs->_st [i].significand [2],
                                        mc->fpregs->_st [i].significand [3]));
    }
    
#elif defined __x86_64__ && defined __linux
    sp = mc->gregs[REG_RSP];
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                                "\n  rip: %04x:%016llx           eflags: %016llx"
                                "\n  rax: %016llx   rbx: %016llx"
                                "\n  rcx: %016llx   rdx: %016llx"
                                "\n  r08: %016llx   r09: %016llx"
                                "\n  r10: %016llx   r11: %016llx"
                                "\n  r12: %016llx   r13: %016llx"
                                "\n  r14: %016llx   r15: %016llx"
                                "\n  rsi: %016llx   rdi: %016llx"
                                "\n  rbp: %016llx   rsp: %016llx"
                                "\n   gs: %04x     fs: %04x",
                                (unsigned)mc->gregs [REG_CSGSFS] & 0xffff,
                                (unsigned long long)mc->gregs [REG_RIP],
                                (unsigned long long)mc->gregs [REG_EFL],
                                (unsigned long long)mc->gregs [REG_RAX],
                                (unsigned long long)mc->gregs [REG_RBX],
                                (unsigned long long)mc->gregs [REG_RCX],
                                (unsigned long long)mc->gregs [REG_RDX],
                                (unsigned long long)mc->gregs [REG_R8],
                                (unsigned long long)mc->gregs [REG_R9],
                                (unsigned long long)mc->gregs [REG_R10],
                                (unsigned long long)mc->gregs [REG_R11],
                                (unsigned long long)mc->gregs [REG_R12],
                                (unsigned long long)mc->gregs [REG_R13],
                                (unsigned long long)mc->gregs [REG_R14],
                                (unsigned long long)mc->gregs [REG_R15],
                                (unsigned long long)mc->gregs [REG_RSI],
                                (unsigned long long)mc->gregs [REG_RDI],
                                (unsigned long long)mc->gregs [REG_RBP],
                                (unsigned long long)mc->gregs [REG_RSP],
                                (unsigned)(mc->gregs [REG_CSGSFS]>>16) & 0xffff,
                                (unsigned)(mc->gregs [REG_CSGSFS]>>32) & 0xffff));
 
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                                "\n\n"
                                "  trap: %llu/%llu"
                                "  oldmask: %16llx   cr2: %016llx",
                                (unsigned long long)mc->gregs [REG_TRAPNO],
                                (unsigned long long)mc->gregs [REG_ERR],
                                (unsigned long long)mc->gregs [REG_OLDMASK],
                                (unsigned long long)mc->gregs [REG_CR2]));
 
    if (mc->fpregs)
    {
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                                    "\n"
                                    "\n  FPU:  control = %04x"
                                    "\n        status  = %04x"
                                    "\n        tag     = %02x"
                                    "\n        op      = %04x"
                                    "\n        ip      = %016lx"
                                    "\n        data    = %016lx"
                                    "\n        mxcsr   = %08x"
                                    "\n        mxcr_mask= %08x",
                                    mc->fpregs->cwd,
                                    mc->fpregs->swd,
                                    mc->fpregs->ftw,
                                    mc->fpregs->fop,
                                    mc->fpregs->rip,
                                    mc->fpregs->rdp,
                                    mc->fpregs->mxcsr,
                                    mc->fpregs->mxcr_mask));
 
    for (int i = 0; i < 8; ++i)
        MYWRITE (fd, buf, snprintf (buf, buf_size,
                                        "\n    %%fp%d = [%04hx:%04hx%04hx%04hx%04hx]",
                                        i,
                                        mc->fpregs->_st [i].exponent,
                                        mc->fpregs->_st [i].significand [0],
                                        mc->fpregs->_st [i].significand [1],
                                        mc->fpregs->_st [i].significand [2],
                                        mc->fpregs->_st [i].significand [3]));
 
    for (int i = 0; i < 16; ++i)
        MYWRITE (fd, buf, snprintf (buf, buf_size,
                                        "\n    %%xmm%02d = [%08x %08x %08x %08x]",
                                        i,
                                        mc->fpregs->_xmm[i].element[0],
                                        mc->fpregs->_xmm[i].element[1],
                                        mc->fpregs->_xmm[i].element[2],
                                        mc->fpregs->_xmm[i].element[3]));
    }
    
#elif __APPLE__ && defined __ppc__
    MYWRITE (fd, buf, snprintf (buf, buf_size, "\n  dar: %08lx   dsisr: %08lx  exception: %08lx",
                                (*mc)->es.dar, (*mc)->es.dsisr, (*mc)->es.exception));
 
    MYWRITE (fd, buf, snprintf (buf, buf_size,
                                "\n  srr0: %08x  srr1: %08x   cr: %08x         xer: %08x"
                                "\n  lr: %08x    ctr: %08x    vrsave: %08x     fpscr: %08x",
                                (*mc)->ss.srr0, (*mc)->ss.srr1, (*mc)->ss.cr, (*mc)->ss.xer,
                                (*mc)->ss.lr, (*mc)->ss.ctr, (*mc)->ss.vrsave, (*mc)->fs.fpscr));
 
    MYWRITE (fd, buf, snprintf (buf, buf_size, "\n  vrvalid: %08x  vscr: %08lx:%08lx:%08lx:%08lx\n",
                                (*mc)->vs.save_vrvalid,
                                (*mc)->vs.save_vscr [0], (*mc)->vs.save_vscr [1],
                                (*mc)->vs.save_vscr [2], (*mc)->vs.save_vscr [3]));
 
    for (unsigned int *regs = &(*mc)->ss.r0, i = 0; i < 32; i += 4)
        MYWRITE (fd, buf, snprintf (buf, buf_size, "\n  r%-2d  %08x   r%-2d  %08x   r%-2d  %08x   r%-2d  %08x",
                                    i, regs [i], i+1, regs [i+1], i+2, regs [i+2], i+3, regs [i+3]));
    for (int i = 0; i < 32; ++i)
        MYWRITE (fd, buf, snprintf (buf, buf_size, "\n  fp%-2d %016qx (%f)", i,
                                    *(unsigned long long *) &(*mc)->fs.fpregs [i],
                                    (*mc)->fs.fpregs [i]));
    for (int i = 0; i < 32; ++i)
    MYWRITE (fd, buf, snprintf (buf, buf_size, "\n  vr%-2d %08lx:%08lx:%08lx:%08lx", i,
                                    (*mc)->vs.save_vr[i][0], (*mc)->vs.save_vr[i][1],
                                    (*mc)->vs.save_vr[i][2], (*mc)->vs.save_vr[i][3]));
#elif defined __aarch64__ && defined __linux
    CxxUtils::aarch64_dump_registers (fd, buf, buf_size, *mc);
#elif __sun
    for (int i = 0; i < NGREG; i++)
    MYWRITE (fd, buf, snprintf (buf, buf_size, "%s  %%r%02d = %08x",
                                    i % 4 == 0 ? "\n" : "", i, mc->gregs [i]));
#else
    dumpMemory (fd, buf, buf_size, mc, sizeof (*mc));
#endif // __i386 && __linux, __sun, other
 
    MYWRITE (fd, "\n", 1);
#endif // HAVE_POSIX_SIGNALS
 
    return sp;
}
 
static char buf[SIGNAL_MESSAGE_BUFSIZE];
bool
Signal::fatalDump ATLAS_NOT_THREAD_SAFE (int sig, siginfo_t *info, void *extra)
{
  return fatalDump (sig, info, extra, s_fatalFd, s_fatalOptions);
}
bool
Signal::fatalDump ATLAS_NOT_THREAD_SAFE (int sig, siginfo_t *info, void *extra,
                                         IOFD fd,
                                         unsigned options)
{
    const unsigned int buf_size = sizeof (buf);
    bool haveCore = false;
    if (sig < 0)
    {
    sig = -sig;
    haveCore = true;
    }
 
    if (options & FATAL_DUMP_SIG)
    {
    MYWRITE (fd, "\n", 1);
    if (s_applicationName)
    {
        MYWRITE (fd, s_applicationName,
             STDC::strlen (s_applicationName));
        MYWRITE (fd, " ", 1);
    }
 
    MYWRITE (fd, buf,
         snprintf (buf, SIGNAL_MESSAGE_BUFSIZE, "(pid=%ld ppid=%ld) received fatal signal %d"
              " (%.100s)%s\n",
              (long) ProcessInfo__pid (), (long) ProcessInfo__ppid (), // wlav :: -> __ (x2)
              sig, name (sig), haveCore ? " (core dumped)" : ""));
 
    MYWRITE (fd, buf, snprintf(buf, buf_size, "signal context:\n"));
    dumpInfo (fd, buf, buf_size, sig, info);
    }
 
    unsigned long sp = 0;
    if (options & FATAL_DUMP_CONTEXT)
    sp = dumpContext (fd, buf, buf_size, extra);
 
    if (options & FATAL_DUMP_STACK)
    {
    MYWRITE (fd, buf, snprintf(buf, buf_size, "\nstack trace:\n"));
        if (s_lastSP) {
          MYWRITE (fd, buf, snprintf(buf, buf_size, "\n(backtrace failed; raw dump follows)\n"));
          MYWRITE (fd, buf, snprintf(buf, buf_size, "%016lx:", s_lastSP.load()));
          dumpMemory (fd, buf, buf_size, reinterpret_cast<void*>(s_lastSP.load()), 1024);
          MYWRITE (fd, buf, snprintf(buf, buf_size, "\n\n"));
        }
        else {
          s_lastSP = sp;
          DebugAids::stacktrace (fd);
        }
        s_lastSP = 0;
    }
 
    if (options & FATAL_DUMP_LIBS)
    {
    MYWRITE (fd, buf, snprintf(buf, buf_size, "\nshared libraries present:\n"));
    try { SharedLibrary::loaded (*SignalDumpCallback); }
    catch (...) { ; }
    }
 
    return true;
}
 
IOFD
Signal::handleFatalFd ATLAS_NOT_THREAD_SAFE (void)
{
    // Automatically initialise on first access.
    if (s_fatalFd == IOFD_INVALID)
    s_fatalFd = STDERR_HANDLE;
 
    return s_fatalFd;
}
 
Signal::FatalHook
Signal::handleFatalHook ATLAS_NOT_THREAD_SAFE (void)
{ return s_fatalHook; }
 
Signal::FatalReturn
Signal::handleFatalReturn ATLAS_NOT_THREAD_SAFE (void)
{ return s_fatalReturn; }
 
unsigned
Signal::handleFatalOptions ATLAS_NOT_THREAD_SAFE (void)
{ return s_fatalOptions; }
 
Signal::QuitHook
Signal::handleQuitHook ATLAS_NOT_THREAD_SAFE (void)
{ return s_quitHook; }
 
int
Signal::fatalLevel ATLAS_NOT_THREAD_SAFE (void)
{ return s_inFatal; }
 
bool
Signal::crashed ATLAS_NOT_THREAD_SAFE (void)
{ return s_crashed; }
 
//} // namespace seal                             wlav
} // namespace Athena                             wlav
 
 
extern "C" {
  void CxxUtils_installFatalHandler ATLAS_NOT_THREAD_SAFE ()
  {
    Athena::Signal::handleFatal(nullptr, 1);
  }
}