#define UNW_LOCAL_ONLY
#include <libunwind.h>

void show_backtrace (void) {
    unw_cursor_t cursor; unw_context_t uc;
    unw_word_t ip, sp;

    unw_getcontext(&uc);
    unw_init_local(&cursor, &uc);
    while (unw_step(&cursor) > 0) {
        unw_get_reg(&cursor, UNW_REG_IP, &ip);
        unw_get_reg(&cursor, UNW_REG_SP, &sp);
        printf ("ip = %lx, sp = %lx\n", (long) ip, (long) sp);
    }
}

#include <stdio.h>  
#include <setjmp.h>  
   
static jmp_buf buf;  
      
void second(void) {  
    printf("second\n");         // 打印  
    longjmp(buf,1);             // 跳回setjmp的调用处 - 使得setjmp返回值为1  
}  
         
void first(void) {  
    second();  
    printf("first\n");          // 不可能执行到此行  
}  
            
int main() {     
    if ( ! setjmp(buf) ) {  
        first();                // 进入此行前，setjmp返回0  
    } else {                    // 当longjmp跳转回，setjmp返回1，因此进入此行  
        printf("main\n");       // 打印  
    }  
    return 0;  
}  

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <setjmp.h>

void first(void);
void second(void);

/* This program's output is:
 *
 *  calling first
 *  calling second
 *  entering second
 *  second failed with type 3 exception; remapping to type 1.
 *  first failed, exception type 1
 *
 *   */

/* Use a file scoped static variable for the exception stack so we can access
 *  * it anywhere within this translation unit. */
static jmp_buf exception_env;
static int exception_type;

int main() {
    void *volatile mem_buffer;

    mem_buffer = NULL;
    if (setjmp(exception_env)) {
        /* if we get here there was an exception */
        printf("first failed, exception type %d\n", exception_type);
    } else {
        /* Run code that may signal failure via longjmp. */
        printf("calling first\n");
        first();
        mem_buffer = malloc(300); /* allocate a resource */
        printf(strcpy((char*) mem_buffer, "first succeeded!")); /* ... this will not happen */
    }
    if (mem_buffer)
        free((void*) mem_buffer); /* carefully deallocate resource */
    return 0;
}

void first(void) {
    jmp_buf my_env;

    printf("calling second\n");
    memcpy(my_env, exception_env, sizeof(jmp_buf));
    switch (setjmp(exception_env)) {
    case 3:
        /* if we get here there was an exception. */
        printf("second failed with type 3 exception; remapping to type 1.\n");
        exception_type = 1;

    default: /* fall through */
        memcpy(exception_env, my_env, sizeof(jmp_buf)); /* restore exception stack */
        longjmp(exception_env, exception_type); /* continue handling the exception */

    case 0:
        /* normal, desired operation */
        second();
        printf("second succeeded\n");  /* not reached */
    }
    memcpy(exception_env, my_env, sizeof(jmp_buf)); /* restore exception stack */
}

void second(void) {
    printf("entering second\n" ); /* reached */
    exception_type = 3;
    longjmp(exception_env, exception_type); /* declare that the program has failed */
    printf("leaving second\n"); /* not reached */
}