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