gcc/frame-dwarf2.c

   1 /* Subroutines needed for unwinding DWARF 2 format stack frame info
   2    for exception handling.  */
   3 /* Compile this one with gcc.  */
   4 /* Copyright (C) 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
   5    Contributed by Jason Merrill <jason@cygnus.com>.
   6
   7 This file is part of GNU CC.
   8
   9 GNU CC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 2, or (at your option)
  12 any later version.
  13
  14 In addition to the permissions in the GNU General Public License, the
  15 Free Software Foundation gives you unlimited permission to link the
  16 compiled version of this file into combinations with other programs,
  17 and to distribute those combinations without any restriction coming
  18 from the use of this file.  (The General Public License restrictions
  19 do apply in other respects; for example, they cover modification of
  20 the file, and distribution when not linked into a combine
  21 executable.)
  22
  23 GNU CC is distributed in the hope that it will be useful,
  24 but WITHOUT ANY WARRANTY; without even the implied warranty of
  25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26 GNU General Public License for more details.
  27
  28 You should have received a copy of the GNU General Public License
  29 along with GNU CC; see the file COPYING.  If not, write to
  30 the Free Software Foundation, 59 Temple Place - Suite 330,
  31 Boston, MA 02111-1307, USA.  */
  32
  33 /* It is incorrect to include config.h here, because this file is being
  34    compiled for the target, and hence definitions concerning only the host
  35    do not apply.  */
  36
  37 #include "tconfig.h"
  38 #include "tsystem.h"
  39
  40 #include "defaults.h"
  41
  42 #ifdef DWARF2_UNWIND_INFO
  43 #include "dwarf2.h"
  44 #include "frame.h"
  45 #include "gthr.h"
  46
  47 #ifdef __GTHREAD_MUTEX_INIT
  48 static __gthread_mutex_t object_mutex = __GTHREAD_MUTEX_INIT;
  49 #else
  50 static __gthread_mutex_t object_mutex;
  51 #endif
  52
  53 /* Don't use `fancy_abort' here even if config.h says to use it.  */
  54 #ifdef abort
  55 #undef abort
  56 #endif
  57
  58 /* Some types used by the DWARF 2 spec.  */
  59
  60 typedef          int  sword __attribute__ ((mode (SI)));
  61 typedef unsigned int  uword __attribute__ ((mode (SI)));
  62 typedef unsigned int  uaddr __attribute__ ((mode (pointer)));
  63 typedef          int  saddr __attribute__ ((mode (pointer)));
  64 typedef unsigned char ubyte;
  65
  66 /* Terminology:
  67    CIE - Common Information Element
  68    FDE - Frame Descriptor Element
  69
  70    There is one per function, and it describes where the function code
  71    is located, and what the register lifetimes and stack layout are
  72    within the function.
  73
  74    The data structures are defined in the DWARF specfication, although
  75    not in a very readable way (see LITERATURE).
  76
  77    Every time an exception is thrown, the code needs to locate the FDE
  78    for the current function, and starts to look for exception regions
  79    from that FDE. This works in a two-level search:
  80    a) in a linear search, find the shared image (i.e. DLL) containing
  81       the PC
  82    b) using the FDE table for that shared object, locate the FDE using
  83       binary search (which requires the sorting).  */
  84
  85 /* The first few fields of a CIE.  The CIE_id field is 0 for a CIE,
  86    to distinguish it from a valid FDE.  FDEs are aligned to an addressing
  87    unit boundary, but the fields within are unaligned.  */
  88
  89 struct dwarf_cie {
  90   uword length;
  91   sword CIE_id;
  92   ubyte version;
  93   char augmentation[0];
  94 } __attribute__ ((packed, aligned (__alignof__ (void *))));
  95
  96 /* The first few fields of an FDE.  */
  97
  98 struct dwarf_fde {
  99   uword length;
 100   sword CIE_delta;
 101   void* pc_begin;
 102   uaddr pc_range;
 103 } __attribute__ ((packed, aligned (__alignof__ (void *))));
 104
 105 typedef struct dwarf_fde fde;
 106
 107 /* Objects to be searched for frame unwind info.  */
 108
 109 static struct object *objects;
 110
 111 /* The information we care about from a CIE.  */
 112
 113 struct cie_info {
 114   char *augmentation;
 115   void *eh_ptr;
 116   int code_align;
 117   int data_align;
 118   unsigned ra_regno;
 119 };
 120
 121 /* The current unwind state, plus a saved copy for DW_CFA_remember_state.  */
 122
 123 struct frame_state_internal
 124 {
 125   struct frame_state s;
 126   struct frame_state_internal *saved_state;
 127 };
 128 \f
 129 /* This is undefined below if we need it to be an actual function.  */
 130 #define init_object_mutex_once()
 131
 132 #if __GTHREADS
 133 #ifdef __GTHREAD_MUTEX_INIT_FUNCTION
 134
 135 /* Helper for init_object_mutex_once.  */
 136
 137 static void
 138 init_object_mutex (void)
 139 {
 140   __GTHREAD_MUTEX_INIT_FUNCTION (&object_mutex);
 141 }
 142
 143 /* Call this to arrange to initialize the object mutex.  */
 144
 145 #undef init_object_mutex_once
 146 static void
 147 init_object_mutex_once (void)
 148 {
 149   static __gthread_once_t once = __GTHREAD_ONCE_INIT;
 150   __gthread_once (&once, init_object_mutex);
 151 }
 152
 153 #endif /* __GTHREAD_MUTEX_INIT_FUNCTION */
 154 #endif /* __GTHREADS */
 155 \f
 156 /* Decode the unsigned LEB128 constant at BUF into the variable pointed to
 157    by R, and return the new value of BUF.  */
 158
 159 static void *
 160 decode_uleb128 (unsigned char *buf, unsigned *r)
 161 {
 162   unsigned shift = 0;
 163   unsigned result = 0;
 164
 165   while (1)
 166     {
 167       unsigned byte = *buf++;
 168       result |= (byte & 0x7f) << shift;
 169       if ((byte & 0x80) == 0)
 170         break;
 171       shift += 7;
 172     }
 173   *r = result;
 174   return buf;
 175 }
 176
 177 /* Decode the signed LEB128 constant at BUF into the variable pointed to
 178    by R, and return the new value of BUF.  */
 179
 180 static void *
 181 decode_sleb128 (unsigned char *buf, int *r)
 182 {
 183   unsigned shift = 0;
 184   unsigned result = 0;
 185   unsigned byte;
 186
 187   while (1)
 188     {
 189       byte = *buf++;
 190       result |= (byte & 0x7f) << shift;
 191       shift += 7;
 192       if ((byte & 0x80) == 0)
 193         break;
 194     }
 195   if (shift < (sizeof (*r) * 8) && (byte & 0x40) != 0)
 196     result |= - (1 << shift);
 197
 198   *r = result;
 199   return buf;
 200 }
 201
 202 /* Read unaligned data from the instruction buffer.  */
 203
 204 union unaligned {
 205   void *p;
 206   unsigned b2 __attribute__ ((mode (HI)));
 207   unsigned b4 __attribute__ ((mode (SI)));
 208   unsigned b8 __attribute__ ((mode (DI)));
 209 } __attribute__ ((packed));
 210 static inline void *
 211 read_pointer (void *p)
 212 { union unaligned *up = p; return up->p; }
 213 static inline unsigned
 214 read_1byte (void *p)
 215 { return *(unsigned char *)p; }
 216 static inline unsigned
 217 read_2byte (void *p)
 218 { union unaligned *up = p; return up->b2; }
 219 static inline unsigned
 220 read_4byte (void *p)
 221 { union unaligned *up = p; return up->b4; }
 222 static inline unsigned long
 223 read_8byte (void *p)
 224 { union unaligned *up = p; return up->b8; }
 225 \f
 226 /* Ordering function for FDEs.  Functions can't overlap, so we just compare
 227    their starting addresses.  */
 228
 229 static inline saddr
 230 fde_compare (fde *x, fde *y)
 231 {
 232   return (saddr)x->pc_begin - (saddr)y->pc_begin;
 233 }
 234
 235 /* Return the address of the FDE after P.  */
 236
 237 static inline fde *
 238 next_fde (fde *p)
 239 {
 240   return (fde *)(((char *)p) + p->length + sizeof (p->length));
 241 }
 242
 243 #include "frame.c"
 244
 245 static size_t
 246 count_fdes (fde *this_fde)
 247 {
 248   size_t count;
 249
 250   for (count = 0; this_fde->length != 0; this_fde = next_fde (this_fde))
 251     {
 252       /* Skip CIEs and linked once FDE entries.  */
 253       if (this_fde->CIE_delta == 0 || this_fde->pc_begin == 0)
 254         continue;
 255
 256       ++count;
 257     }
 258
 259   return count;
 260 }
 261
 262 static void
 263 add_fdes (fde *this_fde, fde_accumulator *accu, void **beg_ptr, void **end_ptr)
 264 {
 265   void *pc_begin = *beg_ptr;
 266   void *pc_end = *end_ptr;
 267
 268   for (; this_fde->length != 0; this_fde = next_fde (this_fde))
 269     {
 270       /* Skip CIEs and linked once FDE entries.  */
 271       if (this_fde->CIE_delta == 0 || this_fde->pc_begin == 0)
 272         continue;
 273
 274       fde_insert (accu, this_fde);
 275
 276       if (this_fde->pc_begin < pc_begin)
 277         pc_begin = this_fde->pc_begin;
 278       if (this_fde->pc_begin + this_fde->pc_range > pc_end)
 279         pc_end = this_fde->pc_begin + this_fde->pc_range;
 280     }
 281
 282   *beg_ptr = pc_begin;
 283   *end_ptr = pc_end;
 284 }
 285
 286 /* search this fde table for the one containing the pc */
 287 static fde *
 288 search_fdes (fde *this_fde, void *pc)
 289 {
 290   for (; this_fde->length != 0; this_fde = next_fde (this_fde))
 291     {
 292       /* Skip CIEs and linked once FDE entries.  */
 293       if (this_fde->CIE_delta == 0 || this_fde->pc_begin == 0)
 294         continue;
 295
 296       if ((uaddr)((char *)pc - (char *)this_fde->pc_begin) < this_fde->pc_range)
 297         return this_fde;
 298     }
 299   return NULL;
 300 }
 301
 302 /* Set up a sorted array of pointers to FDEs for a loaded object.  We
 303    count up the entries before allocating the array because it's likely to
 304    be faster.  We can be called multiple times, should we have failed to
 305    allocate a sorted fde array on a previous occasion.  */
 306
 307 static void
 308 frame_init (struct object* ob)
 309 {
 310   size_t count;
 311   fde_accumulator accu;
 312   void *pc_begin, *pc_end;
 313   fde **array;
 314
 315   if (ob->pc_begin)
 316     count = ob->count;
 317   else if (ob->fde_array)
 318     {
 319       fde **p = ob->fde_array;
 320       for (count = 0; *p; ++p)
 321         count += count_fdes (*p);
 322     }
 323   else
 324     count = count_fdes (ob->fde_begin);
 325   ob->count = count;
 326
 327   if (!start_fde_sort (&accu, count) && ob->pc_begin)
 328     return;
 329
 330   pc_begin = (void*)(uaddr)-1;
 331   pc_end = 0;
 332
 333   if (ob->fde_array)
 334     {
 335       fde **p = ob->fde_array;
 336       for (; *p; ++p)
 337         add_fdes (*p, &accu, &pc_begin, &pc_end);
 338     }
 339   else
 340     add_fdes (ob->fde_begin, &accu, &pc_begin, &pc_end);
 341
 342   array = end_fde_sort (&accu, count);
 343   if (array)
 344     ob->fde_array = array;
 345   ob->pc_begin = pc_begin;
 346   ob->pc_end = pc_end;
 347 }
 348
 349 /* Return a pointer to the FDE for the function containing PC.  */
 350
 351 static fde *
 352 find_fde (void *pc)
 353 {
 354   struct object *ob;
 355   size_t lo, hi;
 356
 357   init_object_mutex_once ();
 358   __gthread_mutex_lock (&object_mutex);
 359
 360   /* Linear search through the objects, to find the one containing the pc. */
 361   for (ob = objects; ob; ob = ob->next)
 362     {
 363       if (ob->pc_begin == 0)
 364         frame_init (ob);
 365       if (pc >= ob->pc_begin && pc < ob->pc_end)
 366         break;
 367     }
 368
 369   if (ob == 0)
 370     {
 371       __gthread_mutex_unlock (&object_mutex);
 372       return 0;
 373     }
 374
 375   if (!ob->fde_array || (void *)ob->fde_array == (void *)ob->fde_begin)
 376     frame_init (ob);
 377
 378   if (ob->fde_array && (void *)ob->fde_array != (void *)ob->fde_begin)
 379     {
 380       __gthread_mutex_unlock (&object_mutex);
 381
 382       /* Standard binary search algorithm.  */
 383       for (lo = 0, hi = ob->count; lo < hi; )
 384         {
 385           size_t i = (lo + hi) / 2;
 386           fde *f = ob->fde_array[i];
 387
 388           if (pc < f->pc_begin)
 389             hi = i;
 390           else if (pc >= f->pc_begin + f->pc_range)
 391             lo = i + 1;
 392           else
 393             return f;
 394         }
 395     }
 396   else
 397     {
 398       /* Long slow labourious linear search, cos we've no memory. */
 399       fde *f;
 400
 401       if (ob->fde_array)
 402         {
 403           fde **p = ob->fde_array;
 404
 405           do
 406             {
 407               f = search_fdes (*p, pc);
 408               if (f)
 409                 break;
 410               p++;
 411             }
 412           while (*p);
 413         }
 414       else
 415         f = search_fdes (ob->fde_begin, pc);
 416       __gthread_mutex_unlock (&object_mutex);
 417       return f;
 418     }
 419   return 0;
 420 }
 421 \f
 422 static inline struct dwarf_cie *
 423 get_cie (fde *f)
 424 {
 425   return ((void *)&f->CIE_delta) - f->CIE_delta;
 426 }
 427
 428 /* Extract any interesting information from the CIE for the translation
 429    unit F belongs to.  */
 430
 431 static void *
 432 extract_cie_info (fde *f, struct cie_info *c)
 433 {
 434   void *p;
 435   int i;
 436
 437   c->augmentation = get_cie (f)->augmentation;
 438
 439   if (strcmp (c->augmentation, "") != 0
 440       && strcmp (c->augmentation, "eh") != 0
 441       && c->augmentation[0] != 'z')
 442     return 0;
 443
 444   p = c->augmentation + strlen (c->augmentation) + 1;
 445
 446   if (strcmp (c->augmentation, "eh") == 0)
 447     {
 448       c->eh_ptr = read_pointer (p);
 449       p += sizeof (void *);
 450     }
 451   else
 452     c->eh_ptr = 0;
 453
 454   p = decode_uleb128 (p, &c->code_align);
 455   p = decode_sleb128 (p, &c->data_align);
 456   c->ra_regno = *(unsigned char *)p++;
 457
 458   /* If the augmentation starts with 'z', we now see the length of the
 459      augmentation fields.  */
 460   if (c->augmentation[0] == 'z')
 461     {
 462       p = decode_uleb128 (p, &i);
 463       p += i;
 464     }
 465
 466   return p;
 467 }
 468
 469 /* Decode a DW_OP stack operation.  */
 470
 471 static void *
 472 decode_stack_op (unsigned char *buf, struct frame_state *state)
 473 {
 474   enum dwarf_location_atom op;
 475   int offset;
 476
 477   op = *buf++;
 478   switch (op)
 479     {
 480     case DW_OP_reg0:
 481     case DW_OP_reg1:
 482     case DW_OP_reg2:
 483     case DW_OP_reg3:
 484     case DW_OP_reg4:
 485     case DW_OP_reg5:
 486     case DW_OP_reg6:
 487     case DW_OP_reg7:
 488     case DW_OP_reg8:
 489     case DW_OP_reg9:
 490     case DW_OP_reg10:
 491     case DW_OP_reg11:
 492     case DW_OP_reg12:
 493     case DW_OP_reg13:
 494     case DW_OP_reg14:
 495     case DW_OP_reg15:
 496     case DW_OP_reg16:
 497     case DW_OP_reg17:
 498     case DW_OP_reg18:
 499     case DW_OP_reg19:
 500     case DW_OP_reg20:
 501     case DW_OP_reg21:
 502     case DW_OP_reg22:
 503     case DW_OP_reg23:
 504     case DW_OP_reg24:
 505     case DW_OP_reg25:
 506     case DW_OP_reg26:
 507     case DW_OP_reg27:
 508     case DW_OP_reg28:
 509     case DW_OP_reg29:
 510     case DW_OP_reg30:
 511     case DW_OP_reg31:
 512       state->cfa_reg = op - DW_OP_reg0;
 513       break;
 514     case DW_OP_regx:
 515       buf = decode_sleb128 (buf, &offset);
 516       state->cfa_reg = offset;
 517       break;
 518     case DW_OP_breg0:
 519     case DW_OP_breg1:
 520     case DW_OP_breg2:
 521     case DW_OP_breg3:
 522     case DW_OP_breg4:
 523     case DW_OP_breg5:
 524     case DW_OP_breg6:
 525     case DW_OP_breg7:
 526     case DW_OP_breg8:
 527     case DW_OP_breg9:
 528     case DW_OP_breg10:
 529     case DW_OP_breg11:
 530     case DW_OP_breg12:
 531     case DW_OP_breg13:
 532     case DW_OP_breg14:
 533     case DW_OP_breg15:
 534     case DW_OP_breg16:
 535     case DW_OP_breg17:
 536     case DW_OP_breg18:
 537     case DW_OP_breg19:
 538     case DW_OP_breg20:
 539     case DW_OP_breg21:
 540     case DW_OP_breg22:
 541     case DW_OP_breg23:
 542     case DW_OP_breg24:
 543     case DW_OP_breg25:
 544     case DW_OP_breg26:
 545     case DW_OP_breg27:
 546     case DW_OP_breg28:
 547     case DW_OP_breg29:
 548     case DW_OP_breg30:
 549     case DW_OP_breg31:
 550       state->cfa_reg = op - DW_OP_breg0;
 551       buf = decode_sleb128 (buf, &offset);
 552       state->base_offset = offset;
 553       break;
 554     case DW_OP_bregx:
 555       buf = decode_sleb128 (buf, &offset);
 556       state->cfa_reg = offset;
 557       buf = decode_sleb128 (buf, &offset);
 558       state->base_offset = offset;
 559       break;
 560     case DW_OP_deref:
 561       state->indirect = 1;
 562       break;
 563     case DW_OP_plus_uconst:
 564       buf = decode_uleb128 (buf, &offset);
 565       state->cfa_offset = offset;
 566       break;
 567     default:
 568       abort ();
 569     }
 570   return buf;
 571 }
 572 /* Decode one instruction's worth of DWARF 2 call frame information.
 573    Used by __frame_state_for.  Takes pointers P to the instruction to
 574    decode, STATE to the current register unwind information, INFO to the
 575    current CIE information, and PC to the current PC value.  Returns a
 576    pointer to the next instruction.  */
 577
 578 static void *
 579 execute_cfa_insn (void *p, struct frame_state_internal *state,
 580                   struct cie_info *info, void **pc)
 581 {
 582   unsigned insn = *(unsigned char *)p++;
 583   unsigned reg;
 584   int offset;
 585
 586   if (insn & DW_CFA_advance_loc)
 587     *pc += ((insn & 0x3f) * info->code_align);
 588   else if (insn & DW_CFA_offset)
 589     {
 590       reg = (insn & 0x3f);
 591       p = decode_uleb128 (p, &offset);
 592       if (reg == state->s.cfa_reg)
 593         /* Don't record anything about this register; it's only used to
 594            reload SP in the epilogue.  We don't want to copy in SP
 595            values for outer frames; we handle restoring SP specially.  */;
 596       else
 597         {
 598           offset *= info->data_align;
 599           state->s.saved[reg] = REG_SAVED_OFFSET;
 600           state->s.reg_or_offset[reg] = offset;
 601         }
 602     }
 603   else if (insn & DW_CFA_restore)
 604     {
 605       reg = (insn & 0x3f);
 606       state->s.saved[reg] = REG_UNSAVED;
 607     }
 608   else switch (insn)
 609     {
 610     case DW_CFA_set_loc:
 611       *pc = read_pointer (p);
 612       p += sizeof (void *);
 613       break;
 614     case DW_CFA_advance_loc1:
 615       *pc += read_1byte (p);
 616       p += 1;
 617       break;
 618     case DW_CFA_advance_loc2:
 619       *pc += read_2byte (p);
 620       p += 2;
 621       break;
 622     case DW_CFA_advance_loc4:
 623       *pc += read_4byte (p);
 624       p += 4;
 625       break;
 626
 627     case DW_CFA_offset_extended:
 628       p = decode_uleb128 (p, &reg);
 629       p = decode_uleb128 (p, &offset);
 630       if (reg == state->s.cfa_reg)
 631         /* Don't record anything; see above.  */;
 632       else
 633         {
 634           offset *= info->data_align;
 635           state->s.saved[reg] = REG_SAVED_OFFSET;
 636           state->s.reg_or_offset[reg] = offset;
 637         }
 638       break;
 639     case DW_CFA_restore_extended:
 640       p = decode_uleb128 (p, &reg);
 641       state->s.saved[reg] = REG_UNSAVED;
 642       break;
 643
 644     case DW_CFA_undefined:
 645     case DW_CFA_same_value:
 646     case DW_CFA_nop:
 647       break;
 648
 649     case DW_CFA_register:
 650       {
 651         unsigned reg2;
 652         p = decode_uleb128 (p, &reg);
 653         p = decode_uleb128 (p, &reg2);
 654         state->s.saved[reg] = REG_SAVED_REG;
 655         state->s.reg_or_offset[reg] = reg2;
 656       }
 657       break;
 658
 659     case DW_CFA_def_cfa:
 660       p = decode_uleb128 (p, &reg);
 661       p = decode_uleb128 (p, &offset);
 662       state->s.cfa_reg = reg;
 663       state->s.cfa_offset = offset;
 664       break;
 665     case DW_CFA_def_cfa_register:
 666       p = decode_uleb128 (p, &reg);
 667       state->s.cfa_reg = reg;
 668       break;
 669     case DW_CFA_def_cfa_offset:
 670       p = decode_uleb128 (p, &offset);
 671       state->s.cfa_offset = offset;
 672       break;
 673     case DW_CFA_def_cfa_expression:
 674       {
 675         void *end;
 676         state->s.cfa_reg = 0;
 677         state->s.cfa_offset = 0;
 678         state->s.base_offset = 0;
 679         state->s.indirect = 0;
 680
 681         p = decode_uleb128 (p, &offset);
 682         end = p + offset;
 683         while (p < end)
 684           p = decode_stack_op (p, &(state->s));
 685         break;
 686       }
 687
 688     case DW_CFA_remember_state:
 689       {
 690         struct frame_state_internal *save =
 691           (struct frame_state_internal *)
 692           malloc (sizeof (struct frame_state_internal));
 693         memcpy (save, state, sizeof (struct frame_state_internal));
 694         state->saved_state = save;
 695       }
 696       break;
 697     case DW_CFA_restore_state:
 698       {
 699         struct frame_state_internal *save = state->saved_state;
 700         memcpy (state, save, sizeof (struct frame_state_internal));
 701         free (save);
 702       }
 703       break;
 704
 705       /* FIXME: Hardcoded for SPARC register window configuration.  */
 706     case DW_CFA_GNU_window_save:
 707       for (reg = 16; reg < 32; ++reg)
 708         {
 709           state->s.saved[reg] = REG_SAVED_OFFSET;
 710           state->s.reg_or_offset[reg] = (reg - 16) * sizeof (void *);
 711         }
 712       break;
 713
 714     case DW_CFA_GNU_args_size:
 715       p = decode_uleb128 (p, &offset);
 716       state->s.args_size = offset;
 717       break;
 718
 719     case DW_CFA_GNU_negative_offset_extended:
 720       p = decode_uleb128 (p, &reg);
 721       p = decode_uleb128 (p, &offset);
 722       offset *= info->data_align;
 723       state->s.saved[reg] = REG_SAVED_OFFSET;
 724       state->s.reg_or_offset[reg] = -offset;
 725       break;
 726
 727     default:
 728       abort ();
 729     }
 730   return p;
 731 }
 732 \f
 733 /* Called from __throw to find the registers to restore for a given
 734    PC_TARGET.  The caller should allocate a local variable of `struct
 735    frame_state' (declared in frame.h) and pass its address to STATE_IN.  */
 736
 737 struct frame_state *
 738 __frame_state_for (void *pc_target, struct frame_state *state_in)
 739 {
 740   fde *f;
 741   void *insn, *end, *pc;
 742   struct cie_info info;
 743   struct frame_state_internal state;
 744
 745   f = find_fde (pc_target);
 746   if (f == 0)
 747     return 0;
 748
 749   insn = extract_cie_info (f, &info);
 750   if (insn == 0)
 751     return 0;
 752
 753   memset (&state, 0, sizeof (state));
 754   state.s.retaddr_column = info.ra_regno;
 755   state.s.eh_ptr = info.eh_ptr;
 756
 757   /* First decode all the insns in the CIE.  */
 758   end = next_fde ((fde*) get_cie (f));
 759   while (insn < end)
 760     insn = execute_cfa_insn (insn, &state, &info, 0);
 761
 762   insn = ((fde *)f) + 1;
 763
 764   if (info.augmentation[0] == 'z')
 765     {
 766       int i;
 767       insn = decode_uleb128 (insn, &i);
 768       insn += i;
 769     }
 770
 771   /* Then the insns in the FDE up to our target PC.  */
 772   end = next_fde (f);
 773   pc = f->pc_begin;
 774   while (insn < end && pc <= pc_target)
 775     insn = execute_cfa_insn (insn, &state, &info, &pc);
 776
 777   memcpy (state_in, &state.s, sizeof (state.s));
 778   return state_in;
 779 }
 780 #endif /* DWARF2_UNWIND_INFO */