gdb/dwarf2-frame.c

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