gdb/dwarf2cfi.c

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