gdb/dwarf2-frame.c

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