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