gdb/dwarf2-frame.c

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