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