gdb/dwarf2cfi.c

   1 /* Stack unwinding code based on dwarf2 frame info for GDB, the GNU debugger.
   2    Copyright 2001, 2002 Free Software Foundation, Inc.
   3    Contributed by Jiri Smid, SuSE Labs.
   4    Based on code written by Daniel Berlin (dan@dberlin.org).
   5
   6    This file is part of GDB.
   7
   8    This program 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 of the License, or
  11    (at your option) any later version.
  12
  13    This program 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 this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "symtab.h"
  25 #include "symfile.h"
  26 #include "objfiles.h"
  27 #include "target.h"
  28 #include "elf/dwarf2.h"
  29 #include "inferior.h"
  30 #include "regcache.h"
  31 #include "dwarf2cfi.h"
  32
  33 /* Common Information Entry - holds information that is shared among many
  34    Frame Descriptors.  */
  35 struct cie_unit
  36 {
  37   /* Offset of this unit in dwarf_frame_buffer.  */
  38   ULONGEST offset;
  39
  40   /* A null-terminated string that identifies the augmentation to this CIE or
  41      to the FDEs that use it.  */
  42   char *augmentation;
  43
  44   /* A constant that is factored out of all advance location instructions.  */
  45   unsigned int code_align;
  46
  47   /* A constant that is factored out of all offset instructions.  */
  48   int data_align;
  49
  50   /* A constant that indicates which regiter represents the return address
  51      of a function.  */
  52   unsigned char ra;
  53
  54   /* Indicates how addresses are encoded.  */
  55   unsigned char addr_encoding;
  56
  57   /* Pointer and length of the cie program.  */
  58   char *data;
  59   unsigned int data_length;
  60
  61   struct objfile *objfile;
  62
  63   /* Next in chain.  */
  64   struct cie_unit *next;
  65 };
  66
  67 /* Frame Description Entry.  */
  68 struct fde_unit
  69 {
  70   /* Address of the first location associated with this entry.  */
  71   CORE_ADDR initial_location;
  72
  73   /* Length of program section described by this entry.  */
  74   CORE_ADDR address_range;
  75
  76   /* Pointer to asociated CIE.  */
  77   struct cie_unit *cie_ptr;
  78
  79   /* Pointer and length of the cie program.  */
  80   char *data;
  81   unsigned int data_length;
  82 };
  83
  84 struct fde_array
  85 {
  86   struct fde_unit **array;
  87   int elems;
  88   int array_size;
  89 };
  90
  91 struct context_reg
  92 {
  93   union
  94   {
  95     unsigned int reg;
  96     long offset;
  97     CORE_ADDR addr;
  98   }
  99   loc;
 100   enum
 101   {
 102     REG_CTX_UNSAVED,
 103     REG_CTX_SAVED_OFFSET,
 104     REG_CTX_SAVED_REG,
 105     REG_CTX_SAVED_ADDR,
 106     REG_CTX_VALUE,
 107   }
 108   how;
 109 };
 110
 111 /* This is the register and unwind state for a particular frame.  */
 112 struct context
 113 {
 114   struct context_reg *reg;
 115
 116   CORE_ADDR cfa;
 117   CORE_ADDR ra;
 118   void *lsda;
 119   int args_size;
 120 };
 121
 122 struct frame_state_reg
 123 {
 124   union
 125   {
 126     unsigned int reg;
 127     long offset;
 128     unsigned char *exp;
 129   }
 130   loc;
 131   enum
 132   {
 133     REG_UNSAVED,
 134     REG_SAVED_OFFSET,
 135     REG_SAVED_REG,
 136     REG_SAVED_EXP,
 137   }
 138   how;
 139 };
 140
 141 struct frame_state
 142 {
 143   /* Each register save state can be described in terms of a CFA slot,
 144      another register, or a location expression.  */
 145   struct frame_state_regs
 146   {
 147     struct frame_state_reg *reg;
 148
 149     /* Used to implement DW_CFA_remember_state.  */
 150     struct frame_state_regs *prev;
 151   }
 152   regs;
 153
 154   /* The CFA can be described in terms of a reg+offset or a
 155      location expression.  */
 156   long cfa_offset;
 157   int cfa_reg;
 158   unsigned char *cfa_exp;
 159   enum
 160   {
 161     CFA_UNSET,
 162     CFA_REG_OFFSET,
 163     CFA_EXP,
 164   }
 165   cfa_how;
 166
 167   /* The PC described by the current frame state.  */
 168   CORE_ADDR pc;
 169
 170   /* The information we care about from the CIE/FDE.  */
 171   int data_align;
 172   unsigned int code_align;
 173   unsigned char retaddr_column;
 174   unsigned char addr_encoding;
 175
 176   struct objfile *objfile;
 177 };
 178
 179 #define UNWIND_CONTEXT(fi) ((struct context *) (fi->context))
 180 \f
 181
 182 static struct cie_unit *cie_chunks;
 183 static struct fde_array fde_chunks;
 184 /* Obstack for allocating temporary storage used during unwind operations.  */
 185 static struct obstack unwind_tmp_obstack;
 186
 187 extern file_ptr dwarf_frame_offset;
 188 extern unsigned int dwarf_frame_size;
 189 extern file_ptr dwarf_eh_frame_offset;
 190 extern unsigned int dwarf_eh_frame_size;
 191
 192 static char *dwarf_frame_buffer;
 193 \f
 194
 195 extern char *dwarf2_read_section (struct objfile *objfile, file_ptr offset,
 196                                   unsigned int size);
 197
 198 static struct fde_unit *fde_unit_alloc (void);
 199 static struct cie_unit *cie_unit_alloc (void);
 200 static void fde_chunks_need_space ();
 201
 202 static struct context *context_alloc ();
 203 static struct frame_state *frame_state_alloc ();
 204 static void unwind_tmp_obstack_free ();
 205 static void context_cpy (struct context *dst, struct context *src);
 206
 207 static unsigned int read_1u (bfd *abfd, char **p);
 208 static int read_1s (bfd *abfd, char **p);
 209 static unsigned int read_2u (bfd *abfd, char **p);
 210 static int read_2s (bfd *abfd, char **p);
 211 static unsigned int read_4u (bfd *abfd, char **p);
 212 static int read_4s (bfd *abfd, char **p);
 213 static ULONGEST read_8u (bfd *abfd, char **p);
 214 static LONGEST read_8s (bfd *abfd, char **p);
 215
 216 static ULONGEST read_uleb128 (bfd *abfd, char **p);
 217 static LONGEST read_sleb128 (bfd *abfd, char **p);
 218 static CORE_ADDR read_pointer (bfd *abfd, char **p);
 219 static CORE_ADDR read_encoded_pointer (bfd *abfd, char **p,
 220                                        unsigned char encoding);
 221
 222 static LONGEST read_initial_length (bfd *abfd, char *buf, int *bytes_read);
 223 static ULONGEST read_length (bfd *abfd, char *buf, int *bytes_read,
 224                              int dwarf64);
 225
 226 static int is_cie (ULONGEST cie_id, int dwarf64);
 227 static int compare_fde_unit (const void *a, const void *b);
 228 void dwarf2_build_frame_info (struct objfile *objfile);
 229
 230 static void execute_cfa_program (struct objfile *objfile, char *insn_ptr,
 231                                  char *insn_end, struct context *context,
 232                                  struct frame_state *fs);
 233 static struct fde_unit *get_fde_for_addr (CORE_ADDR pc);
 234 static void frame_state_for (struct context *context, struct frame_state *fs);
 235 static void get_reg (char *reg, struct context *context, int regnum);
 236 static CORE_ADDR execute_stack_op (struct objfile *objfile,
 237                                    char *op_ptr, char *op_end,
 238                                    struct context *context, CORE_ADDR initial);
 239 static void update_context (struct context *context, struct frame_state *fs,
 240                             int chain);
 241
 242 \f
 243 /* Memory allocation functions.  */
 244 static struct fde_unit *
 245 fde_unit_alloc (void)
 246 {
 247   struct fde_unit *fde;
 248
 249   fde = (struct fde_unit *) xmalloc (sizeof (struct fde_unit));
 250   memset (fde, 0, sizeof (struct fde_unit));
 251   return fde;
 252 }
 253
 254 static struct cie_unit *
 255 cie_unit_alloc (void)
 256 {
 257   struct cie_unit *cie;
 258
 259   cie = (struct cie_unit *) xmalloc (sizeof (struct cie_unit));
 260   memset (cie, 0, sizeof (struct cie_unit));
 261   return cie;
 262 }
 263
 264 static void
 265 fde_chunks_need_space ()
 266 {
 267   if (fde_chunks.elems < fde_chunks.array_size)
 268     return;
 269   fde_chunks.array_size =
 270     fde_chunks.array_size ? 2 * fde_chunks.array_size : 1024;
 271   fde_chunks.array =
 272     xrealloc (fde_chunks.array,
 273               sizeof (struct fde_unit) * fde_chunks.array_size);
 274 }
 275
 276 /* Alocate a new `struct context' on temporary obstack.  */
 277 static struct context *
 278 context_alloc ()
 279 {
 280   struct context *context;
 281
 282   int regs_size = sizeof (struct context_reg) * NUM_REGS;
 283
 284   context = (struct context *) obstack_alloc (&unwind_tmp_obstack,
 285                                               sizeof (struct context));
 286   memset (context, 0, sizeof (struct context));
 287   context->reg = (struct context_reg *) obstack_alloc (&unwind_tmp_obstack,
 288                                                        regs_size);
 289   memset (context->reg, 0, regs_size);
 290   return context;
 291 }
 292
 293 /* Alocate a new `struct frame_state' on temporary obstack.  */
 294 static struct frame_state *
 295 frame_state_alloc ()
 296 {
 297   struct frame_state *fs;
 298
 299   int regs_size = sizeof (struct frame_state_reg) * NUM_REGS;
 300
 301   fs = (struct frame_state *) obstack_alloc (&unwind_tmp_obstack,
 302                                              sizeof (struct frame_state));
 303   memset (fs, 0, sizeof (struct frame_state));
 304   fs->regs.reg = (struct frame_state_reg *)  obstack_alloc (&unwind_tmp_obstack,
 305                                                             regs_size);
 306   memset (fs->regs.reg, 0, regs_size);
 307   return fs;
 308 }
 309
 310 static void
 311 unwind_tmp_obstack_free ()
 312 {
 313   obstack_free (&unwind_tmp_obstack, NULL);
 314   obstack_init (&unwind_tmp_obstack);
 315 }
 316
 317 static void
 318 context_cpy (struct context *dst, struct context *src)
 319 {
 320   int regs_size = sizeof (struct context_reg) * NUM_REGS;
 321   struct context_reg *dreg;
 322
 323   /* Structure dst contains a pointer to an array of
 324    * registers of a given frame as well as src does. This
 325    * array was already allocated before dst was passed to
 326    * context_cpy but the pointer to it was overriden by
 327    * '*dst = *src' and the array was lost. This led to the
 328    * situation, that we've had a copy of src placed in dst,
 329    * but both of them pointed to the same regs array and
 330    * thus we've sometimes blindly rewritten it.  Now we save
 331    * the pointer before copying src to dst, return it back
 332    * after that and copy the registers into their new place
 333    * finally.   ---   mludvig@suse.cz  */
 334   dreg = dst->reg;
 335   *dst = *src;
 336   dst->reg = dreg;
 337
 338   memcpy (dst->reg, src->reg, regs_size);
 339 }
 340
 341 static unsigned int
 342 read_1u (bfd *abfd, char **p)
 343 {
 344   unsigned ret;
 345
 346   ret= bfd_get_8 (abfd, (bfd_byte *) *p);
 347   (*p) ++;
 348   return ret;
 349 }
 350
 351 static int
 352 read_1s (bfd *abfd, char **p)
 353 {
 354   int ret;
 355
 356   ret= bfd_get_signed_8 (abfd, (bfd_byte *) *p);
 357   (*p) ++;
 358   return ret;
 359 }
 360
 361 static unsigned int
 362 read_2u (bfd *abfd, char **p)
 363 {
 364   unsigned ret;
 365
 366   ret= bfd_get_16 (abfd, (bfd_byte *) *p);
 367   (*p) ++;
 368   return ret;
 369 }
 370
 371 static int
 372 read_2s (bfd *abfd, char **p)
 373 {
 374   int ret;
 375
 376   ret= bfd_get_signed_16 (abfd, (bfd_byte *) *p);
 377   (*p) += 2;
 378   return ret;
 379 }
 380
 381 static unsigned int
 382 read_4u (bfd *abfd, char **p)
 383 {
 384   unsigned int ret;
 385
 386   ret= bfd_get_32 (abfd, (bfd_byte *) *p);
 387   (*p) += 4;
 388   return ret;
 389 }
 390
 391 static int
 392 read_4s (bfd *abfd, char **p)
 393 {
 394   int ret;
 395
 396   ret= bfd_get_signed_32 (abfd, (bfd_byte *) *p);
 397   (*p) += 4;
 398   return ret;
 399 }
 400
 401 static ULONGEST
 402 read_8u (bfd *abfd, char **p)
 403 {
 404   ULONGEST ret;
 405
 406   ret = bfd_get_64 (abfd, (bfd_byte *) *p);
 407   (*p) += 8;
 408   return ret;
 409 }
 410
 411 static LONGEST
 412 read_8s (bfd *abfd, char **p)
 413 {
 414   LONGEST ret;
 415
 416   ret = bfd_get_signed_64 (abfd, (bfd_byte *) *p);
 417   (*p) += 8;
 418   return ret;
 419 }
 420
 421 static ULONGEST
 422 read_uleb128 (bfd *abfd, char **p)
 423 {
 424   ULONGEST ret;
 425   int i, shift;
 426   unsigned char byte;
 427
 428   ret = 0;
 429   shift = 0;
 430   i = 0;
 431   while (1)
 432     {
 433       byte = bfd_get_8 (abfd, (bfd_byte *) *p);
 434       (*p) ++;
 435       ret |= ((unsigned long) (byte & 127) << shift);
 436       if ((byte & 128) == 0)
 437         {
 438           break;
 439         }
 440       shift += 7;
 441     }
 442   return ret;
 443 }
 444
 445 static LONGEST
 446 read_sleb128 (bfd *abfd, char **p)
 447 {
 448   LONGEST ret;
 449   int i, shift, size, num_read;
 450   unsigned char byte;
 451
 452   ret = 0;
 453   shift = 0;
 454   size = 32;
 455   num_read = 0;
 456   i = 0;
 457   while (1)
 458     {
 459       byte = bfd_get_8 (abfd, (bfd_byte *) *p);
 460       (*p) ++;
 461       ret |= ((long) (byte & 127) << shift);
 462       shift += 7;
 463       if ((byte & 128) == 0)
 464         {
 465           break;
 466         }
 467     }
 468   if ((shift < size) && (byte & 0x40))
 469     {
 470       ret |= -(1 << shift);
 471     }
 472   return ret;
 473 }
 474
 475 static CORE_ADDR
 476 read_pointer (bfd *abfd, char **p)
 477 {
 478   switch (TARGET_ADDR_BIT / TARGET_CHAR_BIT)
 479     {
 480     case 4:
 481       return read_4u (abfd, p);
 482     case 8:
 483       return read_8u (abfd, p);
 484     default:
 485       error ("dwarf cfi error: unsupported target address length.");
 486     }
 487 }
 488
 489 static CORE_ADDR
 490 read_encoded_pointer (bfd *abfd, char **p, unsigned char encoding)
 491 {
 492   CORE_ADDR ret;
 493
 494   switch (encoding & 0x0f)
 495     {
 496     case DW_EH_PE_absptr:
 497       ret = read_pointer (abfd, p);
 498       break;
 499
 500     case DW_EH_PE_uleb128:
 501       ret = read_uleb128 (abfd, p);
 502       break;
 503     case DW_EH_PE_sleb128:
 504       ret = read_sleb128 (abfd, p);
 505       break;
 506
 507     case DW_EH_PE_udata2:
 508       ret = read_2u (abfd, p);
 509       break;
 510     case DW_EH_PE_udata4:
 511       ret = read_4u (abfd, p);
 512       break;
 513     case DW_EH_PE_udata8:
 514       ret = read_8u (abfd, p);
 515       break;
 516
 517     case DW_EH_PE_sdata2:
 518       ret = read_2s (abfd, p);
 519       break;
 520     case DW_EH_PE_sdata4:
 521       ret = read_4s (abfd, p);
 522       break;
 523     case DW_EH_PE_sdata8:
 524       ret = read_8s (abfd, p);
 525       break;
 526
 527     default:
 528       internal_error (__FILE__, __LINE__,
 529                       "read_encoded_pointer: unknown pointer encoding");
 530     }
 531
 532   if (ret != 0)
 533     switch (encoding & 0xf0)
 534       {
 535       case DW_EH_PE_absptr:
 536         break;
 537       case DW_EH_PE_pcrel:
 538         ret += (CORE_ADDR) *p;
 539         break;
 540       case DW_EH_PE_textrel:
 541       case DW_EH_PE_datarel:
 542       case DW_EH_PE_funcrel:
 543       default:
 544         internal_error (__FILE__, __LINE__,
 545                         "read_encoded_pointer: unknown pointer encoding");
 546       }
 547
 548   return ret;
 549 }
 550
 551 static LONGEST
 552 read_initial_length (bfd * abfd, char *buf, int *bytes_read)
 553 {
 554   LONGEST ret = 0;
 555
 556   ret = bfd_get_32 (abfd, (bfd_byte *) buf);
 557
 558   if (ret == 0xffffffff)
 559     {
 560       ret = bfd_get_64 (abfd, (bfd_byte *) buf + 4);
 561       *bytes_read = 12;
 562     }
 563   else
 564     {
 565       *bytes_read = 4;
 566     }
 567
 568   return ret;
 569 }
 570
 571 static ULONGEST
 572 read_length (bfd * abfd, char *buf, int *bytes_read, int dwarf64)
 573 {
 574   if (dwarf64)
 575     {
 576       *bytes_read = 8;
 577       return read_8u (abfd, &buf);
 578     }
 579   else
 580     {
 581       *bytes_read = 4;
 582       return read_4u (abfd, &buf);
 583     }
 584 }
 585
 586 static void
 587 execute_cfa_program ( struct objfile *objfile, char *insn_ptr, char *insn_end,
 588                       struct context *context, struct frame_state *fs)
 589 {
 590   struct frame_state_regs *unused_rs = NULL;
 591
 592   /* Don't allow remember/restore between CIE and FDE programs.  */
 593   fs->regs.prev = NULL;
 594
 595   while (insn_ptr < insn_end && fs->pc < context->ra)
 596     {
 597       unsigned char insn = *insn_ptr++;
 598       ULONGEST reg, uoffset;
 599       LONGEST offset;
 600
 601       if (insn & DW_CFA_advance_loc)
 602         fs->pc += (insn & 0x3f) * fs->code_align;
 603       else if (insn & DW_CFA_offset)
 604         {
 605           reg = insn & 0x3f;
 606           uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
 607           offset = (long) uoffset * fs->data_align;
 608           fs->regs.reg[reg].how = REG_SAVED_OFFSET;
 609           fs->regs.reg[reg].loc.offset = offset;
 610         }
 611       else if (insn & DW_CFA_restore)
 612         {
 613           reg = insn & 0x3f;
 614           fs->regs.reg[reg].how = REG_UNSAVED;
 615         }
 616       else
 617         switch (insn)
 618           {
 619           case DW_CFA_set_loc:
 620             fs->pc = read_encoded_pointer (objfile->obfd, &insn_ptr,
 621                                            fs->addr_encoding);
 622             break;
 623
 624           case DW_CFA_advance_loc1:
 625             fs->pc += read_1u (objfile->obfd, &insn_ptr);
 626             break;
 627           case DW_CFA_advance_loc2:
 628             fs->pc += read_2u (objfile->obfd, &insn_ptr);
 629             break;
 630           case DW_CFA_advance_loc4:
 631             fs->pc += read_4u (objfile->obfd, &insn_ptr);
 632             break;
 633
 634           case DW_CFA_offset_extended:
 635             reg = read_uleb128 (objfile->obfd, &insn_ptr);
 636             uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
 637             offset = (long) uoffset *fs->data_align;
 638             fs->regs.reg[reg].how = REG_SAVED_OFFSET;
 639             fs->regs.reg[reg].loc.offset = offset;
 640             break;
 641
 642           case DW_CFA_restore_extended:
 643             reg = read_uleb128 (objfile->obfd, &insn_ptr);
 644             fs->regs.reg[reg].how = REG_UNSAVED;
 645             break;
 646
 647           case DW_CFA_undefined:
 648           case DW_CFA_same_value:
 649           case DW_CFA_nop:
 650             break;
 651
 652           case DW_CFA_register:
 653             {
 654               ULONGEST reg2;
 655               reg = read_uleb128 (objfile->obfd, &insn_ptr);
 656               reg2 = read_uleb128 (objfile->obfd, &insn_ptr);
 657               fs->regs.reg[reg].how = REG_SAVED_REG;
 658               fs->regs.reg[reg].loc.reg = reg2;
 659             }
 660             break;
 661
 662           case DW_CFA_remember_state:
 663             {
 664               struct frame_state_regs *new_rs;
 665               if (unused_rs)
 666                 {
 667                   new_rs = unused_rs;
 668                   unused_rs = unused_rs->prev;
 669                 }
 670               else
 671                 new_rs = xmalloc (sizeof (struct frame_state_regs));
 672
 673               *new_rs = fs->regs;
 674               fs->regs.prev = new_rs;
 675             }
 676             break;
 677
 678           case DW_CFA_restore_state:
 679             {
 680               struct frame_state_regs *old_rs = fs->regs.prev;
 681               fs->regs = *old_rs;
 682               old_rs->prev = unused_rs;
 683               unused_rs = old_rs;
 684             }
 685             break;
 686
 687           case DW_CFA_def_cfa:
 688             reg = read_uleb128 (objfile->obfd, &insn_ptr);
 689             uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
 690             fs->cfa_reg = reg;
 691             fs->cfa_offset = uoffset;
 692             fs->cfa_how = CFA_REG_OFFSET;
 693             break;
 694
 695           case DW_CFA_def_cfa_register:
 696             reg = read_uleb128 (objfile->obfd, &insn_ptr);
 697             fs->cfa_reg = reg;
 698             fs->cfa_how = CFA_REG_OFFSET;
 699             break;
 700
 701           case DW_CFA_def_cfa_offset:
 702             uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
 703             fs->cfa_offset = uoffset;
 704             break;
 705
 706           case DW_CFA_def_cfa_expression:
 707             uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
 708             fs->cfa_exp = insn_ptr;
 709             fs->cfa_how = CFA_EXP;
 710             insn_ptr += uoffset;
 711             break;
 712
 713           case DW_CFA_expression:
 714             reg = read_uleb128 (objfile->obfd, &insn_ptr);
 715             uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
 716             fs->regs.reg[reg].how = REG_SAVED_EXP;
 717             fs->regs.reg[reg].loc.exp = insn_ptr;
 718             insn_ptr += uoffset;
 719             break;
 720
 721             /* From the 2.1 draft.  */
 722           case DW_CFA_offset_extended_sf:
 723             reg = read_uleb128 (objfile->obfd, &insn_ptr);
 724             offset = read_sleb128 (objfile->obfd, &insn_ptr);
 725             offset *= fs->data_align;
 726             fs->regs.reg[reg].how = REG_SAVED_OFFSET;
 727             fs->regs.reg[reg].loc.offset = offset;
 728             break;
 729
 730           case DW_CFA_def_cfa_sf:
 731             reg = read_uleb128 (objfile->obfd, &insn_ptr);
 732             offset = read_sleb128 (objfile->obfd, &insn_ptr);
 733             fs->cfa_offset = offset;
 734             fs->cfa_reg = reg;
 735             fs->cfa_how = CFA_REG_OFFSET;
 736             break;
 737
 738           case DW_CFA_def_cfa_offset_sf:
 739             uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
 740             fs->cfa_offset = uoffset;
 741             /* cfa_how deliberately not set.  */
 742             break;
 743
 744           case DW_CFA_GNU_window_save:
 745             /* ??? Hardcoded for SPARC register window configuration.  */
 746             for (reg = 16; reg < 32; ++reg)
 747               {
 748                 fs->regs.reg[reg].how = REG_SAVED_OFFSET;
 749                 fs->regs.reg[reg].loc.offset = (reg - 16) * sizeof (void *);
 750               }
 751             break;
 752
 753           case DW_CFA_GNU_args_size:
 754             uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
 755             context->args_size = uoffset;
 756             break;
 757
 758           case DW_CFA_GNU_negative_offset_extended:
 759             /* Obsoleted by DW_CFA_offset_extended_sf, but used by
 760                older PowerPC code.  */
 761             reg = read_uleb128 (objfile->obfd, &insn_ptr);
 762             uoffset = read_uleb128 (objfile->obfd, &insn_ptr);
 763             offset = (long) uoffset *fs->data_align;
 764             fs->regs.reg[reg].how = REG_SAVED_OFFSET;
 765             fs->regs.reg[reg].loc.offset = -offset;
 766             break;
 767
 768           default:
 769             error ("dwarf cfi error: unknown cfa instruction %d.", insn);
 770           }
 771     }
 772 }
 773
 774 static struct fde_unit *
 775 get_fde_for_addr (CORE_ADDR pc)
 776 {
 777   size_t lo, hi;
 778   struct fde_unit *fde = NULL;
 779   lo = 0;
 780   hi = fde_chunks.elems;
 781
 782   while (lo < hi)
 783     {
 784       size_t i = (lo + hi) / 2;
 785       fde = fde_chunks.array[i];
 786       if (pc < fde->initial_location)
 787         hi = i;
 788       else if (pc >= fde->initial_location + fde->address_range)
 789         lo = i + 1;
 790       else
 791         return fde;
 792     }
 793   return 0;
 794 }
 795
 796 static void
 797 frame_state_for (struct context *context, struct frame_state *fs)
 798 {
 799   struct fde_unit *fde;
 800   struct cie_unit *cie;
 801
 802   context->args_size = 0;
 803   context->lsda = 0;
 804
 805   if ((fde = get_fde_for_addr (context->ra - 1)) != NULL)
 806     {
 807       fs->pc = fde->initial_location;
 808
 809       cie = fde->cie_ptr;
 810       fs->code_align = cie->code_align;
 811       fs->data_align = cie->data_align;
 812       fs->retaddr_column = cie->ra;
 813       fs->addr_encoding = cie->addr_encoding;
 814       fs->objfile = cie->objfile;
 815
 816       execute_cfa_program (cie->objfile, cie->data,
 817                            cie->data + cie->data_length, context, fs);
 818       execute_cfa_program (cie->objfile, fde->data,
 819                            fde->data + fde->data_length, context, fs);
 820     }
 821 }
 822
 823 static void
 824 get_reg (char *reg, struct context *context, int regnum)
 825 {
 826   switch (context->reg[regnum].how)
 827     {
 828     case REG_CTX_UNSAVED:
 829       read_register_gen (regnum, reg);
 830       break;
 831     case REG_CTX_SAVED_OFFSET:
 832       target_read_memory (context->cfa + context->reg[regnum].loc.offset,
 833                           reg, REGISTER_RAW_SIZE (regnum));
 834       break;
 835     case REG_CTX_SAVED_REG:
 836       read_register_gen (context->reg[regnum].loc.reg, reg);
 837       break;
 838     case REG_CTX_SAVED_ADDR:
 839       target_read_memory (context->reg[regnum].loc.addr,
 840                           reg, REGISTER_RAW_SIZE (regnum));
 841       break;
 842     case REG_CTX_VALUE:
 843       memcpy (reg, &context->reg[regnum].loc.addr,
 844               REGISTER_RAW_SIZE (regnum));
 845       break;
 846     default:
 847       internal_error (__FILE__, __LINE__,
 848                       "get_reg: unknown register rule");
 849     }
 850 }
 851
 852 /* Decode a DW_OP stack program.  Return the top of stack.  Push INITIAL
 853    onto the stack to start.  */
 854 static CORE_ADDR
 855 execute_stack_op (struct objfile *objfile,
 856                   char *op_ptr, char *op_end, struct context *context,
 857                   CORE_ADDR initial)
 858 {
 859   CORE_ADDR stack[64];          /* ??? Assume this is enough. */
 860   int stack_elt;
 861
 862   stack[0] = initial;
 863   stack_elt = 1;
 864
 865   while (op_ptr < op_end)
 866     {
 867       enum dwarf_location_atom op = *op_ptr++;
 868       ULONGEST result, reg;
 869       LONGEST offset;
 870
 871       switch (op)
 872         {
 873         case DW_OP_lit0:
 874         case DW_OP_lit1:
 875         case DW_OP_lit2:
 876         case DW_OP_lit3:
 877         case DW_OP_lit4:
 878         case DW_OP_lit5:
 879         case DW_OP_lit6:
 880         case DW_OP_lit7:
 881         case DW_OP_lit8:
 882         case DW_OP_lit9:
 883         case DW_OP_lit10:
 884         case DW_OP_lit11:
 885         case DW_OP_lit12:
 886         case DW_OP_lit13:
 887         case DW_OP_lit14:
 888         case DW_OP_lit15:
 889         case DW_OP_lit16:
 890         case DW_OP_lit17:
 891         case DW_OP_lit18:
 892         case DW_OP_lit19:
 893         case DW_OP_lit20:
 894         case DW_OP_lit21:
 895         case DW_OP_lit22:
 896         case DW_OP_lit23:
 897         case DW_OP_lit24:
 898         case DW_OP_lit25:
 899         case DW_OP_lit26:
 900         case DW_OP_lit27:
 901         case DW_OP_lit28:
 902         case DW_OP_lit29:
 903         case DW_OP_lit30:
 904         case DW_OP_lit31:
 905           result = op - DW_OP_lit0;
 906           break;
 907
 908         case DW_OP_addr:
 909           result = read_pointer (objfile->obfd, &op_ptr);
 910           break;
 911
 912         case DW_OP_const1u:
 913           result = read_1u (objfile->obfd, &op_ptr);
 914           break;
 915         case DW_OP_const1s:
 916           result = read_1s (objfile->obfd, &op_ptr);
 917           break;
 918         case DW_OP_const2u:
 919           result = read_2u (objfile->obfd, &op_ptr);
 920           break;
 921         case DW_OP_const2s:
 922           result = read_2s (objfile->obfd, &op_ptr);
 923           break;
 924         case DW_OP_const4u:
 925           result = read_4u (objfile->obfd, &op_ptr);
 926           break;
 927         case DW_OP_const4s:
 928           result = read_4s (objfile->obfd, &op_ptr);
 929           break;
 930         case DW_OP_const8u:
 931           result = read_8u (objfile->obfd, &op_ptr);
 932           break;
 933         case DW_OP_const8s:
 934           result = read_8s (objfile->obfd, &op_ptr);
 935           break;
 936         case DW_OP_constu:
 937           result = read_uleb128 (objfile->obfd, &op_ptr);
 938           break;
 939         case DW_OP_consts:
 940           result = read_sleb128 (objfile->obfd, &op_ptr);
 941           break;
 942
 943         case DW_OP_reg0:
 944         case DW_OP_reg1:
 945         case DW_OP_reg2:
 946         case DW_OP_reg3:
 947         case DW_OP_reg4:
 948         case DW_OP_reg5:
 949         case DW_OP_reg6:
 950         case DW_OP_reg7:
 951         case DW_OP_reg8:
 952         case DW_OP_reg9:
 953         case DW_OP_reg10:
 954         case DW_OP_reg11:
 955         case DW_OP_reg12:
 956         case DW_OP_reg13:
 957         case DW_OP_reg14:
 958         case DW_OP_reg15:
 959         case DW_OP_reg16:
 960         case DW_OP_reg17:
 961         case DW_OP_reg18:
 962         case DW_OP_reg19:
 963         case DW_OP_reg20:
 964         case DW_OP_reg21:
 965         case DW_OP_reg22:
 966         case DW_OP_reg23:
 967         case DW_OP_reg24:
 968         case DW_OP_reg25:
 969         case DW_OP_reg26:
 970         case DW_OP_reg27:
 971         case DW_OP_reg28:
 972         case DW_OP_reg29:
 973         case DW_OP_reg30:
 974         case DW_OP_reg31:
 975           get_reg ((char *) &result, context, op - DW_OP_reg0);
 976           break;
 977         case DW_OP_regx:
 978           reg = read_uleb128 (objfile->obfd, &op_ptr);
 979           get_reg ((char *) &result, context, reg);
 980           break;
 981
 982         case DW_OP_breg0:
 983         case DW_OP_breg1:
 984         case DW_OP_breg2:
 985         case DW_OP_breg3:
 986         case DW_OP_breg4:
 987         case DW_OP_breg5:
 988         case DW_OP_breg6:
 989         case DW_OP_breg7:
 990         case DW_OP_breg8:
 991         case DW_OP_breg9:
 992         case DW_OP_breg10:
 993         case DW_OP_breg11:
 994         case DW_OP_breg12:
 995         case DW_OP_breg13:
 996         case DW_OP_breg14:
 997         case DW_OP_breg15:
 998         case DW_OP_breg16:
 999         case DW_OP_breg17:
1000         case DW_OP_breg18:
1001         case DW_OP_breg19:
1002         case DW_OP_breg20:
1003         case DW_OP_breg21:
1004         case DW_OP_breg22:
1005         case DW_OP_breg23:
1006         case DW_OP_breg24:
1007         case DW_OP_breg25:
1008         case DW_OP_breg26:
1009         case DW_OP_breg27:
1010         case DW_OP_breg28:
1011         case DW_OP_breg29:
1012         case DW_OP_breg30:
1013         case DW_OP_breg31:
1014           offset = read_sleb128 (objfile->obfd, &op_ptr);
1015           get_reg ((char *) &result, context, op - DW_OP_breg0);
1016           result += offset;
1017           break;
1018         case DW_OP_bregx:
1019           reg = read_uleb128 (objfile->obfd, &op_ptr);
1020           offset = read_sleb128 (objfile->obfd, &op_ptr);
1021           get_reg ((char *) &result, context, reg);
1022           result += offset;
1023           break;
1024
1025         case DW_OP_dup:
1026           if (stack_elt < 1)
1027             internal_error (__FILE__, __LINE__, "execute_stack_op error");
1028           result = stack[stack_elt - 1];
1029           break;
1030
1031         case DW_OP_drop:
1032           if (--stack_elt < 0)
1033             internal_error (__FILE__, __LINE__, "execute_stack_op error");
1034           goto no_push;
1035
1036         case DW_OP_pick:
1037           offset = *op_ptr++;
1038           if (offset >= stack_elt - 1)
1039             internal_error (__FILE__, __LINE__, "execute_stack_op error");
1040           result = stack[stack_elt - 1 - offset];
1041           break;
1042
1043         case DW_OP_over:
1044           if (stack_elt < 2)
1045             internal_error (__FILE__, __LINE__, "execute_stack_op error");
1046           result = stack[stack_elt - 2];
1047           break;
1048
1049         case DW_OP_rot:
1050           {
1051             CORE_ADDR t1, t2, t3;
1052
1053             if (stack_elt < 3)
1054               internal_error (__FILE__, __LINE__, "execute_stack_op error");
1055             t1 = stack[stack_elt - 1];
1056             t2 = stack[stack_elt - 2];
1057             t3 = stack[stack_elt - 3];
1058             stack[stack_elt - 1] = t2;
1059             stack[stack_elt - 2] = t3;
1060             stack[stack_elt - 3] = t1;
1061             goto no_push;
1062           }
1063
1064         case DW_OP_deref:
1065         case DW_OP_deref_size:
1066         case DW_OP_abs:
1067         case DW_OP_neg:
1068         case DW_OP_not:
1069         case DW_OP_plus_uconst:
1070           /* Unary operations.  */
1071           if (--stack_elt < 0)
1072             internal_error (__FILE__, __LINE__, "execute_stack_op error");
1073           result = stack[stack_elt];
1074
1075           switch (op)
1076             {
1077             case DW_OP_deref:
1078               {
1079                 char *ptr = (char *) result;
1080                 result = read_pointer (objfile->obfd, &ptr);
1081               }
1082               break;
1083
1084             case DW_OP_deref_size:
1085               {
1086                 char *ptr = (char *) result;
1087                 switch (*op_ptr++)
1088                   {
1089                   case 1:
1090                     result = read_1u (objfile->obfd, &ptr);
1091                     break;
1092                   case 2:
1093                     result = read_2u (objfile->obfd, &ptr);
1094                     break;
1095                   case 4:
1096                     result = read_4u (objfile->obfd, &ptr);
1097                     break;
1098                   case 8:
1099                     result = read_8u (objfile->obfd, &ptr);
1100                     break;
1101                   default:
1102                     internal_error (__FILE__, __LINE__,
1103                                     "execute_stack_op error");
1104                   }
1105               }
1106               break;
1107
1108             case DW_OP_abs:
1109               if (result < 0)
1110                 result = -result;
1111               break;
1112             case DW_OP_neg:
1113               result = -result;
1114               break;
1115             case DW_OP_not:
1116               result = ~result;
1117               break;
1118             case DW_OP_plus_uconst:
1119               result += read_uleb128 (objfile->obfd, &op_ptr);
1120               break;
1121             default:
1122               break;
1123             }
1124           break;
1125
1126         case DW_OP_and:
1127         case DW_OP_div:
1128         case DW_OP_minus:
1129         case DW_OP_mod:
1130         case DW_OP_mul:
1131         case DW_OP_or:
1132         case DW_OP_plus:
1133         case DW_OP_le:
1134         case DW_OP_ge:
1135         case DW_OP_eq:
1136         case DW_OP_lt:
1137         case DW_OP_gt:
1138         case DW_OP_ne:
1139           {
1140             /* Binary operations.  */
1141             CORE_ADDR first, second;
1142             if ((stack_elt -= 2) < 0)
1143               internal_error (__FILE__, __LINE__, "execute_stack_op error");
1144             second = stack[stack_elt];
1145             first = stack[stack_elt + 1];
1146
1147             switch (op)
1148               {
1149               case DW_OP_and:
1150                 result = second & first;
1151                 break;
1152               case DW_OP_div:
1153                 result = (LONGEST) second / (LONGEST) first;
1154                 break;
1155               case DW_OP_minus:
1156                 result = second - first;
1157                 break;
1158               case DW_OP_mod:
1159                 result = (LONGEST) second % (LONGEST) first;
1160                 break;
1161               case DW_OP_mul:
1162                 result = second * first;
1163                 break;
1164               case DW_OP_or:
1165                 result = second | first;
1166                 break;
1167               case DW_OP_plus:
1168                 result = second + first;
1169                 break;
1170               case DW_OP_shl:
1171                 result = second << first;
1172                 break;
1173               case DW_OP_shr:
1174                 result = second >> first;
1175                 break;
1176               case DW_OP_shra:
1177                 result = (LONGEST) second >> first;
1178                 break;
1179               case DW_OP_xor:
1180                 result = second ^ first;
1181                 break;
1182               case DW_OP_le:
1183                 result = (LONGEST) first <= (LONGEST) second;
1184                 break;
1185               case DW_OP_ge:
1186                 result = (LONGEST) first >= (LONGEST) second;
1187                 break;
1188               case DW_OP_eq:
1189                 result = (LONGEST) first == (LONGEST) second;
1190                 break;
1191               case DW_OP_lt:
1192                 result = (LONGEST) first < (LONGEST) second;
1193                 break;
1194               case DW_OP_gt:
1195                 result = (LONGEST) first > (LONGEST) second;
1196                 break;
1197               case DW_OP_ne:
1198                 result = (LONGEST) first != (LONGEST) second;
1199                 break;
1200               default:  /* This label is here just to avoid warning.  */
1201                 break;
1202               }
1203           }
1204           break;
1205
1206         case DW_OP_skip:
1207           offset = read_2s (objfile->obfd, &op_ptr);
1208           op_ptr += offset;
1209           goto no_push;
1210
1211         case DW_OP_bra:
1212           if (--stack_elt < 0)
1213             internal_error (__FILE__, __LINE__, "execute_stack_op error");
1214           offset = read_2s (objfile->obfd, &op_ptr);
1215           if (stack[stack_elt] != 0)
1216             op_ptr += offset;
1217           goto no_push;
1218
1219         case DW_OP_nop:
1220           goto no_push;
1221
1222         default:
1223           internal_error (__FILE__, __LINE__, "execute_stack_op error");
1224         }
1225
1226       /* Most things push a result value.  */
1227       if ((size_t) stack_elt >= sizeof (stack) / sizeof (*stack))
1228         internal_error (__FILE__, __LINE__, "execute_stack_op error");
1229       stack[++stack_elt] = result;
1230     no_push:;
1231     }
1232
1233   /* We were executing this program to get a value.  It should be
1234      at top of stack.  */
1235   if (--stack_elt < 0)
1236     internal_error (__FILE__, __LINE__, "execute_stack_op error");
1237   return stack[stack_elt];
1238 }
1239
1240 static void
1241 update_context (struct context *context, struct frame_state *fs, int chain)
1242 {
1243   struct context *orig_context;
1244   CORE_ADDR cfa;
1245   long i;
1246
1247   orig_context = context_alloc ();
1248   context_cpy (orig_context, context);
1249   /* Compute this frame's CFA.  */
1250   switch (fs->cfa_how)
1251     {
1252     case CFA_REG_OFFSET:
1253       get_reg ((char *) &cfa, context, fs->cfa_reg);
1254       cfa += fs->cfa_offset;
1255       break;
1256
1257     case CFA_EXP:
1258       /* ??? No way of knowing what register number is the stack pointer
1259          to do the same sort of handling as above.  Assume that if the
1260          CFA calculation is so complicated as to require a stack program
1261          that this will not be a problem.  */
1262       {
1263         char *exp = fs->cfa_exp;
1264         ULONGEST len;
1265
1266         len = read_uleb128 (fs->objfile->obfd, &exp);
1267         cfa = (CORE_ADDR) execute_stack_op (fs->objfile, exp,
1268                                             exp + len, context, 0);
1269         break;
1270       }
1271     default:
1272       break;
1273     }
1274   context->cfa = cfa;
1275
1276   if (!chain)
1277     orig_context->cfa = cfa;
1278
1279   /* Compute the addresses of all registers saved in this frame.  */
1280   for (i = 0; i < NUM_REGS; ++i)
1281     switch (fs->regs.reg[i].how)
1282       {
1283       case REG_UNSAVED:
1284         if (i == SP_REGNUM)
1285           {
1286             context->reg[i].how = REG_CTX_VALUE;
1287             context->reg[i].loc.addr = cfa;
1288           }
1289         else
1290           context->reg[i].how = REG_CTX_UNSAVED;
1291         break;
1292       case REG_SAVED_OFFSET:
1293         context->reg[i].how = REG_CTX_SAVED_OFFSET;
1294         context->reg[i].loc.offset = fs->regs.reg[i].loc.offset;
1295         break;
1296       case REG_SAVED_REG:
1297         switch (orig_context->reg[fs->regs.reg[i].loc.reg].how)
1298           {
1299           case REG_CTX_UNSAVED:
1300             context->reg[i].how = REG_CTX_UNSAVED;
1301             break;
1302           case REG_CTX_SAVED_OFFSET:
1303             context->reg[i].how = REG_CTX_SAVED_OFFSET;
1304             context->reg[i].loc.offset = orig_context->cfa - context->cfa +
1305               orig_context->reg[fs->regs.reg[i].loc.reg].loc.offset;
1306             break;
1307           case REG_CTX_SAVED_REG:
1308             context->reg[i].how = REG_CTX_SAVED_REG;
1309             context->reg[i].loc.reg =
1310               orig_context->reg[fs->regs.reg[i].loc.reg].loc.reg;
1311             break;
1312           case REG_CTX_SAVED_ADDR:
1313             context->reg[i].how = REG_CTX_SAVED_ADDR;
1314             context->reg[i].loc.addr =
1315               orig_context->reg[fs->regs.reg[i].loc.reg].loc.addr;
1316           default:
1317             internal_error (__FILE__, __LINE__,
1318                             "%s: unknown register rule", __func__);
1319           }
1320         break;
1321       case REG_SAVED_EXP:
1322         {
1323           char *exp = fs->regs.reg[i].loc.exp;
1324           ULONGEST len;
1325           CORE_ADDR val;
1326
1327           len = read_uleb128 (fs->objfile->obfd, &exp);
1328           val = execute_stack_op (fs->objfile, exp, exp + len,
1329                                   orig_context, cfa);
1330           context->reg[i].how = REG_CTX_SAVED_ADDR;
1331           context->reg[i].loc.addr = val;
1332         }
1333         break;
1334       default:
1335         internal_error (__FILE__, __LINE__,
1336                         "%s: unknown register rule", __func__);
1337       }
1338   get_reg ((char *) &context->ra, context, fs->retaddr_column);
1339   unwind_tmp_obstack_free ();
1340 }
1341
1342 static int
1343 is_cie (ULONGEST cie_id, int dwarf64)
1344 {
1345   return dwarf64 ? (cie_id == 0xffffffffffffffff) : (cie_id == 0xffffffff);
1346 }
1347
1348 static int
1349 compare_fde_unit (const void *a, const void *b)
1350 {
1351   struct fde_unit **first, **second;
1352   first = (struct fde_unit **) a;
1353   second = (struct fde_unit **) b;
1354   if ((*first)->initial_location > (*second)->initial_location)
1355     return 1;
1356   else if ((*first)->initial_location < (*second)->initial_location)
1357     return -1;
1358   else
1359     return 0;
1360 }
1361
1362 /*  Build the cie_chunks and fde_chunks tables from informations
1363     in .debug_frame section.  */
1364 void
1365 dwarf2_build_frame_info (struct objfile *objfile)
1366 {
1367   bfd *abfd = objfile->obfd;
1368   char *start = NULL;
1369   char *end = NULL;
1370
1371   obstack_init (&unwind_tmp_obstack);
1372
1373   dwarf_frame_buffer = 0;
1374
1375   if (dwarf_frame_offset)
1376     {
1377       dwarf_frame_buffer = dwarf2_read_section (objfile,
1378                                                 dwarf_frame_offset,
1379                                                 dwarf_frame_size);
1380
1381       start = dwarf_frame_buffer;
1382       end = dwarf_frame_buffer + dwarf_frame_size;
1383     }
1384   else if (dwarf_eh_frame_offset)
1385     {
1386       dwarf_frame_buffer = dwarf2_read_section (objfile,
1387                                                 dwarf_eh_frame_offset,
1388                                                 dwarf_eh_frame_size);
1389
1390       start = dwarf_frame_buffer;
1391       end = dwarf_frame_buffer + dwarf_eh_frame_size;
1392     }
1393
1394   if (start)
1395     {
1396       while (start < end)
1397         {
1398           unsigned long length;
1399           ULONGEST cie_id;
1400           ULONGEST unit_offset = start - dwarf_frame_buffer;
1401           int bytes_read;
1402           int dwarf64;
1403           char *block_end;
1404
1405           length = read_initial_length (abfd, start, &bytes_read);
1406           start += bytes_read;
1407           dwarf64 = (bytes_read == 12);
1408           block_end = start + length;
1409
1410           cie_id = read_length (abfd, start, &bytes_read, dwarf64);
1411           start += bytes_read;
1412
1413           if (is_cie (cie_id, dwarf64))
1414             {
1415               struct cie_unit *cie = cie_unit_alloc ();
1416               char *aug;
1417
1418               cie->objfile = objfile;
1419               cie->next = cie_chunks;
1420               cie_chunks = cie;
1421
1422               cie->objfile = objfile;
1423
1424               cie->offset = unit_offset;
1425
1426               start++;          /* version */
1427
1428               cie->augmentation = aug = start;
1429               while (*start)
1430                 start++;
1431               start++;          /* skip past NUL */
1432
1433               cie->code_align = read_uleb128 (abfd, &start);
1434               cie->data_align = read_sleb128 (abfd, &start);
1435               cie->ra = read_1u (abfd, &start);
1436
1437               if (*aug == 'z')
1438                 {
1439                   int xtra = read_uleb128 (abfd, &start);
1440                   start += xtra;
1441                   ++aug;
1442                 }
1443
1444               while (*aug != '\0')
1445                 {
1446                   if (aug[0] == 'e' && aug[1] == 'h')
1447                     {
1448                       start += sizeof (void *);
1449                       aug += 2;
1450                     }
1451                   else if (aug[0] == 'R')
1452                     {
1453                       cie->addr_encoding = *start++;
1454                       aug += 1;
1455                     }
1456                   else if (aug[0] == 'P')
1457                     {
1458                       CORE_ADDR ptr;
1459                       ptr = read_encoded_pointer (abfd, &start,
1460                                                   cie->addr_encoding);
1461                       aug += 1;
1462                     }
1463                   else
1464                     warning ("unknown augmentation");
1465                 }
1466
1467               cie->data = start;
1468               cie->data_length = block_end - start;
1469             }
1470           else
1471             {
1472               struct fde_unit *fde;
1473               struct cie_unit *cie;
1474
1475               fde_chunks_need_space ();
1476               fde = fde_unit_alloc ();
1477
1478               fde_chunks.array[fde_chunks.elems++] = fde;
1479               fde->initial_location = read_pointer (abfd, &start);
1480               fde->address_range = read_pointer (abfd, &start);
1481
1482               for (cie = cie_chunks;
1483                    cie && (cie->offset != cie_id); cie = cie->next);
1484               if (!cie)
1485                 error ("dwarf cfi error: can't find CIE pointer");
1486               fde->cie_ptr = cie;
1487
1488               if (cie->augmentation[0] == 'z')
1489                   read_uleb128 (abfd, &start);
1490
1491               fde->data = start;
1492               fde->data_length = block_end - start;
1493             }
1494           start = block_end;
1495         }
1496       qsort (fde_chunks.array, fde_chunks.elems,
1497              sizeof (struct fde_unit *), compare_fde_unit);
1498     }
1499 }
1500 \f
1501
1502 /* Return the frame address.  */
1503 CORE_ADDR
1504 cfi_read_fp ()
1505 {
1506   struct context *context;
1507   struct frame_state *fs;
1508   CORE_ADDR cfa;
1509
1510   context = context_alloc ();
1511   fs = frame_state_alloc ();
1512
1513   context->ra = read_pc () + 1;
1514
1515   frame_state_for (context, fs);
1516   update_context (context, fs, 0);
1517
1518   cfa = context->cfa;
1519   unwind_tmp_obstack_free ();
1520   return cfa;
1521 }
1522
1523 /* Store the frame address.  This function is not used.  */
1524
1525 void
1526 cfi_write_fp (CORE_ADDR val)
1527 {
1528   struct context *context;
1529   struct frame_state *fs;
1530
1531   context = context_alloc ();
1532   fs = frame_state_alloc ();
1533
1534   context->ra = read_pc () + 1;
1535
1536   frame_state_for (context, fs);
1537
1538   if (fs->cfa_how == CFA_REG_OFFSET)
1539     {
1540       val -= fs->cfa_offset;
1541       write_register_gen (fs->cfa_reg, (char *) &val);
1542     }
1543   else
1544     warning ("Can't write fp.");
1545
1546   unwind_tmp_obstack_free ();
1547 }
1548
1549 /* Restore the machine to the state it had before the current frame
1550    was created.  */
1551 void
1552 cfi_pop_frame (struct frame_info *fi)
1553 {
1554   char regbuf[MAX_REGISTER_RAW_SIZE];
1555   int regnum;
1556
1557   fi = get_current_frame ();
1558
1559   for (regnum = 0; regnum < NUM_REGS; regnum++)
1560     {
1561       get_reg (regbuf, UNWIND_CONTEXT (fi), regnum);
1562       write_register_bytes (REGISTER_BYTE (regnum), regbuf,
1563                             REGISTER_RAW_SIZE (regnum));
1564     }
1565   write_register (PC_REGNUM, UNWIND_CONTEXT (fi)->ra);
1566
1567   flush_cached_frames ();
1568 }
1569
1570 /* Determine the address of the calling function's frame.  */
1571 CORE_ADDR
1572 cfi_frame_chain (struct frame_info *fi)
1573 {
1574   struct context *context;
1575   struct frame_state *fs;
1576   CORE_ADDR cfa;
1577
1578   context = context_alloc ();
1579   fs = frame_state_alloc ();
1580   context_cpy (context, UNWIND_CONTEXT (fi));
1581
1582   /* outermost frame */
1583   if (context->ra == 0)
1584     {
1585       unwind_tmp_obstack_free ();
1586       return 0;
1587     }
1588
1589   frame_state_for (context, fs);
1590   update_context (context, fs, 1);
1591
1592   cfa = context->cfa;
1593   unwind_tmp_obstack_free ();
1594
1595   return cfa;
1596 }
1597
1598 /* Sets the pc of the frame.  */
1599 void
1600 cfi_init_frame_pc (int fromleaf, struct frame_info *fi)
1601 {
1602   if (fi->next)
1603     get_reg ((char *) &(fi->pc), UNWIND_CONTEXT (fi->next), PC_REGNUM);
1604   else
1605     fi->pc = read_pc ();
1606 }
1607
1608 /* Initialize unwind context informations of the frame.  */
1609 void
1610 cfi_init_extra_frame_info (int fromleaf, struct frame_info *fi)
1611 {
1612   struct frame_state *fs;
1613
1614   fs = frame_state_alloc ();
1615   fi->context = frame_obstack_alloc (sizeof (struct context));
1616   UNWIND_CONTEXT (fi)->reg =
1617     frame_obstack_alloc (sizeof (struct context_reg) * NUM_REGS);
1618   memset (UNWIND_CONTEXT (fi)->reg, 0,
1619           sizeof (struct context_reg) * NUM_REGS);
1620
1621   if (fi->next)
1622     {
1623       context_cpy (UNWIND_CONTEXT (fi), UNWIND_CONTEXT (fi->next));
1624       frame_state_for (UNWIND_CONTEXT (fi), fs);
1625       update_context (UNWIND_CONTEXT (fi), fs, 1);
1626     }
1627   else
1628     {
1629       UNWIND_CONTEXT (fi)->ra = fi->pc + 1;
1630       frame_state_for (UNWIND_CONTEXT (fi), fs);
1631       update_context (UNWIND_CONTEXT (fi), fs, 0);
1632     }
1633   unwind_tmp_obstack_free ();
1634 }
1635
1636 /* Obtain return address of the frame.  */
1637 CORE_ADDR
1638 cfi_get_ra (struct frame_info *fi)
1639 {
1640   return UNWIND_CONTEXT (fi)->ra;
1641 }
1642
1643 /* Find register number REGNUM relative to FRAME and put its
1644    (raw) contents in *RAW_BUFFER.  Set *OPTIMIZED if the variable
1645    was optimized out (and thus can't be fetched).  If the variable
1646    was fetched from memory, set *ADDRP to where it was fetched from,
1647    otherwise it was fetched from a register.
1648
1649    The argument RAW_BUFFER must point to aligned memory.  */
1650 void
1651 cfi_get_saved_register (char *raw_buffer,
1652                         int *optimized,
1653                         CORE_ADDR * addrp,
1654                         struct frame_info *frame,
1655                         int regnum, enum lval_type *lval)
1656 {
1657   if (!target_has_registers)
1658     error ("No registers.");
1659
1660   /* Normal systems don't optimize out things with register numbers.  */
1661   if (optimized != NULL)
1662     *optimized = 0;
1663
1664   if (addrp)                    /* default assumption: not found in memory */
1665     *addrp = 0;
1666
1667   if (!frame->next)
1668     {
1669       read_register_gen (regnum, raw_buffer);
1670       if (lval != NULL)
1671         *lval = lval_register;
1672       if (addrp != NULL)
1673         *addrp = REGISTER_BYTE (regnum);
1674     }
1675   else
1676     {
1677       frame = frame->next;
1678       switch (UNWIND_CONTEXT (frame)->reg[regnum].how)
1679         {
1680         case REG_CTX_UNSAVED:
1681           read_register_gen (regnum, raw_buffer);
1682           if (lval != NULL)
1683             *lval = not_lval;
1684           if (optimized != NULL)
1685             *optimized = 1;
1686           break;
1687         case REG_CTX_SAVED_OFFSET:
1688           target_read_memory (UNWIND_CONTEXT (frame)->cfa +
1689                               UNWIND_CONTEXT (frame)->reg[regnum].loc.offset,
1690                               raw_buffer, REGISTER_RAW_SIZE (regnum));
1691           if (lval != NULL)
1692             *lval = lval_memory;
1693           if (addrp != NULL)
1694             *addrp =
1695               UNWIND_CONTEXT (frame)->cfa +
1696               UNWIND_CONTEXT (frame)->reg[regnum].loc.offset;
1697           break;
1698         case REG_CTX_SAVED_REG:
1699           read_register_gen (UNWIND_CONTEXT (frame)->reg[regnum].loc.reg,
1700                              raw_buffer);
1701           if (lval != NULL)
1702             *lval = lval_register;
1703           if (addrp != NULL)
1704             *addrp =
1705               REGISTER_BYTE (UNWIND_CONTEXT (frame)->reg[regnum].loc.reg);
1706           break;
1707         case REG_CTX_SAVED_ADDR:
1708           target_read_memory (UNWIND_CONTEXT (frame)->reg[regnum].loc.addr,
1709                               raw_buffer, REGISTER_RAW_SIZE (regnum));
1710           if (lval != NULL)
1711             *lval = lval_memory;
1712           if (addrp != NULL)
1713             *addrp = UNWIND_CONTEXT (frame)->reg[regnum].loc.addr;
1714           break;
1715         case REG_CTX_VALUE:
1716           memcpy (raw_buffer, &UNWIND_CONTEXT (frame)->reg[regnum].loc.addr,
1717                   REGISTER_RAW_SIZE (regnum));
1718           if (lval != NULL)
1719             *lval = not_lval;
1720           if (optimized != NULL)
1721             *optimized = 0;
1722           break;
1723         default:
1724           internal_error (__FILE__, __LINE__,
1725                           "cfi_get_saved_register: unknown register rule");
1726         }
1727     }
1728 }
1729
1730 /*  Return the register that the function uses for a frame pointer,
1731     plus any necessary offset to be applied to the register before
1732     any frame pointer offsets.  */
1733 void
1734 cfi_virtual_frame_pointer (CORE_ADDR pc, int *frame_reg,
1735                            LONGEST * frame_offset)
1736 {
1737   struct context *context;
1738   struct frame_state *fs;
1739
1740   context = context_alloc ();
1741   fs = frame_state_alloc ();
1742
1743   context->ra = read_pc () + 1;
1744
1745   frame_state_for (context, fs);
1746
1747   if (fs->cfa_how == CFA_REG_OFFSET)
1748     {
1749       *frame_reg = fs->cfa_reg;
1750       *frame_offset = fs->cfa_offset;
1751     }
1752   else
1753     error ("dwarf cfi error: CFA is not defined as CFA_REG_OFFSET");
1754
1755   unwind_tmp_obstack_free ();
1756 }