gdb/dwarf2-frame.c

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