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