gdb/dwarf2-frame.c

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