contrib/gdb-7/gdb/dwarf2-frame.c

   1 /* Frame unwinder for frames with DWARF Call Frame Information.
   2
   3    Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5
   6    Contributed by Mark Kettenis.
   7
   8    This file is part of GDB.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  22
  23 #include "defs.h"
  24 #include "dwarf2expr.h"
  25 #include "dwarf2.h"
  26 #include "frame.h"
  27 #include "frame-base.h"
  28 #include "frame-unwind.h"
  29 #include "gdbcore.h"
  30 #include "gdbtypes.h"
  31 #include "symtab.h"
  32 #include "objfiles.h"
  33 #include "regcache.h"
  34 #include "value.h"
  35
  36 #include "gdb_assert.h"
  37 #include "gdb_string.h"
  38
  39 #include "complaints.h"
  40 #include "dwarf2-frame.h"
  41 #include "ax.h"
  42 #include "dwarf2loc.h"
  43 #include "exceptions.h"
  44
  45 struct comp_unit;
  46
  47 /* Call Frame Information (CFI).  */
  48
  49 /* Common Information Entry (CIE).  */
  50
  51 struct dwarf2_cie
  52 {
  53   /* Computation Unit for this CIE.  */
  54   struct comp_unit *unit;
  55
  56   /* Offset into the .debug_frame section where this CIE was found.
  57      Used to identify this CIE.  */
  58   ULONGEST cie_pointer;
  59
  60   /* Constant that is factored out of all advance location
  61      instructions.  */
  62   ULONGEST code_alignment_factor;
  63
  64   /* Constants that is factored out of all offset instructions.  */
  65   LONGEST data_alignment_factor;
  66
  67   /* Return address column.  */
  68   ULONGEST return_address_register;
  69
  70   /* Instruction sequence to initialize a register set.  */
  71   gdb_byte *initial_instructions;
  72   gdb_byte *end;
  73
  74   /* Saved augmentation, in case it's needed later.  */
  75   char *augmentation;
  76
  77   /* Encoding of addresses.  */
  78   gdb_byte encoding;
  79
  80   /* Target address size in bytes.  */
  81   int addr_size;
  82
  83   /* Target pointer size in bytes.  */
  84   int ptr_size;
  85
  86   /* True if a 'z' augmentation existed.  */
  87   unsigned char saw_z_augmentation;
  88
  89   /* True if an 'S' augmentation existed.  */
  90   unsigned char signal_frame;
  91
  92   /* The version recorded in the CIE.  */
  93   unsigned char version;
  94
  95   /* The segment size.  */
  96   unsigned char segment_size;
  97 };
  98
  99 struct dwarf2_cie_table
 100 {
 101   int num_entries;
 102   struct dwarf2_cie **entries;
 103 };
 104
 105 /* Frame Description Entry (FDE).  */
 106
 107 struct dwarf2_fde
 108 {
 109   /* CIE for this FDE.  */
 110   struct dwarf2_cie *cie;
 111
 112   /* First location associated with this FDE.  */
 113   CORE_ADDR initial_location;
 114
 115   /* Number of bytes of program instructions described by this FDE.  */
 116   CORE_ADDR address_range;
 117
 118   /* Instruction sequence.  */
 119   gdb_byte *instructions;
 120   gdb_byte *end;
 121
 122   /* True if this FDE is read from a .eh_frame instead of a .debug_frame
 123      section.  */
 124   unsigned char eh_frame_p;
 125 };
 126
 127 struct dwarf2_fde_table
 128 {
 129   int num_entries;
 130   struct dwarf2_fde **entries;
 131 };
 132
 133 /* A minimal decoding of DWARF2 compilation units.  We only decode
 134    what's needed to get to the call frame information.  */
 135
 136 struct comp_unit
 137 {
 138   /* Keep the bfd convenient.  */
 139   bfd *abfd;
 140
 141   struct objfile *objfile;
 142
 143   /* Pointer to the .debug_frame section loaded into memory.  */
 144   gdb_byte *dwarf_frame_buffer;
 145
 146   /* Length of the loaded .debug_frame section.  */
 147   bfd_size_type dwarf_frame_size;
 148
 149   /* Pointer to the .debug_frame section.  */
 150   asection *dwarf_frame_section;
 151
 152   /* Base for DW_EH_PE_datarel encodings.  */
 153   bfd_vma dbase;
 154
 155   /* Base for DW_EH_PE_textrel encodings.  */
 156   bfd_vma tbase;
 157 };
 158
 159 static struct dwarf2_fde *dwarf2_frame_find_fde (CORE_ADDR *pc,
 160                                                  CORE_ADDR *out_offset);
 161
 162 static int dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch, int regnum,
 163                                        int eh_frame_p);
 164
 165 static CORE_ADDR read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
 166                                      int ptr_len, const gdb_byte *buf,
 167                                      unsigned int *bytes_read_ptr,
 168                                      CORE_ADDR func_base);
 169 \f
 170
 171 /* Structure describing a frame state.  */
 172
 173 struct dwarf2_frame_state
 174 {
 175   /* Each register save state can be described in terms of a CFA slot,
 176      another register, or a location expression.  */
 177   struct dwarf2_frame_state_reg_info
 178   {
 179     struct dwarf2_frame_state_reg *reg;
 180     int num_regs;
 181
 182     LONGEST cfa_offset;
 183     ULONGEST cfa_reg;
 184     enum {
 185       CFA_UNSET,
 186       CFA_REG_OFFSET,
 187       CFA_EXP
 188     } cfa_how;
 189     const gdb_byte *cfa_exp;
 190
 191     /* Used to implement DW_CFA_remember_state.  */
 192     struct dwarf2_frame_state_reg_info *prev;
 193   } regs;
 194
 195   /* The PC described by the current frame state.  */
 196   CORE_ADDR pc;
 197
 198   /* Initial register set from the CIE.
 199      Used to implement DW_CFA_restore.  */
 200   struct dwarf2_frame_state_reg_info initial;
 201
 202   /* The information we care about from the CIE.  */
 203   LONGEST data_align;
 204   ULONGEST code_align;
 205   ULONGEST retaddr_column;
 206
 207   /* Flags for known producer quirks.  */
 208
 209   /* The ARM compilers, in DWARF2 mode, assume that DW_CFA_def_cfa
 210      and DW_CFA_def_cfa_offset takes a factored offset.  */
 211   int armcc_cfa_offsets_sf;
 212
 213   /* The ARM compilers, in DWARF2 or DWARF3 mode, may assume that
 214      the CFA is defined as REG - OFFSET rather than REG + OFFSET.  */
 215   int armcc_cfa_offsets_reversed;
 216 };
 217
 218 /* Store the length the expression for the CFA in the `cfa_reg' field,
 219    which is unused in that case.  */
 220 #define cfa_exp_len cfa_reg
 221
 222 /* Assert that the register set RS is large enough to store gdbarch_num_regs
 223    columns.  If necessary, enlarge the register set.  */
 224
 225 static void
 226 dwarf2_frame_state_alloc_regs (struct dwarf2_frame_state_reg_info *rs,
 227                                int num_regs)
 228 {
 229   size_t size = sizeof (struct dwarf2_frame_state_reg);
 230
 231   if (num_regs <= rs->num_regs)
 232     return;
 233
 234   rs->reg = (struct dwarf2_frame_state_reg *)
 235     xrealloc (rs->reg, num_regs * size);
 236
 237   /* Initialize newly allocated registers.  */
 238   memset (rs->reg + rs->num_regs, 0, (num_regs - rs->num_regs) * size);
 239   rs->num_regs = num_regs;
 240 }
 241
 242 /* Copy the register columns in register set RS into newly allocated
 243    memory and return a pointer to this newly created copy.  */
 244
 245 static struct dwarf2_frame_state_reg *
 246 dwarf2_frame_state_copy_regs (struct dwarf2_frame_state_reg_info *rs)
 247 {
 248   size_t size = rs->num_regs * sizeof (struct dwarf2_frame_state_reg);
 249   struct dwarf2_frame_state_reg *reg;
 250
 251   reg = (struct dwarf2_frame_state_reg *) xmalloc (size);
 252   memcpy (reg, rs->reg, size);
 253
 254   return reg;
 255 }
 256
 257 /* Release the memory allocated to register set RS.  */
 258
 259 static void
 260 dwarf2_frame_state_free_regs (struct dwarf2_frame_state_reg_info *rs)
 261 {
 262   if (rs)
 263     {
 264       dwarf2_frame_state_free_regs (rs->prev);
 265
 266       xfree (rs->reg);
 267       xfree (rs);
 268     }
 269 }
 270
 271 /* Release the memory allocated to the frame state FS.  */
 272
 273 static void
 274 dwarf2_frame_state_free (void *p)
 275 {
 276   struct dwarf2_frame_state *fs = p;
 277
 278   dwarf2_frame_state_free_regs (fs->initial.prev);
 279   dwarf2_frame_state_free_regs (fs->regs.prev);
 280   xfree (fs->initial.reg);
 281   xfree (fs->regs.reg);
 282   xfree (fs);
 283 }
 284 \f
 285
 286 /* Helper functions for execute_stack_op.  */
 287
 288 static CORE_ADDR
 289 read_reg (void *baton, int reg)
 290 {
 291   struct frame_info *this_frame = (struct frame_info *) baton;
 292   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 293   int regnum;
 294   gdb_byte *buf;
 295
 296   regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
 297
 298   buf = alloca (register_size (gdbarch, regnum));
 299   get_frame_register (this_frame, regnum, buf);
 300
 301   /* Convert the register to an integer.  This returns a LONGEST
 302      rather than a CORE_ADDR, but unpack_pointer does the same thing
 303      under the covers, and this makes more sense for non-pointer
 304      registers.  Maybe read_reg and the associated interfaces should
 305      deal with "struct value" instead of CORE_ADDR.  */
 306   return unpack_long (register_type (gdbarch, regnum), buf);
 307 }
 308
 309 static void
 310 read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
 311 {
 312   read_memory (addr, buf, len);
 313 }
 314
 315 static void
 316 no_get_frame_base (void *baton, const gdb_byte **start, size_t *length)
 317 {
 318   internal_error (__FILE__, __LINE__,
 319                   _("Support for DW_OP_fbreg is unimplemented"));
 320 }
 321
 322 /* Helper function for execute_stack_op.  */
 323
 324 static CORE_ADDR
 325 no_get_frame_cfa (void *baton)
 326 {
 327   internal_error (__FILE__, __LINE__,
 328                   _("Support for DW_OP_call_frame_cfa is unimplemented"));
 329 }
 330
 331 /* Helper function for execute_stack_op.  */
 332
 333 static CORE_ADDR
 334 no_get_frame_pc (void *baton)
 335 {
 336   internal_error (__FILE__, __LINE__, _("\
 337 Support for DW_OP_GNU_implicit_pointer is unimplemented"));
 338 }
 339
 340 static CORE_ADDR
 341 no_get_tls_address (void *baton, CORE_ADDR offset)
 342 {
 343   internal_error (__FILE__, __LINE__, _("\
 344 Support for DW_OP_GNU_push_tls_address is unimplemented"));
 345 }
 346
 347 /* Helper function for execute_stack_op.  */
 348
 349 static void
 350 no_dwarf_call (struct dwarf_expr_context *ctx, size_t die_offset)
 351 {
 352   internal_error (__FILE__, __LINE__,
 353                   _("Support for DW_OP_call* is invalid in CFI"));
 354 }
 355
 356 /* Execute the required actions for both the DW_CFA_restore and
 357 DW_CFA_restore_extended instructions.  */
 358 static void
 359 dwarf2_restore_rule (struct gdbarch *gdbarch, ULONGEST reg_num,
 360                      struct dwarf2_frame_state *fs, int eh_frame_p)
 361 {
 362   ULONGEST reg;
 363
 364   gdb_assert (fs->initial.reg);
 365   reg = dwarf2_frame_adjust_regnum (gdbarch, reg_num, eh_frame_p);
 366   dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 367
 368   /* Check if this register was explicitly initialized in the
 369   CIE initial instructions.  If not, default the rule to
 370   UNSPECIFIED.  */
 371   if (reg < fs->initial.num_regs)
 372     fs->regs.reg[reg] = fs->initial.reg[reg];
 373   else
 374     fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
 375
 376   if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
 377     complaint (&symfile_complaints, _("\
 378 incomplete CFI data; DW_CFA_restore unspecified\n\
 379 register %s (#%d) at %s"),
 380                        gdbarch_register_name
 381                        (gdbarch, gdbarch_dwarf2_reg_to_regnum (gdbarch, reg)),
 382                        gdbarch_dwarf2_reg_to_regnum (gdbarch, reg),
 383                        paddress (gdbarch, fs->pc));
 384 }
 385
 386 static CORE_ADDR
 387 execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
 388                   CORE_ADDR offset, struct frame_info *this_frame,
 389                   CORE_ADDR initial, int initial_in_stack_memory)
 390 {
 391   struct dwarf_expr_context *ctx;
 392   CORE_ADDR result;
 393   struct cleanup *old_chain;
 394
 395   ctx = new_dwarf_expr_context ();
 396   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
 397
 398   ctx->gdbarch = get_frame_arch (this_frame);
 399   ctx->addr_size = addr_size;
 400   ctx->offset = offset;
 401   ctx->baton = this_frame;
 402   ctx->read_reg = read_reg;
 403   ctx->read_mem = read_mem;
 404   ctx->get_frame_base = no_get_frame_base;
 405   ctx->get_frame_cfa = no_get_frame_cfa;
 406   ctx->get_frame_pc = no_get_frame_pc;
 407   ctx->get_tls_address = no_get_tls_address;
 408   ctx->dwarf_call = no_dwarf_call;
 409
 410   dwarf_expr_push (ctx, initial, initial_in_stack_memory);
 411   dwarf_expr_eval (ctx, exp, len);
 412
 413   if (ctx->location == DWARF_VALUE_MEMORY)
 414     result = dwarf_expr_fetch_address (ctx, 0);
 415   else if (ctx->location == DWARF_VALUE_REGISTER)
 416     result = read_reg (this_frame, dwarf_expr_fetch (ctx, 0));
 417   else
 418     {
 419       /* This is actually invalid DWARF, but if we ever do run across
 420          it somehow, we might as well support it.  So, instead, report
 421          it as unimplemented.  */
 422       error (_("\
 423 Not implemented: computing unwound register using explicit value operator"));
 424     }
 425
 426   do_cleanups (old_chain);
 427
 428   return result;
 429 }
 430 \f
 431
 432 static void
 433 execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr,
 434                      const gdb_byte *insn_end, struct gdbarch *gdbarch,
 435                      CORE_ADDR pc, struct dwarf2_frame_state *fs)
 436 {
 437   int eh_frame_p = fde->eh_frame_p;
 438   int bytes_read;
 439   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 440
 441   while (insn_ptr < insn_end && fs->pc <= pc)
 442     {
 443       gdb_byte insn = *insn_ptr++;
 444       ULONGEST utmp, reg;
 445       LONGEST offset;
 446
 447       if ((insn & 0xc0) == DW_CFA_advance_loc)
 448         fs->pc += (insn & 0x3f) * fs->code_align;
 449       else if ((insn & 0xc0) == DW_CFA_offset)
 450         {
 451           reg = insn & 0x3f;
 452           reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 453           insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 454           offset = utmp * fs->data_align;
 455           dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 456           fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 457           fs->regs.reg[reg].loc.offset = offset;
 458         }
 459       else if ((insn & 0xc0) == DW_CFA_restore)
 460         {
 461           reg = insn & 0x3f;
 462           dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
 463         }
 464       else
 465         {
 466           switch (insn)
 467             {
 468             case DW_CFA_set_loc:
 469               fs->pc = read_encoded_value (fde->cie->unit, fde->cie->encoding,
 470                                            fde->cie->ptr_size, insn_ptr,
 471                                            &bytes_read, fde->initial_location);
 472               /* Apply the objfile offset for relocatable objects.  */
 473               fs->pc += ANOFFSET (fde->cie->unit->objfile->section_offsets,
 474                                   SECT_OFF_TEXT (fde->cie->unit->objfile));
 475               insn_ptr += bytes_read;
 476               break;
 477
 478             case DW_CFA_advance_loc1:
 479               utmp = extract_unsigned_integer (insn_ptr, 1, byte_order);
 480               fs->pc += utmp * fs->code_align;
 481               insn_ptr++;
 482               break;
 483             case DW_CFA_advance_loc2:
 484               utmp = extract_unsigned_integer (insn_ptr, 2, byte_order);
 485               fs->pc += utmp * fs->code_align;
 486               insn_ptr += 2;
 487               break;
 488             case DW_CFA_advance_loc4:
 489               utmp = extract_unsigned_integer (insn_ptr, 4, byte_order);
 490               fs->pc += utmp * fs->code_align;
 491               insn_ptr += 4;
 492               break;
 493
 494             case DW_CFA_offset_extended:
 495               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 496               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 497               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 498               offset = utmp * fs->data_align;
 499               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 500               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 501               fs->regs.reg[reg].loc.offset = offset;
 502               break;
 503
 504             case DW_CFA_restore_extended:
 505               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 506               dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
 507               break;
 508
 509             case DW_CFA_undefined:
 510               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 511               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 512               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 513               fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
 514               break;
 515
 516             case DW_CFA_same_value:
 517               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 518               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 519               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 520               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
 521               break;
 522
 523             case DW_CFA_register:
 524               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 525               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 526               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 527               utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
 528               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 529               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
 530               fs->regs.reg[reg].loc.reg = utmp;
 531               break;
 532
 533             case DW_CFA_remember_state:
 534               {
 535                 struct dwarf2_frame_state_reg_info *new_rs;
 536
 537                 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
 538                 *new_rs = fs->regs;
 539                 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
 540                 fs->regs.prev = new_rs;
 541               }
 542               break;
 543
 544             case DW_CFA_restore_state:
 545               {
 546                 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
 547
 548                 if (old_rs == NULL)
 549                   {
 550                     complaint (&symfile_complaints, _("\
 551 bad CFI data; mismatched DW_CFA_restore_state at %s"),
 552                                paddress (gdbarch, fs->pc));
 553                   }
 554                 else
 555                   {
 556                     xfree (fs->regs.reg);
 557                     fs->regs = *old_rs;
 558                     xfree (old_rs);
 559                   }
 560               }
 561               break;
 562
 563             case DW_CFA_def_cfa:
 564               insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
 565               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 566
 567               if (fs->armcc_cfa_offsets_sf)
 568                 utmp *= fs->data_align;
 569
 570               fs->regs.cfa_offset = utmp;
 571               fs->regs.cfa_how = CFA_REG_OFFSET;
 572               break;
 573
 574             case DW_CFA_def_cfa_register:
 575               insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
 576               fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
 577                                                              fs->regs.cfa_reg,
 578                                                              eh_frame_p);
 579               fs->regs.cfa_how = CFA_REG_OFFSET;
 580               break;
 581
 582             case DW_CFA_def_cfa_offset:
 583               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 584
 585               if (fs->armcc_cfa_offsets_sf)
 586                 utmp *= fs->data_align;
 587
 588               fs->regs.cfa_offset = utmp;
 589               /* cfa_how deliberately not set.  */
 590               break;
 591
 592             case DW_CFA_nop:
 593               break;
 594
 595             case DW_CFA_def_cfa_expression:
 596               insn_ptr = read_uleb128 (insn_ptr, insn_end,
 597                                        &fs->regs.cfa_exp_len);
 598               fs->regs.cfa_exp = insn_ptr;
 599               fs->regs.cfa_how = CFA_EXP;
 600               insn_ptr += fs->regs.cfa_exp_len;
 601               break;
 602
 603             case DW_CFA_expression:
 604               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 605               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 606               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 607               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 608               fs->regs.reg[reg].loc.exp = insn_ptr;
 609               fs->regs.reg[reg].exp_len = utmp;
 610               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
 611               insn_ptr += utmp;
 612               break;
 613
 614             case DW_CFA_offset_extended_sf:
 615               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 616               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 617               insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
 618               offset *= fs->data_align;
 619               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 620               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 621               fs->regs.reg[reg].loc.offset = offset;
 622               break;
 623
 624             case DW_CFA_val_offset:
 625               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 626               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 627               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 628               offset = utmp * fs->data_align;
 629               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
 630               fs->regs.reg[reg].loc.offset = offset;
 631               break;
 632
 633             case DW_CFA_val_offset_sf:
 634               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 635               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 636               insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
 637               offset *= fs->data_align;
 638               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
 639               fs->regs.reg[reg].loc.offset = offset;
 640               break;
 641
 642             case DW_CFA_val_expression:
 643               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 644               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 645               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 646               fs->regs.reg[reg].loc.exp = insn_ptr;
 647               fs->regs.reg[reg].exp_len = utmp;
 648               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
 649               insn_ptr += utmp;
 650               break;
 651
 652             case DW_CFA_def_cfa_sf:
 653               insn_ptr = read_uleb128 (insn_ptr, insn_end, &fs->regs.cfa_reg);
 654               fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch,
 655                                                              fs->regs.cfa_reg,
 656                                                              eh_frame_p);
 657               insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
 658               fs->regs.cfa_offset = offset * fs->data_align;
 659               fs->regs.cfa_how = CFA_REG_OFFSET;
 660               break;
 661
 662             case DW_CFA_def_cfa_offset_sf:
 663               insn_ptr = read_sleb128 (insn_ptr, insn_end, &offset);
 664               fs->regs.cfa_offset = offset * fs->data_align;
 665               /* cfa_how deliberately not set.  */
 666               break;
 667
 668             case DW_CFA_GNU_window_save:
 669               /* This is SPARC-specific code, and contains hard-coded
 670                  constants for the register numbering scheme used by
 671                  GCC.  Rather than having a architecture-specific
 672                  operation that's only ever used by a single
 673                  architecture, we provide the implementation here.
 674                  Incidentally that's what GCC does too in its
 675                  unwinder.  */
 676               {
 677                 int size = register_size (gdbarch, 0);
 678
 679                 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
 680                 for (reg = 8; reg < 16; reg++)
 681                   {
 682                     fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
 683                     fs->regs.reg[reg].loc.reg = reg + 16;
 684                   }
 685                 for (reg = 16; reg < 32; reg++)
 686                   {
 687                     fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 688                     fs->regs.reg[reg].loc.offset = (reg - 16) * size;
 689                   }
 690               }
 691               break;
 692
 693             case DW_CFA_GNU_args_size:
 694               /* Ignored.  */
 695               insn_ptr = read_uleb128 (insn_ptr, insn_end, &utmp);
 696               break;
 697
 698             case DW_CFA_GNU_negative_offset_extended:
 699               insn_ptr = read_uleb128 (insn_ptr, insn_end, &reg);
 700               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 701               insn_ptr = read_uleb128 (insn_ptr, insn_end, &offset);
 702               offset *= fs->data_align;
 703               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 704               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 705               fs->regs.reg[reg].loc.offset = -offset;
 706               break;
 707
 708             default:
 709               internal_error (__FILE__, __LINE__,
 710                               _("Unknown CFI encountered."));
 711             }
 712         }
 713     }
 714
 715   /* Don't allow remember/restore between CIE and FDE programs.  */
 716   dwarf2_frame_state_free_regs (fs->regs.prev);
 717   fs->regs.prev = NULL;
 718 }
 719 \f
 720
 721 /* Architecture-specific operations.  */
 722
 723 /* Per-architecture data key.  */
 724 static struct gdbarch_data *dwarf2_frame_data;
 725
 726 struct dwarf2_frame_ops
 727 {
 728   /* Pre-initialize the register state REG for register REGNUM.  */
 729   void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
 730                     struct frame_info *);
 731
 732   /* Check whether the THIS_FRAME is a signal trampoline.  */
 733   int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
 734
 735   /* Convert .eh_frame register number to DWARF register number, or
 736      adjust .debug_frame register number.  */
 737   int (*adjust_regnum) (struct gdbarch *, int, int);
 738 };
 739
 740 /* Default architecture-specific register state initialization
 741    function.  */
 742
 743 static void
 744 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
 745                                struct dwarf2_frame_state_reg *reg,
 746                                struct frame_info *this_frame)
 747 {
 748   /* If we have a register that acts as a program counter, mark it as
 749      a destination for the return address.  If we have a register that
 750      serves as the stack pointer, arrange for it to be filled with the
 751      call frame address (CFA).  The other registers are marked as
 752      unspecified.
 753
 754      We copy the return address to the program counter, since many
 755      parts in GDB assume that it is possible to get the return address
 756      by unwinding the program counter register.  However, on ISA's
 757      with a dedicated return address register, the CFI usually only
 758      contains information to unwind that return address register.
 759
 760      The reason we're treating the stack pointer special here is
 761      because in many cases GCC doesn't emit CFI for the stack pointer
 762      and implicitly assumes that it is equal to the CFA.  This makes
 763      some sense since the DWARF specification (version 3, draft 8,
 764      p. 102) says that:
 765
 766      "Typically, the CFA is defined to be the value of the stack
 767      pointer at the call site in the previous frame (which may be
 768      different from its value on entry to the current frame)."
 769
 770      However, this isn't true for all platforms supported by GCC
 771      (e.g. IBM S/390 and zSeries).  Those architectures should provide
 772      their own architecture-specific initialization function.  */
 773
 774   if (regnum == gdbarch_pc_regnum (gdbarch))
 775     reg->how = DWARF2_FRAME_REG_RA;
 776   else if (regnum == gdbarch_sp_regnum (gdbarch))
 777     reg->how = DWARF2_FRAME_REG_CFA;
 778 }
 779
 780 /* Return a default for the architecture-specific operations.  */
 781
 782 static void *
 783 dwarf2_frame_init (struct obstack *obstack)
 784 {
 785   struct dwarf2_frame_ops *ops;
 786
 787   ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
 788   ops->init_reg = dwarf2_frame_default_init_reg;
 789   return ops;
 790 }
 791
 792 /* Set the architecture-specific register state initialization
 793    function for GDBARCH to INIT_REG.  */
 794
 795 void
 796 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
 797                            void (*init_reg) (struct gdbarch *, int,
 798                                              struct dwarf2_frame_state_reg *,
 799                                              struct frame_info *))
 800 {
 801   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 802
 803   ops->init_reg = init_reg;
 804 }
 805
 806 /* Pre-initialize the register state REG for register REGNUM.  */
 807
 808 static void
 809 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
 810                        struct dwarf2_frame_state_reg *reg,
 811                        struct frame_info *this_frame)
 812 {
 813   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 814
 815   ops->init_reg (gdbarch, regnum, reg, this_frame);
 816 }
 817
 818 /* Set the architecture-specific signal trampoline recognition
 819    function for GDBARCH to SIGNAL_FRAME_P.  */
 820
 821 void
 822 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
 823                                  int (*signal_frame_p) (struct gdbarch *,
 824                                                         struct frame_info *))
 825 {
 826   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 827
 828   ops->signal_frame_p = signal_frame_p;
 829 }
 830
 831 /* Query the architecture-specific signal frame recognizer for
 832    THIS_FRAME.  */
 833
 834 static int
 835 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
 836                              struct frame_info *this_frame)
 837 {
 838   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 839
 840   if (ops->signal_frame_p == NULL)
 841     return 0;
 842   return ops->signal_frame_p (gdbarch, this_frame);
 843 }
 844
 845 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
 846    register numbers.  */
 847
 848 void
 849 dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
 850                                 int (*adjust_regnum) (struct gdbarch *,
 851                                                       int, int))
 852 {
 853   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 854
 855   ops->adjust_regnum = adjust_regnum;
 856 }
 857
 858 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
 859    register.  */
 860
 861 static int
 862 dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch,
 863                             int regnum, int eh_frame_p)
 864 {
 865   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 866
 867   if (ops->adjust_regnum == NULL)
 868     return regnum;
 869   return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
 870 }
 871
 872 static void
 873 dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
 874                           struct dwarf2_fde *fde)
 875 {
 876   struct symtab *s;
 877
 878   s = find_pc_symtab (fs->pc);
 879   if (s == NULL)
 880     return;
 881
 882   if (producer_is_realview (s->producer))
 883     {
 884       if (fde->cie->version == 1)
 885         fs->armcc_cfa_offsets_sf = 1;
 886
 887       if (fde->cie->version == 1)
 888         fs->armcc_cfa_offsets_reversed = 1;
 889
 890       /* The reversed offset problem is present in some compilers
 891          using DWARF3, but it was eventually fixed.  Check the ARM
 892          defined augmentations, which are in the format "armcc" followed
 893          by a list of one-character options.  The "+" option means
 894          this problem is fixed (no quirk needed).  If the armcc
 895          augmentation is missing, the quirk is needed.  */
 896       if (fde->cie->version == 3
 897           && (strncmp (fde->cie->augmentation, "armcc", 5) != 0
 898               || strchr (fde->cie->augmentation + 5, '+') == NULL))
 899         fs->armcc_cfa_offsets_reversed = 1;
 900
 901       return;
 902     }
 903 }
 904 \f
 905
 906 void
 907 dwarf2_compile_cfa_to_ax (struct agent_expr *expr, struct axs_value *loc,
 908                           struct gdbarch *gdbarch,
 909                           CORE_ADDR pc,
 910                           struct dwarf2_per_cu_data *data)
 911 {
 912   const int num_regs = gdbarch_num_regs (gdbarch)
 913                        + gdbarch_num_pseudo_regs (gdbarch);
 914   struct dwarf2_fde *fde;
 915   CORE_ADDR text_offset, cfa;
 916   struct dwarf2_frame_state fs;
 917   int addr_size;
 918
 919   memset (&fs, 0, sizeof (struct dwarf2_frame_state));
 920
 921   fs.pc = pc;
 922
 923   /* Find the correct FDE.  */
 924   fde = dwarf2_frame_find_fde (&fs.pc, &text_offset);
 925   if (fde == NULL)
 926     error (_("Could not compute CFA; needed to translate this expression"));
 927
 928   /* Extract any interesting information from the CIE.  */
 929   fs.data_align = fde->cie->data_alignment_factor;
 930   fs.code_align = fde->cie->code_alignment_factor;
 931   fs.retaddr_column = fde->cie->return_address_register;
 932   addr_size = fde->cie->addr_size;
 933
 934   /* Check for "quirks" - known bugs in producers.  */
 935   dwarf2_frame_find_quirks (&fs, fde);
 936
 937   /* First decode all the insns in the CIE.  */
 938   execute_cfa_program (fde, fde->cie->initial_instructions,
 939                        fde->cie->end, gdbarch, pc, &fs);
 940
 941   /* Save the initialized register set.  */
 942   fs.initial = fs.regs;
 943   fs.initial.reg = dwarf2_frame_state_copy_regs (&fs.regs);
 944
 945   /* Then decode the insns in the FDE up to our target PC.  */
 946   execute_cfa_program (fde, fde->instructions, fde->end, gdbarch, pc, &fs);
 947
 948   /* Calculate the CFA.  */
 949   switch (fs.regs.cfa_how)
 950     {
 951     case CFA_REG_OFFSET:
 952       {
 953         int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, fs.regs.cfa_reg);
 954
 955         if (regnum == -1)
 956           error (_("Unable to access DWARF register number %d"),
 957                  (int) fs.regs.cfa_reg); /* FIXME */
 958         ax_reg (expr, regnum);
 959
 960         if (fs.regs.cfa_offset != 0)
 961           {
 962             if (fs.armcc_cfa_offsets_reversed)
 963               ax_const_l (expr, -fs.regs.cfa_offset);
 964             else
 965               ax_const_l (expr, fs.regs.cfa_offset);
 966             ax_simple (expr, aop_add);
 967           }
 968       }
 969       break;
 970
 971     case CFA_EXP:
 972       ax_const_l (expr, text_offset);
 973       dwarf2_compile_expr_to_ax (expr, loc, gdbarch, addr_size,
 974                                  fs.regs.cfa_exp,
 975                                  fs.regs.cfa_exp + fs.regs.cfa_exp_len,
 976                                  data);
 977       break;
 978
 979     default:
 980       internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
 981     }
 982 }
 983
 984 \f
 985 struct dwarf2_frame_cache
 986 {
 987   /* DWARF Call Frame Address.  */
 988   CORE_ADDR cfa;
 989
 990   /* Set if the return address column was marked as unavailable
 991      (required non-collected memory or registers to compute).  */
 992   int unavailable_retaddr;
 993
 994   /* Set if the return address column was marked as undefined.  */
 995   int undefined_retaddr;
 996
 997   /* Saved registers, indexed by GDB register number, not by DWARF
 998      register number.  */
 999   struct dwarf2_frame_state_reg *reg;
1000
1001   /* Return address register.  */
1002   struct dwarf2_frame_state_reg retaddr_reg;
1003
1004   /* Target address size in bytes.  */
1005   int addr_size;
1006
1007   /* The .text offset.  */
1008   CORE_ADDR text_offset;
1009 };
1010
1011 static struct dwarf2_frame_cache *
1012 dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache)
1013 {
1014   struct cleanup *old_chain;
1015   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1016   const int num_regs = gdbarch_num_regs (gdbarch)
1017                        + gdbarch_num_pseudo_regs (gdbarch);
1018   struct dwarf2_frame_cache *cache;
1019   struct dwarf2_frame_state *fs;
1020   struct dwarf2_fde *fde;
1021   volatile struct gdb_exception ex;
1022
1023   if (*this_cache)
1024     return *this_cache;
1025
1026   /* Allocate a new cache.  */
1027   cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
1028   cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
1029   *this_cache = cache;
1030
1031   /* Allocate and initialize the frame state.  */
1032   fs = XZALLOC (struct dwarf2_frame_state);
1033   old_chain = make_cleanup (dwarf2_frame_state_free, fs);
1034
1035   /* Unwind the PC.
1036
1037      Note that if the next frame is never supposed to return (i.e. a call
1038      to abort), the compiler might optimize away the instruction at
1039      its return address.  As a result the return address will
1040      point at some random instruction, and the CFI for that
1041      instruction is probably worthless to us.  GCC's unwinder solves
1042      this problem by substracting 1 from the return address to get an
1043      address in the middle of a presumed call instruction (or the
1044      instruction in the associated delay slot).  This should only be
1045      done for "normal" frames and not for resume-type frames (signal
1046      handlers, sentinel frames, dummy frames).  The function
1047      get_frame_address_in_block does just this.  It's not clear how
1048      reliable the method is though; there is the potential for the
1049      register state pre-call being different to that on return.  */
1050   fs->pc = get_frame_address_in_block (this_frame);
1051
1052   /* Find the correct FDE.  */
1053   fde = dwarf2_frame_find_fde (&fs->pc, &cache->text_offset);
1054   gdb_assert (fde != NULL);
1055
1056   /* Extract any interesting information from the CIE.  */
1057   fs->data_align = fde->cie->data_alignment_factor;
1058   fs->code_align = fde->cie->code_alignment_factor;
1059   fs->retaddr_column = fde->cie->return_address_register;
1060   cache->addr_size = fde->cie->addr_size;
1061
1062   /* Check for "quirks" - known bugs in producers.  */
1063   dwarf2_frame_find_quirks (fs, fde);
1064
1065   /* First decode all the insns in the CIE.  */
1066   execute_cfa_program (fde, fde->cie->initial_instructions,
1067                        fde->cie->end, gdbarch, get_frame_pc (this_frame), fs);
1068
1069   /* Save the initialized register set.  */
1070   fs->initial = fs->regs;
1071   fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
1072
1073   /* Then decode the insns in the FDE up to our target PC.  */
1074   execute_cfa_program (fde, fde->instructions, fde->end, gdbarch,
1075                        get_frame_pc (this_frame), fs);
1076
1077   TRY_CATCH (ex, RETURN_MASK_ERROR)
1078     {
1079       /* Calculate the CFA.  */
1080       switch (fs->regs.cfa_how)
1081         {
1082         case CFA_REG_OFFSET:
1083           cache->cfa = read_reg (this_frame, fs->regs.cfa_reg);
1084           if (fs->armcc_cfa_offsets_reversed)
1085             cache->cfa -= fs->regs.cfa_offset;
1086           else
1087             cache->cfa += fs->regs.cfa_offset;
1088           break;
1089
1090         case CFA_EXP:
1091           cache->cfa =
1092             execute_stack_op (fs->regs.cfa_exp, fs->regs.cfa_exp_len,
1093                               cache->addr_size, cache->text_offset,
1094                               this_frame, 0, 0);
1095           break;
1096
1097         default:
1098           internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
1099         }
1100     }
1101   if (ex.reason < 0)
1102     {
1103       if (ex.error == NOT_AVAILABLE_ERROR)
1104         {
1105           cache->unavailable_retaddr = 1;
1106           return cache;
1107         }
1108
1109       throw_exception (ex);
1110     }
1111
1112   /* Initialize the register state.  */
1113   {
1114     int regnum;
1115
1116     for (regnum = 0; regnum < num_regs; regnum++)
1117       dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], this_frame);
1118   }
1119
1120   /* Go through the DWARF2 CFI generated table and save its register
1121      location information in the cache.  Note that we don't skip the
1122      return address column; it's perfectly all right for it to
1123      correspond to a real register.  If it doesn't correspond to a
1124      real register, or if we shouldn't treat it as such,
1125      gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
1126      the range [0, gdbarch_num_regs).  */
1127   {
1128     int column;         /* CFI speak for "register number".  */
1129
1130     for (column = 0; column < fs->regs.num_regs; column++)
1131       {
1132         /* Use the GDB register number as the destination index.  */
1133         int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, column);
1134
1135         /* If there's no corresponding GDB register, ignore it.  */
1136         if (regnum < 0 || regnum >= num_regs)
1137           continue;
1138
1139         /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1140            of all debug info registers.  If it doesn't, complain (but
1141            not too loudly).  It turns out that GCC assumes that an
1142            unspecified register implies "same value" when CFI (draft
1143            7) specifies nothing at all.  Such a register could equally
1144            be interpreted as "undefined".  Also note that this check
1145            isn't sufficient; it only checks that all registers in the
1146            range [0 .. max column] are specified, and won't detect
1147            problems when a debug info register falls outside of the
1148            table.  We need a way of iterating through all the valid
1149            DWARF2 register numbers.  */
1150         if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
1151           {
1152             if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
1153               complaint (&symfile_complaints, _("\
1154 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1155                          gdbarch_register_name (gdbarch, regnum),
1156                          paddress (gdbarch, fs->pc));
1157           }
1158         else
1159           cache->reg[regnum] = fs->regs.reg[column];
1160       }
1161   }
1162
1163   /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1164      we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules.  */
1165   {
1166     int regnum;
1167
1168     for (regnum = 0; regnum < num_regs; regnum++)
1169       {
1170         if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
1171             || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
1172           {
1173             struct dwarf2_frame_state_reg *retaddr_reg =
1174               &fs->regs.reg[fs->retaddr_column];
1175
1176             /* It seems rather bizarre to specify an "empty" column as
1177                the return adress column.  However, this is exactly
1178                what GCC does on some targets.  It turns out that GCC
1179                assumes that the return address can be found in the
1180                register corresponding to the return address column.
1181                Incidentally, that's how we should treat a return
1182                address column specifying "same value" too.  */
1183             if (fs->retaddr_column < fs->regs.num_regs
1184                 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
1185                 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
1186               {
1187                 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1188                   cache->reg[regnum] = *retaddr_reg;
1189                 else
1190                   cache->retaddr_reg = *retaddr_reg;
1191               }
1192             else
1193               {
1194                 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1195                   {
1196                     cache->reg[regnum].loc.reg = fs->retaddr_column;
1197                     cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
1198                   }
1199                 else
1200                   {
1201                     cache->retaddr_reg.loc.reg = fs->retaddr_column;
1202                     cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
1203                   }
1204               }
1205           }
1206       }
1207   }
1208
1209   if (fs->retaddr_column < fs->regs.num_regs
1210       && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
1211     cache->undefined_retaddr = 1;
1212
1213   do_cleanups (old_chain);
1214
1215   return cache;
1216 }
1217
1218 static enum unwind_stop_reason
1219 dwarf2_frame_unwind_stop_reason (struct frame_info *this_frame,
1220                                  void **this_cache)
1221 {
1222   struct dwarf2_frame_cache *cache
1223     = dwarf2_frame_cache (this_frame, this_cache);
1224
1225   if (cache->unavailable_retaddr)
1226     return UNWIND_UNAVAILABLE;
1227
1228   if (cache->undefined_retaddr)
1229     return UNWIND_OUTERMOST;
1230
1231   return UNWIND_NO_REASON;
1232 }
1233
1234 static void
1235 dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache,
1236                       struct frame_id *this_id)
1237 {
1238   struct dwarf2_frame_cache *cache =
1239     dwarf2_frame_cache (this_frame, this_cache);
1240
1241   if (cache->unavailable_retaddr)
1242     return;
1243
1244   if (cache->undefined_retaddr)
1245     return;
1246
1247   (*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame));
1248 }
1249
1250 static struct value *
1251 dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1252                             int regnum)
1253 {
1254   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1255   struct dwarf2_frame_cache *cache =
1256     dwarf2_frame_cache (this_frame, this_cache);
1257   CORE_ADDR addr;
1258   int realnum;
1259
1260   switch (cache->reg[regnum].how)
1261     {
1262     case DWARF2_FRAME_REG_UNDEFINED:
1263       /* If CFI explicitly specified that the value isn't defined,
1264          mark it as optimized away; the value isn't available.  */
1265       return frame_unwind_got_optimized (this_frame, regnum);
1266
1267     case DWARF2_FRAME_REG_SAVED_OFFSET:
1268       addr = cache->cfa + cache->reg[regnum].loc.offset;
1269       return frame_unwind_got_memory (this_frame, regnum, addr);
1270
1271     case DWARF2_FRAME_REG_SAVED_REG:
1272       realnum
1273         = gdbarch_dwarf2_reg_to_regnum (gdbarch, cache->reg[regnum].loc.reg);
1274       return frame_unwind_got_register (this_frame, regnum, realnum);
1275
1276     case DWARF2_FRAME_REG_SAVED_EXP:
1277       addr = execute_stack_op (cache->reg[regnum].loc.exp,
1278                                cache->reg[regnum].exp_len,
1279                                cache->addr_size, cache->text_offset,
1280                                this_frame, cache->cfa, 1);
1281       return frame_unwind_got_memory (this_frame, regnum, addr);
1282
1283     case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1284       addr = cache->cfa + cache->reg[regnum].loc.offset;
1285       return frame_unwind_got_constant (this_frame, regnum, addr);
1286
1287     case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1288       addr = execute_stack_op (cache->reg[regnum].loc.exp,
1289                                cache->reg[regnum].exp_len,
1290                                cache->addr_size, cache->text_offset,
1291                                this_frame, cache->cfa, 1);
1292       return frame_unwind_got_constant (this_frame, regnum, addr);
1293
1294     case DWARF2_FRAME_REG_UNSPECIFIED:
1295       /* GCC, in its infinite wisdom decided to not provide unwind
1296          information for registers that are "same value".  Since
1297          DWARF2 (3 draft 7) doesn't define such behavior, said
1298          registers are actually undefined (which is different to CFI
1299          "undefined").  Code above issues a complaint about this.
1300          Here just fudge the books, assume GCC, and that the value is
1301          more inner on the stack.  */
1302       return frame_unwind_got_register (this_frame, regnum, regnum);
1303
1304     case DWARF2_FRAME_REG_SAME_VALUE:
1305       return frame_unwind_got_register (this_frame, regnum, regnum);
1306
1307     case DWARF2_FRAME_REG_CFA:
1308       return frame_unwind_got_address (this_frame, regnum, cache->cfa);
1309
1310     case DWARF2_FRAME_REG_CFA_OFFSET:
1311       addr = cache->cfa + cache->reg[regnum].loc.offset;
1312       return frame_unwind_got_address (this_frame, regnum, addr);
1313
1314     case DWARF2_FRAME_REG_RA_OFFSET:
1315       addr = cache->reg[regnum].loc.offset;
1316       regnum = gdbarch_dwarf2_reg_to_regnum
1317         (gdbarch, cache->retaddr_reg.loc.reg);
1318       addr += get_frame_register_unsigned (this_frame, regnum);
1319       return frame_unwind_got_address (this_frame, regnum, addr);
1320
1321     case DWARF2_FRAME_REG_FN:
1322       return cache->reg[regnum].loc.fn (this_frame, this_cache, regnum);
1323
1324     default:
1325       internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1326     }
1327 }
1328
1329 static int
1330 dwarf2_frame_sniffer (const struct frame_unwind *self,
1331                       struct frame_info *this_frame, void **this_cache)
1332 {
1333   /* Grab an address that is guarenteed to reside somewhere within the
1334      function.  get_frame_pc(), with a no-return next function, can
1335      end up returning something past the end of this function's body.
1336      If the frame we're sniffing for is a signal frame whose start
1337      address is placed on the stack by the OS, its FDE must
1338      extend one byte before its start address or we could potentially
1339      select the FDE of the previous function.  */
1340   CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1341   struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr, NULL);
1342
1343   if (!fde)
1344     return 0;
1345
1346   /* On some targets, signal trampolines may have unwind information.
1347      We need to recognize them so that we set the frame type
1348      correctly.  */
1349
1350   if (fde->cie->signal_frame
1351       || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame),
1352                                       this_frame))
1353     return self->type == SIGTRAMP_FRAME;
1354
1355   return self->type != SIGTRAMP_FRAME;
1356 }
1357
1358 static const struct frame_unwind dwarf2_frame_unwind =
1359 {
1360   NORMAL_FRAME,
1361   dwarf2_frame_unwind_stop_reason,
1362   dwarf2_frame_this_id,
1363   dwarf2_frame_prev_register,
1364   NULL,
1365   dwarf2_frame_sniffer
1366 };
1367
1368 static const struct frame_unwind dwarf2_signal_frame_unwind =
1369 {
1370   SIGTRAMP_FRAME,
1371   dwarf2_frame_unwind_stop_reason,
1372   dwarf2_frame_this_id,
1373   dwarf2_frame_prev_register,
1374   NULL,
1375   dwarf2_frame_sniffer
1376 };
1377
1378 /* Append the DWARF-2 frame unwinders to GDBARCH's list.  */
1379
1380 void
1381 dwarf2_append_unwinders (struct gdbarch *gdbarch)
1382 {
1383   frame_unwind_append_unwinder (gdbarch, &dwarf2_frame_unwind);
1384   frame_unwind_append_unwinder (gdbarch, &dwarf2_signal_frame_unwind);
1385 }
1386 \f
1387
1388 /* There is no explicitly defined relationship between the CFA and the
1389    location of frame's local variables and arguments/parameters.
1390    Therefore, frame base methods on this page should probably only be
1391    used as a last resort, just to avoid printing total garbage as a
1392    response to the "info frame" command.  */
1393
1394 static CORE_ADDR
1395 dwarf2_frame_base_address (struct frame_info *this_frame, void **this_cache)
1396 {
1397   struct dwarf2_frame_cache *cache =
1398     dwarf2_frame_cache (this_frame, this_cache);
1399
1400   return cache->cfa;
1401 }
1402
1403 static const struct frame_base dwarf2_frame_base =
1404 {
1405   &dwarf2_frame_unwind,
1406   dwarf2_frame_base_address,
1407   dwarf2_frame_base_address,
1408   dwarf2_frame_base_address
1409 };
1410
1411 const struct frame_base *
1412 dwarf2_frame_base_sniffer (struct frame_info *this_frame)
1413 {
1414   CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1415
1416   if (dwarf2_frame_find_fde (&block_addr, NULL))
1417     return &dwarf2_frame_base;
1418
1419   return NULL;
1420 }
1421
1422 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1423    the DWARF unwinder.  This is used to implement
1424    DW_OP_call_frame_cfa.  */
1425
1426 CORE_ADDR
1427 dwarf2_frame_cfa (struct frame_info *this_frame)
1428 {
1429   while (get_frame_type (this_frame) == INLINE_FRAME)
1430     this_frame = get_prev_frame (this_frame);
1431   /* This restriction could be lifted if other unwinders are known to
1432      compute the frame base in a way compatible with the DWARF
1433      unwinder.  */
1434   if (! frame_unwinder_is (this_frame, &dwarf2_frame_unwind))
1435     error (_("can't compute CFA for this frame"));
1436   return get_frame_base (this_frame);
1437 }
1438 \f
1439 const struct objfile_data *dwarf2_frame_objfile_data;
1440
1441 static unsigned int
1442 read_1_byte (bfd *abfd, gdb_byte *buf)
1443 {
1444   return bfd_get_8 (abfd, buf);
1445 }
1446
1447 static unsigned int
1448 read_4_bytes (bfd *abfd, gdb_byte *buf)
1449 {
1450   return bfd_get_32 (abfd, buf);
1451 }
1452
1453 static ULONGEST
1454 read_8_bytes (bfd *abfd, gdb_byte *buf)
1455 {
1456   return bfd_get_64 (abfd, buf);
1457 }
1458
1459 static ULONGEST
1460 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1461 {
1462   ULONGEST result;
1463   unsigned int num_read;
1464   int shift;
1465   gdb_byte byte;
1466
1467   result = 0;
1468   shift = 0;
1469   num_read = 0;
1470
1471   do
1472     {
1473       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1474       buf++;
1475       num_read++;
1476       result |= ((byte & 0x7f) << shift);
1477       shift += 7;
1478     }
1479   while (byte & 0x80);
1480
1481   *bytes_read_ptr = num_read;
1482
1483   return result;
1484 }
1485
1486 static LONGEST
1487 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1488 {
1489   LONGEST result;
1490   int shift;
1491   unsigned int num_read;
1492   gdb_byte byte;
1493
1494   result = 0;
1495   shift = 0;
1496   num_read = 0;
1497
1498   do
1499     {
1500       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1501       buf++;
1502       num_read++;
1503       result |= ((byte & 0x7f) << shift);
1504       shift += 7;
1505     }
1506   while (byte & 0x80);
1507
1508   if (shift < 8 * sizeof (result) && (byte & 0x40))
1509     result |= -(((LONGEST)1) << shift);
1510
1511   *bytes_read_ptr = num_read;
1512
1513   return result;
1514 }
1515
1516 static ULONGEST
1517 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1518 {
1519   LONGEST result;
1520
1521   result = bfd_get_32 (abfd, buf);
1522   if (result == 0xffffffff)
1523     {
1524       result = bfd_get_64 (abfd, buf + 4);
1525       *bytes_read_ptr = 12;
1526     }
1527   else
1528     *bytes_read_ptr = 4;
1529
1530   return result;
1531 }
1532 \f
1533
1534 /* Pointer encoding helper functions.  */
1535
1536 /* GCC supports exception handling based on DWARF2 CFI.  However, for
1537    technical reasons, it encodes addresses in its FDE's in a different
1538    way.  Several "pointer encodings" are supported.  The encoding
1539    that's used for a particular FDE is determined by the 'R'
1540    augmentation in the associated CIE.  The argument of this
1541    augmentation is a single byte.
1542
1543    The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1544    LEB128.  This is encoded in bits 0, 1 and 2.  Bit 3 encodes whether
1545    the address is signed or unsigned.  Bits 4, 5 and 6 encode how the
1546    address should be interpreted (absolute, relative to the current
1547    position in the FDE, ...).  Bit 7, indicates that the address
1548    should be dereferenced.  */
1549
1550 static gdb_byte
1551 encoding_for_size (unsigned int size)
1552 {
1553   switch (size)
1554     {
1555     case 2:
1556       return DW_EH_PE_udata2;
1557     case 4:
1558       return DW_EH_PE_udata4;
1559     case 8:
1560       return DW_EH_PE_udata8;
1561     default:
1562       internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1563     }
1564 }
1565
1566 static CORE_ADDR
1567 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1568                     int ptr_len, const gdb_byte *buf,
1569                     unsigned int *bytes_read_ptr,
1570                     CORE_ADDR func_base)
1571 {
1572   ptrdiff_t offset;
1573   CORE_ADDR base;
1574
1575   /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1576      FDE's.  */
1577   if (encoding & DW_EH_PE_indirect)
1578     internal_error (__FILE__, __LINE__,
1579                     _("Unsupported encoding: DW_EH_PE_indirect"));
1580
1581   *bytes_read_ptr = 0;
1582
1583   switch (encoding & 0x70)
1584     {
1585     case DW_EH_PE_absptr:
1586       base = 0;
1587       break;
1588     case DW_EH_PE_pcrel:
1589       base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1590       base += (buf - unit->dwarf_frame_buffer);
1591       break;
1592     case DW_EH_PE_datarel:
1593       base = unit->dbase;
1594       break;
1595     case DW_EH_PE_textrel:
1596       base = unit->tbase;
1597       break;
1598     case DW_EH_PE_funcrel:
1599       base = func_base;
1600       break;
1601     case DW_EH_PE_aligned:
1602       base = 0;
1603       offset = buf - unit->dwarf_frame_buffer;
1604       if ((offset % ptr_len) != 0)
1605         {
1606           *bytes_read_ptr = ptr_len - (offset % ptr_len);
1607           buf += *bytes_read_ptr;
1608         }
1609       break;
1610     default:
1611       internal_error (__FILE__, __LINE__,
1612                       _("Invalid or unsupported encoding"));
1613     }
1614
1615   if ((encoding & 0x07) == 0x00)
1616     {
1617       encoding |= encoding_for_size (ptr_len);
1618       if (bfd_get_sign_extend_vma (unit->abfd))
1619         encoding |= DW_EH_PE_signed;
1620     }
1621
1622   switch (encoding & 0x0f)
1623     {
1624     case DW_EH_PE_uleb128:
1625       {
1626         ULONGEST value;
1627         const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1628
1629         *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1630         return base + value;
1631       }
1632     case DW_EH_PE_udata2:
1633       *bytes_read_ptr += 2;
1634       return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1635     case DW_EH_PE_udata4:
1636       *bytes_read_ptr += 4;
1637       return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1638     case DW_EH_PE_udata8:
1639       *bytes_read_ptr += 8;
1640       return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1641     case DW_EH_PE_sleb128:
1642       {
1643         LONGEST value;
1644         const gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1645
1646         *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1647         return base + value;
1648       }
1649     case DW_EH_PE_sdata2:
1650       *bytes_read_ptr += 2;
1651       return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1652     case DW_EH_PE_sdata4:
1653       *bytes_read_ptr += 4;
1654       return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1655     case DW_EH_PE_sdata8:
1656       *bytes_read_ptr += 8;
1657       return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1658     default:
1659       internal_error (__FILE__, __LINE__,
1660                       _("Invalid or unsupported encoding"));
1661     }
1662 }
1663 \f
1664
1665 static int
1666 bsearch_cie_cmp (const void *key, const void *element)
1667 {
1668   ULONGEST cie_pointer = *(ULONGEST *) key;
1669   struct dwarf2_cie *cie = *(struct dwarf2_cie **) element;
1670
1671   if (cie_pointer == cie->cie_pointer)
1672     return 0;
1673
1674   return (cie_pointer < cie->cie_pointer) ? -1 : 1;
1675 }
1676
1677 /* Find CIE with the given CIE_POINTER in CIE_TABLE.  */
1678 static struct dwarf2_cie *
1679 find_cie (struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer)
1680 {
1681   struct dwarf2_cie **p_cie;
1682
1683   /* The C standard (ISO/IEC 9899:TC2) requires the BASE argument to
1684      bsearch be non-NULL.  */
1685   if (cie_table->entries == NULL)
1686     {
1687       gdb_assert (cie_table->num_entries == 0);
1688       return NULL;
1689     }
1690
1691   p_cie = bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries,
1692                    sizeof (cie_table->entries[0]), bsearch_cie_cmp);
1693   if (p_cie != NULL)
1694     return *p_cie;
1695   return NULL;
1696 }
1697
1698 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it.  */
1699 static void
1700 add_cie (struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie)
1701 {
1702   const int n = cie_table->num_entries;
1703
1704   gdb_assert (n < 1
1705               || cie_table->entries[n - 1]->cie_pointer < cie->cie_pointer);
1706
1707   cie_table->entries =
1708       xrealloc (cie_table->entries, (n + 1) * sizeof (cie_table->entries[0]));
1709   cie_table->entries[n] = cie;
1710   cie_table->num_entries = n + 1;
1711 }
1712
1713 static int
1714 bsearch_fde_cmp (const void *key, const void *element)
1715 {
1716   CORE_ADDR seek_pc = *(CORE_ADDR *) key;
1717   struct dwarf2_fde *fde = *(struct dwarf2_fde **) element;
1718
1719   if (seek_pc < fde->initial_location)
1720     return -1;
1721   if (seek_pc < fde->initial_location + fde->address_range)
1722     return 0;
1723   return 1;
1724 }
1725
1726 /* Find the FDE for *PC.  Return a pointer to the FDE, and store the
1727    inital location associated with it into *PC.  */
1728
1729 static struct dwarf2_fde *
1730 dwarf2_frame_find_fde (CORE_ADDR *pc, CORE_ADDR *out_offset)
1731 {
1732   struct objfile *objfile;
1733
1734   ALL_OBJFILES (objfile)
1735     {
1736       struct dwarf2_fde_table *fde_table;
1737       struct dwarf2_fde **p_fde;
1738       CORE_ADDR offset;
1739       CORE_ADDR seek_pc;
1740
1741       fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1742       if (fde_table == NULL)
1743         {
1744           dwarf2_build_frame_info (objfile);
1745           fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1746         }
1747       gdb_assert (fde_table != NULL);
1748
1749       if (fde_table->num_entries == 0)
1750         continue;
1751
1752       gdb_assert (objfile->section_offsets);
1753       offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1754
1755       gdb_assert (fde_table->num_entries > 0);
1756       if (*pc < offset + fde_table->entries[0]->initial_location)
1757         continue;
1758
1759       seek_pc = *pc - offset;
1760       p_fde = bsearch (&seek_pc, fde_table->entries, fde_table->num_entries,
1761                        sizeof (fde_table->entries[0]), bsearch_fde_cmp);
1762       if (p_fde != NULL)
1763         {
1764           *pc = (*p_fde)->initial_location + offset;
1765           if (out_offset)
1766             *out_offset = offset;
1767           return *p_fde;
1768         }
1769     }
1770   return NULL;
1771 }
1772
1773 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it.  */
1774 static void
1775 add_fde (struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde)
1776 {
1777   if (fde->address_range == 0)
1778     /* Discard useless FDEs.  */
1779     return;
1780
1781   fde_table->num_entries += 1;
1782   fde_table->entries =
1783       xrealloc (fde_table->entries,
1784                 fde_table->num_entries * sizeof (fde_table->entries[0]));
1785   fde_table->entries[fde_table->num_entries - 1] = fde;
1786 }
1787
1788 #ifdef CC_HAS_LONG_LONG
1789 #define DW64_CIE_ID 0xffffffffffffffffULL
1790 #else
1791 #define DW64_CIE_ID ~0
1792 #endif
1793
1794 static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1795                                      int eh_frame_p,
1796                                      struct dwarf2_cie_table *cie_table,
1797                                      struct dwarf2_fde_table *fde_table);
1798
1799 /* Decode the next CIE or FDE.  Return NULL if invalid input, otherwise
1800    the next byte to be processed.  */
1801 static gdb_byte *
1802 decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
1803                       struct dwarf2_cie_table *cie_table,
1804                       struct dwarf2_fde_table *fde_table)
1805 {
1806   struct gdbarch *gdbarch = get_objfile_arch (unit->objfile);
1807   gdb_byte *buf, *end;
1808   LONGEST length;
1809   unsigned int bytes_read;
1810   int dwarf64_p;
1811   ULONGEST cie_id;
1812   ULONGEST cie_pointer;
1813
1814   buf = start;
1815   length = read_initial_length (unit->abfd, buf, &bytes_read);
1816   buf += bytes_read;
1817   end = buf + length;
1818
1819   /* Are we still within the section?  */
1820   if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1821     return NULL;
1822
1823   if (length == 0)
1824     return end;
1825
1826   /* Distinguish between 32 and 64-bit encoded frame info.  */
1827   dwarf64_p = (bytes_read == 12);
1828
1829   /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs.  */
1830   if (eh_frame_p)
1831     cie_id = 0;
1832   else if (dwarf64_p)
1833     cie_id = DW64_CIE_ID;
1834   else
1835     cie_id = DW_CIE_ID;
1836
1837   if (dwarf64_p)
1838     {
1839       cie_pointer = read_8_bytes (unit->abfd, buf);
1840       buf += 8;
1841     }
1842   else
1843     {
1844       cie_pointer = read_4_bytes (unit->abfd, buf);
1845       buf += 4;
1846     }
1847
1848   if (cie_pointer == cie_id)
1849     {
1850       /* This is a CIE.  */
1851       struct dwarf2_cie *cie;
1852       char *augmentation;
1853       unsigned int cie_version;
1854
1855       /* Record the offset into the .debug_frame section of this CIE.  */
1856       cie_pointer = start - unit->dwarf_frame_buffer;
1857
1858       /* Check whether we've already read it.  */
1859       if (find_cie (cie_table, cie_pointer))
1860         return end;
1861
1862       cie = (struct dwarf2_cie *)
1863         obstack_alloc (&unit->objfile->objfile_obstack,
1864                        sizeof (struct dwarf2_cie));
1865       cie->initial_instructions = NULL;
1866       cie->cie_pointer = cie_pointer;
1867
1868       /* The encoding for FDE's in a normal .debug_frame section
1869          depends on the target address size.  */
1870       cie->encoding = DW_EH_PE_absptr;
1871
1872       /* We'll determine the final value later, but we need to
1873          initialize it conservatively.  */
1874       cie->signal_frame = 0;
1875
1876       /* Check version number.  */
1877       cie_version = read_1_byte (unit->abfd, buf);
1878       if (cie_version != 1 && cie_version != 3 && cie_version != 4)
1879         return NULL;
1880       cie->version = cie_version;
1881       buf += 1;
1882
1883       /* Interpret the interesting bits of the augmentation.  */
1884       cie->augmentation = augmentation = (char *) buf;
1885       buf += (strlen (augmentation) + 1);
1886
1887       /* Ignore armcc augmentations.  We only use them for quirks,
1888          and that doesn't happen until later.  */
1889       if (strncmp (augmentation, "armcc", 5) == 0)
1890         augmentation += strlen (augmentation);
1891
1892       /* The GCC 2.x "eh" augmentation has a pointer immediately
1893          following the augmentation string, so it must be handled
1894          first.  */
1895       if (augmentation[0] == 'e' && augmentation[1] == 'h')
1896         {
1897           /* Skip.  */
1898           buf += gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1899           augmentation += 2;
1900         }
1901
1902       if (cie->version >= 4)
1903         {
1904           /* FIXME: check that this is the same as from the CU header.  */
1905           cie->addr_size = read_1_byte (unit->abfd, buf);
1906           ++buf;
1907           cie->segment_size = read_1_byte (unit->abfd, buf);
1908           ++buf;
1909         }
1910       else
1911         {
1912           cie->addr_size = gdbarch_dwarf2_addr_size (gdbarch);
1913           cie->segment_size = 0;
1914         }
1915       /* Address values in .eh_frame sections are defined to have the
1916          target's pointer size.  Watchout: This breaks frame info for
1917          targets with pointer size < address size, unless a .debug_frame
1918          section exists as well.  */
1919       if (eh_frame_p)
1920         cie->ptr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1921       else
1922         cie->ptr_size = cie->addr_size;
1923
1924       cie->code_alignment_factor =
1925         read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1926       buf += bytes_read;
1927
1928       cie->data_alignment_factor =
1929         read_signed_leb128 (unit->abfd, buf, &bytes_read);
1930       buf += bytes_read;
1931
1932       if (cie_version == 1)
1933         {
1934           cie->return_address_register = read_1_byte (unit->abfd, buf);
1935           bytes_read = 1;
1936         }
1937       else
1938         cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1939                                                              &bytes_read);
1940       cie->return_address_register
1941         = dwarf2_frame_adjust_regnum (gdbarch,
1942                                       cie->return_address_register,
1943                                       eh_frame_p);
1944
1945       buf += bytes_read;
1946
1947       cie->saw_z_augmentation = (*augmentation == 'z');
1948       if (cie->saw_z_augmentation)
1949         {
1950           ULONGEST length;
1951
1952           length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1953           buf += bytes_read;
1954           if (buf > end)
1955             return NULL;
1956           cie->initial_instructions = buf + length;
1957           augmentation++;
1958         }
1959
1960       while (*augmentation)
1961         {
1962           /* "L" indicates a byte showing how the LSDA pointer is encoded.  */
1963           if (*augmentation == 'L')
1964             {
1965               /* Skip.  */
1966               buf++;
1967               augmentation++;
1968             }
1969
1970           /* "R" indicates a byte indicating how FDE addresses are encoded.  */
1971           else if (*augmentation == 'R')
1972             {
1973               cie->encoding = *buf++;
1974               augmentation++;
1975             }
1976
1977           /* "P" indicates a personality routine in the CIE augmentation.  */
1978           else if (*augmentation == 'P')
1979             {
1980               /* Skip.  Avoid indirection since we throw away the result.  */
1981               gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1982               read_encoded_value (unit, encoding, cie->ptr_size,
1983                                   buf, &bytes_read, 0);
1984               buf += bytes_read;
1985               augmentation++;
1986             }
1987
1988           /* "S" indicates a signal frame, such that the return
1989              address must not be decremented to locate the call frame
1990              info for the previous frame; it might even be the first
1991              instruction of a function, so decrementing it would take
1992              us to a different function.  */
1993           else if (*augmentation == 'S')
1994             {
1995               cie->signal_frame = 1;
1996               augmentation++;
1997             }
1998
1999           /* Otherwise we have an unknown augmentation.  Assume that either
2000              there is no augmentation data, or we saw a 'z' prefix.  */
2001           else
2002             {
2003               if (cie->initial_instructions)
2004                 buf = cie->initial_instructions;
2005               break;
2006             }
2007         }
2008
2009       cie->initial_instructions = buf;
2010       cie->end = end;
2011       cie->unit = unit;
2012
2013       add_cie (cie_table, cie);
2014     }
2015   else
2016     {
2017       /* This is a FDE.  */
2018       struct dwarf2_fde *fde;
2019
2020       /* In an .eh_frame section, the CIE pointer is the delta between the
2021          address within the FDE where the CIE pointer is stored and the
2022          address of the CIE.  Convert it to an offset into the .eh_frame
2023          section.  */
2024       if (eh_frame_p)
2025         {
2026           cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
2027           cie_pointer -= (dwarf64_p ? 8 : 4);
2028         }
2029
2030       /* In either case, validate the result is still within the section.  */
2031       if (cie_pointer >= unit->dwarf_frame_size)
2032         return NULL;
2033
2034       fde = (struct dwarf2_fde *)
2035         obstack_alloc (&unit->objfile->objfile_obstack,
2036                        sizeof (struct dwarf2_fde));
2037       fde->cie = find_cie (cie_table, cie_pointer);
2038       if (fde->cie == NULL)
2039         {
2040           decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
2041                               eh_frame_p, cie_table, fde_table);
2042           fde->cie = find_cie (cie_table, cie_pointer);
2043         }
2044
2045       gdb_assert (fde->cie != NULL);
2046
2047       fde->initial_location =
2048         read_encoded_value (unit, fde->cie->encoding, fde->cie->ptr_size,
2049                             buf, &bytes_read, 0);
2050       buf += bytes_read;
2051
2052       fde->address_range =
2053         read_encoded_value (unit, fde->cie->encoding & 0x0f,
2054                             fde->cie->ptr_size, buf, &bytes_read, 0);
2055       buf += bytes_read;
2056
2057       /* A 'z' augmentation in the CIE implies the presence of an
2058          augmentation field in the FDE as well.  The only thing known
2059          to be in here at present is the LSDA entry for EH.  So we
2060          can skip the whole thing.  */
2061       if (fde->cie->saw_z_augmentation)
2062         {
2063           ULONGEST length;
2064
2065           length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
2066           buf += bytes_read + length;
2067           if (buf > end)
2068             return NULL;
2069         }
2070
2071       fde->instructions = buf;
2072       fde->end = end;
2073
2074       fde->eh_frame_p = eh_frame_p;
2075
2076       add_fde (fde_table, fde);
2077     }
2078
2079   return end;
2080 }
2081
2082 /* Read a CIE or FDE in BUF and decode it.  */
2083 static gdb_byte *
2084 decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
2085                     struct dwarf2_cie_table *cie_table,
2086                     struct dwarf2_fde_table *fde_table)
2087 {
2088   enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
2089   gdb_byte *ret;
2090   ptrdiff_t start_offset;
2091
2092   while (1)
2093     {
2094       ret = decode_frame_entry_1 (unit, start, eh_frame_p,
2095                                   cie_table, fde_table);
2096       if (ret != NULL)
2097         break;
2098
2099       /* We have corrupt input data of some form.  */
2100
2101       /* ??? Try, weakly, to work around compiler/assembler/linker bugs
2102          and mismatches wrt padding and alignment of debug sections.  */
2103       /* Note that there is no requirement in the standard for any
2104          alignment at all in the frame unwind sections.  Testing for
2105          alignment before trying to interpret data would be incorrect.
2106
2107          However, GCC traditionally arranged for frame sections to be
2108          sized such that the FDE length and CIE fields happen to be
2109          aligned (in theory, for performance).  This, unfortunately,
2110          was done with .align directives, which had the side effect of
2111          forcing the section to be aligned by the linker.
2112
2113          This becomes a problem when you have some other producer that
2114          creates frame sections that are not as strictly aligned.  That
2115          produces a hole in the frame info that gets filled by the
2116          linker with zeros.
2117
2118          The GCC behaviour is arguably a bug, but it's effectively now
2119          part of the ABI, so we're now stuck with it, at least at the
2120          object file level.  A smart linker may decide, in the process
2121          of compressing duplicate CIE information, that it can rewrite
2122          the entire output section without this extra padding.  */
2123
2124       start_offset = start - unit->dwarf_frame_buffer;
2125       if (workaround < ALIGN4 && (start_offset & 3) != 0)
2126         {
2127           start += 4 - (start_offset & 3);
2128           workaround = ALIGN4;
2129           continue;
2130         }
2131       if (workaround < ALIGN8 && (start_offset & 7) != 0)
2132         {
2133           start += 8 - (start_offset & 7);
2134           workaround = ALIGN8;
2135           continue;
2136         }
2137
2138       /* Nothing left to try.  Arrange to return as if we've consumed
2139          the entire input section.  Hopefully we'll get valid info from
2140          the other of .debug_frame/.eh_frame.  */
2141       workaround = FAIL;
2142       ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
2143       break;
2144     }
2145
2146   switch (workaround)
2147     {
2148     case NONE:
2149       break;
2150
2151     case ALIGN4:
2152       complaint (&symfile_complaints, _("\
2153 Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
2154                  unit->dwarf_frame_section->owner->filename,
2155                  unit->dwarf_frame_section->name);
2156       break;
2157
2158     case ALIGN8:
2159       complaint (&symfile_complaints, _("\
2160 Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
2161                  unit->dwarf_frame_section->owner->filename,
2162                  unit->dwarf_frame_section->name);
2163       break;
2164
2165     default:
2166       complaint (&symfile_complaints,
2167                  _("Corrupt data in %s:%s"),
2168                  unit->dwarf_frame_section->owner->filename,
2169                  unit->dwarf_frame_section->name);
2170       break;
2171     }
2172
2173   return ret;
2174 }
2175 \f
2176
2177 /* Imported from dwarf2read.c.  */
2178 extern void dwarf2_get_section_info (struct objfile *, const char *,
2179                                      asection **, gdb_byte **,
2180                                      bfd_size_type *);
2181
2182 static int
2183 qsort_fde_cmp (const void *a, const void *b)
2184 {
2185   struct dwarf2_fde *aa = *(struct dwarf2_fde **)a;
2186   struct dwarf2_fde *bb = *(struct dwarf2_fde **)b;
2187
2188   if (aa->initial_location == bb->initial_location)
2189     {
2190       if (aa->address_range != bb->address_range
2191           && aa->eh_frame_p == 0 && bb->eh_frame_p == 0)
2192         /* Linker bug, e.g. gold/10400.
2193            Work around it by keeping stable sort order.  */
2194         return (a < b) ? -1 : 1;
2195       else
2196         /* Put eh_frame entries after debug_frame ones.  */
2197         return aa->eh_frame_p - bb->eh_frame_p;
2198     }
2199
2200   return (aa->initial_location < bb->initial_location) ? -1 : 1;
2201 }
2202
2203 void
2204 dwarf2_build_frame_info (struct objfile *objfile)
2205 {
2206   struct comp_unit *unit;
2207   gdb_byte *frame_ptr;
2208   struct dwarf2_cie_table cie_table;
2209   struct dwarf2_fde_table fde_table;
2210   struct dwarf2_fde_table *fde_table2;
2211
2212   cie_table.num_entries = 0;
2213   cie_table.entries = NULL;
2214
2215   fde_table.num_entries = 0;
2216   fde_table.entries = NULL;
2217
2218   /* Build a minimal decoding of the DWARF2 compilation unit.  */
2219   unit = (struct comp_unit *) obstack_alloc (&objfile->objfile_obstack,
2220                                              sizeof (struct comp_unit));
2221   unit->abfd = objfile->obfd;
2222   unit->objfile = objfile;
2223   unit->dbase = 0;
2224   unit->tbase = 0;
2225
2226   dwarf2_get_section_info (objfile, ".eh_frame",
2227                            &unit->dwarf_frame_section,
2228                            &unit->dwarf_frame_buffer,
2229                            &unit->dwarf_frame_size);
2230   if (unit->dwarf_frame_size)
2231     {
2232       asection *got, *txt;
2233
2234       /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2235          that is used for the i386/amd64 target, which currently is
2236          the only target in GCC that supports/uses the
2237          DW_EH_PE_datarel encoding.  */
2238       got = bfd_get_section_by_name (unit->abfd, ".got");
2239       if (got)
2240         unit->dbase = got->vma;
2241
2242       /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2243          so far.  */
2244       txt = bfd_get_section_by_name (unit->abfd, ".text");
2245       if (txt)
2246         unit->tbase = txt->vma;
2247
2248       frame_ptr = unit->dwarf_frame_buffer;
2249       while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2250         frame_ptr = decode_frame_entry (unit, frame_ptr, 1,
2251                                         &cie_table, &fde_table);
2252
2253       if (cie_table.num_entries != 0)
2254         {
2255           /* Reinit cie_table: debug_frame has different CIEs.  */
2256           xfree (cie_table.entries);
2257           cie_table.num_entries = 0;
2258           cie_table.entries = NULL;
2259         }
2260     }
2261
2262   dwarf2_get_section_info (objfile, ".debug_frame",
2263                            &unit->dwarf_frame_section,
2264                            &unit->dwarf_frame_buffer,
2265                            &unit->dwarf_frame_size);
2266   if (unit->dwarf_frame_size)
2267     {
2268       frame_ptr = unit->dwarf_frame_buffer;
2269       while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2270         frame_ptr = decode_frame_entry (unit, frame_ptr, 0,
2271                                         &cie_table, &fde_table);
2272     }
2273
2274   /* Discard the cie_table, it is no longer needed.  */
2275   if (cie_table.num_entries != 0)
2276     {
2277       xfree (cie_table.entries);
2278       cie_table.entries = NULL;   /* Paranoia.  */
2279       cie_table.num_entries = 0;  /* Paranoia.  */
2280     }
2281
2282   /* Copy fde_table to obstack: it is needed at runtime.  */
2283   fde_table2 = (struct dwarf2_fde_table *)
2284     obstack_alloc (&objfile->objfile_obstack, sizeof (*fde_table2));
2285
2286   if (fde_table.num_entries == 0)
2287     {
2288       fde_table2->entries = NULL;
2289       fde_table2->num_entries = 0;
2290     }
2291   else
2292     {
2293       struct dwarf2_fde *fde_prev = NULL;
2294       struct dwarf2_fde *first_non_zero_fde = NULL;
2295       int i;
2296
2297       /* Prepare FDE table for lookups.  */
2298       qsort (fde_table.entries, fde_table.num_entries,
2299              sizeof (fde_table.entries[0]), qsort_fde_cmp);
2300
2301       /* Check for leftovers from --gc-sections.  The GNU linker sets
2302          the relevant symbols to zero, but doesn't zero the FDE *end*
2303          ranges because there's no relocation there.  It's (offset,
2304          length), not (start, end).  On targets where address zero is
2305          just another valid address this can be a problem, since the
2306          FDEs appear to be non-empty in the output --- we could pick
2307          out the wrong FDE.  To work around this, when overlaps are
2308          detected, we prefer FDEs that do not start at zero.
2309
2310          Start by finding the first FDE with non-zero start.  Below
2311          we'll discard all FDEs that start at zero and overlap this
2312          one.  */
2313       for (i = 0; i < fde_table.num_entries; i++)
2314         {
2315           struct dwarf2_fde *fde = fde_table.entries[i];
2316
2317           if (fde->initial_location != 0)
2318             {
2319               first_non_zero_fde = fde;
2320               break;
2321             }
2322         }
2323
2324       /* Since we'll be doing bsearch, squeeze out identical (except
2325          for eh_frame_p) fde entries so bsearch result is predictable.
2326          Also discard leftovers from --gc-sections.  */
2327       fde_table2->num_entries = 0;
2328       for (i = 0; i < fde_table.num_entries; i++)
2329         {
2330           struct dwarf2_fde *fde = fde_table.entries[i];
2331
2332           if (fde->initial_location == 0
2333               && first_non_zero_fde != NULL
2334               && (first_non_zero_fde->initial_location
2335                   < fde->initial_location + fde->address_range))
2336             continue;
2337
2338           if (fde_prev != NULL
2339               && fde_prev->initial_location == fde->initial_location)
2340             continue;
2341
2342           obstack_grow (&objfile->objfile_obstack, &fde_table.entries[i],
2343                         sizeof (fde_table.entries[0]));
2344           ++fde_table2->num_entries;
2345           fde_prev = fde;
2346         }
2347       fde_table2->entries = obstack_finish (&objfile->objfile_obstack);
2348
2349       /* Discard the original fde_table.  */
2350       xfree (fde_table.entries);
2351     }
2352
2353   set_objfile_data (objfile, dwarf2_frame_objfile_data, fde_table2);
2354 }
2355
2356 /* Provide a prototype to silence -Wmissing-prototypes.  */
2357 void _initialize_dwarf2_frame (void);
2358
2359 void
2360 _initialize_dwarf2_frame (void)
2361 {
2362   dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2363   dwarf2_frame_objfile_data = register_objfile_data ();
2364 }