gdb/dwarf2-frame.c

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