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