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