gdb/dwarf2-frame.c

   1 /* Frame unwinder for frames with DWARF Call Frame Information.
   2
   3    Copyright (C) 2003-2013 Free Software Foundation, Inc.
   4
   5    Contributed by Mark Kettenis.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "dwarf2expr.h"
  24 #include "dwarf2.h"
  25 #include "frame.h"
  26 #include "frame-base.h"
  27 #include "frame-unwind.h"
  28 #include "gdbcore.h"
  29 #include "gdbtypes.h"
  30 #include "symtab.h"
  31 #include "objfiles.h"
  32 #include "regcache.h"
  33 #include "value.h"
  34
  35 #include "gdb_assert.h"
  36 #include "gdb_string.h"
  37
  38 #include "complaints.h"
  39 #include "dwarf2-frame.h"
  40 #include "ax.h"
  41 #include "dwarf2loc.h"
  42 #include "exceptions.h"
  43 #include "dwarf2-frame-tailcall.h"
  44
  45 struct comp_unit;
  46
  47 /* Call Frame Information (CFI).  */
  48
  49 /* Common Information Entry (CIE).  */
  50
  51 struct dwarf2_cie
  52 {
  53   /* Computation Unit for this CIE.  */
  54   struct comp_unit *unit;
  55
  56   /* Offset into the .debug_frame section where this CIE was found.
  57      Used to identify this CIE.  */
  58   ULONGEST cie_pointer;
  59
  60   /* Constant that is factored out of all advance location
  61      instructions.  */
  62   ULONGEST code_alignment_factor;
  63
  64   /* Constants that is factored out of all offset instructions.  */
  65   LONGEST data_alignment_factor;
  66
  67   /* Return address column.  */
  68   ULONGEST return_address_register;
  69
  70   /* Instruction sequence to initialize a register set.  */
  71   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;
 294   gdb_byte *buf;
 295
 296   regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
 297
 298   buf = alloca (register_size (gdbarch, regnum));
 299   get_frame_register (this_frame, regnum, buf);
 300
 301   /* Convert the register to an integer.  This returns a LONGEST
 302      rather than a CORE_ADDR, but unpack_pointer does the same thing
 303      under the covers, and this makes more sense for non-pointer
 304      registers.  Maybe read_addr_from_reg and the associated interfaces
 305      should deal with "struct value" instead of CORE_ADDR.  */
 306   return unpack_long (register_type (gdbarch, regnum), buf);
 307 }
 308
 309 /* Implement struct dwarf_expr_context_funcs' "get_reg_value" callback.  */
 310
 311 static struct value *
 312 get_reg_value (void *baton, struct type *type, int reg)
 313 {
 314   struct frame_info *this_frame = (struct frame_info *) baton;
 315   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 316   int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, reg);
 317
 318   return value_from_register (type, regnum, this_frame);
 319 }
 320
 321 static void
 322 read_mem (void *baton, gdb_byte *buf, CORE_ADDR addr, size_t len)
 323 {
 324   read_memory (addr, buf, len);
 325 }
 326
 327 /* Execute the required actions for both the DW_CFA_restore and
 328 DW_CFA_restore_extended instructions.  */
 329 static void
 330 dwarf2_restore_rule (struct gdbarch *gdbarch, ULONGEST reg_num,
 331                      struct dwarf2_frame_state *fs, int eh_frame_p)
 332 {
 333   ULONGEST reg;
 334
 335   gdb_assert (fs->initial.reg);
 336   reg = dwarf2_frame_adjust_regnum (gdbarch, reg_num, eh_frame_p);
 337   dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 338
 339   /* Check if this register was explicitly initialized in the
 340   CIE initial instructions.  If not, default the rule to
 341   UNSPECIFIED.  */
 342   if (reg < fs->initial.num_regs)
 343     fs->regs.reg[reg] = fs->initial.reg[reg];
 344   else
 345     fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNSPECIFIED;
 346
 347   if (fs->regs.reg[reg].how == DWARF2_FRAME_REG_UNSPECIFIED)
 348     complaint (&symfile_complaints, _("\
 349 incomplete CFI data; DW_CFA_restore unspecified\n\
 350 register %s (#%d) at %s"),
 351                        gdbarch_register_name
 352                        (gdbarch, gdbarch_dwarf2_reg_to_regnum (gdbarch, reg)),
 353                        gdbarch_dwarf2_reg_to_regnum (gdbarch, reg),
 354                        paddress (gdbarch, fs->pc));
 355 }
 356
 357 /* Virtual method table for execute_stack_op below.  */
 358
 359 static const struct dwarf_expr_context_funcs dwarf2_frame_ctx_funcs =
 360 {
 361   read_addr_from_reg,
 362   get_reg_value,
 363   read_mem,
 364   ctx_no_get_frame_base,
 365   ctx_no_get_frame_cfa,
 366   ctx_no_get_frame_pc,
 367   ctx_no_get_tls_address,
 368   ctx_no_dwarf_call,
 369   ctx_no_get_base_type,
 370   ctx_no_push_dwarf_reg_entry_value,
 371   ctx_no_get_addr_index
 372 };
 373
 374 static CORE_ADDR
 375 execute_stack_op (const gdb_byte *exp, ULONGEST len, int addr_size,
 376                   CORE_ADDR offset, struct frame_info *this_frame,
 377                   CORE_ADDR initial, int initial_in_stack_memory)
 378 {
 379   struct dwarf_expr_context *ctx;
 380   CORE_ADDR result;
 381   struct cleanup *old_chain;
 382
 383   ctx = new_dwarf_expr_context ();
 384   old_chain = make_cleanup_free_dwarf_expr_context (ctx);
 385   make_cleanup_value_free_to_mark (value_mark ());
 386
 387   ctx->gdbarch = get_frame_arch (this_frame);
 388   ctx->addr_size = addr_size;
 389   ctx->ref_addr_size = -1;
 390   ctx->offset = offset;
 391   ctx->baton = this_frame;
 392   ctx->funcs = &dwarf2_frame_ctx_funcs;
 393
 394   dwarf_expr_push_address (ctx, initial, initial_in_stack_memory);
 395   dwarf_expr_eval (ctx, exp, len);
 396
 397   if (ctx->location == DWARF_VALUE_MEMORY)
 398     result = dwarf_expr_fetch_address (ctx, 0);
 399   else if (ctx->location == DWARF_VALUE_REGISTER)
 400     result = read_addr_from_reg (this_frame,
 401                                  value_as_long (dwarf_expr_fetch (ctx, 0)));
 402   else
 403     {
 404       /* This is actually invalid DWARF, but if we ever do run across
 405          it somehow, we might as well support it.  So, instead, report
 406          it as unimplemented.  */
 407       error (_("\
 408 Not implemented: computing unwound register using explicit value operator"));
 409     }
 410
 411   do_cleanups (old_chain);
 412
 413   return result;
 414 }
 415 \f
 416
 417 /* Execute FDE program from INSN_PTR possibly up to INSN_END or up to inferior
 418    PC.  Modify FS state accordingly.  Return current INSN_PTR where the
 419    execution has stopped, one can resume it on the next call.  */
 420
 421 static const gdb_byte *
 422 execute_cfa_program (struct dwarf2_fde *fde, const gdb_byte *insn_ptr,
 423                      const gdb_byte *insn_end, struct gdbarch *gdbarch,
 424                      CORE_ADDR pc, struct dwarf2_frame_state *fs)
 425 {
 426   int eh_frame_p = fde->eh_frame_p;
 427   unsigned int bytes_read;
 428   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
 429
 430   while (insn_ptr < insn_end && fs->pc <= pc)
 431     {
 432       gdb_byte insn = *insn_ptr++;
 433       uint64_t utmp, reg;
 434       int64_t offset;
 435
 436       if ((insn & 0xc0) == DW_CFA_advance_loc)
 437         fs->pc += (insn & 0x3f) * fs->code_align;
 438       else if ((insn & 0xc0) == DW_CFA_offset)
 439         {
 440           reg = insn & 0x3f;
 441           reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 442           insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 443           offset = utmp * fs->data_align;
 444           dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 445           fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 446           fs->regs.reg[reg].loc.offset = offset;
 447         }
 448       else if ((insn & 0xc0) == DW_CFA_restore)
 449         {
 450           reg = insn & 0x3f;
 451           dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
 452         }
 453       else
 454         {
 455           switch (insn)
 456             {
 457             case DW_CFA_set_loc:
 458               fs->pc = read_encoded_value (fde->cie->unit, fde->cie->encoding,
 459                                            fde->cie->ptr_size, insn_ptr,
 460                                            &bytes_read, fde->initial_location);
 461               /* Apply the objfile offset for relocatable objects.  */
 462               fs->pc += ANOFFSET (fde->cie->unit->objfile->section_offsets,
 463                                   SECT_OFF_TEXT (fde->cie->unit->objfile));
 464               insn_ptr += bytes_read;
 465               break;
 466
 467             case DW_CFA_advance_loc1:
 468               utmp = extract_unsigned_integer (insn_ptr, 1, byte_order);
 469               fs->pc += utmp * fs->code_align;
 470               insn_ptr++;
 471               break;
 472             case DW_CFA_advance_loc2:
 473               utmp = extract_unsigned_integer (insn_ptr, 2, byte_order);
 474               fs->pc += utmp * fs->code_align;
 475               insn_ptr += 2;
 476               break;
 477             case DW_CFA_advance_loc4:
 478               utmp = extract_unsigned_integer (insn_ptr, 4, byte_order);
 479               fs->pc += utmp * fs->code_align;
 480               insn_ptr += 4;
 481               break;
 482
 483             case DW_CFA_offset_extended:
 484               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 485               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 486               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 487               offset = utmp * fs->data_align;
 488               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 489               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 490               fs->regs.reg[reg].loc.offset = offset;
 491               break;
 492
 493             case DW_CFA_restore_extended:
 494               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 495               dwarf2_restore_rule (gdbarch, reg, fs, eh_frame_p);
 496               break;
 497
 498             case DW_CFA_undefined:
 499               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 500               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 501               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 502               fs->regs.reg[reg].how = DWARF2_FRAME_REG_UNDEFINED;
 503               break;
 504
 505             case DW_CFA_same_value:
 506               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 507               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 508               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 509               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAME_VALUE;
 510               break;
 511
 512             case DW_CFA_register:
 513               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 514               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 515               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 516               utmp = dwarf2_frame_adjust_regnum (gdbarch, utmp, eh_frame_p);
 517               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 518               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
 519               fs->regs.reg[reg].loc.reg = utmp;
 520               break;
 521
 522             case DW_CFA_remember_state:
 523               {
 524                 struct dwarf2_frame_state_reg_info *new_rs;
 525
 526                 new_rs = XMALLOC (struct dwarf2_frame_state_reg_info);
 527                 *new_rs = fs->regs;
 528                 fs->regs.reg = dwarf2_frame_state_copy_regs (&fs->regs);
 529                 fs->regs.prev = new_rs;
 530               }
 531               break;
 532
 533             case DW_CFA_restore_state:
 534               {
 535                 struct dwarf2_frame_state_reg_info *old_rs = fs->regs.prev;
 536
 537                 if (old_rs == NULL)
 538                   {
 539                     complaint (&symfile_complaints, _("\
 540 bad CFI data; mismatched DW_CFA_restore_state at %s"),
 541                                paddress (gdbarch, fs->pc));
 542                   }
 543                 else
 544                   {
 545                     xfree (fs->regs.reg);
 546                     fs->regs = *old_rs;
 547                     xfree (old_rs);
 548                   }
 549               }
 550               break;
 551
 552             case DW_CFA_def_cfa:
 553               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 554               fs->regs.cfa_reg = reg;
 555               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 556
 557               if (fs->armcc_cfa_offsets_sf)
 558                 utmp *= fs->data_align;
 559
 560               fs->regs.cfa_offset = utmp;
 561               fs->regs.cfa_how = CFA_REG_OFFSET;
 562               break;
 563
 564             case DW_CFA_def_cfa_register:
 565               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 566               fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, reg,
 567                                                              eh_frame_p);
 568               fs->regs.cfa_how = CFA_REG_OFFSET;
 569               break;
 570
 571             case DW_CFA_def_cfa_offset:
 572               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 573
 574               if (fs->armcc_cfa_offsets_sf)
 575                 utmp *= fs->data_align;
 576
 577               fs->regs.cfa_offset = utmp;
 578               /* cfa_how deliberately not set.  */
 579               break;
 580
 581             case DW_CFA_nop:
 582               break;
 583
 584             case DW_CFA_def_cfa_expression:
 585               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 586               fs->regs.cfa_exp_len = utmp;
 587               fs->regs.cfa_exp = insn_ptr;
 588               fs->regs.cfa_how = CFA_EXP;
 589               insn_ptr += fs->regs.cfa_exp_len;
 590               break;
 591
 592             case DW_CFA_expression:
 593               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 594               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 595               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 596               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 597               fs->regs.reg[reg].loc.exp = insn_ptr;
 598               fs->regs.reg[reg].exp_len = utmp;
 599               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_EXP;
 600               insn_ptr += utmp;
 601               break;
 602
 603             case DW_CFA_offset_extended_sf:
 604               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 605               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 606               insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
 607               offset *= fs->data_align;
 608               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 609               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 610               fs->regs.reg[reg].loc.offset = offset;
 611               break;
 612
 613             case DW_CFA_val_offset:
 614               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 615               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 616               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 617               offset = utmp * fs->data_align;
 618               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
 619               fs->regs.reg[reg].loc.offset = offset;
 620               break;
 621
 622             case DW_CFA_val_offset_sf:
 623               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 624               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 625               insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
 626               offset *= fs->data_align;
 627               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_OFFSET;
 628               fs->regs.reg[reg].loc.offset = offset;
 629               break;
 630
 631             case DW_CFA_val_expression:
 632               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 633               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 634               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 635               fs->regs.reg[reg].loc.exp = insn_ptr;
 636               fs->regs.reg[reg].exp_len = utmp;
 637               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_VAL_EXP;
 638               insn_ptr += utmp;
 639               break;
 640
 641             case DW_CFA_def_cfa_sf:
 642               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 643               fs->regs.cfa_reg = dwarf2_frame_adjust_regnum (gdbarch, reg,
 644                                                              eh_frame_p);
 645               insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
 646               fs->regs.cfa_offset = offset * fs->data_align;
 647               fs->regs.cfa_how = CFA_REG_OFFSET;
 648               break;
 649
 650             case DW_CFA_def_cfa_offset_sf:
 651               insn_ptr = safe_read_sleb128 (insn_ptr, insn_end, &offset);
 652               fs->regs.cfa_offset = offset * fs->data_align;
 653               /* cfa_how deliberately not set.  */
 654               break;
 655
 656             case DW_CFA_GNU_window_save:
 657               /* This is SPARC-specific code, and contains hard-coded
 658                  constants for the register numbering scheme used by
 659                  GCC.  Rather than having a architecture-specific
 660                  operation that's only ever used by a single
 661                  architecture, we provide the implementation here.
 662                  Incidentally that's what GCC does too in its
 663                  unwinder.  */
 664               {
 665                 int size = register_size (gdbarch, 0);
 666
 667                 dwarf2_frame_state_alloc_regs (&fs->regs, 32);
 668                 for (reg = 8; reg < 16; reg++)
 669                   {
 670                     fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_REG;
 671                     fs->regs.reg[reg].loc.reg = reg + 16;
 672                   }
 673                 for (reg = 16; reg < 32; reg++)
 674                   {
 675                     fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 676                     fs->regs.reg[reg].loc.offset = (reg - 16) * size;
 677                   }
 678               }
 679               break;
 680
 681             case DW_CFA_GNU_args_size:
 682               /* Ignored.  */
 683               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 684               break;
 685
 686             case DW_CFA_GNU_negative_offset_extended:
 687               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &reg);
 688               reg = dwarf2_frame_adjust_regnum (gdbarch, reg, eh_frame_p);
 689               insn_ptr = safe_read_uleb128 (insn_ptr, insn_end, &utmp);
 690               offset = utmp * fs->data_align;
 691               dwarf2_frame_state_alloc_regs (&fs->regs, reg + 1);
 692               fs->regs.reg[reg].how = DWARF2_FRAME_REG_SAVED_OFFSET;
 693               fs->regs.reg[reg].loc.offset = -offset;
 694               break;
 695
 696             default:
 697               internal_error (__FILE__, __LINE__,
 698                               _("Unknown CFI encountered."));
 699             }
 700         }
 701     }
 702
 703   if (fs->initial.reg == NULL)
 704     {
 705       /* Don't allow remember/restore between CIE and FDE programs.  */
 706       dwarf2_frame_state_free_regs (fs->regs.prev);
 707       fs->regs.prev = NULL;
 708     }
 709
 710   return insn_ptr;
 711 }
 712 \f
 713
 714 /* Architecture-specific operations.  */
 715
 716 /* Per-architecture data key.  */
 717 static struct gdbarch_data *dwarf2_frame_data;
 718
 719 struct dwarf2_frame_ops
 720 {
 721   /* Pre-initialize the register state REG for register REGNUM.  */
 722   void (*init_reg) (struct gdbarch *, int, struct dwarf2_frame_state_reg *,
 723                     struct frame_info *);
 724
 725   /* Check whether the THIS_FRAME is a signal trampoline.  */
 726   int (*signal_frame_p) (struct gdbarch *, struct frame_info *);
 727
 728   /* Convert .eh_frame register number to DWARF register number, or
 729      adjust .debug_frame register number.  */
 730   int (*adjust_regnum) (struct gdbarch *, int, int);
 731 };
 732
 733 /* Default architecture-specific register state initialization
 734    function.  */
 735
 736 static void
 737 dwarf2_frame_default_init_reg (struct gdbarch *gdbarch, int regnum,
 738                                struct dwarf2_frame_state_reg *reg,
 739                                struct frame_info *this_frame)
 740 {
 741   /* If we have a register that acts as a program counter, mark it as
 742      a destination for the return address.  If we have a register that
 743      serves as the stack pointer, arrange for it to be filled with the
 744      call frame address (CFA).  The other registers are marked as
 745      unspecified.
 746
 747      We copy the return address to the program counter, since many
 748      parts in GDB assume that it is possible to get the return address
 749      by unwinding the program counter register.  However, on ISA's
 750      with a dedicated return address register, the CFI usually only
 751      contains information to unwind that return address register.
 752
 753      The reason we're treating the stack pointer special here is
 754      because in many cases GCC doesn't emit CFI for the stack pointer
 755      and implicitly assumes that it is equal to the CFA.  This makes
 756      some sense since the DWARF specification (version 3, draft 8,
 757      p. 102) says that:
 758
 759      "Typically, the CFA is defined to be the value of the stack
 760      pointer at the call site in the previous frame (which may be
 761      different from its value on entry to the current frame)."
 762
 763      However, this isn't true for all platforms supported by GCC
 764      (e.g. IBM S/390 and zSeries).  Those architectures should provide
 765      their own architecture-specific initialization function.  */
 766
 767   if (regnum == gdbarch_pc_regnum (gdbarch))
 768     reg->how = DWARF2_FRAME_REG_RA;
 769   else if (regnum == gdbarch_sp_regnum (gdbarch))
 770     reg->how = DWARF2_FRAME_REG_CFA;
 771 }
 772
 773 /* Return a default for the architecture-specific operations.  */
 774
 775 static void *
 776 dwarf2_frame_init (struct obstack *obstack)
 777 {
 778   struct dwarf2_frame_ops *ops;
 779
 780   ops = OBSTACK_ZALLOC (obstack, struct dwarf2_frame_ops);
 781   ops->init_reg = dwarf2_frame_default_init_reg;
 782   return ops;
 783 }
 784
 785 /* Set the architecture-specific register state initialization
 786    function for GDBARCH to INIT_REG.  */
 787
 788 void
 789 dwarf2_frame_set_init_reg (struct gdbarch *gdbarch,
 790                            void (*init_reg) (struct gdbarch *, int,
 791                                              struct dwarf2_frame_state_reg *,
 792                                              struct frame_info *))
 793 {
 794   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 795
 796   ops->init_reg = init_reg;
 797 }
 798
 799 /* Pre-initialize the register state REG for register REGNUM.  */
 800
 801 static void
 802 dwarf2_frame_init_reg (struct gdbarch *gdbarch, int regnum,
 803                        struct dwarf2_frame_state_reg *reg,
 804                        struct frame_info *this_frame)
 805 {
 806   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 807
 808   ops->init_reg (gdbarch, regnum, reg, this_frame);
 809 }
 810
 811 /* Set the architecture-specific signal trampoline recognition
 812    function for GDBARCH to SIGNAL_FRAME_P.  */
 813
 814 void
 815 dwarf2_frame_set_signal_frame_p (struct gdbarch *gdbarch,
 816                                  int (*signal_frame_p) (struct gdbarch *,
 817                                                         struct frame_info *))
 818 {
 819   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 820
 821   ops->signal_frame_p = signal_frame_p;
 822 }
 823
 824 /* Query the architecture-specific signal frame recognizer for
 825    THIS_FRAME.  */
 826
 827 static int
 828 dwarf2_frame_signal_frame_p (struct gdbarch *gdbarch,
 829                              struct frame_info *this_frame)
 830 {
 831   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 832
 833   if (ops->signal_frame_p == NULL)
 834     return 0;
 835   return ops->signal_frame_p (gdbarch, this_frame);
 836 }
 837
 838 /* Set the architecture-specific adjustment of .eh_frame and .debug_frame
 839    register numbers.  */
 840
 841 void
 842 dwarf2_frame_set_adjust_regnum (struct gdbarch *gdbarch,
 843                                 int (*adjust_regnum) (struct gdbarch *,
 844                                                       int, int))
 845 {
 846   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 847
 848   ops->adjust_regnum = adjust_regnum;
 849 }
 850
 851 /* Translate a .eh_frame register to DWARF register, or adjust a .debug_frame
 852    register.  */
 853
 854 static int
 855 dwarf2_frame_adjust_regnum (struct gdbarch *gdbarch,
 856                             int regnum, int eh_frame_p)
 857 {
 858   struct dwarf2_frame_ops *ops = gdbarch_data (gdbarch, dwarf2_frame_data);
 859
 860   if (ops->adjust_regnum == NULL)
 861     return regnum;
 862   return ops->adjust_regnum (gdbarch, regnum, eh_frame_p);
 863 }
 864
 865 static void
 866 dwarf2_frame_find_quirks (struct dwarf2_frame_state *fs,
 867                           struct dwarf2_fde *fde)
 868 {
 869   struct symtab *s;
 870
 871   s = find_pc_symtab (fs->pc);
 872   if (s == NULL)
 873     return;
 874
 875   if (producer_is_realview (s->producer))
 876     {
 877       if (fde->cie->version == 1)
 878         fs->armcc_cfa_offsets_sf = 1;
 879
 880       if (fde->cie->version == 1)
 881         fs->armcc_cfa_offsets_reversed = 1;
 882
 883       /* The reversed offset problem is present in some compilers
 884          using DWARF3, but it was eventually fixed.  Check the ARM
 885          defined augmentations, which are in the format "armcc" followed
 886          by a list of one-character options.  The "+" option means
 887          this problem is fixed (no quirk needed).  If the armcc
 888          augmentation is missing, the quirk is needed.  */
 889       if (fde->cie->version == 3
 890           && (strncmp (fde->cie->augmentation, "armcc", 5) != 0
 891               || strchr (fde->cie->augmentation + 5, '+') == NULL))
 892         fs->armcc_cfa_offsets_reversed = 1;
 893
 894       return;
 895     }
 896 }
 897 \f
 898
 899 void
 900 dwarf2_compile_cfa_to_ax (struct agent_expr *expr, struct axs_value *loc,
 901                           struct gdbarch *gdbarch,
 902                           CORE_ADDR pc,
 903                           struct dwarf2_per_cu_data *data)
 904 {
 905   struct dwarf2_fde *fde;
 906   CORE_ADDR text_offset;
 907   struct dwarf2_frame_state fs;
 908   int addr_size;
 909
 910   memset (&fs, 0, sizeof (struct dwarf2_frame_state));
 911
 912   fs.pc = pc;
 913
 914   /* Find the correct FDE.  */
 915   fde = dwarf2_frame_find_fde (&fs.pc, &text_offset);
 916   if (fde == NULL)
 917     error (_("Could not compute CFA; needed to translate this expression"));
 918
 919   /* Extract any interesting information from the CIE.  */
 920   fs.data_align = fde->cie->data_alignment_factor;
 921   fs.code_align = fde->cie->code_alignment_factor;
 922   fs.retaddr_column = fde->cie->return_address_register;
 923   addr_size = fde->cie->addr_size;
 924
 925   /* Check for "quirks" - known bugs in producers.  */
 926   dwarf2_frame_find_quirks (&fs, fde);
 927
 928   /* First decode all the insns in the CIE.  */
 929   execute_cfa_program (fde, fde->cie->initial_instructions,
 930                        fde->cie->end, gdbarch, pc, &fs);
 931
 932   /* Save the initialized register set.  */
 933   fs.initial = fs.regs;
 934   fs.initial.reg = dwarf2_frame_state_copy_regs (&fs.regs);
 935
 936   /* Then decode the insns in the FDE up to our target PC.  */
 937   execute_cfa_program (fde, fde->instructions, fde->end, gdbarch, pc, &fs);
 938
 939   /* Calculate the CFA.  */
 940   switch (fs.regs.cfa_how)
 941     {
 942     case CFA_REG_OFFSET:
 943       {
 944         int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, fs.regs.cfa_reg);
 945
 946         if (regnum == -1)
 947           error (_("Unable to access DWARF register number %d"),
 948                  (int) fs.regs.cfa_reg); /* FIXME */
 949         ax_reg (expr, regnum);
 950
 951         if (fs.regs.cfa_offset != 0)
 952           {
 953             if (fs.armcc_cfa_offsets_reversed)
 954               ax_const_l (expr, -fs.regs.cfa_offset);
 955             else
 956               ax_const_l (expr, fs.regs.cfa_offset);
 957             ax_simple (expr, aop_add);
 958           }
 959       }
 960       break;
 961
 962     case CFA_EXP:
 963       ax_const_l (expr, text_offset);
 964       dwarf2_compile_expr_to_ax (expr, loc, gdbarch, addr_size,
 965                                  fs.regs.cfa_exp,
 966                                  fs.regs.cfa_exp + fs.regs.cfa_exp_len,
 967                                  data);
 968       break;
 969
 970     default:
 971       internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
 972     }
 973 }
 974
 975 \f
 976 struct dwarf2_frame_cache
 977 {
 978   /* DWARF Call Frame Address.  */
 979   CORE_ADDR cfa;
 980
 981   /* Set if the return address column was marked as unavailable
 982      (required non-collected memory or registers to compute).  */
 983   int unavailable_retaddr;
 984
 985   /* Set if the return address column was marked as undefined.  */
 986   int undefined_retaddr;
 987
 988   /* Saved registers, indexed by GDB register number, not by DWARF
 989      register number.  */
 990   struct dwarf2_frame_state_reg *reg;
 991
 992   /* Return address register.  */
 993   struct dwarf2_frame_state_reg retaddr_reg;
 994
 995   /* Target address size in bytes.  */
 996   int addr_size;
 997
 998   /* The .text offset.  */
 999   CORE_ADDR text_offset;
1000
1001   /* If not NULL then this frame is the bottom frame of a TAILCALL_FRAME
1002      sequence.  If NULL then it is a normal case with no TAILCALL_FRAME
1003      involved.  Non-bottom frames of a virtual tail call frames chain use
1004      dwarf2_tailcall_frame_unwind unwinder so this field does not apply for
1005      them.  */
1006   void *tailcall_cache;
1007 };
1008
1009 /* A cleanup that sets a pointer to NULL.  */
1010
1011 static void
1012 clear_pointer_cleanup (void *arg)
1013 {
1014   void **ptr = arg;
1015
1016   *ptr = NULL;
1017 }
1018
1019 static struct dwarf2_frame_cache *
1020 dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache)
1021 {
1022   struct cleanup *reset_cache_cleanup, *old_chain;
1023   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1024   const int num_regs = gdbarch_num_regs (gdbarch)
1025                        + gdbarch_num_pseudo_regs (gdbarch);
1026   struct dwarf2_frame_cache *cache;
1027   struct dwarf2_frame_state *fs;
1028   struct dwarf2_fde *fde;
1029   volatile struct gdb_exception ex;
1030   CORE_ADDR entry_pc;
1031   LONGEST entry_cfa_sp_offset;
1032   int entry_cfa_sp_offset_p = 0;
1033   const gdb_byte *instr;
1034
1035   if (*this_cache)
1036     return *this_cache;
1037
1038   /* Allocate a new cache.  */
1039   cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
1040   cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
1041   *this_cache = cache;
1042   reset_cache_cleanup = make_cleanup (clear_pointer_cleanup, this_cache);
1043
1044   /* Allocate and initialize the frame state.  */
1045   fs = XZALLOC (struct dwarf2_frame_state);
1046   old_chain = make_cleanup (dwarf2_frame_state_free, fs);
1047
1048   /* Unwind the PC.
1049
1050      Note that if the next frame is never supposed to return (i.e. a call
1051      to abort), the compiler might optimize away the instruction at
1052      its return address.  As a result the return address will
1053      point at some random instruction, and the CFI for that
1054      instruction is probably worthless to us.  GCC's unwinder solves
1055      this problem by substracting 1 from the return address to get an
1056      address in the middle of a presumed call instruction (or the
1057      instruction in the associated delay slot).  This should only be
1058      done for "normal" frames and not for resume-type frames (signal
1059      handlers, sentinel frames, dummy frames).  The function
1060      get_frame_address_in_block does just this.  It's not clear how
1061      reliable the method is though; there is the potential for the
1062      register state pre-call being different to that on return.  */
1063   fs->pc = get_frame_address_in_block (this_frame);
1064
1065   /* Find the correct FDE.  */
1066   fde = dwarf2_frame_find_fde (&fs->pc, &cache->text_offset);
1067   gdb_assert (fde != NULL);
1068
1069   /* Extract any interesting information from the CIE.  */
1070   fs->data_align = fde->cie->data_alignment_factor;
1071   fs->code_align = fde->cie->code_alignment_factor;
1072   fs->retaddr_column = fde->cie->return_address_register;
1073   cache->addr_size = fde->cie->addr_size;
1074
1075   /* Check for "quirks" - known bugs in producers.  */
1076   dwarf2_frame_find_quirks (fs, fde);
1077
1078   /* First decode all the insns in the CIE.  */
1079   execute_cfa_program (fde, fde->cie->initial_instructions,
1080                        fde->cie->end, gdbarch,
1081                        get_frame_address_in_block (this_frame), fs);
1082
1083   /* Save the initialized register set.  */
1084   fs->initial = fs->regs;
1085   fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
1086
1087   if (get_frame_func_if_available (this_frame, &entry_pc))
1088     {
1089       /* Decode the insns in the FDE up to the entry PC.  */
1090       instr = execute_cfa_program (fde, fde->instructions, fde->end, gdbarch,
1091                                    entry_pc, fs);
1092
1093       if (fs->regs.cfa_how == CFA_REG_OFFSET
1094           && (gdbarch_dwarf2_reg_to_regnum (gdbarch, fs->regs.cfa_reg)
1095               == gdbarch_sp_regnum (gdbarch)))
1096         {
1097           entry_cfa_sp_offset = fs->regs.cfa_offset;
1098           entry_cfa_sp_offset_p = 1;
1099         }
1100     }
1101   else
1102     instr = fde->instructions;
1103
1104   /* Then decode the insns in the FDE up to our target PC.  */
1105   execute_cfa_program (fde, instr, fde->end, gdbarch,
1106                        get_frame_address_in_block (this_frame), fs);
1107
1108   TRY_CATCH (ex, RETURN_MASK_ERROR)
1109     {
1110       /* Calculate the CFA.  */
1111       switch (fs->regs.cfa_how)
1112         {
1113         case CFA_REG_OFFSET:
1114           cache->cfa = read_addr_from_reg (this_frame, fs->regs.cfa_reg);
1115           if (fs->armcc_cfa_offsets_reversed)
1116             cache->cfa -= fs->regs.cfa_offset;
1117           else
1118             cache->cfa += fs->regs.cfa_offset;
1119           break;
1120
1121         case CFA_EXP:
1122           cache->cfa =
1123             execute_stack_op (fs->regs.cfa_exp, fs->regs.cfa_exp_len,
1124                               cache->addr_size, cache->text_offset,
1125                               this_frame, 0, 0);
1126           break;
1127
1128         default:
1129           internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
1130         }
1131     }
1132   if (ex.reason < 0)
1133     {
1134       if (ex.error == NOT_AVAILABLE_ERROR)
1135         {
1136           cache->unavailable_retaddr = 1;
1137           do_cleanups (old_chain);
1138           discard_cleanups (reset_cache_cleanup);
1139           return cache;
1140         }
1141
1142       throw_exception (ex);
1143     }
1144
1145   /* Initialize the register state.  */
1146   {
1147     int regnum;
1148
1149     for (regnum = 0; regnum < num_regs; regnum++)
1150       dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], this_frame);
1151   }
1152
1153   /* Go through the DWARF2 CFI generated table and save its register
1154      location information in the cache.  Note that we don't skip the
1155      return address column; it's perfectly all right for it to
1156      correspond to a real register.  If it doesn't correspond to a
1157      real register, or if we shouldn't treat it as such,
1158      gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
1159      the range [0, gdbarch_num_regs).  */
1160   {
1161     int column;         /* CFI speak for "register number".  */
1162
1163     for (column = 0; column < fs->regs.num_regs; column++)
1164       {
1165         /* Use the GDB register number as the destination index.  */
1166         int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, column);
1167
1168         /* If there's no corresponding GDB register, ignore it.  */
1169         if (regnum < 0 || regnum >= num_regs)
1170           continue;
1171
1172         /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1173            of all debug info registers.  If it doesn't, complain (but
1174            not too loudly).  It turns out that GCC assumes that an
1175            unspecified register implies "same value" when CFI (draft
1176            7) specifies nothing at all.  Such a register could equally
1177            be interpreted as "undefined".  Also note that this check
1178            isn't sufficient; it only checks that all registers in the
1179            range [0 .. max column] are specified, and won't detect
1180            problems when a debug info register falls outside of the
1181            table.  We need a way of iterating through all the valid
1182            DWARF2 register numbers.  */
1183         if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
1184           {
1185             if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
1186               complaint (&symfile_complaints, _("\
1187 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1188                          gdbarch_register_name (gdbarch, regnum),
1189                          paddress (gdbarch, fs->pc));
1190           }
1191         else
1192           cache->reg[regnum] = fs->regs.reg[column];
1193       }
1194   }
1195
1196   /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1197      we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules.  */
1198   {
1199     int regnum;
1200
1201     for (regnum = 0; regnum < num_regs; regnum++)
1202       {
1203         if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
1204             || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
1205           {
1206             struct dwarf2_frame_state_reg *retaddr_reg =
1207               &fs->regs.reg[fs->retaddr_column];
1208
1209             /* It seems rather bizarre to specify an "empty" column as
1210                the return adress column.  However, this is exactly
1211                what GCC does on some targets.  It turns out that GCC
1212                assumes that the return address can be found in the
1213                register corresponding to the return address column.
1214                Incidentally, that's how we should treat a return
1215                address column specifying "same value" too.  */
1216             if (fs->retaddr_column < fs->regs.num_regs
1217                 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
1218                 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
1219               {
1220                 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1221                   cache->reg[regnum] = *retaddr_reg;
1222                 else
1223                   cache->retaddr_reg = *retaddr_reg;
1224               }
1225             else
1226               {
1227                 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1228                   {
1229                     cache->reg[regnum].loc.reg = fs->retaddr_column;
1230                     cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
1231                   }
1232                 else
1233                   {
1234                     cache->retaddr_reg.loc.reg = fs->retaddr_column;
1235                     cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
1236                   }
1237               }
1238           }
1239       }
1240   }
1241
1242   if (fs->retaddr_column < fs->regs.num_regs
1243       && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
1244     cache->undefined_retaddr = 1;
1245
1246   do_cleanups (old_chain);
1247
1248   /* Try to find a virtual tail call frames chain with bottom (callee) frame
1249      starting at THIS_FRAME.  */
1250   dwarf2_tailcall_sniffer_first (this_frame, &cache->tailcall_cache,
1251                                  (entry_cfa_sp_offset_p
1252                                   ? &entry_cfa_sp_offset : NULL));
1253
1254   discard_cleanups (reset_cache_cleanup);
1255   return cache;
1256 }
1257
1258 static enum unwind_stop_reason
1259 dwarf2_frame_unwind_stop_reason (struct frame_info *this_frame,
1260                                  void **this_cache)
1261 {
1262   struct dwarf2_frame_cache *cache
1263     = dwarf2_frame_cache (this_frame, this_cache);
1264
1265   if (cache->unavailable_retaddr)
1266     return UNWIND_UNAVAILABLE;
1267
1268   if (cache->undefined_retaddr)
1269     return UNWIND_OUTERMOST;
1270
1271   return UNWIND_NO_REASON;
1272 }
1273
1274 static void
1275 dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache,
1276                       struct frame_id *this_id)
1277 {
1278   struct dwarf2_frame_cache *cache =
1279     dwarf2_frame_cache (this_frame, this_cache);
1280
1281   if (cache->unavailable_retaddr)
1282     return;
1283
1284   if (cache->undefined_retaddr)
1285     return;
1286
1287   (*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame));
1288 }
1289
1290 static struct value *
1291 dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1292                             int regnum)
1293 {
1294   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1295   struct dwarf2_frame_cache *cache =
1296     dwarf2_frame_cache (this_frame, this_cache);
1297   CORE_ADDR addr;
1298   int realnum;
1299
1300   /* Non-bottom frames of a virtual tail call frames chain use
1301      dwarf2_tailcall_frame_unwind unwinder so this code does not apply for
1302      them.  If dwarf2_tailcall_prev_register_first does not have specific value
1303      unwind the register, tail call frames are assumed to have the register set
1304      of the top caller.  */
1305   if (cache->tailcall_cache)
1306     {
1307       struct value *val;
1308
1309       val = dwarf2_tailcall_prev_register_first (this_frame,
1310                                                  &cache->tailcall_cache,
1311                                                  regnum);
1312       if (val)
1313         return val;
1314     }
1315
1316   switch (cache->reg[regnum].how)
1317     {
1318     case DWARF2_FRAME_REG_UNDEFINED:
1319       /* If CFI explicitly specified that the value isn't defined,
1320          mark it as optimized away; the value isn't available.  */
1321       return frame_unwind_got_optimized (this_frame, regnum);
1322
1323     case DWARF2_FRAME_REG_SAVED_OFFSET:
1324       addr = cache->cfa + cache->reg[regnum].loc.offset;
1325       return frame_unwind_got_memory (this_frame, regnum, addr);
1326
1327     case DWARF2_FRAME_REG_SAVED_REG:
1328       realnum
1329         = gdbarch_dwarf2_reg_to_regnum (gdbarch, cache->reg[regnum].loc.reg);
1330       return frame_unwind_got_register (this_frame, regnum, realnum);
1331
1332     case DWARF2_FRAME_REG_SAVED_EXP:
1333       addr = execute_stack_op (cache->reg[regnum].loc.exp,
1334                                cache->reg[regnum].exp_len,
1335                                cache->addr_size, cache->text_offset,
1336                                this_frame, cache->cfa, 1);
1337       return frame_unwind_got_memory (this_frame, regnum, addr);
1338
1339     case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1340       addr = cache->cfa + cache->reg[regnum].loc.offset;
1341       return frame_unwind_got_constant (this_frame, regnum, addr);
1342
1343     case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1344       addr = execute_stack_op (cache->reg[regnum].loc.exp,
1345                                cache->reg[regnum].exp_len,
1346                                cache->addr_size, cache->text_offset,
1347                                this_frame, cache->cfa, 1);
1348       return frame_unwind_got_constant (this_frame, regnum, addr);
1349
1350     case DWARF2_FRAME_REG_UNSPECIFIED:
1351       /* GCC, in its infinite wisdom decided to not provide unwind
1352          information for registers that are "same value".  Since
1353          DWARF2 (3 draft 7) doesn't define such behavior, said
1354          registers are actually undefined (which is different to CFI
1355          "undefined").  Code above issues a complaint about this.
1356          Here just fudge the books, assume GCC, and that the value is
1357          more inner on the stack.  */
1358       return frame_unwind_got_register (this_frame, regnum, regnum);
1359
1360     case DWARF2_FRAME_REG_SAME_VALUE:
1361       return frame_unwind_got_register (this_frame, regnum, regnum);
1362
1363     case DWARF2_FRAME_REG_CFA:
1364       return frame_unwind_got_address (this_frame, regnum, cache->cfa);
1365
1366     case DWARF2_FRAME_REG_CFA_OFFSET:
1367       addr = cache->cfa + cache->reg[regnum].loc.offset;
1368       return frame_unwind_got_address (this_frame, regnum, addr);
1369
1370     case DWARF2_FRAME_REG_RA_OFFSET:
1371       addr = cache->reg[regnum].loc.offset;
1372       regnum = gdbarch_dwarf2_reg_to_regnum
1373         (gdbarch, cache->retaddr_reg.loc.reg);
1374       addr += get_frame_register_unsigned (this_frame, regnum);
1375       return frame_unwind_got_address (this_frame, regnum, addr);
1376
1377     case DWARF2_FRAME_REG_FN:
1378       return cache->reg[regnum].loc.fn (this_frame, this_cache, regnum);
1379
1380     default:
1381       internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1382     }
1383 }
1384
1385 /* Proxy for tailcall_frame_dealloc_cache for bottom frame of a virtual tail
1386    call frames chain.  */
1387
1388 static void
1389 dwarf2_frame_dealloc_cache (struct frame_info *self, void *this_cache)
1390 {
1391   struct dwarf2_frame_cache *cache = dwarf2_frame_cache (self, &this_cache);
1392
1393   if (cache->tailcall_cache)
1394     dwarf2_tailcall_frame_unwind.dealloc_cache (self, cache->tailcall_cache);
1395 }
1396
1397 static int
1398 dwarf2_frame_sniffer (const struct frame_unwind *self,
1399                       struct frame_info *this_frame, void **this_cache)
1400 {
1401   /* Grab an address that is guarenteed to reside somewhere within the
1402      function.  get_frame_pc(), with a no-return next function, can
1403      end up returning something past the end of this function's body.
1404      If the frame we're sniffing for is a signal frame whose start
1405      address is placed on the stack by the OS, its FDE must
1406      extend one byte before its start address or we could potentially
1407      select the FDE of the previous function.  */
1408   CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1409   struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr, NULL);
1410
1411   if (!fde)
1412     return 0;
1413
1414   /* On some targets, signal trampolines may have unwind information.
1415      We need to recognize them so that we set the frame type
1416      correctly.  */
1417
1418   if (fde->cie->signal_frame
1419       || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame),
1420                                       this_frame))
1421     return self->type == SIGTRAMP_FRAME;
1422
1423   if (self->type != NORMAL_FRAME)
1424     return 0;
1425
1426   /* Preinitializa the cache so that TAILCALL_FRAME can find the record by
1427      dwarf2_tailcall_sniffer_first.  */
1428   dwarf2_frame_cache (this_frame, this_cache);
1429
1430   return 1;
1431 }
1432
1433 static const struct frame_unwind dwarf2_frame_unwind =
1434 {
1435   NORMAL_FRAME,
1436   dwarf2_frame_unwind_stop_reason,
1437   dwarf2_frame_this_id,
1438   dwarf2_frame_prev_register,
1439   NULL,
1440   dwarf2_frame_sniffer,
1441   dwarf2_frame_dealloc_cache
1442 };
1443
1444 static const struct frame_unwind dwarf2_signal_frame_unwind =
1445 {
1446   SIGTRAMP_FRAME,
1447   dwarf2_frame_unwind_stop_reason,
1448   dwarf2_frame_this_id,
1449   dwarf2_frame_prev_register,
1450   NULL,
1451   dwarf2_frame_sniffer,
1452
1453   /* TAILCALL_CACHE can never be in such frame to need dealloc_cache.  */
1454   NULL
1455 };
1456
1457 /* Append the DWARF-2 frame unwinders to GDBARCH's list.  */
1458
1459 void
1460 dwarf2_append_unwinders (struct gdbarch *gdbarch)
1461 {
1462   /* TAILCALL_FRAME must be first to find the record by
1463      dwarf2_tailcall_sniffer_first.  */
1464   frame_unwind_append_unwinder (gdbarch, &dwarf2_tailcall_frame_unwind);
1465
1466   frame_unwind_append_unwinder (gdbarch, &dwarf2_frame_unwind);
1467   frame_unwind_append_unwinder (gdbarch, &dwarf2_signal_frame_unwind);
1468 }
1469 \f
1470
1471 /* There is no explicitly defined relationship between the CFA and the
1472    location of frame's local variables and arguments/parameters.
1473    Therefore, frame base methods on this page should probably only be
1474    used as a last resort, just to avoid printing total garbage as a
1475    response to the "info frame" command.  */
1476
1477 static CORE_ADDR
1478 dwarf2_frame_base_address (struct frame_info *this_frame, void **this_cache)
1479 {
1480   struct dwarf2_frame_cache *cache =
1481     dwarf2_frame_cache (this_frame, this_cache);
1482
1483   return cache->cfa;
1484 }
1485
1486 static const struct frame_base dwarf2_frame_base =
1487 {
1488   &dwarf2_frame_unwind,
1489   dwarf2_frame_base_address,
1490   dwarf2_frame_base_address,
1491   dwarf2_frame_base_address
1492 };
1493
1494 const struct frame_base *
1495 dwarf2_frame_base_sniffer (struct frame_info *this_frame)
1496 {
1497   CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1498
1499   if (dwarf2_frame_find_fde (&block_addr, NULL))
1500     return &dwarf2_frame_base;
1501
1502   return NULL;
1503 }
1504
1505 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1506    the DWARF unwinder.  This is used to implement
1507    DW_OP_call_frame_cfa.  */
1508
1509 CORE_ADDR
1510 dwarf2_frame_cfa (struct frame_info *this_frame)
1511 {
1512   while (get_frame_type (this_frame) == INLINE_FRAME)
1513     this_frame = get_prev_frame (this_frame);
1514   /* This restriction could be lifted if other unwinders are known to
1515      compute the frame base in a way compatible with the DWARF
1516      unwinder.  */
1517   if (!frame_unwinder_is (this_frame, &dwarf2_frame_unwind)
1518       && !frame_unwinder_is (this_frame, &dwarf2_tailcall_frame_unwind))
1519     error (_("can't compute CFA for this frame"));
1520   if (get_frame_unwind_stop_reason (this_frame) == UNWIND_UNAVAILABLE)
1521     throw_error (NOT_AVAILABLE_ERROR,
1522                  _("can't compute CFA for this frame: "
1523                    "required registers or memory are unavailable"));
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 }