gdb/dwarf2-frame.c

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