void __go_panic (struct __go_empty_interface arg) { G *g; Panic *n; g = runtime_g (); n = (Panic *) __go_alloc (sizeof (Panic)); n->arg = arg; n->next = g->_panic; g->_panic = n; /* Run all the defer functions. */ while (1) { Defer *d; void (*pfn) (void *); d = g->_defer; if (d == NULL) break; pfn = (void (*) (void *)) d->pfn; d->pfn = 0; if (pfn != NULL) { (*pfn) (d->arg); if (n->recovered) { /* Some defer function called recover. That means that we should stop running this panic. */ g->_panic = n->next; __go_free (n); /* Now unwind the stack by throwing an exception. The compiler has arranged to create exception handlers in each function which uses a defer statement. These exception handlers will check whether the entry on the top of the defer stack is from the current function. If it is, we have unwound the stack far enough. */ __go_unwind_stack (); /* __go_unwind_stack should not return. */ abort (); } /* Because we executed that defer function by a panic, and it did not call recover, we know that we are not returning from the calling function--we are panicing through it. */ *d->frame = 0; } g->_defer = d->next; /* This may be called by a cgo callback routine to defer the call to syscall.CgocallBackDone, in which case we will not have a memory context. Don't try to free anything in that case--the GC will release it later. */ if (runtime_m () != NULL) runtime_freedefer (d); } /* The panic was not recovered. */ runtime_startpanic (); __printpanics (g->_panic); runtime_dopanic (0); }
void __go_panic (struct __go_empty_interface arg) { struct __go_panic_stack *n; if (__go_panic_defer == NULL) __go_panic_defer = ((struct __go_panic_defer_struct *) __go_alloc (sizeof (struct __go_panic_defer_struct))); n = (struct __go_panic_stack *) __go_alloc (sizeof (struct __go_panic_stack)); n->__arg = arg; n->__next = __go_panic_defer->__panic; __go_panic_defer->__panic = n; /* Run all the defer functions. */ while (1) { struct __go_defer_stack *d; void (*pfn) (void *); d = __go_panic_defer->__defer; if (d == NULL) break; pfn = d->__pfn; d->__pfn = NULL; if (pfn != NULL) { (*pfn) (d->__arg); if (n->__was_recovered) { /* Some defer function called recover. That means that we should stop running this panic. */ __go_panic_defer->__panic = n->__next; __go_free (n); /* Now unwind the stack by throwing an exception. The compiler has arranged to create exception handlers in each function which uses a defer statement. These exception handlers will check whether the entry on the top of the defer stack is from the current function. If it is, we have unwound the stack far enough. */ __go_unwind_stack (); /* __go_unwind_stack should not return. */ abort (); } } __go_panic_defer->__defer = d->__next; __go_free (d); } /* The panic was not recovered. */ __printpanics (__go_panic_defer->__panic); /* FIXME: We should dump a call stack here. */ abort (); }