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