gdb/dwarf2cfi.c

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