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