gdb/dwarf2-frame.c

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