libgo/runtime/go-panic.c

   1 /* go-panic.c -- support for the go panic function.
   2
   3    Copyright 2009 The Go Authors. All rights reserved.
   4    Use of this source code is governed by a BSD-style
   5    license that can be found in the LICENSE file.  */
   6
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9
  10 #include "runtime.h"
  11 #include "arch.h"
  12 #include "malloc.h"
  13 #include "go-alloc.h"
  14 #include "go-panic.h"
  15 #include "interface.h"
  16
  17 /* Print the panic stack.  This is used when there is no recover.  */
  18
  19 static void
  20 __printpanics (Panic *p)
  21 {
  22   if (p->next != NULL)
  23     {
  24       __printpanics (p->next);
  25       runtime_printf ("\t");
  26     }
  27   runtime_printf ("panic: ");
  28   runtime_printany (p->arg);
  29   if (p->recovered)
  30     runtime_printf (" [recovered]");
  31   runtime_printf ("\n");
  32 }
  33
  34 /* This implements __go_panic which is used for the panic
  35    function.  */
  36
  37 void
  38 __go_panic (struct __go_empty_interface arg)
  39 {
  40   G *g;
  41   Panic *n;
  42
  43   g = runtime_g ();
  44
  45   n = (Panic *) __go_alloc (sizeof (Panic));
  46   n->arg = arg;
  47   n->next = g->_panic;
  48   g->_panic = n;
  49
  50   /* Run all the defer functions.  */
  51
  52   while (1)
  53     {
  54       Defer *d;
  55       void (*pfn) (void *);
  56
  57       d = g->_defer;
  58       if (d == NULL)
  59         break;
  60
  61       pfn = (void (*) (void *)) d->pfn;
  62       d->pfn = 0;
  63
  64       if (pfn != NULL)
  65         {
  66           (*pfn) (d->arg);
  67
  68           if (n->recovered)
  69             {
  70               /* Some defer function called recover.  That means that
  71                  we should stop running this panic.  */
  72
  73               g->_panic = n->next;
  74               __go_free (n);
  75
  76               /* Now unwind the stack by throwing an exception.  The
  77                  compiler has arranged to create exception handlers in
  78                  each function which uses a defer statement.  These
  79                  exception handlers will check whether the entry on
  80                  the top of the defer stack is from the current
  81                  function.  If it is, we have unwound the stack far
  82                  enough.  */
  83               __go_unwind_stack ();
  84
  85               /* __go_unwind_stack should not return.  */
  86               abort ();
  87             }
  88
  89           /* Because we executed that defer function by a panic, and
  90              it did not call recover, we know that we are not
  91              returning from the calling function--we are panicing
  92              through it.  */
  93           *d->frame = 0;
  94         }
  95
  96       g->_defer = d->next;
  97
  98       /* This may be called by a cgo callback routine to defer the
  99          call to syscall.CgocallBackDone, in which case we will not
 100          have a memory context.  Don't try to free anything in that
 101          case--the GC will release it later.  */
 102       if (runtime_m () != NULL)
 103         runtime_freedefer (d);
 104     }
 105
 106   /* The panic was not recovered.  */
 107
 108   runtime_startpanic ();
 109   __printpanics (g->_panic);
 110   runtime_dopanic (0);
 111 }