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