gdb/dwarf2-frame.c

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