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