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