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