libgo/runtime/go-recover.c

   1 /* go-recover.c -- support for the go recover function.
   2
   3    Copyright 2010 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 "runtime.h"
   8 #include "interface.h"
   9 #include "go-panic.h"
  10 #include "go-defer.h"
  11
  12 /* If the top of the defer stack can be recovered, then return it.
  13    Otherwise return NULL.  */
  14
  15 static struct __go_defer_stack *
  16 current_defer ()
  17 {
  18   G *g;
  19   struct __go_defer_stack *d;
  20
  21   g = runtime_g ();
  22
  23   d = g->defer;
  24   if (d == NULL)
  25     return NULL;
  26
  27   /* The panic which would be recovered is the one on the top of the
  28      panic stack.  We do not want to recover it if that panic was on
  29      the top of the panic stack when this function was deferred.  */
  30   if (d->__panic == g->panic)
  31     return NULL;
  32
  33   /* The deferred thunk will call _go_set_defer_retaddr.  If this has
  34      not happened, then we have not been called via defer, and we can
  35      not recover.  */
  36   if (d->__retaddr == NULL)
  37     return NULL;
  38
  39   return d;
  40 }
  41
  42 /* This is called by a thunk to see if the real function should be
  43    permitted to recover a panic value.  Recovering a value is
  44    permitted if the thunk was called directly by defer.  RETADDR is
  45    the return address of the function which is calling
  46    __go_can_recover--this is, the thunk.  */
  47
  48 _Bool
  49 __go_can_recover (void *retaddr)
  50 {
  51   struct __go_defer_stack *d;
  52   const char* ret;
  53   const char* dret;
  54   Location locs[16];
  55   const byte *name;
  56   intgo len;
  57   int n;
  58   int i;
  59   _Bool found_ffi_callback;
  60
  61   d = current_defer ();
  62   if (d == NULL)
  63     return 0;
  64
  65   ret = (const char *) __builtin_extract_return_addr (retaddr);
  66
  67   dret = (const char *) d->__retaddr;
  68   if (ret <= dret && ret + 16 >= dret)
  69     return 1;
  70
  71   /* On some systems, in some cases, the return address does not work
  72      reliably.  See http://gcc.gnu.org/PR60406.  If we are permitted
  73      to call recover, the call stack will look like this:
  74        __go_panic, __go_undefer, etc.
  75        thunk to call deferred function (calls __go_set_defer_retaddr)
  76        function that calls __go_can_recover (passing return address)
  77        __go_can_recover
  78      Calling runtime_callers will skip the thunks.  So if our caller's
  79      caller starts with __go, then we are permitted to call
  80      recover.  */
  81
  82   if (runtime_callers (1, &locs[0], 2, false) < 2)
  83     return 0;
  84
  85   name = locs[1].function.str;
  86   len = locs[1].function.len;
  87
  88   /* Although locs[1].function is a Go string, we know it is
  89      NUL-terminated.  */
  90   if (len > 4
  91       && __builtin_strchr ((const char *) name, '.') == NULL
  92       && __builtin_strncmp ((const char *) name, "__go_", 4) == 0)
  93     return 1;
  94
  95   /* If we are called from __go_makefunc_can_recover, then we need to
  96      look one level higher.  */
  97   if (locs[0].function.len > 0
  98       && __builtin_strcmp ((const char *) locs[0].function.str,
  99                            "__go_makefunc_can_recover") == 0)
 100     {
 101       if (runtime_callers (3, &locs[0], 1, false) < 1)
 102         return 0;
 103       name = locs[0].function.str;
 104       len = locs[0].function.len;
 105       if (len > 4
 106           && __builtin_strchr ((const char *) name, '.') == NULL
 107           && __builtin_strncmp ((const char *) name, "__go_", 4) == 0)
 108         return 1;
 109     }
 110
 111   /* If the function calling recover was created by reflect.MakeFunc,
 112      then __go_makefunc_can_recover or __go_makefunc_ffi_can_recover
 113      will have set the __makefunc_can_recover field.  */
 114   if (!d->__makefunc_can_recover)
 115     return 0;
 116
 117   /* We look up the stack, ignoring libffi functions and functions in
 118      the reflect package, until we find reflect.makeFuncStub or
 119      reflect.ffi_callback called by FFI functions.  Then we check the
 120      caller of that function.  */
 121
 122   n = runtime_callers (2, &locs[0], sizeof locs / sizeof locs[0], false);
 123   found_ffi_callback = 0;
 124   for (i = 0; i < n; i++)
 125     {
 126       const byte *name;
 127
 128       if (locs[i].function.len == 0)
 129         {
 130           /* No function name means this caller isn't Go code.  Assume
 131              that this is libffi.  */
 132           continue;
 133         }
 134
 135       /* Ignore functions in libffi.  */
 136       name = locs[i].function.str;
 137       if (__builtin_strncmp ((const char *) name, "ffi_", 4) == 0)
 138         continue;
 139
 140       if (found_ffi_callback)
 141         break;
 142
 143       if (__builtin_strcmp ((const char *) name, "reflect.ffi_callback") == 0)
 144         {
 145           found_ffi_callback = 1;
 146           continue;
 147         }
 148
 149       if (__builtin_strcmp ((const char *) name, "reflect.makeFuncStub") == 0)
 150         {
 151           i++;
 152           break;
 153         }
 154
 155       /* Ignore other functions in the reflect package.  */
 156       if (__builtin_strncmp ((const char *) name, "reflect.", 8) == 0)
 157         continue;
 158
 159       /* We should now be looking at the real caller.  */
 160       break;
 161     }
 162
 163   if (i < n && locs[i].function.len > 0)
 164     {
 165       name = locs[i].function.str;
 166       if (__builtin_strncmp ((const char *) name, "__go_", 4) == 0)
 167         return 1;
 168     }
 169
 170   return 0;
 171 }
 172
 173 /* This function is called when code is about to enter a function
 174    created by reflect.MakeFunc.  It is called by the function stub
 175    used by MakeFunc.  If the stub is permitted to call recover, then a
 176    real MakeFunc function is permitted to call recover.  */
 177
 178 void
 179 __go_makefunc_can_recover (void *retaddr)
 180 {
 181   struct __go_defer_stack *d;
 182
 183   d = current_defer ();
 184   if (d == NULL)
 185     return;
 186
 187   /* If we are already in a call stack of MakeFunc functions, there is
 188      nothing we can usefully check here.  */
 189   if (d->__makefunc_can_recover)
 190     return;
 191
 192   if (__go_can_recover (retaddr))
 193     d->__makefunc_can_recover = 1;
 194 }
 195
 196 /* This function is called when code is about to enter a function
 197    created by the libffi version of reflect.MakeFunc.  This function
 198    is passed the names of the callers of the libffi code that called
 199    the stub.  It uses to decide whether it is permitted to call
 200    recover, and sets d->__makefunc_can_recover so that __go_recover
 201    can make the same decision.  */
 202
 203 void
 204 __go_makefunc_ffi_can_recover (struct Location *loc, int n)
 205 {
 206   struct __go_defer_stack *d;
 207   const byte *name;
 208   intgo len;
 209
 210   d = current_defer ();
 211   if (d == NULL)
 212     return;
 213
 214   /* If we are already in a call stack of MakeFunc functions, there is
 215      nothing we can usefully check here.  */
 216   if (d->__makefunc_can_recover)
 217     return;
 218
 219   /* LOC points to the caller of our caller.  That will be a thunk.
 220      If its caller was a runtime function, then it was called directly
 221      by defer.  */
 222
 223   if (n < 2)
 224     return;
 225
 226   name = (loc + 1)->function.str;
 227   len = (loc + 1)->function.len;
 228   if (len > 4
 229       && __builtin_strchr ((const char *) name, '.') == NULL
 230       && __builtin_strncmp ((const char *) name, "__go_", 4) == 0)
 231     d->__makefunc_can_recover = 1;
 232 }
 233
 234 /* This function is called when code is about to exit a function
 235    created by reflect.MakeFunc.  It is called by the function stub
 236    used by MakeFunc.  It clears the __makefunc_can_recover field.
 237    It's OK to always clear this field, because __go_can_recover will
 238    only be called by a stub created for a function that calls recover.
 239    That stub will not call a function created by reflect.MakeFunc, so
 240    by the time we get here any caller higher up on the call stack no
 241    longer needs the information.  */
 242
 243 void
 244 __go_makefunc_returning (void)
 245 {
 246   struct __go_defer_stack *d;
 247
 248   d = runtime_g ()->defer;
 249   if (d != NULL)
 250     d->__makefunc_can_recover = 0;
 251 }
 252
 253 /* This is only called when it is valid for the caller to recover the
 254    value on top of the panic stack, if there is one.  */
 255
 256 struct __go_empty_interface
 257 __go_recover ()
 258 {
 259   G *g;
 260   struct __go_panic_stack *p;
 261
 262   g = runtime_g ();
 263
 264   if (g->panic == NULL || g->panic->__was_recovered)
 265     {
 266       struct __go_empty_interface ret;
 267
 268       ret.__type_descriptor = NULL;
 269       ret.__object = NULL;
 270       return ret;
 271     }
 272   p = g->panic;
 273   p->__was_recovered = 1;
 274   return p->__arg;
 275 }