gdb/dwarf2cfi.c

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