openbmc/build/tmp/deploy/sdk/witherspoon-2019-08-08/sysroots/armv6-openbmc-linux-gnueabi/usr/src/debug/glibc/2.29-r0/git/stdlib/abort.c
void abort(void)
{
    struct sigaction act;
    sigset_t sigs;

    /* First acquire the lock.  */
    __libc_lock_lock_recursive(lock);

    /* Now it's for sure we are alone.  But recursive calls are possible.  */

    /* Unblock SIGABRT.  */
    if (stage == 0)
    {
        ++stage;
        __sigemptyset(&sigs);
        __sigaddset(&sigs, SIGABRT);
        __sigprocmask(SIG_UNBLOCK, &sigs, 0);
    }

    /* Send signal which possibly calls a user handler.  */
    if (stage == 1)
    {
        /* This stage is special: we must allow repeated calls of
       `abort' when a user defined handler for SIGABRT is installed.
       This is risky since the `raise' implementation might also
       fail but I don't see another possibility.  */
        int save_stage = stage;

        stage = 0;
        __libc_lock_unlock_recursive(lock);

        raise(SIGABRT);

        __libc_lock_lock_recursive(lock);
        stage = save_stage + 1;
    }

    /* There was a handler installed.  Now remove it.  */
    if (stage == 2)
    {
        ++stage;
        memset(&act, '\0', sizeof(struct sigaction));
        act.sa_handler = SIG_DFL;
        __sigfillset(&act.sa_mask);
        act.sa_flags = 0;
        __sigaction(SIGABRT, &act, NULL);
    }

    /* Try again.  */
    if (stage == 3)
    {
        ++stage;
        raise(SIGABRT);
    }

    /* Now try to abort using the system specific command.  */
    if (stage == 4)
    {
        ++stage;
        ABORT_INSTRUCTION;
    }

    /* If we can't signal ourselves and the abort instruction failed, exit.  */
    if (stage == 5)
    {
        ++stage;
        _exit(127);
    }

    /* If even this fails try to use the provided instruction to crash
       or otherwise make sure we never return.  */
    while (1)
        /* Try for ever and ever.  */
        ABORT_INSTRUCTION;
}
/* Cause an abnormal program termination with core-dump.  */
Cause an abnormal program termination with core-dump.
Cause an abnormal program termination with core - dump .
void abort(void)
{
    struct sigaction act;
    sigset_t sigs;
    __libc_lock_lock_recursive(lock);
    if (stage == 0)
    {
        ++stage;
        __sigemptyset(&sigs);
        __sigaddset(&sigs, SIGABRT);
        __sigprocmask(SIG_UNBLOCK, &sigs, 0);
    }
    if (stage == 1)
    {
        int save_stage = stage;
        stage = 0;
        __libc_lock_unlock_recursive(lock);
        raise(SIGABRT);
        __libc_lock_lock_recursive(lock);
        stage = save_stage + 1;
    }
    if (stage == 2)
    {
        ++stage;
        memset(&act, '\0', sizeof(struct sigaction));
        act.sa_handler = SIG_DFL;
        __sigfillset(&act.sa_mask);
        act.sa_flags = 0;
        __sigaction(SIGABRT, &act, NULL);
    }
    if (stage == 3)
    {
        ++stage;
        raise(SIGABRT);
    }
    if (stage == 4)
    {
        ++stage;
        ABORT_INSTRUCTION;
    }
    if (stage == 5)
    {
        ++stage;
        _exit(127);
    }
    while (1)
        ABORT_INSTRUCTION;
}
void abort ( void ) { struct sigaction act ; sigset_t sigs ; __libc_lock_lock_recursive ( lock ) ; if ( stage == 0 ) { ++ stage ; __sigemptyset ( & sigs ) ; __sigaddset ( & sigs , SIGABRT ) ; __sigprocmask ( SIG_UNBLOCK , & sigs , 0 ) ; } if ( stage == 1 ) { int save_stage = stage ; stage = 0 ; __libc_lock_unlock_recursive ( lock ) ; raise ( SIGABRT ) ; __libc_lock_lock_recursive ( lock ) ; stage = save_stage + 1 ; } if ( stage == 2 ) { ++ stage ; memset ( & act , ' \0 ' , sizeof ( struct sigaction ) ) ; act . sa_handler = SIG_DFL ; __sigfillset ( & act . sa_mask ) ; act . sa_flags = 0 ; __sigaction ( SIGABRT , & act , NULL ) ; } if ( stage == 3 ) { ++ stage ; raise ( SIGABRT ) ; } if ( stage == 4 ) { ++ stage ; ABORT_INSTRUCTION ; } if ( stage == 5 ) { ++ stage ; _exit ( 127 ) ; } while ( 1 ) ABORT_INSTRUCTION ; }
Cause an abnormal program termination with core-dump.
Cause an abnormal program termination with core - dump .
/* First acquire the lock.  */ /* Now it's for sure we are alone.  But recursive calls are possible.  */ /* Unblock SIGABRT.  */ /* Send signal which possibly calls a user handler.  */ /* This stage is special: we must allow repeated calls of
       `abort' when a user defined handler for SIGABRT is installed.
       This is risky since the `raise' implementation might also
       fail but I don't see another possibility.  */ /* There was a handler installed.  Now remove it.  */ /* Try again.  */ /* Now try to abort using the system specific command.  */ /* If we can't signal ourselves and the abort instruction failed, exit.  */ /* If even this fails try to use the provided instruction to crash
       or otherwise make sure we never return.  */ /* Try for ever and ever.  */