gdb/dwarf2-frame.c

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