gdb/dwarf2-frame.c

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