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
  14 #include "runtime.h"
  15
  16 /* These constants are documented here:
  17    https://refspecs.linuxfoundation.org/LSB_3.0.0/LSB-PDA/LSB-PDA/dwarfext.html
  18  */
  19
  20 #define DW_EH_PE_omit     0xff
  21 #define DW_EH_PE_absptr   0x00
  22 #define DW_EH_PE_uleb128  0x01
  23 #define DW_EH_PE_udata2   0x02
  24 #define DW_EH_PE_udata4   0x03
  25 #define DW_EH_PE_udata8   0x04
  26 #define DW_EH_PE_sleb128  0x09
  27 #define DW_EH_PE_sdata2   0x0A
  28 #define DW_EH_PE_sdata4   0x0B
  29 #define DW_EH_PE_sdata8   0x0C
  30 #define DW_EH_PE_pcrel    0x10
  31 #define DW_EH_PE_textrel  0x20
  32 #define DW_EH_PE_datarel  0x30
  33 #define DW_EH_PE_funcrel  0x40
  34 #define DW_EH_PE_aligned  0x50
  35 #define DW_EH_PE_indirect 0x80
  36
  37 /* The code for a Go exception.  */
  38
  39 #ifdef __ARM_EABI_UNWINDER__
  40 static const _Unwind_Exception_Class __go_exception_class =
  41   { 'G', 'N', 'U', 'C', 'G', 'O', '\0', '\0' };
  42 #else
  43 static const _Unwind_Exception_Class __go_exception_class =
  44   ((((((((_Unwind_Exception_Class) 'G'
  45          << 8 | (_Unwind_Exception_Class) 'N')
  46         << 8 | (_Unwind_Exception_Class) 'U')
  47        << 8 | (_Unwind_Exception_Class) 'C')
  48       << 8 | (_Unwind_Exception_Class) 'G')
  49      << 8 | (_Unwind_Exception_Class) 'O')
  50     << 8 | (_Unwind_Exception_Class) '\0')
  51    << 8 | (_Unwind_Exception_Class) '\0');
  52 #endif
  53
  54 /* Rethrow an exception.  */
  55
  56 void rethrowException (void) __asm__(GOSYM_PREFIX "runtime.rethrowException");
  57
  58 void
  59 rethrowException ()
  60 {
  61   struct _Unwind_Exception *hdr;
  62   _Unwind_Reason_Code reason;
  63
  64   hdr = (struct _Unwind_Exception *) runtime_g()->exception;
  65
  66 #ifdef __USING_SJLJ_EXCEPTIONS__
  67   reason = _Unwind_SjLj_Resume_or_Rethrow (hdr);
  68 #else
  69 #if defined(_LIBUNWIND_STD_ABI)
  70   reason = _Unwind_RaiseException (hdr);
  71 #else
  72   reason = _Unwind_Resume_or_Rethrow (hdr);
  73 #endif
  74 #endif
  75
  76   /* Rethrowing the exception should not return.  */
  77   runtime_printf ("failed to rethrow unwind exception (reason=%d)\n", reason);
  78   abort();
  79 }
  80
  81 /* Return the size of the type that holds an exception header, so that
  82    it can be allocated by Go code.  */
  83
  84 uintptr unwindExceptionSize(void)
  85   __asm__ (GOSYM_PREFIX "runtime.unwindExceptionSize");
  86
  87 uintptr
  88 unwindExceptionSize ()
  89 {
  90   uintptr ret, align;
  91
  92   ret = sizeof (struct _Unwind_Exception);
  93   /* Adjust the size fo make sure that we can get an aligned value.  */
  94   align = __alignof__ (struct _Unwind_Exception);
  95   if (align > __alignof__ (uintptr))
  96     ret += align - __alignof__ (uintptr);
  97   return ret;
  98 }
  99
 100 /* Throw an exception.  This is called with g->exception pointing to
 101    an uninitialized _Unwind_Exception instance.  */
 102
 103 void throwException (void) __asm__(GOSYM_PREFIX "runtime.throwException");
 104
 105 void
 106 throwException ()
 107 {
 108   struct _Unwind_Exception *hdr;
 109   uintptr align;
 110   _Unwind_Reason_Code reason;
 111
 112   hdr = (struct _Unwind_Exception *)runtime_g ()->exception;
 113
 114   /* Make sure the value is correctly aligned.  It will be large
 115      enough, because of unwindExceptionSize.  */
 116   align = __alignof__ (struct _Unwind_Exception);
 117   hdr = ((struct _Unwind_Exception *)
 118          (((uintptr) hdr + align - 1) &~ (align - 1)));
 119
 120   __builtin_memcpy (&hdr->exception_class, &__go_exception_class,
 121                     sizeof hdr->exception_class);
 122   hdr->exception_cleanup = NULL;
 123
 124 #ifdef __USING_SJLJ_EXCEPTIONS__
 125   reason = _Unwind_SjLj_RaiseException (hdr);
 126 #else
 127   reason = _Unwind_RaiseException (hdr);
 128 #endif
 129
 130   /* Raising an exception should not return.  */
 131   runtime_printf ("failed to throw unwind exception (reason=%d)\n", reason);
 132   abort ();
 133 }
 134
 135 static inline _Unwind_Ptr
 136 encoded_value_base (uint8_t encoding, struct _Unwind_Context *context)
 137 {
 138   if (encoding == DW_EH_PE_omit)
 139     return 0;
 140   switch (encoding & 0x70)
 141     {
 142       case DW_EH_PE_absptr:
 143       case DW_EH_PE_pcrel:
 144       case DW_EH_PE_aligned:
 145         return 0;
 146       case DW_EH_PE_textrel:
 147         return _Unwind_GetTextRelBase(context);
 148       case DW_EH_PE_datarel:
 149         return _Unwind_GetDataRelBase(context);
 150       case DW_EH_PE_funcrel:
 151         return _Unwind_GetRegionStart(context);
 152     }
 153   abort ();
 154 }
 155
 156 /* Read an unsigned leb128 value.  */
 157
 158 static inline const uint8_t *
 159 read_uleb128 (const uint8_t *p, _uleb128_t *val)
 160 {
 161   unsigned int shift = 0;
 162   _uleb128_t result = 0;
 163   uint8_t byte;
 164
 165   do
 166     {
 167       byte = *p++;
 168       result |= ((_uleb128_t)byte & 0x7f) << shift;
 169       shift += 7;
 170     }
 171   while (byte & 0x80);
 172
 173   *val = result;
 174   return p;
 175 }
 176
 177 /* Similar, but read a signed leb128 value.  */
 178
 179 static inline const uint8_t *
 180 read_sleb128 (const uint8_t *p, _sleb128_t *val)
 181 {
 182   unsigned int shift = 0;
 183   _uleb128_t result = 0;
 184   uint8_t byte;
 185
 186   do
 187     {
 188       byte = *p++;
 189       result |= ((_uleb128_t)byte & 0x7f) << shift;
 190       shift += 7;
 191     }
 192   while (byte & 0x80);
 193
 194   /* sign extension */
 195   if (shift < (8 * sizeof(result)) && (byte & 0x40) != 0)
 196     result |= (((_uleb128_t)~0) << shift);
 197
 198   *val = (_sleb128_t)result;
 199   return p;
 200 }
 201
 202 #define ROUND_UP_TO_PVB(x) (x + sizeof(void *) - 1) &- sizeof(void *)
 203
 204 static inline const uint8_t *
 205 read_encoded_value (struct _Unwind_Context *context, uint8_t encoding,
 206                     const uint8_t *p, _Unwind_Ptr *val)
 207 {
 208   _Unwind_Ptr base = encoded_value_base (encoding, context);
 209   _Unwind_Internal_Ptr decoded = 0;
 210   const uint8_t *origp = p;
 211
 212   if (encoding == DW_EH_PE_aligned)
 213     {
 214       _Unwind_Internal_Ptr uip = (_Unwind_Internal_Ptr)p;
 215       uip = ROUND_UP_TO_PVB (uip);
 216       decoded = *(_Unwind_Internal_Ptr *)uip;
 217       p = (const uint8_t *)(uip + sizeof(void *));
 218     }
 219   else
 220     {
 221       switch (encoding & 0x0f)
 222         {
 223           case DW_EH_PE_sdata2:
 224             {
 225               int16_t result;
 226               __builtin_memcpy (&result, p, sizeof(int16_t));
 227               decoded = result;
 228               p += sizeof(int16_t);
 229               break;
 230             }
 231           case DW_EH_PE_udata2:
 232             {
 233               uint16_t result;
 234               __builtin_memcpy (&result, p, sizeof(uint16_t));
 235               decoded = result;
 236               p += sizeof(uint16_t);
 237               break;
 238             }
 239           case DW_EH_PE_sdata4:
 240             {
 241               int32_t result;
 242               __builtin_memcpy (&result, p, sizeof(int32_t));
 243               decoded = result;
 244               p += sizeof(int32_t);
 245               break;
 246             }
 247           case DW_EH_PE_udata4:
 248             {
 249               uint32_t result;
 250               __builtin_memcpy (&result, p, sizeof(uint32_t));
 251               decoded = result;
 252               p += sizeof(uint32_t);
 253               break;
 254             }
 255           case DW_EH_PE_sdata8:
 256             {
 257               int64_t result;
 258               __builtin_memcpy (&result, p, sizeof(int64_t));
 259               decoded = result;
 260               p += sizeof(int64_t);
 261               break;
 262             }
 263           case DW_EH_PE_udata8:
 264             {
 265               uint64_t result;
 266               __builtin_memcpy (&result, p, sizeof(uint64_t));
 267               decoded = result;
 268               p += sizeof(uint64_t);
 269               break;
 270             }
 271           case DW_EH_PE_uleb128:
 272             {
 273               _uleb128_t value;
 274               p = read_uleb128 (p, &value);
 275               decoded = (_Unwind_Internal_Ptr)value;
 276               break;
 277             }
 278           case DW_EH_PE_sleb128:
 279             {
 280               _sleb128_t value;
 281               p = read_sleb128 (p, &value);
 282               decoded = (_Unwind_Internal_Ptr)value;
 283               break;
 284             }
 285           case DW_EH_PE_absptr:
 286             __builtin_memcpy (&decoded, (const void *)p, sizeof(const void*));
 287             p += sizeof(void *);
 288             break;
 289           default:
 290             abort ();
 291         }
 292
 293       if (decoded == 0)
 294         {
 295           *val = decoded;
 296           return p;
 297         }
 298
 299       if ((encoding & 0x70) == DW_EH_PE_pcrel)
 300         decoded += ((_Unwind_Internal_Ptr)origp);
 301       else
 302         decoded += base;
 303
 304       if ((encoding & DW_EH_PE_indirect) != 0)
 305         decoded = *(_Unwind_Internal_Ptr *)decoded;
 306     }
 307   *val = decoded;
 308   return p;
 309 }
 310
 311 static inline int
 312 value_size (uint8_t encoding)
 313 {
 314   switch (encoding & 0x0f)
 315     {
 316       case DW_EH_PE_sdata2:
 317       case DW_EH_PE_udata2:
 318         return 2;
 319       case DW_EH_PE_sdata4:
 320       case DW_EH_PE_udata4:
 321         return 4;
 322       case DW_EH_PE_sdata8:
 323       case DW_EH_PE_udata8:
 324         return 8;
 325       case DW_EH_PE_absptr:
 326         return sizeof(uintptr);
 327       default:
 328         break;
 329     }
 330   abort ();
 331 }
 332
 333 /* The rest of this code is really similar to gcc/unwind-c.c and
 334    libjava/exception.cc.  */
 335
 336 typedef struct
 337 {
 338   _Unwind_Ptr Start;
 339   _Unwind_Ptr LPStart;
 340   _Unwind_Ptr ttype_base;
 341   const unsigned char *TType;
 342   const unsigned char *action_table;
 343   unsigned char ttype_encoding;
 344   unsigned char call_site_encoding;
 345 } lsda_header_info;
 346
 347 static const unsigned char *
 348 parse_lsda_header (struct _Unwind_Context *context, const unsigned char *p,
 349                    lsda_header_info *info)
 350 {
 351   _uleb128_t tmp;
 352   unsigned char lpstart_encoding;
 353
 354   info->Start = (context ? _Unwind_GetRegionStart (context) : 0);
 355
 356   /* Find @LPStart, the base to which landing pad offsets are relative.  */
 357   lpstart_encoding = *p++;
 358   if (lpstart_encoding != DW_EH_PE_omit)
 359     p = read_encoded_value (context, lpstart_encoding, p, &info->LPStart);
 360   else
 361     info->LPStart = info->Start;
 362
 363   /* Find @TType, the base of the handler and exception spec type data.  */
 364   info->ttype_encoding = *p++;
 365   if (info->ttype_encoding != DW_EH_PE_omit)
 366     {
 367       p = read_uleb128 (p, &tmp);
 368       info->TType = p + tmp;
 369     }
 370   else
 371     info->TType = 0;
 372
 373   /* The encoding and length of the call-site table; the action table
 374      immediately follows.  */
 375   info->call_site_encoding = *p++;
 376   p = read_uleb128 (p, &tmp);
 377   info->action_table = p + tmp;
 378
 379   return p;
 380 }
 381
 382 /* The personality function is invoked when unwinding the stack due to
 383    a panic.  Its job is to find the cleanup and exception handlers to
 384    run.  We can't split the stack here, because we won't be able to
 385    unwind from that split.  */
 386
 387 #ifdef __ARM_EABI_UNWINDER__
 388 /* ARM EABI personality routines must also unwind the stack.  */
 389 #define CONTINUE_UNWINDING \
 390   do                                                            \
 391     {                                                           \
 392       if (__gnu_unwind_frame (ue_header, context) != _URC_OK)   \
 393         return _URC_FAILURE;                                    \
 394       return _URC_CONTINUE_UNWIND;                              \
 395     }                                                           \
 396   while (0)
 397 #else
 398 #define CONTINUE_UNWINDING return _URC_CONTINUE_UNWIND
 399 #endif
 400
 401 #ifdef __ARM_EABI_UNWINDER__
 402 #define STOP_UNWINDING _URC_FAILURE
 403 #else
 404 #define STOP_UNWINDING _URC_NORMAL_STOP
 405 #endif
 406
 407 #ifdef __USING_SJLJ_EXCEPTIONS__
 408 #define PERSONALITY_FUNCTION    __gccgo_personality_sj0
 409 #define __builtin_eh_return_data_regno(x) x
 410 #else
 411 #define PERSONALITY_FUNCTION    __gccgo_personality_v0
 412 #endif
 413
 414 #ifdef __ARM_EABI_UNWINDER__
 415 _Unwind_Reason_Code
 416 PERSONALITY_FUNCTION (_Unwind_State, struct _Unwind_Exception *,
 417                       struct _Unwind_Context *)
 418   __attribute__ ((no_split_stack, flatten, target ("general-regs-only")));
 419
 420 _Unwind_Reason_Code
 421 PERSONALITY_FUNCTION (_Unwind_State state,
 422                       struct _Unwind_Exception * ue_header,
 423                       struct _Unwind_Context * context)
 424 #else
 425 _Unwind_Reason_Code
 426 PERSONALITY_FUNCTION (int, _Unwind_Action, _Unwind_Exception_Class,
 427                       struct _Unwind_Exception *, struct _Unwind_Context *)
 428   __attribute__ ((no_split_stack, flatten));
 429
 430 _Unwind_Reason_Code
 431 PERSONALITY_FUNCTION (int version,
 432                       _Unwind_Action actions,
 433                       _Unwind_Exception_Class exception_class,
 434                       struct _Unwind_Exception *ue_header,
 435                       struct _Unwind_Context *context)
 436 #endif
 437 {
 438   lsda_header_info info;
 439   const unsigned char *language_specific_data, *p, *action_record;
 440   _Unwind_Ptr landing_pad, ip;
 441   int ip_before_insn = 0;
 442   _Bool is_foreign;
 443   G *g;
 444
 445 #ifdef __ARM_EABI_UNWINDER__
 446   _Unwind_Action actions;
 447
 448   switch (state & _US_ACTION_MASK)
 449     {
 450     case _US_VIRTUAL_UNWIND_FRAME:
 451       if (state & _UA_FORCE_UNWIND)
 452         /* We are called from _Unwind_Backtrace.  No handler to run.  */
 453         CONTINUE_UNWINDING;
 454       actions = _UA_SEARCH_PHASE;
 455       break;
 456
 457     case _US_UNWIND_FRAME_STARTING:
 458       actions = _UA_CLEANUP_PHASE;
 459       if (!(state & _US_FORCE_UNWIND)
 460           && ue_header->barrier_cache.sp == _Unwind_GetGR(context, 13))
 461         actions |= _UA_HANDLER_FRAME;
 462       break;
 463
 464     case _US_UNWIND_FRAME_RESUME:
 465       CONTINUE_UNWINDING;
 466       break;
 467
 468     default:
 469       abort();
 470     }
 471   actions |= state & _US_FORCE_UNWIND;
 472
 473   is_foreign = 0;
 474
 475   /* The dwarf unwinder assumes the context structure holds things like the
 476      function and LSDA pointers.  The ARM implementation caches these in
 477      the exception header (UCB).  To avoid rewriting everything we make the
 478      virtual IP register point at the UCB.  */
 479   ip = (_Unwind_Ptr) ue_header;
 480   _Unwind_SetGR (context, 12, ip);
 481 #else
 482   if (version != 1)
 483     return _URC_FATAL_PHASE1_ERROR;
 484
 485   is_foreign = exception_class != __go_exception_class;
 486 #endif
 487
 488   language_specific_data = (const unsigned char *)
 489     _Unwind_GetLanguageSpecificData (context);
 490
 491   /* If no LSDA, then there are no handlers or cleanups.  */
 492   if (! language_specific_data)
 493     CONTINUE_UNWINDING;
 494
 495   /* Parse the LSDA header.  */
 496   p = parse_lsda_header (context, language_specific_data, &info);
 497 #ifdef HAVE_GETIPINFO
 498   ip = _Unwind_GetIPInfo (context, &ip_before_insn);
 499 #else
 500   ip = _Unwind_GetIP (context);
 501 #endif
 502   if (! ip_before_insn)
 503     --ip;
 504   landing_pad = 0;
 505   action_record = NULL;
 506
 507 #ifdef __USING_SJLJ_EXCEPTIONS__
 508   /* The given "IP" is an index into the call-site table, with two
 509      exceptions -- -1 means no-action, and 0 means terminate.  But
 510      since we're using uleb128 values, we've not got random access
 511      to the array.  */
 512   if ((int) ip <= 0)
 513     return _URC_CONTINUE_UNWIND;
 514   else
 515     {
 516       _uleb128_t cs_lp, cs_action;
 517       do
 518         {
 519           p = read_uleb128 (p, &cs_lp);
 520           p = read_uleb128 (p, &cs_action);
 521         }
 522       while (--ip);
 523
 524       /* Can never have null landing pad for sjlj -- that would have
 525          been indicated by a -1 call site index.  */
 526       landing_pad = (_Unwind_Ptr)cs_lp + 1;
 527       if (cs_action)
 528         action_record = info.action_table + cs_action - 1;
 529       goto found_something;
 530     }
 531 #else
 532   /* Search the call-site table for the action associated with this IP.  */
 533   while (p < info.action_table)
 534     {
 535       _Unwind_Ptr cs_start, cs_len, cs_lp;
 536       _uleb128_t cs_action;
 537
 538       /* Note that all call-site encodings are "absolute" displacements.  */
 539       p = read_encoded_value (0, info.call_site_encoding, p, &cs_start);
 540       p = read_encoded_value (0, info.call_site_encoding, p, &cs_len);
 541       p = read_encoded_value (0, info.call_site_encoding, p, &cs_lp);
 542       p = read_uleb128 (p, &cs_action);
 543
 544       /* The table is sorted, so if we've passed the ip, stop.  */
 545       if (ip < info.Start + cs_start)
 546         p = info.action_table;
 547       else if (ip < info.Start + cs_start + cs_len)
 548         {
 549           if (cs_lp)
 550             landing_pad = info.LPStart + cs_lp;
 551           if (cs_action)
 552             action_record = info.action_table + cs_action - 1;
 553           goto found_something;
 554         }
 555     }
 556 #endif
 557
 558   /* IP is not in table.  No associated cleanups.  */
 559   CONTINUE_UNWINDING;
 560
 561  found_something:
 562   if (landing_pad == 0)
 563     {
 564       /* IP is present, but has a null landing pad.
 565          No handler to be run.  */
 566       CONTINUE_UNWINDING;
 567     }
 568
 569   if (actions & _UA_SEARCH_PHASE)
 570     {
 571       if (action_record == 0)
 572         {
 573           /* This indicates a cleanup rather than an exception
 574              handler.  */
 575           CONTINUE_UNWINDING;
 576         }
 577
 578       return _URC_HANDLER_FOUND;
 579     }
 580
 581   /* It's possible for g to be NULL here for an exception thrown by a
 582      language other than Go.  */
 583   g = runtime_g ();
 584   if (g == NULL)
 585     {
 586       if (!is_foreign)
 587         abort ();
 588     }
 589   else
 590     {
 591       g->exception = ue_header;
 592       g->isforeign = is_foreign;
 593     }
 594
 595   _Unwind_SetGR (context, __builtin_eh_return_data_regno (0),
 596                  (_Unwind_Ptr) ue_header);
 597   _Unwind_SetGR (context, __builtin_eh_return_data_regno (1), 0);
 598   _Unwind_SetIP (context, landing_pad);
 599   return _URC_INSTALL_CONTEXT;
 600 }
 601
 602 // A dummy personality function, which doesn't capture any exception
 603 // and simply passes by. This is used for functions that don't
 604 // capture exceptions but need LSDA for stack maps.
 605 _Unwind_Reason_Code
 606 __gccgo_personality_dummy (int, _Unwind_Action, _Unwind_Exception_Class,
 607                       struct _Unwind_Exception *, struct _Unwind_Context *)
 608   __attribute__ ((no_split_stack));
 609
 610 _Unwind_Reason_Code
 611 #ifdef __ARM_EABI_UNWINDER__
 612 __attribute__ ((target ("general-regs-only")))
 613 #endif
 614 __gccgo_personality_dummy (int version __attribute__ ((unused)),
 615                       _Unwind_Action actions __attribute__ ((unused)),
 616                       _Unwind_Exception_Class exception_class __attribute__ ((unused)),
 617                       struct _Unwind_Exception *ue_header __attribute__ ((unused)),
 618                       struct _Unwind_Context *context __attribute__ ((unused)))
 619 {
 620   CONTINUE_UNWINDING;
 621 }
 622
 623 // A sentinel value for Go functions.
 624 // A function is a Go function if it has LSDA, which has type info,
 625 // and the first (dummy) landing pad's type info is a pointer to
 626 // this value.
 627 #define GO_FUNC_SENTINEL ((uint64)'G' | ((uint64)'O'<<8) | \
 628                           ((uint64)'.'<<16) | ((uint64)'.'<<24) | \
 629                           ((uint64)'F'<<32) | ((uint64)'U'<<40) | \
 630                           ((uint64)'N'<<48) | ((uint64)'C'<<56))
 631
 632 struct _stackmap {
 633   uint32 len;
 634   uint8 data[1]; // variabe length
 635 };
 636
 637 extern void
 638   runtime_scanstackblockwithmap (uintptr ip, uintptr sp, uintptr size, uint8 *ptrmask, void* gcw)
 639   __asm__ (GOSYM_PREFIX "runtime.scanstackblockwithmap");
 640
 641 #define FOUND        0
 642 #define NOTFOUND_OK  1
 643 #define NOTFOUND_BAD 2
 644
 645 // Helper function to search for stack maps in the unwinding records of a frame.
 646 // If found, populate ip, sp, and stackmap. Returns the #define'd values above.
 647 static int
 648 findstackmaps (struct _Unwind_Context *context, _Unwind_Ptr *ip, _Unwind_Ptr *sp, struct _stackmap **stackmap)
 649 {
 650   lsda_header_info info;
 651   const unsigned char *language_specific_data, *p, *action_record;
 652   bool first;
 653   struct _stackmap *stackmap1;
 654   _Unwind_Ptr ip1;
 655   int ip_before_insn = 0;
 656   _sleb128_t index;
 657   int size;
 658
 659 #ifdef HAVE_GETIPINFO
 660   ip1 = _Unwind_GetIPInfo (context, &ip_before_insn);
 661 #else
 662   ip1 = _Unwind_GetIP (context);
 663 #endif
 664   if (! ip_before_insn)
 665     --ip1;
 666
 667   if (ip != NULL)
 668     *ip = ip1;
 669   if (sp != NULL)
 670     *sp = _Unwind_GetCFA (context);
 671
 672 #ifdef __ARM_EABI_UNWINDER__
 673   {
 674     _Unwind_Control_Block *ucbp;
 675     ucbp = (_Unwind_Control_Block *) _Unwind_GetGR (context, 12);
 676     if (*ucbp->pr_cache.ehtp & (1u << 31))
 677       // The "compact" model is used, with one of the predefined
 678       // personality functions. It doesn't have standard LSDA.
 679       return NOTFOUND_OK;
 680   }
 681 #endif
 682
 683   language_specific_data = (const unsigned char *)
 684     _Unwind_GetLanguageSpecificData (context);
 685
 686   /* If no LSDA, then there is no stack maps.  */
 687   if (! language_specific_data)
 688     return NOTFOUND_OK;
 689
 690   p = parse_lsda_header (context, language_specific_data, &info);
 691
 692   if (info.TType == NULL)
 693     return NOTFOUND_OK;
 694
 695   size = value_size (info.ttype_encoding);
 696
 697   action_record = NULL;
 698   first = true;
 699
 700   /* Search the call-site table for the action associated with this IP.  */
 701   while (p < info.action_table)
 702     {
 703       _Unwind_Ptr cs_start, cs_len, cs_lp;
 704       _uleb128_t cs_action;
 705
 706       /* Note that all call-site encodings are "absolute" displacements.  */
 707       p = read_encoded_value (0, info.call_site_encoding, p, &cs_start);
 708       p = read_encoded_value (0, info.call_site_encoding, p, &cs_len);
 709       p = read_encoded_value (0, info.call_site_encoding, p, &cs_lp);
 710       p = read_uleb128 (p, &cs_action);
 711
 712       if (first)
 713         {
 714           // For a Go function, the first entry points to the sentinel value.
 715           // Check this here.
 716           const unsigned char *p1, *action1;
 717           uint64 *x;
 718
 719           if (!cs_action)
 720             return NOTFOUND_OK;
 721
 722           action1 = info.action_table + cs_action - 1;
 723           read_sleb128 (action1, &index);
 724           p1 = info.TType - index*size;
 725           read_encoded_value (context, info.ttype_encoding, p1, (_Unwind_Ptr*)&x);
 726           if (x == NULL || *x != GO_FUNC_SENTINEL)
 727             return NOTFOUND_OK;
 728
 729           first = false;
 730           continue;
 731         }
 732
 733       /* The table is sorted, so if we've passed the ip, stop.  */
 734       if (ip1 < info.Start + cs_start)
 735         return NOTFOUND_BAD;
 736       else if (ip1 < info.Start + cs_start + cs_len)
 737         {
 738           if (cs_action)
 739             action_record = info.action_table + cs_action - 1;
 740           break;
 741         }
 742     }
 743
 744   if (action_record == NULL)
 745     return NOTFOUND_BAD;
 746
 747   read_sleb128 (action_record, &index);
 748   p = info.TType - index*size;
 749   read_encoded_value (context, info.ttype_encoding, p, (_Unwind_Ptr*)&stackmap1);
 750   if (stackmap1 == NULL)
 751     return NOTFOUND_BAD;
 752
 753   if (stackmap != NULL)
 754     *stackmap = stackmap1;
 755   return FOUND;
 756 }
 757
 758 struct scanstate {
 759   void* gcw;      // the GC worker, passed into scanstackwithmap_callback
 760   uintptr lastsp; // the last (outermost) SP of Go function seen in a traceback, set by the callback
 761 };
 762
 763 // Callback function to scan a stack frame with stack maps.
 764 // It skips non-Go functions.
 765 static _Unwind_Reason_Code
 766 scanstackwithmap_callback (struct _Unwind_Context *context, void *arg)
 767 {
 768   struct _stackmap *stackmap;
 769   _Unwind_Ptr ip, sp;
 770   G* gp;
 771   struct scanstate* state = (struct scanstate*) arg;
 772   void *gcw;
 773
 774   gp = runtime_g ();
 775   gcw = state->gcw;
 776
 777   switch (findstackmaps (context, &ip, &sp, &stackmap))
 778     {
 779       case NOTFOUND_OK:
 780         // Not a Go function. Skip this frame.
 781         return _URC_NO_REASON;
 782       case NOTFOUND_BAD:
 783         {
 784           // No stack map found.
 785           // If we're scanning from the signal stack, the goroutine
 786           // may be not stopped at a safepoint. Allow this case.
 787           if (gp != gp->m->gsignal)
 788             {
 789               // TODO: print gp, pc, sp
 790               runtime_throw ("no stack map");
 791             }
 792           return STOP_UNWINDING;
 793         }
 794       case FOUND:
 795         break;
 796       default:
 797         abort ();
 798     }
 799
 800   state->lastsp = sp;
 801   runtime_scanstackblockwithmap (ip, sp, (uintptr)(stackmap->len) * sizeof(uintptr), stackmap->data, gcw);
 802
 803   return _URC_NO_REASON;
 804 }
 805
 806 // Scan the stack with stack maps. Return whether the scan
 807 // succeeded.
 808 bool
 809 scanstackwithmap (void *gcw)
 810 {
 811   _Unwind_Reason_Code code;
 812   bool ret;
 813   struct scanstate state;
 814   G* gp;
 815   G* curg;
 816
 817   state.gcw = gcw;
 818   state.lastsp = 0;
 819   gp = runtime_g ();
 820   curg = gp->m->curg;
 821
 822   runtime_xadd (&__go_runtime_in_callers, 1);
 823   code = _Unwind_Backtrace (scanstackwithmap_callback, (void*)&state);
 824   runtime_xadd (&__go_runtime_in_callers, -1);
 825   ret = (code == _URC_END_OF_STACK);
 826   if (ret && gp == gp->m->gsignal)
 827     {
 828       // For signal-triggered scan, the unwinder may not be able to unwind
 829       // the whole stack while it still reports _URC_END_OF_STACK (e.g.
 830       // signal is delivered in vdso). Check that we actually reached the
 831       // the end of the stack, that is, the SP on entry.
 832       if (state.lastsp != curg->entrysp)
 833         ret = false;
 834     }
 835   return ret;
 836 }
 837
 838 // Returns whether stack map is enabled.
 839 bool
 840 usestackmaps ()
 841 {
 842   return runtime_usestackmaps;
 843 }
 844
 845 // Callback function to probe if a stack frame has stack maps.
 846 static _Unwind_Reason_Code
 847 probestackmaps_callback (struct _Unwind_Context *context,
 848                          void *arg __attribute__ ((unused)))
 849 {
 850   switch (findstackmaps (context, NULL, NULL, NULL))
 851     {
 852       case NOTFOUND_OK:
 853       case NOTFOUND_BAD:
 854         return _URC_NO_REASON;
 855       case FOUND:
 856         break;
 857       default:
 858         abort ();
 859     }
 860
 861   // Found a stack map. No need to keep unwinding.
 862   runtime_usestackmaps = true;
 863   return STOP_UNWINDING;
 864 }
 865
 866 // Try to find a stack map, store the result in global variable runtime_usestackmaps.
 867 // Called in start-up time from Go code, so there is a Go frame on the stack.
 868 bool
 869 probestackmaps ()
 870 {
 871   runtime_usestackmaps = false;
 872   _Unwind_Backtrace (probestackmaps_callback, NULL);
 873   return runtime_usestackmaps;
 874 }