libgo/runtime/go-unwind.c

   1 /* go-unwind.c -- unwind the stack for panic/recover.
   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 "config.h"
   8
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11
  12 #include "unwind.h"
  13 #define NO_SIZE_OF_ENCODED_VALUE
  14 #include "unwind-pe.h"
  15
  16 #include "runtime.h"
  17
  18 /* The code for a Go exception.  */
  19
  20 #ifdef __ARM_EABI_UNWINDER__
  21 static const _Unwind_Exception_Class __go_exception_class =
  22   { 'G', 'N', 'U', 'C', 'G', 'O', '\0', '\0' };
  23 #else
  24 static const _Unwind_Exception_Class __go_exception_class =
  25   ((((((((_Unwind_Exception_Class) 'G'
  26          << 8 | (_Unwind_Exception_Class) 'N')
  27         << 8 | (_Unwind_Exception_Class) 'U')
  28        << 8 | (_Unwind_Exception_Class) 'C')
  29       << 8 | (_Unwind_Exception_Class) 'G')
  30      << 8 | (_Unwind_Exception_Class) 'O')
  31     << 8 | (_Unwind_Exception_Class) '\0')
  32    << 8 | (_Unwind_Exception_Class) '\0');
  33 #endif
  34
  35 /* Rethrow an exception.  */
  36
  37 void rethrowException (void) __asm__(GOSYM_PREFIX "runtime.rethrowException");
  38
  39 void
  40 rethrowException ()
  41 {
  42   struct _Unwind_Exception *hdr;
  43
  44   hdr = (struct _Unwind_Exception *) runtime_g()->exception;
  45
  46 #ifdef __USING_SJLJ_EXCEPTIONS__
  47   _Unwind_SjLj_Resume_or_Rethrow (hdr);
  48 #else
  49 #if defined(_LIBUNWIND_STD_ABI)
  50   _Unwind_RaiseException (hdr);
  51 #else
  52   _Unwind_Resume_or_Rethrow (hdr);
  53 #endif
  54 #endif
  55
  56   /* Rethrowing the exception should not return.  */
  57   abort();
  58 }
  59
  60 /* Return the size of the type that holds an exception header, so that
  61    it can be allocated by Go code.  */
  62
  63 uintptr unwindExceptionSize(void)
  64   __asm__ (GOSYM_PREFIX "runtime.unwindExceptionSize");
  65
  66 uintptr
  67 unwindExceptionSize ()
  68 {
  69   uintptr ret, align;
  70
  71   ret = sizeof (struct _Unwind_Exception);
  72   /* Adjust the size fo make sure that we can get an aligned value.  */
  73   align = __alignof__ (struct _Unwind_Exception);
  74   if (align > __alignof__ (uintptr))
  75     ret += align - __alignof__ (uintptr);
  76   return ret;
  77 }
  78
  79 /* Throw an exception.  This is called with g->exception pointing to
  80    an uninitialized _Unwind_Exception instance.  */
  81
  82 void throwException (void) __asm__(GOSYM_PREFIX "runtime.throwException");
  83
  84 void
  85 throwException ()
  86 {
  87   struct _Unwind_Exception *hdr;
  88   uintptr align;
  89
  90   hdr = (struct _Unwind_Exception *)runtime_g ()->exception;
  91
  92   /* Make sure the value is correctly aligned.  It will be large
  93      enough, because of unwindExceptionSize.  */
  94   align = __alignof__ (struct _Unwind_Exception);
  95   hdr = ((struct _Unwind_Exception *)
  96          (((uintptr) hdr + align - 1) &~ (align - 1)));
  97
  98   __builtin_memcpy (&hdr->exception_class, &__go_exception_class,
  99                     sizeof hdr->exception_class);
 100   hdr->exception_cleanup = NULL;
 101
 102 #ifdef __USING_SJLJ_EXCEPTIONS__
 103   _Unwind_SjLj_RaiseException (hdr);
 104 #else
 105   _Unwind_RaiseException (hdr);
 106 #endif
 107
 108   /* Raising an exception should not return.  */
 109   abort ();
 110 }
 111
 112 /* The rest of this code is really similar to gcc/unwind-c.c and
 113    libjava/exception.cc.  */
 114
 115 typedef struct
 116 {
 117   _Unwind_Ptr Start;
 118   _Unwind_Ptr LPStart;
 119   _Unwind_Ptr ttype_base;
 120   const unsigned char *TType;
 121   const unsigned char *action_table;
 122   unsigned char ttype_encoding;
 123   unsigned char call_site_encoding;
 124 } lsda_header_info;
 125
 126 static const unsigned char *
 127 parse_lsda_header (struct _Unwind_Context *context, const unsigned char *p,
 128                    lsda_header_info *info)
 129 {
 130   _uleb128_t tmp;
 131   unsigned char lpstart_encoding;
 132
 133   info->Start = (context ? _Unwind_GetRegionStart (context) : 0);
 134
 135   /* Find @LPStart, the base to which landing pad offsets are relative.  */
 136   lpstart_encoding = *p++;
 137   if (lpstart_encoding != DW_EH_PE_omit)
 138     p = read_encoded_value (context, lpstart_encoding, p, &info->LPStart);
 139   else
 140     info->LPStart = info->Start;
 141
 142   /* Find @TType, the base of the handler and exception spec type data.  */
 143   info->ttype_encoding = *p++;
 144   if (info->ttype_encoding != DW_EH_PE_omit)
 145     {
 146       p = read_uleb128 (p, &tmp);
 147       info->TType = p + tmp;
 148     }
 149   else
 150     info->TType = 0;
 151
 152   /* The encoding and length of the call-site table; the action table
 153      immediately follows.  */
 154   info->call_site_encoding = *p++;
 155   p = read_uleb128 (p, &tmp);
 156   info->action_table = p + tmp;
 157
 158   return p;
 159 }
 160
 161 /* The personality function is invoked when unwinding the stack due to
 162    a panic.  Its job is to find the cleanup and exception handlers to
 163    run.  We can't split the stack here, because we won't be able to
 164    unwind from that split.  */
 165
 166 #ifdef __ARM_EABI_UNWINDER__
 167 /* ARM EABI personality routines must also unwind the stack.  */
 168 #define CONTINUE_UNWINDING \
 169   do                                                            \
 170     {                                                           \
 171       if (__gnu_unwind_frame (ue_header, context) != _URC_OK)   \
 172         return _URC_FAILURE;                                    \
 173       return _URC_CONTINUE_UNWIND;                              \
 174     }                                                           \
 175   while (0)
 176 #else
 177 #define CONTINUE_UNWINDING return _URC_CONTINUE_UNWIND
 178 #endif
 179
 180 #ifdef __USING_SJLJ_EXCEPTIONS__
 181 #define PERSONALITY_FUNCTION    __gccgo_personality_sj0
 182 #define __builtin_eh_return_data_regno(x) x
 183 #else
 184 #define PERSONALITY_FUNCTION    __gccgo_personality_v0
 185 #endif
 186
 187 #ifdef __ARM_EABI_UNWINDER__
 188 _Unwind_Reason_Code
 189 PERSONALITY_FUNCTION (_Unwind_State, struct _Unwind_Exception *,
 190                       struct _Unwind_Context *)
 191   __attribute__ ((no_split_stack, flatten));
 192
 193 _Unwind_Reason_Code
 194 PERSONALITY_FUNCTION (_Unwind_State state,
 195                       struct _Unwind_Exception * ue_header,
 196                       struct _Unwind_Context * context)
 197 #else
 198 _Unwind_Reason_Code
 199 PERSONALITY_FUNCTION (int, _Unwind_Action, _Unwind_Exception_Class,
 200                       struct _Unwind_Exception *, struct _Unwind_Context *)
 201   __attribute__ ((no_split_stack, flatten));
 202
 203 _Unwind_Reason_Code
 204 PERSONALITY_FUNCTION (int version,
 205                       _Unwind_Action actions,
 206                       _Unwind_Exception_Class exception_class,
 207                       struct _Unwind_Exception *ue_header,
 208                       struct _Unwind_Context *context)
 209 #endif
 210 {
 211   lsda_header_info info;
 212   const unsigned char *language_specific_data, *p, *action_record;
 213   _Unwind_Ptr landing_pad, ip;
 214   int ip_before_insn = 0;
 215   _Bool is_foreign;
 216   G *g;
 217
 218 #ifdef __ARM_EABI_UNWINDER__
 219   _Unwind_Action actions;
 220
 221   switch (state & _US_ACTION_MASK)
 222     {
 223     case _US_VIRTUAL_UNWIND_FRAME:
 224       actions = _UA_SEARCH_PHASE;
 225       break;
 226
 227     case _US_UNWIND_FRAME_STARTING:
 228       actions = _UA_CLEANUP_PHASE;
 229       if (!(state & _US_FORCE_UNWIND)
 230           && ue_header->barrier_cache.sp == _Unwind_GetGR(context, 13))
 231         actions |= _UA_HANDLER_FRAME;
 232       break;
 233
 234     case _US_UNWIND_FRAME_RESUME:
 235       CONTINUE_UNWINDING;
 236       break;
 237
 238     default:
 239       abort();
 240     }
 241   actions |= state & _US_FORCE_UNWIND;
 242
 243   is_foreign = 0;
 244
 245   /* The dwarf unwinder assumes the context structure holds things like the
 246      function and LSDA pointers.  The ARM implementation caches these in
 247      the exception header (UCB).  To avoid rewriting everything we make the
 248      virtual IP register point at the UCB.  */
 249   ip = (_Unwind_Ptr) ue_header;
 250   _Unwind_SetGR (context, 12, ip);
 251 #else
 252   if (version != 1)
 253     return _URC_FATAL_PHASE1_ERROR;
 254
 255   is_foreign = exception_class != __go_exception_class;
 256 #endif
 257
 258   language_specific_data = (const unsigned char *)
 259     _Unwind_GetLanguageSpecificData (context);
 260
 261   /* If no LSDA, then there are no handlers or cleanups.  */
 262   if (! language_specific_data)
 263     CONTINUE_UNWINDING;
 264
 265   /* Parse the LSDA header.  */
 266   p = parse_lsda_header (context, language_specific_data, &info);
 267 #ifdef HAVE_GETIPINFO
 268   ip = _Unwind_GetIPInfo (context, &ip_before_insn);
 269 #else
 270   ip = _Unwind_GetIP (context);
 271 #endif
 272   if (! ip_before_insn)
 273     --ip;
 274   landing_pad = 0;
 275   action_record = NULL;
 276
 277 #ifdef __USING_SJLJ_EXCEPTIONS__
 278   /* The given "IP" is an index into the call-site table, with two
 279      exceptions -- -1 means no-action, and 0 means terminate.  But
 280      since we're using uleb128 values, we've not got random access
 281      to the array.  */
 282   if ((int) ip <= 0)
 283     return _URC_CONTINUE_UNWIND;
 284   else
 285     {
 286       _uleb128_t cs_lp, cs_action;
 287       do
 288         {
 289           p = read_uleb128 (p, &cs_lp);
 290           p = read_uleb128 (p, &cs_action);
 291         }
 292       while (--ip);
 293
 294       /* Can never have null landing pad for sjlj -- that would have
 295          been indicated by a -1 call site index.  */
 296       landing_pad = (_Unwind_Ptr)cs_lp + 1;
 297       if (cs_action)
 298         action_record = info.action_table + cs_action - 1;
 299       goto found_something;
 300     }
 301 #else
 302   /* Search the call-site table for the action associated with this IP.  */
 303   while (p < info.action_table)
 304     {
 305       _Unwind_Ptr cs_start, cs_len, cs_lp;
 306       _uleb128_t cs_action;
 307
 308       /* Note that all call-site encodings are "absolute" displacements.  */
 309       p = read_encoded_value (0, info.call_site_encoding, p, &cs_start);
 310       p = read_encoded_value (0, info.call_site_encoding, p, &cs_len);
 311       p = read_encoded_value (0, info.call_site_encoding, p, &cs_lp);
 312       p = read_uleb128 (p, &cs_action);
 313
 314       /* The table is sorted, so if we've passed the ip, stop.  */
 315       if (ip < info.Start + cs_start)
 316         p = info.action_table;
 317       else if (ip < info.Start + cs_start + cs_len)
 318         {
 319           if (cs_lp)
 320             landing_pad = info.LPStart + cs_lp;
 321           if (cs_action)
 322             action_record = info.action_table + cs_action - 1;
 323           goto found_something;
 324         }
 325     }
 326 #endif
 327
 328   /* IP is not in table.  No associated cleanups.  */
 329   CONTINUE_UNWINDING;
 330
 331  found_something:
 332   if (landing_pad == 0)
 333     {
 334       /* IP is present, but has a null landing pad.
 335          No handler to be run.  */
 336       CONTINUE_UNWINDING;
 337     }
 338
 339   if (actions & _UA_SEARCH_PHASE)
 340     {
 341       if (action_record == 0)
 342         {
 343           /* This indicates a cleanup rather than an exception
 344              handler.  */
 345           CONTINUE_UNWINDING;
 346         }
 347
 348       return _URC_HANDLER_FOUND;
 349     }
 350
 351   /* It's possible for g to be NULL here for an exception thrown by a
 352      language other than Go.  */
 353   g = runtime_g ();
 354   if (g == NULL)
 355     {
 356       if (!is_foreign)
 357         abort ();
 358     }
 359   else
 360     {
 361       g->exception = ue_header;
 362       g->isforeign = is_foreign;
 363     }
 364
 365   _Unwind_SetGR (context, __builtin_eh_return_data_regno (0),
 366                  (_Unwind_Ptr) ue_header);
 367   _Unwind_SetGR (context, __builtin_eh_return_data_regno (1), 0);
 368   _Unwind_SetIP (context, landing_pad);
 369   return _URC_INSTALL_CONTEXT;
 370 }