contrib/gdb-7/gdb/dwarf2-frame.c

   1 /* Frame unwinder for frames with DWARF Call Frame Information.
   2
   3    Copyright (C) 2003, 2004, 2005, 2007, 2008, 2009
   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   static const char *arm_idents[] = {
 843     "ARM C Compiler, ADS",
 844     "Thumb C Compiler, ADS",
 845     "ARM C++ Compiler, ADS",
 846     "Thumb C++ Compiler, ADS",
 847     "ARM/Thumb C/C++ Compiler, RVCT"
 848   };
 849   int i;
 850
 851   struct symtab *s;
 852
 853   s = find_pc_symtab (fs->pc);
 854   if (s == NULL || s->producer == NULL)
 855     return;
 856
 857   for (i = 0; i < ARRAY_SIZE (arm_idents); i++)
 858     if (strncmp (s->producer, arm_idents[i], strlen (arm_idents[i])) == 0)
 859       {
 860         if (fde->cie->version == 1)
 861           fs->armcc_cfa_offsets_sf = 1;
 862
 863         if (fde->cie->version == 1)
 864           fs->armcc_cfa_offsets_reversed = 1;
 865
 866         /* The reversed offset problem is present in some compilers
 867            using DWARF3, but it was eventually fixed.  Check the ARM
 868            defined augmentations, which are in the format "armcc" followed
 869            by a list of one-character options.  The "+" option means
 870            this problem is fixed (no quirk needed).  If the armcc
 871            augmentation is missing, the quirk is needed.  */
 872         if (fde->cie->version == 3
 873             && (strncmp (fde->cie->augmentation, "armcc", 5) != 0
 874                 || strchr (fde->cie->augmentation + 5, '+') == NULL))
 875           fs->armcc_cfa_offsets_reversed = 1;
 876
 877         return;
 878       }
 879 }
 880 \f
 881
 882 struct dwarf2_frame_cache
 883 {
 884   /* DWARF Call Frame Address.  */
 885   CORE_ADDR cfa;
 886
 887   /* Set if the return address column was marked as undefined.  */
 888   int undefined_retaddr;
 889
 890   /* Saved registers, indexed by GDB register number, not by DWARF
 891      register number.  */
 892   struct dwarf2_frame_state_reg *reg;
 893
 894   /* Return address register.  */
 895   struct dwarf2_frame_state_reg retaddr_reg;
 896
 897   /* Target address size in bytes.  */
 898   int addr_size;
 899 };
 900
 901 static struct dwarf2_frame_cache *
 902 dwarf2_frame_cache (struct frame_info *this_frame, void **this_cache)
 903 {
 904   struct cleanup *old_chain;
 905   struct gdbarch *gdbarch = get_frame_arch (this_frame);
 906   const int num_regs = gdbarch_num_regs (gdbarch)
 907                        + gdbarch_num_pseudo_regs (gdbarch);
 908   struct dwarf2_frame_cache *cache;
 909   struct dwarf2_frame_state *fs;
 910   struct dwarf2_fde *fde;
 911
 912   if (*this_cache)
 913     return *this_cache;
 914
 915   /* Allocate a new cache.  */
 916   cache = FRAME_OBSTACK_ZALLOC (struct dwarf2_frame_cache);
 917   cache->reg = FRAME_OBSTACK_CALLOC (num_regs, struct dwarf2_frame_state_reg);
 918
 919   /* Allocate and initialize the frame state.  */
 920   fs = XMALLOC (struct dwarf2_frame_state);
 921   memset (fs, 0, sizeof (struct dwarf2_frame_state));
 922   old_chain = make_cleanup (dwarf2_frame_state_free, fs);
 923
 924   /* Unwind the PC.
 925
 926      Note that if the next frame is never supposed to return (i.e. a call
 927      to abort), the compiler might optimize away the instruction at
 928      its return address.  As a result the return address will
 929      point at some random instruction, and the CFI for that
 930      instruction is probably worthless to us.  GCC's unwinder solves
 931      this problem by substracting 1 from the return address to get an
 932      address in the middle of a presumed call instruction (or the
 933      instruction in the associated delay slot).  This should only be
 934      done for "normal" frames and not for resume-type frames (signal
 935      handlers, sentinel frames, dummy frames).  The function
 936      get_frame_address_in_block does just this.  It's not clear how
 937      reliable the method is though; there is the potential for the
 938      register state pre-call being different to that on return.  */
 939   fs->pc = get_frame_address_in_block (this_frame);
 940
 941   /* Find the correct FDE.  */
 942   fde = dwarf2_frame_find_fde (&fs->pc);
 943   gdb_assert (fde != NULL);
 944
 945   /* Extract any interesting information from the CIE.  */
 946   fs->data_align = fde->cie->data_alignment_factor;
 947   fs->code_align = fde->cie->code_alignment_factor;
 948   fs->retaddr_column = fde->cie->return_address_register;
 949   cache->addr_size = fde->cie->addr_size;
 950
 951   /* Check for "quirks" - known bugs in producers.  */
 952   dwarf2_frame_find_quirks (fs, fde);
 953
 954   /* First decode all the insns in the CIE.  */
 955   execute_cfa_program (fde, fde->cie->initial_instructions,
 956                        fde->cie->end, this_frame, fs);
 957
 958   /* Save the initialized register set.  */
 959   fs->initial = fs->regs;
 960   fs->initial.reg = dwarf2_frame_state_copy_regs (&fs->regs);
 961
 962   /* Then decode the insns in the FDE up to our target PC.  */
 963   execute_cfa_program (fde, fde->instructions, fde->end, this_frame, fs);
 964
 965   /* Calculate the CFA.  */
 966   switch (fs->regs.cfa_how)
 967     {
 968     case CFA_REG_OFFSET:
 969       cache->cfa = read_reg (this_frame, fs->regs.cfa_reg);
 970       if (fs->armcc_cfa_offsets_reversed)
 971         cache->cfa -= fs->regs.cfa_offset;
 972       else
 973         cache->cfa += fs->regs.cfa_offset;
 974       break;
 975
 976     case CFA_EXP:
 977       cache->cfa =
 978         execute_stack_op (fs->regs.cfa_exp, fs->regs.cfa_exp_len,
 979                           cache->addr_size, this_frame, 0, 0);
 980       break;
 981
 982     default:
 983       internal_error (__FILE__, __LINE__, _("Unknown CFA rule."));
 984     }
 985
 986   /* Initialize the register state.  */
 987   {
 988     int regnum;
 989
 990     for (regnum = 0; regnum < num_regs; regnum++)
 991       dwarf2_frame_init_reg (gdbarch, regnum, &cache->reg[regnum], this_frame);
 992   }
 993
 994   /* Go through the DWARF2 CFI generated table and save its register
 995      location information in the cache.  Note that we don't skip the
 996      return address column; it's perfectly all right for it to
 997      correspond to a real register.  If it doesn't correspond to a
 998      real register, or if we shouldn't treat it as such,
 999      gdbarch_dwarf2_reg_to_regnum should be defined to return a number outside
1000      the range [0, gdbarch_num_regs).  */
1001   {
1002     int column;         /* CFI speak for "register number".  */
1003
1004     for (column = 0; column < fs->regs.num_regs; column++)
1005       {
1006         /* Use the GDB register number as the destination index.  */
1007         int regnum = gdbarch_dwarf2_reg_to_regnum (gdbarch, column);
1008
1009         /* If there's no corresponding GDB register, ignore it.  */
1010         if (regnum < 0 || regnum >= num_regs)
1011           continue;
1012
1013         /* NOTE: cagney/2003-09-05: CFI should specify the disposition
1014            of all debug info registers.  If it doesn't, complain (but
1015            not too loudly).  It turns out that GCC assumes that an
1016            unspecified register implies "same value" when CFI (draft
1017            7) specifies nothing at all.  Such a register could equally
1018            be interpreted as "undefined".  Also note that this check
1019            isn't sufficient; it only checks that all registers in the
1020            range [0 .. max column] are specified, and won't detect
1021            problems when a debug info register falls outside of the
1022            table.  We need a way of iterating through all the valid
1023            DWARF2 register numbers.  */
1024         if (fs->regs.reg[column].how == DWARF2_FRAME_REG_UNSPECIFIED)
1025           {
1026             if (cache->reg[regnum].how == DWARF2_FRAME_REG_UNSPECIFIED)
1027               complaint (&symfile_complaints, _("\
1028 incomplete CFI data; unspecified registers (e.g., %s) at %s"),
1029                          gdbarch_register_name (gdbarch, regnum),
1030                          paddress (gdbarch, fs->pc));
1031           }
1032         else
1033           cache->reg[regnum] = fs->regs.reg[column];
1034       }
1035   }
1036
1037   /* Eliminate any DWARF2_FRAME_REG_RA rules, and save the information
1038      we need for evaluating DWARF2_FRAME_REG_RA_OFFSET rules.  */
1039   {
1040     int regnum;
1041
1042     for (regnum = 0; regnum < num_regs; regnum++)
1043       {
1044         if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA
1045             || cache->reg[regnum].how == DWARF2_FRAME_REG_RA_OFFSET)
1046           {
1047             struct dwarf2_frame_state_reg *retaddr_reg =
1048               &fs->regs.reg[fs->retaddr_column];
1049
1050             /* It seems rather bizarre to specify an "empty" column as
1051                the return adress column.  However, this is exactly
1052                what GCC does on some targets.  It turns out that GCC
1053                assumes that the return address can be found in the
1054                register corresponding to the return address column.
1055                Incidentally, that's how we should treat a return
1056                address column specifying "same value" too.  */
1057             if (fs->retaddr_column < fs->regs.num_regs
1058                 && retaddr_reg->how != DWARF2_FRAME_REG_UNSPECIFIED
1059                 && retaddr_reg->how != DWARF2_FRAME_REG_SAME_VALUE)
1060               {
1061                 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1062                   cache->reg[regnum] = *retaddr_reg;
1063                 else
1064                   cache->retaddr_reg = *retaddr_reg;
1065               }
1066             else
1067               {
1068                 if (cache->reg[regnum].how == DWARF2_FRAME_REG_RA)
1069                   {
1070                     cache->reg[regnum].loc.reg = fs->retaddr_column;
1071                     cache->reg[regnum].how = DWARF2_FRAME_REG_SAVED_REG;
1072                   }
1073                 else
1074                   {
1075                     cache->retaddr_reg.loc.reg = fs->retaddr_column;
1076                     cache->retaddr_reg.how = DWARF2_FRAME_REG_SAVED_REG;
1077                   }
1078               }
1079           }
1080       }
1081   }
1082
1083   if (fs->retaddr_column < fs->regs.num_regs
1084       && fs->regs.reg[fs->retaddr_column].how == DWARF2_FRAME_REG_UNDEFINED)
1085     cache->undefined_retaddr = 1;
1086
1087   do_cleanups (old_chain);
1088
1089   *this_cache = cache;
1090   return cache;
1091 }
1092
1093 static void
1094 dwarf2_frame_this_id (struct frame_info *this_frame, void **this_cache,
1095                       struct frame_id *this_id)
1096 {
1097   struct dwarf2_frame_cache *cache =
1098     dwarf2_frame_cache (this_frame, this_cache);
1099
1100   if (cache->undefined_retaddr)
1101     return;
1102
1103   (*this_id) = frame_id_build (cache->cfa, get_frame_func (this_frame));
1104 }
1105
1106 static struct value *
1107 dwarf2_frame_prev_register (struct frame_info *this_frame, void **this_cache,
1108                             int regnum)
1109 {
1110   struct gdbarch *gdbarch = get_frame_arch (this_frame);
1111   struct dwarf2_frame_cache *cache =
1112     dwarf2_frame_cache (this_frame, this_cache);
1113   CORE_ADDR addr;
1114   int realnum;
1115
1116   switch (cache->reg[regnum].how)
1117     {
1118     case DWARF2_FRAME_REG_UNDEFINED:
1119       /* If CFI explicitly specified that the value isn't defined,
1120          mark it as optimized away; the value isn't available.  */
1121       return frame_unwind_got_optimized (this_frame, regnum);
1122
1123     case DWARF2_FRAME_REG_SAVED_OFFSET:
1124       addr = cache->cfa + cache->reg[regnum].loc.offset;
1125       return frame_unwind_got_memory (this_frame, regnum, addr);
1126
1127     case DWARF2_FRAME_REG_SAVED_REG:
1128       realnum
1129         = gdbarch_dwarf2_reg_to_regnum (gdbarch, cache->reg[regnum].loc.reg);
1130       return frame_unwind_got_register (this_frame, regnum, realnum);
1131
1132     case DWARF2_FRAME_REG_SAVED_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_memory (this_frame, regnum, addr);
1137
1138     case DWARF2_FRAME_REG_SAVED_VAL_OFFSET:
1139       addr = cache->cfa + cache->reg[regnum].loc.offset;
1140       return frame_unwind_got_constant (this_frame, regnum, addr);
1141
1142     case DWARF2_FRAME_REG_SAVED_VAL_EXP:
1143       addr = execute_stack_op (cache->reg[regnum].loc.exp,
1144                                cache->reg[regnum].exp_len,
1145                                cache->addr_size, this_frame, cache->cfa, 1);
1146       return frame_unwind_got_constant (this_frame, regnum, addr);
1147
1148     case DWARF2_FRAME_REG_UNSPECIFIED:
1149       /* GCC, in its infinite wisdom decided to not provide unwind
1150          information for registers that are "same value".  Since
1151          DWARF2 (3 draft 7) doesn't define such behavior, said
1152          registers are actually undefined (which is different to CFI
1153          "undefined").  Code above issues a complaint about this.
1154          Here just fudge the books, assume GCC, and that the value is
1155          more inner on the stack.  */
1156       return frame_unwind_got_register (this_frame, regnum, regnum);
1157
1158     case DWARF2_FRAME_REG_SAME_VALUE:
1159       return frame_unwind_got_register (this_frame, regnum, regnum);
1160
1161     case DWARF2_FRAME_REG_CFA:
1162       return frame_unwind_got_address (this_frame, regnum, cache->cfa);
1163
1164     case DWARF2_FRAME_REG_CFA_OFFSET:
1165       addr = cache->cfa + cache->reg[regnum].loc.offset;
1166       return frame_unwind_got_address (this_frame, regnum, addr);
1167
1168     case DWARF2_FRAME_REG_RA_OFFSET:
1169       addr = cache->reg[regnum].loc.offset;
1170       regnum = gdbarch_dwarf2_reg_to_regnum
1171         (gdbarch, cache->retaddr_reg.loc.reg);
1172       addr += get_frame_register_unsigned (this_frame, regnum);
1173       return frame_unwind_got_address (this_frame, regnum, addr);
1174
1175     case DWARF2_FRAME_REG_FN:
1176       return cache->reg[regnum].loc.fn (this_frame, this_cache, regnum);
1177
1178     default:
1179       internal_error (__FILE__, __LINE__, _("Unknown register rule."));
1180     }
1181 }
1182
1183 static int
1184 dwarf2_frame_sniffer (const struct frame_unwind *self,
1185                       struct frame_info *this_frame, void **this_cache)
1186 {
1187   /* Grab an address that is guarenteed to reside somewhere within the
1188      function.  get_frame_pc(), with a no-return next function, can
1189      end up returning something past the end of this function's body.
1190      If the frame we're sniffing for is a signal frame whose start
1191      address is placed on the stack by the OS, its FDE must
1192      extend one byte before its start address or we could potentially
1193      select the FDE of the previous function.  */
1194   CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1195   struct dwarf2_fde *fde = dwarf2_frame_find_fde (&block_addr);
1196   if (!fde)
1197     return 0;
1198
1199   /* On some targets, signal trampolines may have unwind information.
1200      We need to recognize them so that we set the frame type
1201      correctly.  */
1202
1203   if (fde->cie->signal_frame
1204       || dwarf2_frame_signal_frame_p (get_frame_arch (this_frame),
1205                                       this_frame))
1206     return self->type == SIGTRAMP_FRAME;
1207
1208   return self->type != SIGTRAMP_FRAME;
1209 }
1210
1211 static const struct frame_unwind dwarf2_frame_unwind =
1212 {
1213   NORMAL_FRAME,
1214   dwarf2_frame_this_id,
1215   dwarf2_frame_prev_register,
1216   NULL,
1217   dwarf2_frame_sniffer
1218 };
1219
1220 static const struct frame_unwind dwarf2_signal_frame_unwind =
1221 {
1222   SIGTRAMP_FRAME,
1223   dwarf2_frame_this_id,
1224   dwarf2_frame_prev_register,
1225   NULL,
1226   dwarf2_frame_sniffer
1227 };
1228
1229 /* Append the DWARF-2 frame unwinders to GDBARCH's list.  */
1230
1231 void
1232 dwarf2_append_unwinders (struct gdbarch *gdbarch)
1233 {
1234   frame_unwind_append_unwinder (gdbarch, &dwarf2_frame_unwind);
1235   frame_unwind_append_unwinder (gdbarch, &dwarf2_signal_frame_unwind);
1236 }
1237 \f
1238
1239 /* There is no explicitly defined relationship between the CFA and the
1240    location of frame's local variables and arguments/parameters.
1241    Therefore, frame base methods on this page should probably only be
1242    used as a last resort, just to avoid printing total garbage as a
1243    response to the "info frame" command.  */
1244
1245 static CORE_ADDR
1246 dwarf2_frame_base_address (struct frame_info *this_frame, void **this_cache)
1247 {
1248   struct dwarf2_frame_cache *cache =
1249     dwarf2_frame_cache (this_frame, this_cache);
1250
1251   return cache->cfa;
1252 }
1253
1254 static const struct frame_base dwarf2_frame_base =
1255 {
1256   &dwarf2_frame_unwind,
1257   dwarf2_frame_base_address,
1258   dwarf2_frame_base_address,
1259   dwarf2_frame_base_address
1260 };
1261
1262 const struct frame_base *
1263 dwarf2_frame_base_sniffer (struct frame_info *this_frame)
1264 {
1265   CORE_ADDR block_addr = get_frame_address_in_block (this_frame);
1266   if (dwarf2_frame_find_fde (&block_addr))
1267     return &dwarf2_frame_base;
1268
1269   return NULL;
1270 }
1271
1272 /* Compute the CFA for THIS_FRAME, but only if THIS_FRAME came from
1273    the DWARF unwinder.  This is used to implement
1274    DW_OP_call_frame_cfa.  */
1275
1276 CORE_ADDR
1277 dwarf2_frame_cfa (struct frame_info *this_frame)
1278 {
1279   while (get_frame_type (this_frame) == INLINE_FRAME)
1280     this_frame = get_prev_frame (this_frame);
1281   /* This restriction could be lifted if other unwinders are known to
1282      compute the frame base in a way compatible with the DWARF
1283      unwinder.  */
1284   if (! frame_unwinder_is (this_frame, &dwarf2_frame_unwind))
1285     error (_("can't compute CFA for this frame"));
1286   return get_frame_base (this_frame);
1287 }
1288 \f
1289 const struct objfile_data *dwarf2_frame_objfile_data;
1290
1291 static unsigned int
1292 read_1_byte (bfd *abfd, gdb_byte *buf)
1293 {
1294   return bfd_get_8 (abfd, buf);
1295 }
1296
1297 static unsigned int
1298 read_4_bytes (bfd *abfd, gdb_byte *buf)
1299 {
1300   return bfd_get_32 (abfd, buf);
1301 }
1302
1303 static ULONGEST
1304 read_8_bytes (bfd *abfd, gdb_byte *buf)
1305 {
1306   return bfd_get_64 (abfd, buf);
1307 }
1308
1309 static ULONGEST
1310 read_unsigned_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1311 {
1312   ULONGEST result;
1313   unsigned int num_read;
1314   int shift;
1315   gdb_byte byte;
1316
1317   result = 0;
1318   shift = 0;
1319   num_read = 0;
1320
1321   do
1322     {
1323       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1324       buf++;
1325       num_read++;
1326       result |= ((byte & 0x7f) << shift);
1327       shift += 7;
1328     }
1329   while (byte & 0x80);
1330
1331   *bytes_read_ptr = num_read;
1332
1333   return result;
1334 }
1335
1336 static LONGEST
1337 read_signed_leb128 (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1338 {
1339   LONGEST result;
1340   int shift;
1341   unsigned int num_read;
1342   gdb_byte byte;
1343
1344   result = 0;
1345   shift = 0;
1346   num_read = 0;
1347
1348   do
1349     {
1350       byte = bfd_get_8 (abfd, (bfd_byte *) buf);
1351       buf++;
1352       num_read++;
1353       result |= ((byte & 0x7f) << shift);
1354       shift += 7;
1355     }
1356   while (byte & 0x80);
1357
1358   if (shift < 8 * sizeof (result) && (byte & 0x40))
1359     result |= -(((LONGEST)1) << shift);
1360
1361   *bytes_read_ptr = num_read;
1362
1363   return result;
1364 }
1365
1366 static ULONGEST
1367 read_initial_length (bfd *abfd, gdb_byte *buf, unsigned int *bytes_read_ptr)
1368 {
1369   LONGEST result;
1370
1371   result = bfd_get_32 (abfd, buf);
1372   if (result == 0xffffffff)
1373     {
1374       result = bfd_get_64 (abfd, buf + 4);
1375       *bytes_read_ptr = 12;
1376     }
1377   else
1378     *bytes_read_ptr = 4;
1379
1380   return result;
1381 }
1382 \f
1383
1384 /* Pointer encoding helper functions.  */
1385
1386 /* GCC supports exception handling based on DWARF2 CFI.  However, for
1387    technical reasons, it encodes addresses in its FDE's in a different
1388    way.  Several "pointer encodings" are supported.  The encoding
1389    that's used for a particular FDE is determined by the 'R'
1390    augmentation in the associated CIE.  The argument of this
1391    augmentation is a single byte.
1392
1393    The address can be encoded as 2 bytes, 4 bytes, 8 bytes, or as a
1394    LEB128.  This is encoded in bits 0, 1 and 2.  Bit 3 encodes whether
1395    the address is signed or unsigned.  Bits 4, 5 and 6 encode how the
1396    address should be interpreted (absolute, relative to the current
1397    position in the FDE, ...).  Bit 7, indicates that the address
1398    should be dereferenced.  */
1399
1400 static gdb_byte
1401 encoding_for_size (unsigned int size)
1402 {
1403   switch (size)
1404     {
1405     case 2:
1406       return DW_EH_PE_udata2;
1407     case 4:
1408       return DW_EH_PE_udata4;
1409     case 8:
1410       return DW_EH_PE_udata8;
1411     default:
1412       internal_error (__FILE__, __LINE__, _("Unsupported address size"));
1413     }
1414 }
1415
1416 static CORE_ADDR
1417 read_encoded_value (struct comp_unit *unit, gdb_byte encoding,
1418                     int ptr_len, gdb_byte *buf, unsigned int *bytes_read_ptr,
1419                     CORE_ADDR func_base)
1420 {
1421   ptrdiff_t offset;
1422   CORE_ADDR base;
1423
1424   /* GCC currently doesn't generate DW_EH_PE_indirect encodings for
1425      FDE's.  */
1426   if (encoding & DW_EH_PE_indirect)
1427     internal_error (__FILE__, __LINE__,
1428                     _("Unsupported encoding: DW_EH_PE_indirect"));
1429
1430   *bytes_read_ptr = 0;
1431
1432   switch (encoding & 0x70)
1433     {
1434     case DW_EH_PE_absptr:
1435       base = 0;
1436       break;
1437     case DW_EH_PE_pcrel:
1438       base = bfd_get_section_vma (unit->abfd, unit->dwarf_frame_section);
1439       base += (buf - unit->dwarf_frame_buffer);
1440       break;
1441     case DW_EH_PE_datarel:
1442       base = unit->dbase;
1443       break;
1444     case DW_EH_PE_textrel:
1445       base = unit->tbase;
1446       break;
1447     case DW_EH_PE_funcrel:
1448       base = func_base;
1449       break;
1450     case DW_EH_PE_aligned:
1451       base = 0;
1452       offset = buf - unit->dwarf_frame_buffer;
1453       if ((offset % ptr_len) != 0)
1454         {
1455           *bytes_read_ptr = ptr_len - (offset % ptr_len);
1456           buf += *bytes_read_ptr;
1457         }
1458       break;
1459     default:
1460       internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1461     }
1462
1463   if ((encoding & 0x07) == 0x00)
1464     {
1465       encoding |= encoding_for_size (ptr_len);
1466       if (bfd_get_sign_extend_vma (unit->abfd))
1467         encoding |= DW_EH_PE_signed;
1468     }
1469
1470   switch (encoding & 0x0f)
1471     {
1472     case DW_EH_PE_uleb128:
1473       {
1474         ULONGEST value;
1475         gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1476         *bytes_read_ptr += read_uleb128 (buf, end_buf, &value) - buf;
1477         return base + value;
1478       }
1479     case DW_EH_PE_udata2:
1480       *bytes_read_ptr += 2;
1481       return (base + bfd_get_16 (unit->abfd, (bfd_byte *) buf));
1482     case DW_EH_PE_udata4:
1483       *bytes_read_ptr += 4;
1484       return (base + bfd_get_32 (unit->abfd, (bfd_byte *) buf));
1485     case DW_EH_PE_udata8:
1486       *bytes_read_ptr += 8;
1487       return (base + bfd_get_64 (unit->abfd, (bfd_byte *) buf));
1488     case DW_EH_PE_sleb128:
1489       {
1490         LONGEST value;
1491         gdb_byte *end_buf = buf + (sizeof (value) + 1) * 8 / 7;
1492         *bytes_read_ptr += read_sleb128 (buf, end_buf, &value) - buf;
1493         return base + value;
1494       }
1495     case DW_EH_PE_sdata2:
1496       *bytes_read_ptr += 2;
1497       return (base + bfd_get_signed_16 (unit->abfd, (bfd_byte *) buf));
1498     case DW_EH_PE_sdata4:
1499       *bytes_read_ptr += 4;
1500       return (base + bfd_get_signed_32 (unit->abfd, (bfd_byte *) buf));
1501     case DW_EH_PE_sdata8:
1502       *bytes_read_ptr += 8;
1503       return (base + bfd_get_signed_64 (unit->abfd, (bfd_byte *) buf));
1504     default:
1505       internal_error (__FILE__, __LINE__, _("Invalid or unsupported encoding"));
1506     }
1507 }
1508 \f
1509
1510 static int
1511 bsearch_cie_cmp (const void *key, const void *element)
1512 {
1513   ULONGEST cie_pointer = *(ULONGEST *) key;
1514   struct dwarf2_cie *cie = *(struct dwarf2_cie **) element;
1515
1516   if (cie_pointer == cie->cie_pointer)
1517     return 0;
1518
1519   return (cie_pointer < cie->cie_pointer) ? -1 : 1;
1520 }
1521
1522 /* Find CIE with the given CIE_POINTER in CIE_TABLE.  */
1523 static struct dwarf2_cie *
1524 find_cie (struct dwarf2_cie_table *cie_table, ULONGEST cie_pointer)
1525 {
1526   struct dwarf2_cie **p_cie;
1527
1528   p_cie = bsearch (&cie_pointer, cie_table->entries, cie_table->num_entries,
1529                    sizeof (cie_table->entries[0]), bsearch_cie_cmp);
1530   if (p_cie != NULL)
1531     return *p_cie;
1532   return NULL;
1533 }
1534
1535 /* Add a pointer to new CIE to the CIE_TABLE, allocating space for it.  */
1536 static void
1537 add_cie (struct dwarf2_cie_table *cie_table, struct dwarf2_cie *cie)
1538 {
1539   const int n = cie_table->num_entries;
1540
1541   gdb_assert (n < 1
1542               || cie_table->entries[n - 1]->cie_pointer < cie->cie_pointer);
1543
1544   cie_table->entries =
1545       xrealloc (cie_table->entries, (n + 1) * sizeof (cie_table->entries[0]));
1546   cie_table->entries[n] = cie;
1547   cie_table->num_entries = n + 1;
1548 }
1549
1550 static int
1551 bsearch_fde_cmp (const void *key, const void *element)
1552 {
1553   CORE_ADDR seek_pc = *(CORE_ADDR *) key;
1554   struct dwarf2_fde *fde = *(struct dwarf2_fde **) element;
1555   if (seek_pc < fde->initial_location)
1556     return -1;
1557   if (seek_pc < fde->initial_location + fde->address_range)
1558     return 0;
1559   return 1;
1560 }
1561
1562 /* Find the FDE for *PC.  Return a pointer to the FDE, and store the
1563    inital location associated with it into *PC.  */
1564
1565 static struct dwarf2_fde *
1566 dwarf2_frame_find_fde (CORE_ADDR *pc)
1567 {
1568   struct objfile *objfile;
1569
1570   ALL_OBJFILES (objfile)
1571     {
1572       struct dwarf2_fde_table *fde_table;
1573       struct dwarf2_fde **p_fde;
1574       CORE_ADDR offset;
1575       CORE_ADDR seek_pc;
1576
1577       fde_table = objfile_data (objfile, dwarf2_frame_objfile_data);
1578       if (fde_table == NULL)
1579         continue;
1580
1581       gdb_assert (objfile->section_offsets);
1582       offset = ANOFFSET (objfile->section_offsets, SECT_OFF_TEXT (objfile));
1583
1584       gdb_assert (fde_table->num_entries > 0);
1585       if (*pc < offset + fde_table->entries[0]->initial_location)
1586         continue;
1587
1588       seek_pc = *pc - offset;
1589       p_fde = bsearch (&seek_pc, fde_table->entries, fde_table->num_entries,
1590                        sizeof (fde_table->entries[0]), bsearch_fde_cmp);
1591       if (p_fde != NULL)
1592         {
1593           *pc = (*p_fde)->initial_location + offset;
1594           return *p_fde;
1595         }
1596     }
1597   return NULL;
1598 }
1599
1600 /* Add a pointer to new FDE to the FDE_TABLE, allocating space for it.  */
1601 static void
1602 add_fde (struct dwarf2_fde_table *fde_table, struct dwarf2_fde *fde)
1603 {
1604   if (fde->address_range == 0)
1605     /* Discard useless FDEs.  */
1606     return;
1607
1608   fde_table->num_entries += 1;
1609   fde_table->entries =
1610       xrealloc (fde_table->entries,
1611                 fde_table->num_entries * sizeof (fde_table->entries[0]));
1612   fde_table->entries[fde_table->num_entries - 1] = fde;
1613 }
1614
1615 #ifdef CC_HAS_LONG_LONG
1616 #define DW64_CIE_ID 0xffffffffffffffffULL
1617 #else
1618 #define DW64_CIE_ID ~0
1619 #endif
1620
1621 static gdb_byte *decode_frame_entry (struct comp_unit *unit, gdb_byte *start,
1622                                      int eh_frame_p,
1623                                      struct dwarf2_cie_table *cie_table,
1624                                      struct dwarf2_fde_table *fde_table);
1625
1626 /* Decode the next CIE or FDE.  Return NULL if invalid input, otherwise
1627    the next byte to be processed.  */
1628 static gdb_byte *
1629 decode_frame_entry_1 (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
1630                       struct dwarf2_cie_table *cie_table,
1631                       struct dwarf2_fde_table *fde_table)
1632 {
1633   struct gdbarch *gdbarch = get_objfile_arch (unit->objfile);
1634   gdb_byte *buf, *end;
1635   LONGEST length;
1636   unsigned int bytes_read;
1637   int dwarf64_p;
1638   ULONGEST cie_id;
1639   ULONGEST cie_pointer;
1640
1641   buf = start;
1642   length = read_initial_length (unit->abfd, buf, &bytes_read);
1643   buf += bytes_read;
1644   end = buf + length;
1645
1646   /* Are we still within the section? */
1647   if (end > unit->dwarf_frame_buffer + unit->dwarf_frame_size)
1648     return NULL;
1649
1650   if (length == 0)
1651     return end;
1652
1653   /* Distinguish between 32 and 64-bit encoded frame info.  */
1654   dwarf64_p = (bytes_read == 12);
1655
1656   /* In a .eh_frame section, zero is used to distinguish CIEs from FDEs.  */
1657   if (eh_frame_p)
1658     cie_id = 0;
1659   else if (dwarf64_p)
1660     cie_id = DW64_CIE_ID;
1661   else
1662     cie_id = DW_CIE_ID;
1663
1664   if (dwarf64_p)
1665     {
1666       cie_pointer = read_8_bytes (unit->abfd, buf);
1667       buf += 8;
1668     }
1669   else
1670     {
1671       cie_pointer = read_4_bytes (unit->abfd, buf);
1672       buf += 4;
1673     }
1674
1675   if (cie_pointer == cie_id)
1676     {
1677       /* This is a CIE.  */
1678       struct dwarf2_cie *cie;
1679       char *augmentation;
1680       unsigned int cie_version;
1681
1682       /* Record the offset into the .debug_frame section of this CIE.  */
1683       cie_pointer = start - unit->dwarf_frame_buffer;
1684
1685       /* Check whether we've already read it.  */
1686       if (find_cie (cie_table, cie_pointer))
1687         return end;
1688
1689       cie = (struct dwarf2_cie *)
1690         obstack_alloc (&unit->objfile->objfile_obstack,
1691                        sizeof (struct dwarf2_cie));
1692       cie->initial_instructions = NULL;
1693       cie->cie_pointer = cie_pointer;
1694
1695       /* The encoding for FDE's in a normal .debug_frame section
1696          depends on the target address size.  */
1697       cie->encoding = DW_EH_PE_absptr;
1698
1699       /* The target address size.  For .eh_frame FDEs this is considered
1700          equal to the size of a target pointer.  For .dwarf_frame FDEs,
1701          this is supposed to be the target address size from the associated
1702          CU header.  FIXME: We do not have a good way to determine the
1703          latter.  Always use the target pointer size for now.  */
1704       cie->addr_size = gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1705
1706       /* We'll determine the final value later, but we need to
1707          initialize it conservatively.  */
1708       cie->signal_frame = 0;
1709
1710       /* Check version number.  */
1711       cie_version = read_1_byte (unit->abfd, buf);
1712       if (cie_version != 1 && cie_version != 3)
1713         return NULL;
1714       cie->version = cie_version;
1715       buf += 1;
1716
1717       /* Interpret the interesting bits of the augmentation.  */
1718       cie->augmentation = augmentation = (char *) buf;
1719       buf += (strlen (augmentation) + 1);
1720
1721       /* Ignore armcc augmentations.  We only use them for quirks,
1722          and that doesn't happen until later.  */
1723       if (strncmp (augmentation, "armcc", 5) == 0)
1724         augmentation += strlen (augmentation);
1725
1726       /* The GCC 2.x "eh" augmentation has a pointer immediately
1727          following the augmentation string, so it must be handled
1728          first.  */
1729       if (augmentation[0] == 'e' && augmentation[1] == 'h')
1730         {
1731           /* Skip.  */
1732           buf += gdbarch_ptr_bit (gdbarch) / TARGET_CHAR_BIT;
1733           augmentation += 2;
1734         }
1735
1736       cie->code_alignment_factor =
1737         read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1738       buf += bytes_read;
1739
1740       cie->data_alignment_factor =
1741         read_signed_leb128 (unit->abfd, buf, &bytes_read);
1742       buf += bytes_read;
1743
1744       if (cie_version == 1)
1745         {
1746           cie->return_address_register = read_1_byte (unit->abfd, buf);
1747           bytes_read = 1;
1748         }
1749       else
1750         cie->return_address_register = read_unsigned_leb128 (unit->abfd, buf,
1751                                                              &bytes_read);
1752       cie->return_address_register
1753         = dwarf2_frame_adjust_regnum (gdbarch,
1754                                       cie->return_address_register,
1755                                       eh_frame_p);
1756
1757       buf += bytes_read;
1758
1759       cie->saw_z_augmentation = (*augmentation == 'z');
1760       if (cie->saw_z_augmentation)
1761         {
1762           ULONGEST length;
1763
1764           length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1765           buf += bytes_read;
1766           if (buf > end)
1767             return NULL;
1768           cie->initial_instructions = buf + length;
1769           augmentation++;
1770         }
1771
1772       while (*augmentation)
1773         {
1774           /* "L" indicates a byte showing how the LSDA pointer is encoded.  */
1775           if (*augmentation == 'L')
1776             {
1777               /* Skip.  */
1778               buf++;
1779               augmentation++;
1780             }
1781
1782           /* "R" indicates a byte indicating how FDE addresses are encoded.  */
1783           else if (*augmentation == 'R')
1784             {
1785               cie->encoding = *buf++;
1786               augmentation++;
1787             }
1788
1789           /* "P" indicates a personality routine in the CIE augmentation.  */
1790           else if (*augmentation == 'P')
1791             {
1792               /* Skip.  Avoid indirection since we throw away the result.  */
1793               gdb_byte encoding = (*buf++) & ~DW_EH_PE_indirect;
1794               read_encoded_value (unit, encoding, cie->addr_size,
1795                                   buf, &bytes_read, 0);
1796               buf += bytes_read;
1797               augmentation++;
1798             }
1799
1800           /* "S" indicates a signal frame, such that the return
1801              address must not be decremented to locate the call frame
1802              info for the previous frame; it might even be the first
1803              instruction of a function, so decrementing it would take
1804              us to a different function.  */
1805           else if (*augmentation == 'S')
1806             {
1807               cie->signal_frame = 1;
1808               augmentation++;
1809             }
1810
1811           /* Otherwise we have an unknown augmentation.  Assume that either
1812              there is no augmentation data, or we saw a 'z' prefix.  */
1813           else
1814             {
1815               if (cie->initial_instructions)
1816                 buf = cie->initial_instructions;
1817               break;
1818             }
1819         }
1820
1821       cie->initial_instructions = buf;
1822       cie->end = end;
1823       cie->unit = unit;
1824
1825       add_cie (cie_table, cie);
1826     }
1827   else
1828     {
1829       /* This is a FDE.  */
1830       struct dwarf2_fde *fde;
1831
1832       /* In an .eh_frame section, the CIE pointer is the delta between the
1833          address within the FDE where the CIE pointer is stored and the
1834          address of the CIE.  Convert it to an offset into the .eh_frame
1835          section.  */
1836       if (eh_frame_p)
1837         {
1838           cie_pointer = buf - unit->dwarf_frame_buffer - cie_pointer;
1839           cie_pointer -= (dwarf64_p ? 8 : 4);
1840         }
1841
1842       /* In either case, validate the result is still within the section.  */
1843       if (cie_pointer >= unit->dwarf_frame_size)
1844         return NULL;
1845
1846       fde = (struct dwarf2_fde *)
1847         obstack_alloc (&unit->objfile->objfile_obstack,
1848                        sizeof (struct dwarf2_fde));
1849       fde->cie = find_cie (cie_table, cie_pointer);
1850       if (fde->cie == NULL)
1851         {
1852           decode_frame_entry (unit, unit->dwarf_frame_buffer + cie_pointer,
1853                               eh_frame_p, cie_table, fde_table);
1854           fde->cie = find_cie (cie_table, cie_pointer);
1855         }
1856
1857       gdb_assert (fde->cie != NULL);
1858
1859       fde->initial_location =
1860         read_encoded_value (unit, fde->cie->encoding, fde->cie->addr_size,
1861                             buf, &bytes_read, 0);
1862       buf += bytes_read;
1863
1864       fde->address_range =
1865         read_encoded_value (unit, fde->cie->encoding & 0x0f,
1866                             fde->cie->addr_size, buf, &bytes_read, 0);
1867       buf += bytes_read;
1868
1869       /* A 'z' augmentation in the CIE implies the presence of an
1870          augmentation field in the FDE as well.  The only thing known
1871          to be in here at present is the LSDA entry for EH.  So we
1872          can skip the whole thing.  */
1873       if (fde->cie->saw_z_augmentation)
1874         {
1875           ULONGEST length;
1876
1877           length = read_unsigned_leb128 (unit->abfd, buf, &bytes_read);
1878           buf += bytes_read + length;
1879           if (buf > end)
1880             return NULL;
1881         }
1882
1883       fde->instructions = buf;
1884       fde->end = end;
1885
1886       fde->eh_frame_p = eh_frame_p;
1887
1888       add_fde (fde_table, fde);
1889     }
1890
1891   return end;
1892 }
1893
1894 /* Read a CIE or FDE in BUF and decode it.  */
1895 static gdb_byte *
1896 decode_frame_entry (struct comp_unit *unit, gdb_byte *start, int eh_frame_p,
1897                     struct dwarf2_cie_table *cie_table,
1898                     struct dwarf2_fde_table *fde_table)
1899 {
1900   enum { NONE, ALIGN4, ALIGN8, FAIL } workaround = NONE;
1901   gdb_byte *ret;
1902   const char *msg;
1903   ptrdiff_t start_offset;
1904
1905   while (1)
1906     {
1907       ret = decode_frame_entry_1 (unit, start, eh_frame_p,
1908                                   cie_table, fde_table);
1909       if (ret != NULL)
1910         break;
1911
1912       /* We have corrupt input data of some form.  */
1913
1914       /* ??? Try, weakly, to work around compiler/assembler/linker bugs
1915          and mismatches wrt padding and alignment of debug sections.  */
1916       /* Note that there is no requirement in the standard for any
1917          alignment at all in the frame unwind sections.  Testing for
1918          alignment before trying to interpret data would be incorrect.
1919
1920          However, GCC traditionally arranged for frame sections to be
1921          sized such that the FDE length and CIE fields happen to be
1922          aligned (in theory, for performance).  This, unfortunately,
1923          was done with .align directives, which had the side effect of
1924          forcing the section to be aligned by the linker.
1925
1926          This becomes a problem when you have some other producer that
1927          creates frame sections that are not as strictly aligned.  That
1928          produces a hole in the frame info that gets filled by the
1929          linker with zeros.
1930
1931          The GCC behaviour is arguably a bug, but it's effectively now
1932          part of the ABI, so we're now stuck with it, at least at the
1933          object file level.  A smart linker may decide, in the process
1934          of compressing duplicate CIE information, that it can rewrite
1935          the entire output section without this extra padding.  */
1936
1937       start_offset = start - unit->dwarf_frame_buffer;
1938       if (workaround < ALIGN4 && (start_offset & 3) != 0)
1939         {
1940           start += 4 - (start_offset & 3);
1941           workaround = ALIGN4;
1942           continue;
1943         }
1944       if (workaround < ALIGN8 && (start_offset & 7) != 0)
1945         {
1946           start += 8 - (start_offset & 7);
1947           workaround = ALIGN8;
1948           continue;
1949         }
1950
1951       /* Nothing left to try.  Arrange to return as if we've consumed
1952          the entire input section.  Hopefully we'll get valid info from
1953          the other of .debug_frame/.eh_frame.  */
1954       workaround = FAIL;
1955       ret = unit->dwarf_frame_buffer + unit->dwarf_frame_size;
1956       break;
1957     }
1958
1959   switch (workaround)
1960     {
1961     case NONE:
1962       break;
1963
1964     case ALIGN4:
1965       complaint (&symfile_complaints,
1966                  _("Corrupt data in %s:%s; align 4 workaround apparently succeeded"),
1967                  unit->dwarf_frame_section->owner->filename,
1968                  unit->dwarf_frame_section->name);
1969       break;
1970
1971     case ALIGN8:
1972       complaint (&symfile_complaints,
1973                  _("Corrupt data in %s:%s; align 8 workaround apparently succeeded"),
1974                  unit->dwarf_frame_section->owner->filename,
1975                  unit->dwarf_frame_section->name);
1976       break;
1977
1978     default:
1979       complaint (&symfile_complaints,
1980                  _("Corrupt data in %s:%s"),
1981                  unit->dwarf_frame_section->owner->filename,
1982                  unit->dwarf_frame_section->name);
1983       break;
1984     }
1985
1986   return ret;
1987 }
1988 \f
1989
1990 /* Imported from dwarf2read.c.  */
1991 extern void dwarf2_get_section_info (struct objfile *, const char *, asection **,
1992                                      gdb_byte **, bfd_size_type *);
1993
1994 static int
1995 qsort_fde_cmp (const void *a, const void *b)
1996 {
1997   struct dwarf2_fde *aa = *(struct dwarf2_fde **)a;
1998   struct dwarf2_fde *bb = *(struct dwarf2_fde **)b;
1999
2000   if (aa->initial_location == bb->initial_location)
2001     {
2002       if (aa->address_range != bb->address_range
2003           && aa->eh_frame_p == 0 && bb->eh_frame_p == 0)
2004         /* Linker bug, e.g. gold/10400.
2005            Work around it by keeping stable sort order.  */
2006         return (a < b) ? -1 : 1;
2007       else
2008         /* Put eh_frame entries after debug_frame ones.  */
2009         return aa->eh_frame_p - bb->eh_frame_p;
2010     }
2011
2012   return (aa->initial_location < bb->initial_location) ? -1 : 1;
2013 }
2014
2015 void
2016 dwarf2_build_frame_info (struct objfile *objfile)
2017 {
2018   struct comp_unit *unit;
2019   gdb_byte *frame_ptr;
2020   struct dwarf2_cie_table cie_table;
2021   struct dwarf2_fde_table fde_table;
2022
2023   cie_table.num_entries = 0;
2024   cie_table.entries = NULL;
2025
2026   fde_table.num_entries = 0;
2027   fde_table.entries = NULL;
2028
2029   /* Build a minimal decoding of the DWARF2 compilation unit.  */
2030   unit = (struct comp_unit *) obstack_alloc (&objfile->objfile_obstack,
2031                                              sizeof (struct comp_unit));
2032   unit->abfd = objfile->obfd;
2033   unit->objfile = objfile;
2034   unit->dbase = 0;
2035   unit->tbase = 0;
2036
2037   dwarf2_get_section_info (objfile, ".eh_frame",
2038                            &unit->dwarf_frame_section,
2039                            &unit->dwarf_frame_buffer,
2040                            &unit->dwarf_frame_size);
2041   if (unit->dwarf_frame_size)
2042     {
2043       asection *got, *txt;
2044
2045       /* FIXME: kettenis/20030602: This is the DW_EH_PE_datarel base
2046          that is used for the i386/amd64 target, which currently is
2047          the only target in GCC that supports/uses the
2048          DW_EH_PE_datarel encoding.  */
2049       got = bfd_get_section_by_name (unit->abfd, ".got");
2050       if (got)
2051         unit->dbase = got->vma;
2052
2053       /* GCC emits the DW_EH_PE_textrel encoding type on sh and ia64
2054          so far.  */
2055       txt = bfd_get_section_by_name (unit->abfd, ".text");
2056       if (txt)
2057         unit->tbase = txt->vma;
2058
2059       frame_ptr = unit->dwarf_frame_buffer;
2060       while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2061         frame_ptr = decode_frame_entry (unit, frame_ptr, 1,
2062                                         &cie_table, &fde_table);
2063
2064       if (cie_table.num_entries != 0)
2065         {
2066           /* Reinit cie_table: debug_frame has different CIEs.  */
2067           xfree (cie_table.entries);
2068           cie_table.num_entries = 0;
2069           cie_table.entries = NULL;
2070         }
2071     }
2072
2073   dwarf2_get_section_info (objfile, ".debug_frame",
2074                            &unit->dwarf_frame_section,
2075                            &unit->dwarf_frame_buffer,
2076                            &unit->dwarf_frame_size);
2077   if (unit->dwarf_frame_size)
2078     {
2079       frame_ptr = unit->dwarf_frame_buffer;
2080       while (frame_ptr < unit->dwarf_frame_buffer + unit->dwarf_frame_size)
2081         frame_ptr = decode_frame_entry (unit, frame_ptr, 0,
2082                                         &cie_table, &fde_table);
2083     }
2084
2085   /* Discard the cie_table, it is no longer needed.  */
2086   if (cie_table.num_entries != 0)
2087     {
2088       xfree (cie_table.entries);
2089       cie_table.entries = NULL;   /* Paranoia.  */
2090       cie_table.num_entries = 0;  /* Paranoia.  */
2091     }
2092
2093   if (fde_table.num_entries != 0)
2094     {
2095       struct dwarf2_fde_table *fde_table2;
2096       int i, j;
2097
2098       /* Prepare FDE table for lookups.  */
2099       qsort (fde_table.entries, fde_table.num_entries,
2100              sizeof (fde_table.entries[0]), qsort_fde_cmp);
2101
2102       /* Copy fde_table to obstack: it is needed at runtime.  */
2103       fde_table2 = (struct dwarf2_fde_table *)
2104           obstack_alloc (&objfile->objfile_obstack, sizeof (*fde_table2));
2105
2106       /* Since we'll be doing bsearch, squeeze out identical (except for
2107          eh_frame_p) fde entries so bsearch result is predictable.  */
2108       for (i = 0, j = 0; j < fde_table.num_entries; ++i)
2109         {
2110           const int k = j;
2111
2112           obstack_grow (&objfile->objfile_obstack, &fde_table.entries[j],
2113                         sizeof (fde_table.entries[0]));
2114           while (++j < fde_table.num_entries
2115                  && (fde_table.entries[k]->initial_location ==
2116                      fde_table.entries[j]->initial_location))
2117             /* Skip.  */;
2118         }
2119       fde_table2->entries = obstack_finish (&objfile->objfile_obstack);
2120       fde_table2->num_entries = i;
2121       set_objfile_data (objfile, dwarf2_frame_objfile_data, fde_table2);
2122
2123       /* Discard the original fde_table.  */
2124       xfree (fde_table.entries);
2125     }
2126 }
2127
2128 /* Provide a prototype to silence -Wmissing-prototypes.  */
2129 void _initialize_dwarf2_frame (void);
2130
2131 void
2132 _initialize_dwarf2_frame (void)
2133 {
2134   dwarf2_frame_data = gdbarch_data_register_pre_init (dwarf2_frame_init);
2135   dwarf2_frame_objfile_data = register_objfile_data ();
2136 }