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   fde = get_fde_for_addr (context->ra - 1);
 806
 807   if (fde == NULL)
 808     return;
 809
 810   fs->pc = fde->initial_location;
 811
 812   if (fde->cie_ptr)
 813   {
 814       cie = fde->cie_ptr;
 815
 816       fs->code_align = cie->code_align;
 817       fs->data_align = cie->data_align;
 818       fs->retaddr_column = cie->ra;
 819       fs->addr_encoding = cie->addr_encoding;
 820       fs->objfile = cie->objfile;
 821
 822       execute_cfa_program (cie->objfile, cie->data,
 823                            cie->data + cie->data_length, context, fs);
 824       execute_cfa_program (cie->objfile, fde->data,
 825                            fde->data + fde->data_length, context, fs);
 826   }
 827   else
 828         internal_error (__FILE__, __LINE__,
 829                 "%s(): Internal error: fde->cie_ptr==NULL !",
 830                 __func__);
 831 }
 832
 833 static void
 834 get_reg (char *reg, struct context *context, int regnum)
 835 {
 836   switch (context->reg[regnum].how)
 837     {
 838     case REG_CTX_UNSAVED:
 839       read_register_gen (regnum, reg);
 840       break;
 841     case REG_CTX_SAVED_OFFSET:
 842       target_read_memory (context->cfa + context->reg[regnum].loc.offset,
 843                           reg, REGISTER_RAW_SIZE (regnum));
 844       break;
 845     case REG_CTX_SAVED_REG:
 846       read_register_gen (context->reg[regnum].loc.reg, reg);
 847       break;
 848     case REG_CTX_SAVED_ADDR:
 849       target_read_memory (context->reg[regnum].loc.addr,
 850                           reg, REGISTER_RAW_SIZE (regnum));
 851       break;
 852     case REG_CTX_VALUE:
 853       memcpy (reg, &context->reg[regnum].loc.addr,
 854               REGISTER_RAW_SIZE (regnum));
 855       break;
 856     default:
 857       internal_error (__FILE__, __LINE__,
 858                       "get_reg: unknown register rule");
 859     }
 860 }
 861
 862 /* Decode a DW_OP stack program.  Return the top of stack.  Push INITIAL
 863    onto the stack to start.  */
 864 static CORE_ADDR
 865 execute_stack_op (struct objfile *objfile,
 866                   char *op_ptr, char *op_end, struct context *context,
 867                   CORE_ADDR initial)
 868 {
 869   CORE_ADDR stack[64];          /* ??? Assume this is enough. */
 870   int stack_elt;
 871
 872   stack[0] = initial;
 873   stack_elt = 1;
 874
 875   while (op_ptr < op_end)
 876     {
 877       enum dwarf_location_atom op = *op_ptr++;
 878       ULONGEST result, reg;
 879       LONGEST offset;
 880
 881       switch (op)
 882         {
 883         case DW_OP_lit0:
 884         case DW_OP_lit1:
 885         case DW_OP_lit2:
 886         case DW_OP_lit3:
 887         case DW_OP_lit4:
 888         case DW_OP_lit5:
 889         case DW_OP_lit6:
 890         case DW_OP_lit7:
 891         case DW_OP_lit8:
 892         case DW_OP_lit9:
 893         case DW_OP_lit10:
 894         case DW_OP_lit11:
 895         case DW_OP_lit12:
 896         case DW_OP_lit13:
 897         case DW_OP_lit14:
 898         case DW_OP_lit15:
 899         case DW_OP_lit16:
 900         case DW_OP_lit17:
 901         case DW_OP_lit18:
 902         case DW_OP_lit19:
 903         case DW_OP_lit20:
 904         case DW_OP_lit21:
 905         case DW_OP_lit22:
 906         case DW_OP_lit23:
 907         case DW_OP_lit24:
 908         case DW_OP_lit25:
 909         case DW_OP_lit26:
 910         case DW_OP_lit27:
 911         case DW_OP_lit28:
 912         case DW_OP_lit29:
 913         case DW_OP_lit30:
 914         case DW_OP_lit31:
 915           result = op - DW_OP_lit0;
 916           break;
 917
 918         case DW_OP_addr:
 919           result = read_pointer (objfile->obfd, &op_ptr);
 920           break;
 921
 922         case DW_OP_const1u:
 923           result = read_1u (objfile->obfd, &op_ptr);
 924           break;
 925         case DW_OP_const1s:
 926           result = read_1s (objfile->obfd, &op_ptr);
 927           break;
 928         case DW_OP_const2u:
 929           result = read_2u (objfile->obfd, &op_ptr);
 930           break;
 931         case DW_OP_const2s:
 932           result = read_2s (objfile->obfd, &op_ptr);
 933           break;
 934         case DW_OP_const4u:
 935           result = read_4u (objfile->obfd, &op_ptr);
 936           break;
 937         case DW_OP_const4s:
 938           result = read_4s (objfile->obfd, &op_ptr);
 939           break;
 940         case DW_OP_const8u:
 941           result = read_8u (objfile->obfd, &op_ptr);
 942           break;
 943         case DW_OP_const8s:
 944           result = read_8s (objfile->obfd, &op_ptr);
 945           break;
 946         case DW_OP_constu:
 947           result = read_uleb128 (objfile->obfd, &op_ptr);
 948           break;
 949         case DW_OP_consts:
 950           result = read_sleb128 (objfile->obfd, &op_ptr);
 951           break;
 952
 953         case DW_OP_reg0:
 954         case DW_OP_reg1:
 955         case DW_OP_reg2:
 956         case DW_OP_reg3:
 957         case DW_OP_reg4:
 958         case DW_OP_reg5:
 959         case DW_OP_reg6:
 960         case DW_OP_reg7:
 961         case DW_OP_reg8:
 962         case DW_OP_reg9:
 963         case DW_OP_reg10:
 964         case DW_OP_reg11:
 965         case DW_OP_reg12:
 966         case DW_OP_reg13:
 967         case DW_OP_reg14:
 968         case DW_OP_reg15:
 969         case DW_OP_reg16:
 970         case DW_OP_reg17:
 971         case DW_OP_reg18:
 972         case DW_OP_reg19:
 973         case DW_OP_reg20:
 974         case DW_OP_reg21:
 975         case DW_OP_reg22:
 976         case DW_OP_reg23:
 977         case DW_OP_reg24:
 978         case DW_OP_reg25:
 979         case DW_OP_reg26:
 980         case DW_OP_reg27:
 981         case DW_OP_reg28:
 982         case DW_OP_reg29:
 983         case DW_OP_reg30:
 984         case DW_OP_reg31:
 985           get_reg ((char *) &result, context, op - DW_OP_reg0);
 986           break;
 987         case DW_OP_regx:
 988           reg = read_uleb128 (objfile->obfd, &op_ptr);
 989           get_reg ((char *) &result, context, reg);
 990           break;
 991
 992         case DW_OP_breg0:
 993         case DW_OP_breg1:
 994         case DW_OP_breg2:
 995         case DW_OP_breg3:
 996         case DW_OP_breg4:
 997         case DW_OP_breg5:
 998         case DW_OP_breg6:
 999         case DW_OP_breg7:
1000         case DW_OP_breg8:
1001         case DW_OP_breg9:
1002         case DW_OP_breg10:
1003         case DW_OP_breg11:
1004         case DW_OP_breg12:
1005         case DW_OP_breg13:
1006         case DW_OP_breg14:
1007         case DW_OP_breg15:
1008         case DW_OP_breg16:
1009         case DW_OP_breg17:
1010         case DW_OP_breg18:
1011         case DW_OP_breg19:
1012         case DW_OP_breg20:
1013         case DW_OP_breg21:
1014         case DW_OP_breg22:
1015         case DW_OP_breg23:
1016         case DW_OP_breg24:
1017         case DW_OP_breg25:
1018         case DW_OP_breg26:
1019         case DW_OP_breg27:
1020         case DW_OP_breg28:
1021         case DW_OP_breg29:
1022         case DW_OP_breg30:
1023         case DW_OP_breg31:
1024           offset = read_sleb128 (objfile->obfd, &op_ptr);
1025           get_reg ((char *) &result, context, op - DW_OP_breg0);
1026           result += offset;
1027           break;
1028         case DW_OP_bregx:
1029           reg = read_uleb128 (objfile->obfd, &op_ptr);
1030           offset = read_sleb128 (objfile->obfd, &op_ptr);
1031           get_reg ((char *) &result, context, reg);
1032           result += offset;
1033           break;
1034
1035         case DW_OP_dup:
1036           if (stack_elt < 1)
1037             internal_error (__FILE__, __LINE__, "execute_stack_op error");
1038           result = stack[stack_elt - 1];
1039           break;
1040
1041         case DW_OP_drop:
1042           if (--stack_elt < 0)
1043             internal_error (__FILE__, __LINE__, "execute_stack_op error");
1044           goto no_push;
1045
1046         case DW_OP_pick:
1047           offset = *op_ptr++;
1048           if (offset >= stack_elt - 1)
1049             internal_error (__FILE__, __LINE__, "execute_stack_op error");
1050           result = stack[stack_elt - 1 - offset];
1051           break;
1052
1053         case DW_OP_over:
1054           if (stack_elt < 2)
1055             internal_error (__FILE__, __LINE__, "execute_stack_op error");
1056           result = stack[stack_elt - 2];
1057           break;
1058
1059         case DW_OP_rot:
1060           {
1061             CORE_ADDR t1, t2, t3;
1062
1063             if (stack_elt < 3)
1064               internal_error (__FILE__, __LINE__, "execute_stack_op error");
1065             t1 = stack[stack_elt - 1];
1066             t2 = stack[stack_elt - 2];
1067             t3 = stack[stack_elt - 3];
1068             stack[stack_elt - 1] = t2;
1069             stack[stack_elt - 2] = t3;
1070             stack[stack_elt - 3] = t1;
1071             goto no_push;
1072           }
1073
1074         case DW_OP_deref:
1075         case DW_OP_deref_size:
1076         case DW_OP_abs:
1077         case DW_OP_neg:
1078         case DW_OP_not:
1079         case DW_OP_plus_uconst:
1080           /* Unary operations.  */
1081           if (--stack_elt < 0)
1082             internal_error (__FILE__, __LINE__, "execute_stack_op error");
1083           result = stack[stack_elt];
1084
1085           switch (op)
1086             {
1087             case DW_OP_deref:
1088               {
1089                 char *ptr = (char *) result;
1090                 result = read_pointer (objfile->obfd, &ptr);
1091               }
1092               break;
1093
1094             case DW_OP_deref_size:
1095               {
1096                 char *ptr = (char *) result;
1097                 switch (*op_ptr++)
1098                   {
1099                   case 1:
1100                     result = read_1u (objfile->obfd, &ptr);
1101                     break;
1102                   case 2:
1103                     result = read_2u (objfile->obfd, &ptr);
1104                     break;
1105                   case 4:
1106                     result = read_4u (objfile->obfd, &ptr);
1107                     break;
1108                   case 8:
1109                     result = read_8u (objfile->obfd, &ptr);
1110                     break;
1111                   default:
1112                     internal_error (__FILE__, __LINE__,
1113                                     "execute_stack_op error");
1114                   }
1115               }
1116               break;
1117
1118             case DW_OP_abs:
1119               if (result < 0)
1120                 result = -result;
1121               break;
1122             case DW_OP_neg:
1123               result = -result;
1124               break;
1125             case DW_OP_not:
1126               result = ~result;
1127               break;
1128             case DW_OP_plus_uconst:
1129               result += read_uleb128 (objfile->obfd, &op_ptr);
1130               break;
1131             default:
1132               break;
1133             }
1134           break;
1135
1136         case DW_OP_and:
1137         case DW_OP_div:
1138         case DW_OP_minus:
1139         case DW_OP_mod:
1140         case DW_OP_mul:
1141         case DW_OP_or:
1142         case DW_OP_plus:
1143         case DW_OP_le:
1144         case DW_OP_ge:
1145         case DW_OP_eq:
1146         case DW_OP_lt:
1147         case DW_OP_gt:
1148         case DW_OP_ne:
1149           {
1150             /* Binary operations.  */
1151             CORE_ADDR first, second;
1152             if ((stack_elt -= 2) < 0)
1153               internal_error (__FILE__, __LINE__, "execute_stack_op error");
1154             second = stack[stack_elt];
1155             first = stack[stack_elt + 1];
1156
1157             switch (op)
1158               {
1159               case DW_OP_and:
1160                 result = second & first;
1161                 break;
1162               case DW_OP_div:
1163                 result = (LONGEST) second / (LONGEST) first;
1164                 break;
1165               case DW_OP_minus:
1166                 result = second - first;
1167                 break;
1168               case DW_OP_mod:
1169                 result = (LONGEST) second % (LONGEST) first;
1170                 break;
1171               case DW_OP_mul:
1172                 result = second * first;
1173                 break;
1174               case DW_OP_or:
1175                 result = second | first;
1176                 break;
1177               case DW_OP_plus:
1178                 result = second + first;
1179                 break;
1180               case DW_OP_shl:
1181                 result = second << first;
1182                 break;
1183               case DW_OP_shr:
1184                 result = second >> first;
1185                 break;
1186               case DW_OP_shra:
1187                 result = (LONGEST) second >> first;
1188                 break;
1189               case DW_OP_xor:
1190                 result = second ^ first;
1191                 break;
1192               case DW_OP_le:
1193                 result = (LONGEST) first <= (LONGEST) second;
1194                 break;
1195               case DW_OP_ge:
1196                 result = (LONGEST) first >= (LONGEST) second;
1197                 break;
1198               case DW_OP_eq:
1199                 result = (LONGEST) first == (LONGEST) second;
1200                 break;
1201               case DW_OP_lt:
1202                 result = (LONGEST) first < (LONGEST) second;
1203                 break;
1204               case DW_OP_gt:
1205                 result = (LONGEST) first > (LONGEST) second;
1206                 break;
1207               case DW_OP_ne:
1208                 result = (LONGEST) first != (LONGEST) second;
1209                 break;
1210               default:  /* This label is here just to avoid warning.  */
1211                 break;
1212               }
1213           }
1214           break;
1215
1216         case DW_OP_skip:
1217           offset = read_2s (objfile->obfd, &op_ptr);
1218           op_ptr += offset;
1219           goto no_push;
1220
1221         case DW_OP_bra:
1222           if (--stack_elt < 0)
1223             internal_error (__FILE__, __LINE__, "execute_stack_op error");
1224           offset = read_2s (objfile->obfd, &op_ptr);
1225           if (stack[stack_elt] != 0)
1226             op_ptr += offset;
1227           goto no_push;
1228
1229         case DW_OP_nop:
1230           goto no_push;
1231
1232         default:
1233           internal_error (__FILE__, __LINE__, "execute_stack_op error");
1234         }
1235
1236       /* Most things push a result value.  */
1237       if ((size_t) stack_elt >= sizeof (stack) / sizeof (*stack))
1238         internal_error (__FILE__, __LINE__, "execute_stack_op error");
1239       stack[++stack_elt] = result;
1240     no_push:;
1241     }
1242
1243   /* We were executing this program to get a value.  It should be
1244      at top of stack.  */
1245   if (--stack_elt < 0)
1246     internal_error (__FILE__, __LINE__, "execute_stack_op error");
1247   return stack[stack_elt];
1248 }
1249
1250 static void
1251 update_context (struct context *context, struct frame_state *fs, int chain)
1252 {
1253   struct context *orig_context;
1254   CORE_ADDR cfa;
1255   long i;
1256
1257   orig_context = context_alloc ();
1258   context_cpy (orig_context, context);
1259   /* Compute this frame's CFA.  */
1260   switch (fs->cfa_how)
1261     {
1262     case CFA_REG_OFFSET:
1263       get_reg ((char *) &cfa, context, fs->cfa_reg);
1264       cfa += fs->cfa_offset;
1265       break;
1266
1267     case CFA_EXP:
1268       /* ??? No way of knowing what register number is the stack pointer
1269          to do the same sort of handling as above.  Assume that if the
1270          CFA calculation is so complicated as to require a stack program
1271          that this will not be a problem.  */
1272       {
1273         char *exp = fs->cfa_exp;
1274         ULONGEST len;
1275
1276         len = read_uleb128 (fs->objfile->obfd, &exp);
1277         cfa = (CORE_ADDR) execute_stack_op (fs->objfile, exp,
1278                                             exp + len, context, 0);
1279         break;
1280       }
1281     default:
1282       break;
1283     }
1284   context->cfa = cfa;
1285
1286   if (!chain)
1287     orig_context->cfa = cfa;
1288
1289   /* Compute the addresses of all registers saved in this frame.  */
1290   for (i = 0; i < NUM_REGS; ++i)
1291     switch (fs->regs.reg[i].how)
1292       {
1293       case REG_UNSAVED:
1294         if (i == SP_REGNUM)
1295           {
1296             context->reg[i].how = REG_CTX_VALUE;
1297             context->reg[i].loc.addr = cfa;
1298           }
1299         else
1300           context->reg[i].how = REG_CTX_UNSAVED;
1301         break;
1302       case REG_SAVED_OFFSET:
1303         context->reg[i].how = REG_CTX_SAVED_OFFSET;
1304         context->reg[i].loc.offset = fs->regs.reg[i].loc.offset;
1305         break;
1306       case REG_SAVED_REG:
1307         switch (orig_context->reg[fs->regs.reg[i].loc.reg].how)
1308           {
1309           case REG_CTX_UNSAVED:
1310             context->reg[i].how = REG_CTX_UNSAVED;
1311             break;
1312           case REG_CTX_SAVED_OFFSET:
1313             context->reg[i].how = REG_CTX_SAVED_OFFSET;
1314             context->reg[i].loc.offset = orig_context->cfa - context->cfa +
1315               orig_context->reg[fs->regs.reg[i].loc.reg].loc.offset;
1316             break;
1317           case REG_CTX_SAVED_REG:
1318             context->reg[i].how = REG_CTX_SAVED_REG;
1319             context->reg[i].loc.reg =
1320               orig_context->reg[fs->regs.reg[i].loc.reg].loc.reg;
1321             break;
1322           case REG_CTX_SAVED_ADDR:
1323             context->reg[i].how = REG_CTX_SAVED_ADDR;
1324             context->reg[i].loc.addr =
1325               orig_context->reg[fs->regs.reg[i].loc.reg].loc.addr;
1326           default:
1327             internal_error (__FILE__, __LINE__,
1328                             "%s: unknown register rule", __func__);
1329           }
1330         break;
1331       case REG_SAVED_EXP:
1332         {
1333           char *exp = fs->regs.reg[i].loc.exp;
1334           ULONGEST len;
1335           CORE_ADDR val;
1336
1337           len = read_uleb128 (fs->objfile->obfd, &exp);
1338           val = execute_stack_op (fs->objfile, exp, exp + len,
1339                                   orig_context, cfa);
1340           context->reg[i].how = REG_CTX_SAVED_ADDR;
1341           context->reg[i].loc.addr = val;
1342         }
1343         break;
1344       default:
1345         internal_error (__FILE__, __LINE__,
1346                         "%s: unknown register rule", __func__);
1347       }
1348   get_reg ((char *) &context->ra, context, fs->retaddr_column);
1349   unwind_tmp_obstack_free ();
1350 }
1351
1352 static int
1353 is_cie (ULONGEST cie_id, int dwarf64)
1354 {
1355   return dwarf64 ? (cie_id == 0xffffffffffffffff) : (cie_id == 0xffffffff);
1356 }
1357
1358 static int
1359 compare_fde_unit (const void *a, const void *b)
1360 {
1361   struct fde_unit **first, **second;
1362   first = (struct fde_unit **) a;
1363   second = (struct fde_unit **) b;
1364   if ((*first)->initial_location > (*second)->initial_location)
1365     return 1;
1366   else if ((*first)->initial_location < (*second)->initial_location)
1367     return -1;
1368   else
1369     return 0;
1370 }
1371
1372 /*  Build the cie_chunks and fde_chunks tables from informations
1373     in .debug_frame section.  */
1374 void
1375 dwarf2_build_frame_info (struct objfile *objfile)
1376 {
1377   bfd *abfd = objfile->obfd;
1378   char *start = NULL;
1379   char *end = NULL;
1380   int from_eh = 0;
1381
1382   obstack_init (&unwind_tmp_obstack);
1383
1384   dwarf_frame_buffer = 0;
1385
1386   if (dwarf_frame_offset)
1387     {
1388       dwarf_frame_buffer = dwarf2_read_section (objfile,
1389                                                 dwarf_frame_offset,
1390                                                 dwarf_frame_size);
1391
1392       start = dwarf_frame_buffer;
1393       end = dwarf_frame_buffer + dwarf_frame_size;
1394     }
1395   else if (dwarf_eh_frame_offset)
1396     {
1397       dwarf_frame_buffer = dwarf2_read_section (objfile,
1398                                                 dwarf_eh_frame_offset,
1399                                                 dwarf_eh_frame_size);
1400
1401       start = dwarf_frame_buffer;
1402       end = dwarf_frame_buffer + dwarf_eh_frame_size;
1403
1404       from_eh = 1;
1405     }
1406
1407   if (start)
1408     {
1409       while (start < end)
1410         {
1411           unsigned long length;
1412           ULONGEST cie_id;
1413           ULONGEST unit_offset = start - dwarf_frame_buffer;
1414           int bytes_read;
1415           int dwarf64;
1416           char *block_end;
1417
1418           length = read_initial_length (abfd, start, &bytes_read);
1419           start += bytes_read;
1420           dwarf64 = (bytes_read == 12);
1421           block_end = start + length;
1422
1423           cie_id = read_length (abfd, start, &bytes_read, dwarf64);
1424           start += bytes_read;
1425
1426           if ((from_eh && cie_id == 0) || is_cie (cie_id, dwarf64))
1427             {
1428               struct cie_unit *cie = cie_unit_alloc ();
1429               char *aug;
1430
1431               cie->objfile = objfile;
1432               cie->next = cie_chunks;
1433               cie_chunks = cie;
1434
1435               cie->objfile = objfile;
1436
1437               cie->offset = unit_offset;
1438
1439               start++;          /* version */
1440
1441               cie->augmentation = aug = start;
1442               while (*start)
1443                 start++;
1444               start++;          /* skip past NUL */
1445
1446               cie->code_align = read_uleb128 (abfd, &start);
1447               cie->data_align = read_sleb128 (abfd, &start);
1448               cie->ra = read_1u (abfd, &start);
1449
1450               if (*aug == 'z')
1451                 {
1452                   int xtra = read_uleb128 (abfd, &start);
1453                   start += xtra;
1454                   ++aug;
1455                 }
1456
1457               while (*aug != '\0')
1458                 {
1459                   if (aug[0] == 'e' && aug[1] == 'h')
1460                     {
1461                       start += sizeof (void *);
1462                       aug += 2;
1463                     }
1464                   else if (aug[0] == 'R')
1465                     {
1466                       cie->addr_encoding = *start++;
1467                       aug += 1;
1468                     }
1469                   else if (aug[0] == 'P')
1470                     {
1471                       CORE_ADDR ptr;
1472                       ptr = read_encoded_pointer (abfd, &start,
1473                                                   cie->addr_encoding);
1474                       aug += 1;
1475                     }
1476                   else
1477                     warning ("%s(): unknown augmentation", __func__);
1478                 }
1479
1480               cie->data = start;
1481               cie->data_length = block_end - start;
1482             }
1483           else
1484             {
1485               struct fde_unit *fde;
1486               struct cie_unit *cie;
1487
1488               fde_chunks_need_space ();
1489               fde = fde_unit_alloc ();
1490
1491               fde_chunks.array[fde_chunks.elems++] = fde;
1492
1493               fde->initial_location = read_pointer (abfd, &start)
1494                 + ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1495               fde->address_range = read_pointer (abfd, &start);
1496
1497               cie = cie_chunks;
1498               while(cie)
1499               {
1500                 if (cie->objfile == objfile)
1501                 {
1502                   if (from_eh && (cie->offset == (unit_offset + bytes_read - cie_id)))
1503                       break;
1504                   if (!from_eh && (cie->offset == cie_id))
1505                     break;
1506                 }
1507
1508                 cie = cie->next;
1509               }
1510
1511               if (!cie)
1512                 error ("%s(): can't find CIE pointer", __func__);
1513               fde->cie_ptr = cie;
1514
1515               if (cie->augmentation[0] == 'z')
1516                   read_uleb128 (abfd, &start);
1517
1518               fde->data = start;
1519               fde->data_length = block_end - start;
1520             }
1521           start = block_end;
1522         }
1523       qsort (fde_chunks.array, fde_chunks.elems,
1524              sizeof (struct fde_unit *), compare_fde_unit);
1525     }
1526 }
1527 \f
1528
1529 /* Return the frame address.  */
1530 CORE_ADDR
1531 cfi_read_fp ()
1532 {
1533   struct context *context;
1534   struct frame_state *fs;
1535   CORE_ADDR cfa;
1536
1537   context = context_alloc ();
1538   fs = frame_state_alloc ();
1539
1540   context->ra = read_pc () + 1;
1541
1542   frame_state_for (context, fs);
1543   update_context (context, fs, 0);
1544
1545   cfa = context->cfa;
1546   unwind_tmp_obstack_free ();
1547   return cfa;
1548 }
1549
1550 /* Store the frame address.  This function is not used.  */
1551
1552 void
1553 cfi_write_fp (CORE_ADDR val)
1554 {
1555   struct context *context;
1556   struct frame_state *fs;
1557
1558   context = context_alloc ();
1559   fs = frame_state_alloc ();
1560
1561   context->ra = read_pc () + 1;
1562
1563   frame_state_for (context, fs);
1564
1565   if (fs->cfa_how == CFA_REG_OFFSET)
1566     {
1567       val -= fs->cfa_offset;
1568       write_register_gen (fs->cfa_reg, (char *) &val);
1569     }
1570   else
1571     warning ("Can't write fp.");
1572
1573   unwind_tmp_obstack_free ();
1574 }
1575
1576 /* Restore the machine to the state it had before the current frame
1577    was created.  */
1578 void
1579 cfi_pop_frame (struct frame_info *fi)
1580 {
1581   char regbuf[MAX_REGISTER_RAW_SIZE];
1582   int regnum;
1583
1584   fi = get_current_frame ();
1585
1586   for (regnum = 0; regnum < NUM_REGS; regnum++)
1587     {
1588       get_reg (regbuf, UNWIND_CONTEXT (fi), regnum);
1589       write_register_bytes (REGISTER_BYTE (regnum), regbuf,
1590                             REGISTER_RAW_SIZE (regnum));
1591     }
1592   write_register (PC_REGNUM, UNWIND_CONTEXT (fi)->ra);
1593
1594   flush_cached_frames ();
1595 }
1596
1597 /* Determine the address of the calling function's frame.  */
1598 CORE_ADDR
1599 cfi_frame_chain (struct frame_info *fi)
1600 {
1601   struct context *context;
1602   struct frame_state *fs;
1603   CORE_ADDR cfa;
1604
1605   context = context_alloc ();
1606   fs = frame_state_alloc ();
1607   context_cpy (context, UNWIND_CONTEXT (fi));
1608
1609   /* outermost frame */
1610   if (context->ra == 0)
1611     {
1612       unwind_tmp_obstack_free ();
1613       return 0;
1614     }
1615
1616   frame_state_for (context, fs);
1617   update_context (context, fs, 1);
1618
1619   cfa = context->cfa;
1620   unwind_tmp_obstack_free ();
1621
1622   return cfa;
1623 }
1624
1625 /* Sets the pc of the frame.  */
1626 void
1627 cfi_init_frame_pc (int fromleaf, struct frame_info *fi)
1628 {
1629   if (fi->next)
1630     get_reg ((char *) &(fi->pc), UNWIND_CONTEXT (fi->next), PC_REGNUM);
1631   else
1632     fi->pc = read_pc ();
1633 }
1634
1635 /* Initialize unwind context informations of the frame.  */
1636 void
1637 cfi_init_extra_frame_info (int fromleaf, struct frame_info *fi)
1638 {
1639   struct frame_state *fs;
1640
1641   fs = frame_state_alloc ();
1642   fi->context = frame_obstack_alloc (sizeof (struct context));
1643   UNWIND_CONTEXT (fi)->reg =
1644     frame_obstack_alloc (sizeof (struct context_reg) * NUM_REGS);
1645   memset (UNWIND_CONTEXT (fi)->reg, 0,
1646           sizeof (struct context_reg) * NUM_REGS);
1647
1648   if (fi->next)
1649     {
1650       context_cpy (UNWIND_CONTEXT (fi), UNWIND_CONTEXT (fi->next));
1651       frame_state_for (UNWIND_CONTEXT (fi), fs);
1652       update_context (UNWIND_CONTEXT (fi), fs, 1);
1653     }
1654   else
1655     {
1656       UNWIND_CONTEXT (fi)->ra = fi->pc + 1;
1657       frame_state_for (UNWIND_CONTEXT (fi), fs);
1658       update_context (UNWIND_CONTEXT (fi), fs, 0);
1659     }
1660   unwind_tmp_obstack_free ();
1661 }
1662
1663 /* Obtain return address of the frame.  */
1664 CORE_ADDR
1665 cfi_get_ra (struct frame_info *fi)
1666 {
1667   return UNWIND_CONTEXT (fi)->ra;
1668 }
1669
1670 /* Find register number REGNUM relative to FRAME and put its
1671    (raw) contents in *RAW_BUFFER.  Set *OPTIMIZED if the variable
1672    was optimized out (and thus can't be fetched).  If the variable
1673    was fetched from memory, set *ADDRP to where it was fetched from,
1674    otherwise it was fetched from a register.
1675
1676    The argument RAW_BUFFER must point to aligned memory.  */
1677 void
1678 cfi_get_saved_register (char *raw_buffer,
1679                         int *optimized,
1680                         CORE_ADDR * addrp,
1681                         struct frame_info *frame,
1682                         int regnum, enum lval_type *lval)
1683 {
1684   if (!target_has_registers)
1685     error ("No registers.");
1686
1687   /* Normal systems don't optimize out things with register numbers.  */
1688   if (optimized != NULL)
1689     *optimized = 0;
1690
1691   if (addrp)                    /* default assumption: not found in memory */
1692     *addrp = 0;
1693
1694   if (!frame->next)
1695     {
1696       read_register_gen (regnum, raw_buffer);
1697       if (lval != NULL)
1698         *lval = lval_register;
1699       if (addrp != NULL)
1700         *addrp = REGISTER_BYTE (regnum);
1701     }
1702   else
1703     {
1704       frame = frame->next;
1705       switch (UNWIND_CONTEXT (frame)->reg[regnum].how)
1706         {
1707         case REG_CTX_UNSAVED:
1708           read_register_gen (regnum, raw_buffer);
1709           if (lval != NULL)
1710             *lval = not_lval;
1711           if (optimized != NULL)
1712             *optimized = 1;
1713           break;
1714         case REG_CTX_SAVED_OFFSET:
1715           target_read_memory (UNWIND_CONTEXT (frame)->cfa +
1716                               UNWIND_CONTEXT (frame)->reg[regnum].loc.offset,
1717                               raw_buffer, REGISTER_RAW_SIZE (regnum));
1718           if (lval != NULL)
1719             *lval = lval_memory;
1720           if (addrp != NULL)
1721             *addrp =
1722               UNWIND_CONTEXT (frame)->cfa +
1723               UNWIND_CONTEXT (frame)->reg[regnum].loc.offset;
1724           break;
1725         case REG_CTX_SAVED_REG:
1726           read_register_gen (UNWIND_CONTEXT (frame)->reg[regnum].loc.reg,
1727                              raw_buffer);
1728           if (lval != NULL)
1729             *lval = lval_register;
1730           if (addrp != NULL)
1731             *addrp =
1732               REGISTER_BYTE (UNWIND_CONTEXT (frame)->reg[regnum].loc.reg);
1733           break;
1734         case REG_CTX_SAVED_ADDR:
1735           target_read_memory (UNWIND_CONTEXT (frame)->reg[regnum].loc.addr,
1736                               raw_buffer, REGISTER_RAW_SIZE (regnum));
1737           if (lval != NULL)
1738             *lval = lval_memory;
1739           if (addrp != NULL)
1740             *addrp = UNWIND_CONTEXT (frame)->reg[regnum].loc.addr;
1741           break;
1742         case REG_CTX_VALUE:
1743           memcpy (raw_buffer, &UNWIND_CONTEXT (frame)->reg[regnum].loc.addr,
1744                   REGISTER_RAW_SIZE (regnum));
1745           if (lval != NULL)
1746             *lval = not_lval;
1747           if (optimized != NULL)
1748             *optimized = 0;
1749           break;
1750         default:
1751           internal_error (__FILE__, __LINE__,
1752                           "cfi_get_saved_register: unknown register rule");
1753         }
1754     }
1755 }
1756
1757 /*  Return the register that the function uses for a frame pointer,
1758     plus any necessary offset to be applied to the register before
1759     any frame pointer offsets.  */
1760 void
1761 cfi_virtual_frame_pointer (CORE_ADDR pc, int *frame_reg,
1762                            LONGEST * frame_offset)
1763 {
1764   struct context *context;
1765   struct frame_state *fs;
1766
1767   context = context_alloc ();
1768   fs = frame_state_alloc ();
1769
1770   context->ra = read_pc () + 1;
1771
1772   frame_state_for (context, fs);
1773
1774   if (fs->cfa_how == CFA_REG_OFFSET)
1775     {
1776       *frame_reg = fs->cfa_reg;
1777       *frame_offset = fs->cfa_offset;
1778     }
1779   else
1780     error ("dwarf cfi error: CFA is not defined as CFA_REG_OFFSET");
1781
1782   unwind_tmp_obstack_free ();
1783 }