gcc/frame.c

   1 /* Subroutines needed for unwinding stack frames for exception handling.  */
   2 /* Compile this one with gcc.  */
   3 /* Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
   4    Contributed by Jason Merrill <jason@cygnus.com>.
   5
   6 This file is part of GNU CC.
   7
   8 GNU CC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GNU CC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GNU CC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23 /* As a special exception, if you link this library with other files,
  24    some of which are compiled with GCC, to produce an executable,
  25    this library does not by itself cause the resulting executable
  26    to be covered by the GNU General Public License.
  27    This exception does not however invalidate any other reasons why
  28    the executable file might be covered by the GNU General Public License.  */
  29
  30 /* It is incorrect to include config.h here, because this file is being
  31    compiled for the target, and hence definitions concerning only the host
  32    do not apply.  */
  33
  34 #include "tconfig.h"
  35
  36 /* We disable this when inhibit_libc, so that gcc can still be built without
  37    needing header files first.  */
  38 /* ??? This is not a good solution, since prototypes may be required in
  39    some cases for correct code.  See also libgcc2.c.  */
  40 #ifndef inhibit_libc
  41 /* fixproto guarantees these system headers exist. */
  42 #include <stdlib.h>
  43 #include <unistd.h>
  44
  45 #else
  46 #include <stddef.h>
  47 #ifndef malloc
  48 extern void *malloc (size_t);
  49 #endif
  50 #ifndef free
  51 extern void free (void *);
  52 #endif
  53 #endif
  54
  55 #include "defaults.h"
  56
  57 #ifdef DWARF2_UNWIND_INFO
  58 #include "dwarf2.h"
  59 #include <stddef.h>
  60 #include "frame.h"
  61 #include "gthr.h"
  62
  63 #ifdef __GTHREAD_MUTEX_INIT
  64 static __gthread_mutex_t object_mutex = __GTHREAD_MUTEX_INIT;
  65 #else
  66 static __gthread_mutex_t object_mutex;
  67 #endif
  68
  69 /* Don't use `fancy_abort' here even if config.h says to use it.  */
  70 #ifdef abort
  71 #undef abort
  72 #endif
  73
  74 /* Some types used by the DWARF 2 spec.  */
  75
  76 typedef          int  sword __attribute__ ((mode (SI)));
  77 typedef unsigned int  uword __attribute__ ((mode (SI)));
  78 typedef unsigned int  uaddr __attribute__ ((mode (pointer)));
  79 typedef          int  saddr __attribute__ ((mode (pointer)));
  80 typedef unsigned char ubyte;
  81
  82 /* Terminology:
  83    CIE - Common Information Element
  84    FDE - Frame Descriptor Element
  85
  86    There is one per function, and it describes where the function code
  87    is located, and what the register lifetimes and stack layout are
  88    within the function.
  89
  90    The data structures are defined in the DWARF specfication, although
  91    not in a very readable way (see LITERATURE).
  92
  93    Every time an exception is thrown, the code needs to locate the FDE
  94    for the current function, and starts to look for exception regions
  95    from that FDE. This works in a two-level search:
  96    a) in a linear search, find the shared image (i.e. DLL) containing
  97       the PC
  98    b) using the FDE table for that shared object, locate the FDE using
  99       binary search (which requires the sorting).  */
 100
 101 /* The first few fields of a CIE.  The CIE_id field is 0 for a CIE,
 102    to distinguish it from a valid FDE.  FDEs are aligned to an addressing
 103    unit boundary, but the fields within are unaligned.  */
 104
 105 struct dwarf_cie {
 106   uword length;
 107   sword CIE_id;
 108   ubyte version;
 109   char augmentation[0];
 110 } __attribute__ ((packed, aligned (__alignof__ (void *))));
 111
 112 /* The first few fields of an FDE.  */
 113
 114 struct dwarf_fde {
 115   uword length;
 116   sword CIE_delta;
 117   void* pc_begin;
 118   uaddr pc_range;
 119 } __attribute__ ((packed, aligned (__alignof__ (void *))));
 120
 121 typedef struct dwarf_fde fde;
 122
 123 /* Objects to be searched for frame unwind info.  */
 124
 125 static struct object *objects;
 126
 127 /* The information we care about from a CIE.  */
 128
 129 struct cie_info {
 130   char *augmentation;
 131   void *eh_ptr;
 132   int code_align;
 133   int data_align;
 134   unsigned ra_regno;
 135 };
 136
 137 /* The current unwind state, plus a saved copy for DW_CFA_remember_state.  */
 138
 139 struct frame_state_internal
 140 {
 141   struct frame_state s;
 142   struct frame_state_internal *saved_state;
 143 };
 144 \f
 145 /* This is undefined below if we need it to be an actual function.  */
 146 #define init_object_mutex_once()
 147
 148 #if __GTHREADS
 149 #ifdef __GTHREAD_MUTEX_INIT_FUNCTION
 150
 151 /* Helper for init_object_mutex_once.  */
 152
 153 static void
 154 init_object_mutex (void)
 155 {
 156   __GTHREAD_MUTEX_INIT_FUNCTION (&object_mutex);
 157 }
 158
 159 /* Call this to arrange to initialize the object mutex.  */
 160
 161 #undef init_object_mutex_once
 162 static void
 163 init_object_mutex_once (void)
 164 {
 165   static __gthread_once_t once = __GTHREAD_ONCE_INIT;
 166   __gthread_once (&once, init_object_mutex);
 167 }
 168
 169 #endif /* __GTHREAD_MUTEX_INIT_FUNCTION */
 170 #endif /* __GTHREADS */
 171 \f
 172 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to
 173    by R, and return the new value of BUF.  */
 174
 175 static void *
 176 decode_uleb128 (unsigned char *buf, unsigned *r)
 177 {
 178   unsigned shift = 0;
 179   unsigned result = 0;
 180
 181   while (1)
 182     {
 183       unsigned byte = *buf++;
 184       result |= (byte & 0x7f) << shift;
 185       if ((byte & 0x80) == 0)
 186         break;
 187       shift += 7;
 188     }
 189   *r = result;
 190   return buf;
 191 }
 192
 193 /* Decode the signed LEB128 constant at BUF into the variable pointed to
 194    by R, and return the new value of BUF.  */
 195
 196 static void *
 197 decode_sleb128 (unsigned char *buf, int *r)
 198 {
 199   unsigned shift = 0;
 200   unsigned result = 0;
 201   unsigned byte;
 202
 203   while (1)
 204     {
 205       byte = *buf++;
 206       result |= (byte & 0x7f) << shift;
 207       shift += 7;
 208       if ((byte & 0x80) == 0)
 209         break;
 210     }
 211   if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
 212     result |= - (1 << shift);
 213
 214   *r = result;
 215   return buf;
 216 }
 217
 218 /* Read unaligned data from the instruction buffer.  */
 219
 220 union unaligned {
 221   void *p;
 222   unsigned b2 __attribute__ ((mode (HI)));
 223   unsigned b4 __attribute__ ((mode (SI)));
 224   unsigned b8 __attribute__ ((mode (DI)));
 225 } __attribute__ ((packed));
 226 static inline void *
 227 read_pointer (void *p)
 228 { union unaligned *up = p; return up->p; }
 229 static inline unsigned
 230 read_1byte (void *p)
 231 { return *(unsigned char *)p; }
 232 static inline unsigned
 233 read_2byte (void *p)
 234 { union unaligned *up = p; return up->b2; }
 235 static inline unsigned
 236 read_4byte (void *p)
 237 { union unaligned *up = p; return up->b4; }
 238 static inline unsigned long
 239 read_8byte (void *p)
 240 { union unaligned *up = p; return up->b8; }
 241 \f
 242 /* Ordering function for FDEs.  Functions can't overlap, so we just compare
 243    their starting addresses.  */
 244
 245 static inline saddr
 246 fde_compare (fde *x, fde *y)
 247 {
 248   return (saddr)x->pc_begin - (saddr)y->pc_begin;
 249 }
 250
 251 /* Return the address of the FDE after P.  */
 252
 253 static inline fde *
 254 next_fde (fde *p)
 255 {
 256   return (fde *)(((char *)p) + p->length + sizeof (p->length));
 257 }
 258
 259 /* Sorting an array of FDEs by address.
 260    (Ideally we would have the linker sort the FDEs so we don't have to do
 261    it at run time. But the linkers are not yet prepared for this.)  */
 262
 263 /* This is a special mix of insertion sort and heap sort, optimized for
 264    the data sets that actually occur. They look like
 265    101 102 103 127 128 105 108 110 190 111 115 119 125 160 126 129 130.
 266    I.e. a linearly increasing sequence (coming from functions in the text
 267    section), with additionally a few unordered elements (coming from functions
 268    in gnu_linkonce sections) whose values are higher than the values in the
 269    surrounding linear sequence (but not necessarily higher than the values
 270    at the end of the linear sequence!).
 271    The worst-case total run time is O(N) + O(n log (n)), where N is the
 272    total number of FDEs and n is the number of erratic ones.  */
 273
 274 typedef struct fde_vector
 275 {
 276   fde **array;
 277   size_t count;
 278 } fde_vector;
 279
 280 typedef struct fde_accumulator
 281 {
 282   fde_vector linear;
 283   fde_vector erratic;
 284 } fde_accumulator;
 285
 286 static inline void
 287 start_fde_sort (fde_accumulator *accu, size_t count)
 288 {
 289   accu->linear.array = (fde **) malloc (sizeof (fde *) * count);
 290   accu->erratic.array = (fde **) malloc (sizeof (fde *) * count);
 291   accu->linear.count = 0;
 292   accu->erratic.count = 0;
 293 }
 294
 295 static inline void
 296 fde_insert (fde_accumulator *accu, fde *this_fde)
 297 {
 298   accu->linear.array[accu->linear.count++] = this_fde;
 299 }
 300
 301 /* Split LINEAR into a linear sequence with low values and an erratic
 302    sequence with high values, put the linear one (of longest possible
 303    length) into LINEAR and the erratic one into ERRATIC. This is O(N).  */
 304 static inline void
 305 fde_split (fde_vector *linear, fde_vector *erratic)
 306 {
 307   size_t count = linear->count;
 308   size_t linear_max = (size_t) -1;
 309   size_t previous_max[count];
 310   size_t i, j;
 311
 312   for (i = 0; i < count; i++)
 313     {
 314       for (j = linear_max;
 315            j != (size_t) -1
 316            && fde_compare (linear->array[i], linear->array[j]) < 0;
 317            j = previous_max[j])
 318         {
 319           erratic->array[erratic->count++] = linear->array[j];
 320           linear->array[j] = (fde *) NULL;
 321         }
 322       previous_max[i] = j;
 323       linear_max = i;
 324     }
 325
 326   for (i = 0, j = 0; i < count; i++)
 327     if (linear->array[i] != (fde *) NULL)
 328       linear->array[j++] = linear->array[i];
 329   linear->count = j;
 330 }
 331
 332 /* This is O(n log(n)).  BSD/OS defines heapsort in stdlib.h, so we must
 333    use a name that does not conflict.  */
 334 static inline void
 335 frame_heapsort (fde_vector *erratic)
 336 {
 337   /* For a description of this algorithm, see:
 338      Samuel P. Harbison, Guy L. Steele Jr.: C, a reference manual, 2nd ed.,
 339      p. 60-61. */
 340   fde ** a = erratic->array;
 341   /* A portion of the array is called a "heap" if for all i>=0:
 342      If i and 2i+1 are valid indices, then a[i] >= a[2i+1].
 343      If i and 2i+2 are valid indices, then a[i] >= a[2i+2]. */
 344 #define SWAP(x,y) do { fde * tmp = x; x = y; y = tmp; } while (0)
 345   size_t n = erratic->count;
 346   size_t m = n;
 347   size_t i;
 348
 349   while (m > 0)
 350     {
 351       /* Invariant: a[m..n-1] is a heap. */
 352       m--;
 353       for (i = m; 2*i+1 < n; )
 354         {
 355           if (2*i+2 < n
 356               && fde_compare (a[2*i+2], a[2*i+1]) > 0
 357               && fde_compare (a[2*i+2], a[i]) > 0)
 358             {
 359               SWAP (a[i], a[2*i+2]);
 360               i = 2*i+2;
 361             }
 362           else if (fde_compare (a[2*i+1], a[i]) > 0)
 363             {
 364               SWAP (a[i], a[2*i+1]);
 365               i = 2*i+1;
 366             }
 367           else
 368             break;
 369         }
 370     }
 371   while (n > 1)
 372     {
 373       /* Invariant: a[0..n-1] is a heap. */
 374       n--;
 375       SWAP (a[0], a[n]);
 376       for (i = 0; 2*i+1 < n; )
 377         {
 378           if (2*i+2 < n
 379               && fde_compare (a[2*i+2], a[2*i+1]) > 0
 380               && fde_compare (a[2*i+2], a[i]) > 0)
 381             {
 382               SWAP (a[i], a[2*i+2]);
 383               i = 2*i+2;
 384             }
 385           else if (fde_compare (a[2*i+1], a[i]) > 0)
 386             {
 387               SWAP (a[i], a[2*i+1]);
 388               i = 2*i+1;
 389             }
 390           else
 391             break;
 392         }
 393     }
 394 #undef SWAP
 395 }
 396
 397 /* Merge V1 and V2, both sorted, and put the result into V1. */
 398 static void
 399 fde_merge (fde_vector *v1, const fde_vector *v2)
 400 {
 401   size_t i1, i2;
 402   fde * fde2;
 403
 404   i2 = v2->count;
 405   if (i2 > 0)
 406     {
 407       i1 = v1->count;
 408       do {
 409         i2--;
 410         fde2 = v2->array[i2];
 411         while (i1 > 0 && fde_compare (v1->array[i1-1], fde2) > 0)
 412           {
 413             v1->array[i1+i2] = v1->array[i1-1];
 414             i1--;
 415           }
 416         v1->array[i1+i2] = fde2;
 417       } while (i2 > 0);
 418       v1->count += v2->count;
 419     }
 420 }
 421
 422 static fde **
 423 end_fde_sort (fde_accumulator *accu, size_t count)
 424 {
 425   if (accu->linear.count != count)
 426     abort ();
 427   fde_split (&accu->linear, &accu->erratic);
 428   if (accu->linear.count + accu->erratic.count != count)
 429     abort ();
 430   frame_heapsort (&accu->erratic);
 431   fde_merge (&accu->linear, &accu->erratic);
 432   free (accu->erratic.array);
 433   return accu->linear.array;
 434 }
 435
 436 static size_t
 437 count_fdes (fde *this_fde)
 438 {
 439   size_t count;
 440
 441   for (count = 0; this_fde->length != 0; this_fde = next_fde (this_fde))
 442     {
 443       /* Skip CIEs and linked once FDE entries.  */
 444       if (this_fde->CIE_delta == 0 || this_fde->pc_begin == 0)
 445         continue;
 446
 447       ++count;
 448     }
 449
 450   return count;
 451 }
 452
 453 static void
 454 add_fdes (fde *this_fde, fde_accumulator *accu, void **beg_ptr, void **end_ptr)
 455 {
 456   void *pc_begin = *beg_ptr;
 457   void *pc_end = *end_ptr;
 458
 459   for (; this_fde->length != 0; this_fde = next_fde (this_fde))
 460     {
 461       /* Skip CIEs and linked once FDE entries.  */
 462       if (this_fde->CIE_delta == 0 || this_fde->pc_begin == 0)
 463         continue;
 464
 465       fde_insert (accu, this_fde);
 466
 467       if (this_fde->pc_begin < pc_begin)
 468         pc_begin = this_fde->pc_begin;
 469       if (this_fde->pc_begin + this_fde->pc_range > pc_end)
 470         pc_end = this_fde->pc_begin + this_fde->pc_range;
 471     }
 472
 473   *beg_ptr = pc_begin;
 474   *end_ptr = pc_end;
 475 }
 476
 477 /* Set up a sorted array of pointers to FDEs for a loaded object.  We
 478    count up the entries before allocating the array because it's likely to
 479    be faster.  */
 480
 481 static void
 482 frame_init (struct object* ob)
 483 {
 484   size_t count;
 485   fde_accumulator accu;
 486   void *pc_begin, *pc_end;
 487
 488   if (ob->fde_array)
 489     {
 490       fde **p = ob->fde_array;
 491       for (count = 0; *p; ++p)
 492         count += count_fdes (*p);
 493     }
 494   else
 495     count = count_fdes (ob->fde_begin);
 496
 497   ob->count = count;
 498
 499   start_fde_sort (&accu, count);
 500   pc_begin = (void*)(uaddr)-1;
 501   pc_end = 0;
 502
 503   if (ob->fde_array)
 504     {
 505       fde **p = ob->fde_array;
 506       for (; *p; ++p)
 507         add_fdes (*p, &accu, &pc_begin, &pc_end);
 508     }
 509   else
 510     add_fdes (ob->fde_begin, &accu, &pc_begin, &pc_end);
 511
 512   ob->fde_array = end_fde_sort (&accu, count);
 513   ob->pc_begin = pc_begin;
 514   ob->pc_end = pc_end;
 515 }
 516
 517 /* Return a pointer to the FDE for the function containing PC.  */
 518
 519 static fde *
 520 find_fde (void *pc)
 521 {
 522   struct object *ob;
 523   size_t lo, hi;
 524
 525   init_object_mutex_once ();
 526   __gthread_mutex_lock (&object_mutex);
 527
 528   for (ob = objects; ob; ob = ob->next)
 529     {
 530       if (ob->pc_begin == 0)
 531         frame_init (ob);
 532       if (pc >= ob->pc_begin && pc < ob->pc_end)
 533         break;
 534     }
 535
 536   __gthread_mutex_unlock (&object_mutex);
 537
 538   if (ob == 0)
 539     return 0;
 540
 541   /* Standard binary search algorithm.  */
 542   for (lo = 0, hi = ob->count; lo < hi; )
 543     {
 544       size_t i = (lo + hi) / 2;
 545       fde *f = ob->fde_array[i];
 546
 547       if (pc < f->pc_begin)
 548         hi = i;
 549       else if (pc >= f->pc_begin + f->pc_range)
 550         lo = i + 1;
 551       else
 552         return f;
 553     }
 554
 555   return 0;
 556 }
 557 \f
 558 static inline struct dwarf_cie *
 559 get_cie (fde *f)
 560 {
 561   return ((void *)&f->CIE_delta) - f->CIE_delta;
 562 }
 563
 564 /* Extract any interesting information from the CIE for the translation
 565    unit F belongs to.  */
 566
 567 static void *
 568 extract_cie_info (fde *f, struct cie_info *c)
 569 {
 570   void *p;
 571   int i;
 572
 573   c->augmentation = get_cie (f)->augmentation;
 574
 575   if (strcmp (c->augmentation, "") != 0
 576       && strcmp (c->augmentation, "eh") != 0
 577       && c->augmentation[0] != 'z')
 578     return 0;
 579
 580   p = c->augmentation + strlen (c->augmentation) + 1;
 581
 582   if (strcmp (c->augmentation, "eh") == 0)
 583     {
 584       c->eh_ptr = read_pointer (p);
 585       p += sizeof (void *);
 586     }
 587   else
 588     c->eh_ptr = 0;
 589
 590   p = decode_uleb128 (p, &c->code_align);
 591   p = decode_sleb128 (p, &c->data_align);
 592   c->ra_regno = *(unsigned char *)p++;
 593
 594   /* If the augmentation starts with 'z', we now see the length of the
 595      augmentation fields.  */
 596   if (c->augmentation[0] == 'z')
 597     {
 598       p = decode_uleb128 (p, &i);
 599       p += i;
 600     }
 601
 602   return p;
 603 }
 604
 605 /* Decode one instruction's worth of DWARF 2 call frame information.
 606    Used by __frame_state_for.  Takes pointers P to the instruction to
 607    decode, STATE to the current register unwind information, INFO to the
 608    current CIE information, and PC to the current PC value.  Returns a
 609    pointer to the next instruction.  */
 610
 611 static void *
 612 execute_cfa_insn (void *p, struct frame_state_internal *state,
 613                   struct cie_info *info, void **pc)
 614 {
 615   unsigned insn = *(unsigned char *)p++;
 616   unsigned reg;
 617   int offset;
 618
 619   if (insn & DW_CFA_advance_loc)
 620     *pc += ((insn & 0x3f) * info->code_align);
 621   else if (insn & DW_CFA_offset)
 622     {
 623       reg = (insn & 0x3f);
 624       p = decode_uleb128 (p, &offset);
 625       offset *= info->data_align;
 626       state->s.saved[reg] = REG_SAVED_OFFSET;
 627       state->s.reg_or_offset[reg] = offset;
 628     }
 629   else if (insn & DW_CFA_restore)
 630     {
 631       reg = (insn & 0x3f);
 632       state->s.saved[reg] = REG_UNSAVED;
 633     }
 634   else switch (insn)
 635     {
 636     case DW_CFA_set_loc:
 637       *pc = read_pointer (p);
 638       p += sizeof (void *);
 639       break;
 640     case DW_CFA_advance_loc1:
 641       *pc += read_1byte (p);
 642       p += 1;
 643       break;
 644     case DW_CFA_advance_loc2:
 645       *pc += read_2byte (p);
 646       p += 2;
 647       break;
 648     case DW_CFA_advance_loc4:
 649       *pc += read_4byte (p);
 650       p += 4;
 651       break;
 652
 653     case DW_CFA_offset_extended:
 654       p = decode_uleb128 (p, &reg);
 655       p = decode_uleb128 (p, &offset);
 656       offset *= info->data_align;
 657       state->s.saved[reg] = REG_SAVED_OFFSET;
 658       state->s.reg_or_offset[reg] = offset;
 659       break;
 660     case DW_CFA_restore_extended:
 661       p = decode_uleb128 (p, &reg);
 662       state->s.saved[reg] = REG_UNSAVED;
 663       break;
 664
 665     case DW_CFA_undefined:
 666     case DW_CFA_same_value:
 667     case DW_CFA_nop:
 668       break;
 669
 670     case DW_CFA_register:
 671       {
 672         unsigned reg2;
 673         p = decode_uleb128 (p, &reg);
 674         p = decode_uleb128 (p, &reg2);
 675         state->s.saved[reg] = REG_SAVED_REG;
 676         state->s.reg_or_offset[reg] = reg2;
 677       }
 678       break;
 679
 680     case DW_CFA_def_cfa:
 681       p = decode_uleb128 (p, &reg);
 682       p = decode_uleb128 (p, &offset);
 683       state->s.cfa_reg = reg;
 684       state->s.cfa_offset = offset;
 685       break;
 686     case DW_CFA_def_cfa_register:
 687       p = decode_uleb128 (p, &reg);
 688       state->s.cfa_reg = reg;
 689       break;
 690     case DW_CFA_def_cfa_offset:
 691       p = decode_uleb128 (p, &offset);
 692       state->s.cfa_offset = offset;
 693       break;
 694
 695     case DW_CFA_remember_state:
 696       {
 697         struct frame_state_internal *save =
 698           (struct frame_state_internal *)
 699           malloc (sizeof (struct frame_state_internal));
 700         memcpy (save, state, sizeof (struct frame_state_internal));
 701         state->saved_state = save;
 702       }
 703       break;
 704     case DW_CFA_restore_state:
 705       {
 706         struct frame_state_internal *save = state->saved_state;
 707         memcpy (state, save, sizeof (struct frame_state_internal));
 708         free (save);
 709       }
 710       break;
 711
 712       /* FIXME: Hardcoded for SPARC register window configuration.  */
 713     case DW_CFA_GNU_window_save:
 714       for (reg = 16; reg < 32; ++reg)
 715         {
 716           state->s.saved[reg] = REG_SAVED_OFFSET;
 717           state->s.reg_or_offset[reg] = (reg - 16) * sizeof (void *);
 718         }
 719       break;
 720
 721     case DW_CFA_GNU_args_size:
 722       p = decode_uleb128 (p, &offset);
 723       state->s.args_size = offset;
 724       break;
 725
 726     default:
 727       abort ();
 728     }
 729   return p;
 730 }
 731 \f
 732 /* Called from crtbegin.o to register the unwind info for an object.  */
 733
 734 void
 735 __register_frame_info (void *begin, struct object *ob)
 736 {
 737   ob->fde_begin = begin;
 738
 739   ob->pc_begin = ob->pc_end = 0;
 740   ob->fde_array = 0;
 741   ob->count = 0;
 742
 743   init_object_mutex_once ();
 744   __gthread_mutex_lock (&object_mutex);
 745
 746   ob->next = objects;
 747   objects = ob;
 748
 749   __gthread_mutex_unlock (&object_mutex);
 750 }
 751
 752 void
 753 __register_frame (void *begin)
 754 {
 755   struct object *ob = (struct object *) malloc (sizeof (struct object));
 756   __register_frame_info (begin, ob);
 757 }
 758
 759 /* Similar, but BEGIN is actually a pointer to a table of unwind entries
 760    for different translation units.  Called from the file generated by
 761    collect2.  */
 762
 763 void
 764 __register_frame_info_table (void *begin, struct object *ob)
 765 {
 766   ob->fde_begin = begin;
 767   ob->fde_array = begin;
 768
 769   ob->pc_begin = ob->pc_end = 0;
 770   ob->count = 0;
 771
 772   init_object_mutex_once ();
 773   __gthread_mutex_lock (&object_mutex);
 774
 775   ob->next = objects;
 776   objects = ob;
 777
 778   __gthread_mutex_unlock (&object_mutex);
 779 }
 780
 781 void
 782 __register_frame_table (void *begin)
 783 {
 784   struct object *ob = (struct object *) malloc (sizeof (struct object));
 785   __register_frame_info_table (begin, ob);
 786 }
 787
 788 /* Called from crtbegin.o to deregister the unwind info for an object.  */
 789
 790 void *
 791 __deregister_frame_info (void *begin)
 792 {
 793   struct object **p;
 794
 795   init_object_mutex_once ();
 796   __gthread_mutex_lock (&object_mutex);
 797
 798   p = &objects;
 799   while (*p)
 800     {
 801       if ((*p)->fde_begin == begin)
 802         {
 803           struct object *ob = *p;
 804           *p = (*p)->next;
 805
 806           /* If we've run init_frame for this object, free the FDE array.  */
 807           if (ob->pc_begin)
 808             free (ob->fde_array);
 809
 810           __gthread_mutex_unlock (&object_mutex);
 811           return (void *) ob;
 812         }
 813       p = &((*p)->next);
 814     }
 815
 816   __gthread_mutex_unlock (&object_mutex);
 817   abort ();
 818 }
 819
 820 void
 821 __deregister_frame (void *begin)
 822 {
 823   free (__deregister_frame_info (begin));
 824 }
 825
 826 /* Called from __throw to find the registers to restore for a given
 827    PC_TARGET.  The caller should allocate a local variable of `struct
 828    frame_state' (declared in frame.h) and pass its address to STATE_IN.  */
 829
 830 struct frame_state *
 831 __frame_state_for (void *pc_target, struct frame_state *state_in)
 832 {
 833   fde *f;
 834   void *insn, *end, *pc;
 835   struct cie_info info;
 836   struct frame_state_internal state;
 837
 838   f = find_fde (pc_target);
 839   if (f == 0)
 840     return 0;
 841
 842   insn = extract_cie_info (f, &info);
 843   if (insn == 0)
 844     return 0;
 845
 846   memset (&state, 0, sizeof (state));
 847   state.s.retaddr_column = info.ra_regno;
 848   state.s.eh_ptr = info.eh_ptr;
 849
 850   /* First decode all the insns in the CIE.  */
 851   end = next_fde ((fde*) get_cie (f));
 852   while (insn < end)
 853     insn = execute_cfa_insn (insn, &state, &info, 0);
 854
 855   insn = ((fde *)f) + 1;
 856
 857   if (info.augmentation[0] == 'z')
 858     {
 859       int i;
 860       insn = decode_uleb128 (insn, &i);
 861       insn += i;
 862     }
 863
 864   /* Then the insns in the FDE up to our target PC.  */
 865   end = next_fde (f);
 866   pc = f->pc_begin;
 867   while (insn < end && pc <= pc_target)
 868     insn = execute_cfa_insn (insn, &state, &info, &pc);
 869
 870   memcpy (state_in, &state.s, sizeof (state.s));
 871   return state_in;
 872 }
 873 #endif /* DWARF2_UNWIND_INFO */